From 4afba657dd553bc53a377fa4815b08ece59d6a2f Mon Sep 17 00:00:00 2001
From: Danila Beseda <danila-beseda@yandex-team.ru>
Date: Thu, 3 Sep 2026 15:06:43 +0300
Subject: [PATCH 1/3] feat: add public path fallback

---
 README.md                                  |  38 ++++
 src/common/config.ts                       |  81 ++++++++
 src/common/models/index.ts                 |  47 +++++
 src/common/webpack/config.ts               |  32 ++-
 src/common/webpack/public-path-fallback.js | 226 +++++++++++++++++++++
 5 files changed, 415 insertions(+), 9 deletions(-)
 create mode 100644 src/common/webpack/public-path-fallback.js

diff --git a/README.md b/README.md
index 3a282b0..ff63dd1 100755
--- a/README.md
+++ b/README.md
@@ -214,6 +214,8 @@ Set it to wherever the `dist/public/build` output is actually served: `'/'` if a
 
 If dynamic imports 404 at `/build/js/...` while other assets load from `/js/...`, or HMR breaks in dev, set this global — changing `publicPath` in config will not help.
 
+If the runtime should retry another base URL when a chunk fails to load from this one, see [`publicPathFallback`](#production-build).
+
 #### Options
 
 All paths must be specified relative `rootDir` of the project.
@@ -358,6 +360,42 @@ With this `{rootDir}/src/ui/tsconfig.json`:
   - `publicPath` (`string`) - public path to access files from the browser
   - `compress` (`boolean`) - upload also gzip and brotli compressed versions of files
   - `additionalPattern` (`string[]`) — patterns for uploading additional files. By default, only files generated by webpack are loaded.
+- `publicPathFallback` (`Array<string | {publicPath: string, hosts?: string | RegExp | Array<string | RegExp>}>`) — ordered public paths to retry a failed async chunk from. Disabled by default.
+
+  On failure, the runtime switches to and sticks with the next candidate for all later loads, so only the first failing chunk pays for a degraded CDN.
+
+  `window.__PUBLIC_PATH__` holds the current public path and is always tried first automatically — moved to the front of the list (or de-duplicated there) whether or not it's also configured. So `publicPathFallback` should only ever list backups; a single entry is already useful.
+
+  Each entry is a plain string, or an object:
+
+  - `publicPath` (`string`) — the backup base URL.
+  - `hosts` (`string | RegExp | Array<string | RegExp>`, optional) — restricts the entry to hosts it applies to, matched against `location.hostname`. A string must match exactly, a `RegExp` is tested against it; matching is always case-insensitive. Omitted means every host.
+
+  ```ts
+  import {defineConfig} from '@gravity-ui/app-builder';
+
+  export default defineConfig({
+    client: {
+      publicPathFallback: [
+        {publicPath: 'https://cdn.example.ru/build/', hosts: /\.ru$/},
+        {publicPath: 'https://cdn.example.kz/build/', hosts: 'app.example.kz'},
+        '/build/',
+      ],
+    },
+  });
+  // on app.example.ru: window.__PUBLIC_PATH__ -> https://cdn.example.ru/build/ -> /build/
+  // on app.example.kz: window.__PUBLIC_PATH__ -> https://cdn.example.kz/build/ -> /build/
+  // anywhere else:     window.__PUBLIC_PATH__ -> /build/
+  ```
+
+  Independent of `cdn`, which only handles uploading static — use this whether the upload is done by app-builder or by something else entirely.
+
+  If you add the local public path as a candidate, use whatever your build actually serves from — `/build/` by default, but `publicPathPrefix` and module federation asset isolation both change it.
+
+  Covers only lazy JS chunks and their async CSS. **Not covered**: initial `<script>`/`<link>` tags (they load before any bundle code runs — a primary outage there has to be handled in the page template) and worker scripts.
+
+  The option has no effect in dev mode, in SSR builds, or with `moduleFederation`.
+
 - `sentryConfig` (`Options`) — `@sentry/webpack-plugin` [configuration options](https://www.npmjs.com/package/@sentry/webpack-plugin/v/2.7.1).
 
 ##### Optimization
diff --git a/src/common/config.ts b/src/common/config.ts
index 13d277d..f3edd5e 100755
--- a/src/common/config.ts
+++ b/src/common/config.ts
@@ -11,6 +11,7 @@ import paths from './paths.js';
 import type {CosmiconfigResult} from 'cosmiconfig';
 
 import type {
+    CdnHostPattern,
     ClientConfig,
     LibraryConfig,
     NormalizedClientConfig,
@@ -19,6 +20,8 @@ import type {
     NormalizedServerConfig,
     NormalizedServiceConfig,
     ProjectConfig,
+    PublicPathFallback,
+    PublicPathFallbackEntry,
     ServerConfig,
     ServiceConfig,
 } from './models/index.js';
@@ -36,6 +39,83 @@ function remapPaths(paths: string | string[]) {
     return splitPaths(paths).map((p) => path.resolve(process.cwd(), p));
 }
 
+function withTrailingSlash(publicPath: string) {
+    return /[\\/]$/.test(publicPath) ? publicPath : `${publicPath}/`;
+}
+
+function normalizeHostPatterns(hosts: PublicPathFallbackEntry['hosts']) {
+    if (!hosts) {
+        return undefined;
+    }
+
+    const patterns = (Array.isArray(hosts) ? hosts : [hosts]).map((host) => ({
+        source: toPatternSource(host),
+        flags: toPatternFlags(host),
+    }));
+
+    return patterns.length > 0 ? patterns : undefined;
+}
+
+// 'app.example.ru' -> '^app\.example\.ru$';
+function toPatternSource(host: CdnHostPattern) {
+    return typeof host === 'string'
+        ? `^${host.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`
+        : host.source;
+}
+
+// Forces case-insensitivity (`location.hostname` is always lower case) and drops
+// `g`/`y`, which would make a shared RegExp instance stateful across calls.
+function toPatternFlags(host: CdnHostPattern) {
+    return `i${typeof host === 'string' ? '' : host.flags.replace(/[giy]/g, '')}`;
+}
+
+function normalizePublicPathFallbacks(client: ClientConfig, mode?: string): PublicPathFallback[] {
+    if (!client.publicPathFallback?.length || mode === 'dev') {
+        return [];
+    }
+
+    if (client.moduleFederation) {
+        logger.warning(
+            stripIndent`
+                publicPathFallback option is disabled because moduleFederation is configured.
+                Module federation remotes load their entries and chunks through their own runtime,
+                which the fallback cannot reach.
+            `,
+        );
+        return [];
+    }
+
+    const candidates: PublicPathFallback[] = [];
+    for (const entry of client.publicPathFallback) {
+        const candidate = normalizeFallbackEntry(entry);
+
+        if (candidate && !isDuplicatePublicPath(candidates, candidate.publicPath)) {
+            candidates.push(candidate);
+        }
+    }
+
+    return candidates;
+}
+
+function normalizeFallbackEntry(
+    entry: string | PublicPathFallbackEntry,
+): PublicPathFallback | undefined {
+    const {publicPath, hosts} = typeof entry === 'string' ? {publicPath: entry} : entry;
+
+    if (!publicPath) {
+        return undefined;
+    }
+
+    return omitUndefined({
+        publicPath: withTrailingSlash(publicPath),
+        hosts: normalizeHostPatterns(hosts),
+    }) as PublicPathFallback;
+}
+
+function isDuplicatePublicPath(candidates: PublicPathFallback[], publicPath: string) {
+    return candidates.some((candidate) => candidate.publicPath === publicPath);
+}
+
 function omitUndefined<T extends object>(obj: T) {
     const newObj: Record<string, any> = {};
     for (const [key, value] of Object.entries(obj)) {
@@ -264,6 +344,7 @@ async function normalizeClientConfig(client: ClientConfig, mode?: 'dev' | 'build
         publicPath,
         cdnPublicPath: cdnConfig?.publicPath,
         browserPublicPath,
+        publicPathFallbacks: normalizePublicPathFallbacks(client, mode),
         assetsManifestFile:
             client.assetsManifestFile ||
             (client.moduleFederation?.version
diff --git a/src/common/models/index.ts b/src/common/models/index.ts
index f9abc25..53e3f97 100755
--- a/src/common/models/index.ts
+++ b/src/common/models/index.ts
@@ -372,6 +372,25 @@ export interface ClientCommonConfig {
     };
     // TODO(DakEnviy): Allow only one cdn config
     cdn?: CdnUploadConfig | CdnUploadConfig[];
+    /**
+     * Ordered public paths to retry a failed async chunk from.
+     *
+     * On failure, the runtime switches to and sticks with the next candidate for all
+     * later loads.
+     *
+     * `window.__PUBLIC_PATH__` is always tried first - moved to the front whether or not
+     * it's also listed here, so this array usually holds only backups. Entries with
+     * `hosts` apply only when `location.hostname` matches.
+     *
+     * Covers only lazy JS chunks and their async CSS. Not covered: initial `<script>`/
+     * `<link>` tags (they load before any bundle code runs - a primary outage there
+     * has to be handled in the page template) and worker scripts.
+     *
+     * Has no effect in dev mode, in SSR builds, or with `moduleFederation`.
+     *
+     * @example [{publicPath: 'https://cdn.example.ru/build/', hosts: /\.ru$/}, '/build/']
+     */
+    publicPathFallback?: (string | PublicPathFallbackEntry)[];
     /**
      * use webpack 5 Web Workers [syntax](https://webpack.js.org/guides/web-workers/#syntax)
      *
@@ -492,6 +511,29 @@ export interface CdnUploadConfig {
     additionalPattern?: string | string[];
 }
 
+export type CdnHostPattern = string | RegExp;
+
+export interface PublicPathFallbackEntry {
+    /** The backup base URL to retry a failed chunk from. */
+    publicPath: string;
+    /**
+     * Hosts this public path may be used on.
+     *
+     * A string must match the whole `location.hostname` exactly; a RegExp is tested
+     * as-is. Matching is always case-insensitive (`location.hostname` is lower case).
+     * When omitted, the public path is used on every host.
+     *
+     * @example ['app.example.ru', /\.example\.kz$/]
+     */
+    hosts?: CdnHostPattern | CdnHostPattern[];
+}
+
+/** Serialized form of `PublicPathFallbackEntry`, injected into the bundle via `DefinePlugin`. */
+export interface PublicPathFallback {
+    publicPath: string;
+    hosts?: {source: string; flags: string}[];
+}
+
 export interface ServerConfig {
     port?: number | true;
     watch?: string[];
@@ -587,6 +629,11 @@ export type NormalizedClientBaseConfig = Omit<
      * (concatenated with micro-frontend name if module federation is configured).
      */
     browserPublicPath: string;
+    /**
+     * Ordered list of public paths the runtime may load async chunks from,
+     * derived from `publicPathFallback`. Empty if the fallback is disabled.
+     */
+    publicPathFallbacks: PublicPathFallback[];
     assetsManifestFile: string;
     hiddenSourceMap: boolean;
     svgr: NonNullable<ClientConfig['svgr']>;
diff --git a/src/common/webpack/config.ts b/src/common/webpack/config.ts
index 1232d30..35d70f1 100644
--- a/src/common/webpack/config.ts
+++ b/src/common/webpack/config.ts
@@ -463,31 +463,44 @@ export function configureResolve({isEnvProduction, config}: HelperOptions) {
     } satisfies webpack.ResolveOptions;
 }
 
-function createEntryArray(entry: string | string[]) {
+function getRuntimeEntries({config, isSsr}: HelperOptions) {
+    const runtimeEntries = [require.resolve('./public-path.js')];
+
+    if (!isSsr && config.publicPathFallbacks.length > 0) {
+        runtimeEntries.push(require.resolve('./public-path-fallback.js'));
+    }
+
+    return runtimeEntries;
+}
+
+function createEntryArray(entry: string | string[], runtimeEntries: string[]) {
     if (typeof entry === 'string') {
-        return [require.resolve('./public-path.js'), entry];
+        return [...runtimeEntries, entry];
     }
 
-    return [require.resolve('./public-path.js'), ...entry];
+    return [...runtimeEntries, ...entry];
 }
 
-function addEntry(entry: Record<string, string[]>, file: string) {
+function addEntry(entry: Record<string, string[]>, file: string, runtimeEntries: string[]) {
     return {
         ...entry,
-        [path.parse(file).name]: createEntryArray(file),
+        [path.parse(file).name]: createEntryArray(file, runtimeEntries),
     };
 }
 
-function configureEntry({config, entriesDirectory}: HelperOptions) {
+function configureEntry(options: HelperOptions) {
+    const {config, entriesDirectory} = options;
+    const runtimeEntries = getRuntimeEntries(options);
+
     if (typeof config.entry === 'string' || Array.isArray(config.entry)) {
-        return createEntryArray(config.entry);
+        return createEntryArray(config.entry, runtimeEntries);
     }
 
     if (typeof config.entry === 'object') {
         return Object.entries(config.entry).reduce<Record<string, string[]>>(
             (acc, [key, value]) => ({
                 ...acc,
-                [key]: createEntryArray(value),
+                [key]: createEntryArray(value, runtimeEntries),
             }),
             {},
         );
@@ -535,7 +548,7 @@ function configureEntry({config, entriesDirectory}: HelperOptions) {
     }
 
     return entryFiles.reduce<Record<string, string[]>>(
-        (acc, file) => addEntry(acc, path.resolve(entriesDirectory, file)),
+        (acc, file) => addEntry(acc, path.resolve(entriesDirectory, file), runtimeEntries),
         {},
     );
 }
@@ -1125,6 +1138,7 @@ function getDefinitions({config, isSsr}: HelperOptions) {
         'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
         'process.env.IS_SSR': JSON.stringify(isSsr),
         'process.env.PUBLIC_PATH': JSON.stringify(config.browserPublicPath),
+        __PUBLIC_PATH_FALLBACKS__: JSON.stringify(isSsr ? [] : config.publicPathFallbacks),
         ...config.definitions,
     };
 }
diff --git a/src/common/webpack/public-path-fallback.js b/src/common/webpack/public-path-fallback.js
new file mode 100644
index 0000000..a9b45ad
--- /dev/null
+++ b/src/common/webpack/public-path-fallback.js
@@ -0,0 +1,226 @@
+/* eslint-env browser */
+/* eslint-disable camelcase, no-console */
+/* global __webpack_require__, __webpack_public_path__:writable, __PUBLIC_PATH_FALLBACKS__ */
+
+/*
+ * Sticky public path fallback for async chunk loading, prepended to every client entry
+ * right after public-path.js. Runs in the browser.
+ */
+
+const STATE_KEY = '__PUBLIC_PATH_FALLBACK_STATE__';
+const PREFIX = '[app-builder] ';
+
+install();
+
+function install() {
+    if (isUnsupportedRuntime()) {
+        return;
+    }
+
+    const req = __webpack_require__;
+    const originalEnsure = req && req.e;
+
+    const hasAsyncChunks = typeof originalEnsure === 'function';
+    if (!hasAsyncChunks) {
+        return;
+    }
+
+    const candidates = buildCandidateList();
+    if (candidates.length < 2) {
+        return;
+    }
+
+    const state = getOrCreateState();
+    state.candidates = candidates;
+    if (!state.active || candidates.indexOf(state.active) === -1) {
+        state.active = firstAlive() || candidates[0];
+    }
+    setPublicPath(state.active);
+
+    req.e = (chunkId) => start(chunkId);
+
+    if (req.e === originalEnsure) {
+        console.warn(
+            PREFIX + 'public path fallback is inactive: __webpack_require__.e is not writable.',
+        );
+    }
+
+    function start(chunkId) {
+        let promise;
+
+        try {
+            promise = attempt(chunkId, state.active);
+        } catch (error) {
+            return handleFailure(chunkId, state.active, error);
+        }
+
+        if (!promise || typeof promise.then !== 'function') {
+            return promise;
+        }
+
+        return promise.then(null, (error) => handleFailure(chunkId, state.active, error));
+    }
+
+    function attempt(chunkId, candidate) {
+        const previous = __webpack_public_path__;
+
+        if (candidate === previous) {
+            return originalEnsure.call(req, chunkId);
+        }
+
+        setPublicPath(candidate);
+        try {
+            return originalEnsure.call(req, chunkId);
+        } finally {
+            setPublicPath(previous);
+        }
+    }
+
+    function handleFailure(chunkId, failedPath, error) {
+        if (!isLoadError(error)) {
+            return Promise.reject(error);
+        }
+
+        const promoted = markDead(failedPath, chunkId, error);
+        return promoted ? start(chunkId) : Promise.reject(error);
+    }
+
+    function markDead(deadPath, chunkId, error) {
+        if (state.dead.indexOf(deadPath) === -1) {
+            state.dead.push(deadPath);
+        }
+
+        const next = firstAlive();
+
+        console.warn(
+            PREFIX +
+                `failed to load chunk "${chunkId}" from "${deadPath}"` +
+                (next ? `; switching public path to "${next}"` : '; no fallbacks left'),
+            error,
+        );
+
+        if (!next) {
+            return false;
+        }
+
+        if (next !== state.active) {
+            state.active = next;
+            setPublicPath(next);
+        }
+
+        return true;
+    }
+
+    function firstAlive() {
+        for (const candidate of state.candidates) {
+            if (state.dead.indexOf(candidate) === -1) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+}
+
+function isUnsupportedRuntime() {
+    return typeof window === 'undefined' || typeof document === 'undefined';
+}
+
+function buildCandidateList() {
+    const candidates = selectCandidates(__PUBLIC_PATH_FALLBACKS__, getHostname());
+
+    const initial = __webpack_public_path__;
+    if (typeof initial === 'string' && initial) {
+        moveToFront(candidates, initial);
+    }
+
+    return candidates;
+}
+
+function moveToFront(list, value) {
+    const at = list.indexOf(value);
+    if (at !== -1) {
+        list.splice(at, 1);
+    }
+    list.unshift(value);
+}
+
+function getOrCreateState() {
+    // Shared via window, not a closure, so multiple webpack runtimes on one page
+    // (a micro-frontend shell, an embedded second bundle) agree on one dead CDN.
+    if (!window[STATE_KEY]) {
+        window[STATE_KEY] = {dead: [], active: null};
+    }
+
+    return window[STATE_KEY];
+}
+
+function setPublicPath(value) {
+    // Compiles to `__webpack_require__.p = value` in both webpack and rspack
+    __webpack_public_path__ = value;
+}
+
+function getHostname() {
+    try {
+        return window.location.hostname || '';
+    } catch {
+        return '';
+    }
+}
+
+function selectCandidates(fallbacks, hostname) {
+    const result = [];
+
+    if (!Array.isArray(fallbacks)) {
+        return result;
+    }
+
+    for (const fallback of fallbacks) {
+        if (!fallback || typeof fallback.publicPath !== 'string' || !fallback.publicPath) {
+            continue;
+        }
+
+        if (matchesHost(fallback.hosts, hostname) && result.indexOf(fallback.publicPath) === -1) {
+            result.push(fallback.publicPath);
+        }
+    }
+
+    return result;
+}
+
+function matchesHost(hosts, hostname) {
+    if (!Array.isArray(hosts) || hosts.length === 0) {
+        return true;
+    }
+
+    return hosts.some((host) => {
+        try {
+            // eslint-disable-next-line security/detect-non-literal-regexp
+            return new RegExp(host.source, host.flags).test(hostname);
+        } catch (error) {
+            console.warn(PREFIX + `invalid host pattern "/${host.source}/${host.flags}"`, error);
+            return false;
+        }
+    });
+}
+
+function isLoadError(error) {
+    return (
+        Boolean(error) &&
+        (isJsChunkLoadError(error) || isCssChunkLoadError(error) || hasLoadFailureMessage(error))
+    );
+}
+
+function isJsChunkLoadError(error) {
+    return error.name === 'ChunkLoadError'; // webpack + rspack jsonp chunk loading
+}
+
+function isCssChunkLoadError(error) {
+    return error.code === 'CSS_CHUNK_LOAD_FAILED'; // mini-css-extract-plugin + CssExtractRspackPlugin
+}
+
+function hasLoadFailureMessage(error) {
+    return (
+        typeof error.message === 'string' &&
+        /Loading (?:CSS )?chunk [\s\S]*failed/i.test(error.message)
+    );
+}

From 171cbe5217f8c7ebe4b5d286099a98a0a812df61 Mon Sep 17 00:00:00 2001
From: Danila Beseda <danila-beseda@yandex-team.ru>
Date: Fri, 4 Sep 2026 19:37:33 +0300
Subject: [PATCH 2/3] feat: add custom event for public path fallback failures

---
 README.md                                  | 10 ++++++++++
 src/common/models/index.ts                 | 13 +++++++++++++
 src/common/webpack/browser-events.js       | 15 +++++++++++++++
 src/common/webpack/public-path-fallback.js |  9 +++++++++
 src/index.ts                               |  1 +
 5 files changed, 48 insertions(+)
 create mode 100644 src/common/webpack/browser-events.js

diff --git a/README.md b/README.md
index ff63dd1..9168a6d 100755
--- a/README.md
+++ b/README.md
@@ -396,6 +396,16 @@ With this `{rootDir}/src/ui/tsconfig.json`:
 
   The option has no effect in dev mode, in SSR builds, or with `moduleFederation`.
 
+  Every switch (or exhaustion) dispatches a `window` `CustomEvent` named `app-builder:public-path-fallback` with `detail` typed as the exported `PublicPathFallbackEventDetail` (`nextPath` is `null` when no candidate is left) — listen for it to report failures to your own monitoring.
+
+  ```ts
+  import type {PublicPathFallbackEventDetail} from '@gravity-ui/app-builder';
+
+  window.addEventListener('app-builder:public-path-fallback', (event) => {
+    const {chunkId, deadPath, nextPath, error} = (event as CustomEvent<PublicPathFallbackEventDetail>).detail;
+  });
+  ```
+
 - `sentryConfig` (`Options`) — `@sentry/webpack-plugin` [configuration options](https://www.npmjs.com/package/@sentry/webpack-plugin/v/2.7.1).
 
 ##### Optimization
diff --git a/src/common/models/index.ts b/src/common/models/index.ts
index 53e3f97..b4ead9b 100755
--- a/src/common/models/index.ts
+++ b/src/common/models/index.ts
@@ -534,6 +534,19 @@ export interface PublicPathFallback {
     hosts?: {source: string; flags: string}[];
 }
 
+/**
+ * `detail` of the `app-builder:public-path-fallback` window `CustomEvent`,
+ * dispatched on every switch or exhaustion. Cast to `CustomEvent<PublicPathFallbackEventDetail>`
+ * in the event listener, e.g. `window.addEventListener('app-builder:public-path-fallback', (event) => ...)`.
+ */
+export interface PublicPathFallbackEventDetail {
+    chunkId: string | number;
+    deadPath: string;
+    /** Next public path now active, or `null` when every candidate is exhausted. */
+    nextPath: string | null;
+    error: Error;
+}
+
 export interface ServerConfig {
     port?: number | true;
     watch?: string[];
diff --git a/src/common/webpack/browser-events.js b/src/common/webpack/browser-events.js
new file mode 100644
index 0000000..3f51915
--- /dev/null
+++ b/src/common/webpack/browser-events.js
@@ -0,0 +1,15 @@
+/* eslint-env browser */
+
+const NAMESPACE = 'app-builder';
+
+export const BrowserEvents = {
+    PublicPathFallback: `${NAMESPACE}:public-path-fallback`,
+};
+
+export function dispatchBrowserEvent(name, detail) {
+    if (typeof window === 'undefined' || typeof window.CustomEvent !== 'function') {
+        return;
+    }
+
+    window.dispatchEvent(new CustomEvent(name, {detail}));
+}
diff --git a/src/common/webpack/public-path-fallback.js b/src/common/webpack/public-path-fallback.js
index a9b45ad..a68dc3f 100644
--- a/src/common/webpack/public-path-fallback.js
+++ b/src/common/webpack/public-path-fallback.js
@@ -7,6 +7,8 @@
  * right after public-path.js. Runs in the browser.
  */
 
+import {BrowserEvents, dispatchBrowserEvent} from './browser-events.js';
+
 const STATE_KEY = '__PUBLIC_PATH_FALLBACK_STATE__';
 const PREFIX = '[app-builder] ';
 
@@ -99,6 +101,13 @@ function install() {
             error,
         );
 
+        dispatchBrowserEvent(BrowserEvents.PublicPathFallback, {
+            chunkId,
+            deadPath,
+            nextPath: next,
+            error,
+        });
+
         if (!next) {
             return false;
         }
diff --git a/src/index.ts b/src/index.ts
index c1c0463..0434889 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -14,4 +14,5 @@ export type {
     LibraryConfig,
     ModuleFederationConfig,
     ProjectFileConfig,
+    PublicPathFallbackEventDetail,
 } from './common/models/index.js';

From 0d93829285821b5d76036a9275ee812af1afb59f Mon Sep 17 00:00:00 2001
From: Danila Beseda <danila-beseda@yandex-team.ru>
Date: Mon, 7 Sep 2026 15:11:23 +0300
Subject: [PATCH 3/3] Fix prettier

---
 README.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9168a6d..0a80a03 100755
--- a/README.md
+++ b/README.md
@@ -402,7 +402,9 @@ With this `{rootDir}/src/ui/tsconfig.json`:
   import type {PublicPathFallbackEventDetail} from '@gravity-ui/app-builder';
 
   window.addEventListener('app-builder:public-path-fallback', (event) => {
-    const {chunkId, deadPath, nextPath, error} = (event as CustomEvent<PublicPathFallbackEventDetail>).detail;
+    const {chunkId, deadPath, nextPath, error} = (
+      event as CustomEvent<PublicPathFallbackEventDetail>
+    ).detail;
   });
   ```