@tramvai/module-render 5.50.0 → 6.59.0

package/lib/browser.js

@@ -1,11 +1,10 @@
 import { __decorate } from 'tslib';
 import { Module, provide, commandLineListTokens, DI_TOKEN, optional } from '@tramvai/core';
 import { STORE_TOKEN, LOGGER_TOKEN, CONTEXT_TOKEN } from '@tramvai/tokens-common';
-import { RESOURCES_REGISTRY, CUSTOM_RENDER, EXTEND_RENDER, RENDERER_CALLBACK, USE_REACT_STRICT_MODE, REACT_SERVER_RENDER_MODE, DEFAULT_ERROR_BOUNDARY_COMPONENT, RENDER_MODE, MODERN_SATISFIES_TOKEN } from '@tramvai/tokens-render';
+import { RESOURCES_REGISTRY, CUSTOM_RENDER, EXTEND_RENDER, RENDERER_CALLBACK, USE_REACT_STRICT_MODE, REACT_SERVER_RENDER_MODE, DEFAULT_ERROR_BOUNDARY_COMPONENT, RENDER_MODE } from '@tramvai/tokens-render';
 export * from '@tramvai/tokens-render';
 import { beforeResolveHooksToken, PageErrorStore, setPageErrorEvent } from '@tramvai/module-router';
 export { PageErrorStore, setPageErrorEvent } from '@tramvai/module-router';
-import { COOKIE_MANAGER_TOKEN } from '@tramvai/module-common';
 import { rendering } from './client/index.browser.js';
 import { LayoutModule } from './shared/LayoutModule.browser.js';
 import { providers } from './shared/providers.browser.js';
@@ -110,16 +109,6 @@ RenderModule = RenderModule_1 = __decorate([
                 provide: RENDER_MODE,
                 useValue: 'legacy',
             }),
-            provide({
-                provide: MODERN_SATISFIES_TOKEN,
-                useFactory: ({ cookieManager }) => {
-                    const result = cookieManager.get('_t_modern');
-                    return result === 'true' || result === 'false' ? JSON.parse(result) : false;
-                },
-                deps: {
-                    cookieManager: COOKIE_MANAGER_TOKEN,
-                },
-            }),
             provide({
                 provide: REACT_SERVER_RENDER_MODE,
                 useValue: 'sync',

package/lib/resourcesInliner/resourcesInliner.es.js

@@ -31,80 +31,84 @@ const removeSourceMapFromString = (file) => {
     return file.replace(/(\n\/\/# sourceMappingURL=.*)/g, '');
 };
 class ResourcesInliner {
-    constructor({ resourcesRegistryCache, resourceInlineThreshold, logger, assetsPrefixFactory }) {
-        this.internalFilesCache = new Map();
-        this.runningRequests = new Set();
-        this.scheduleFileLoad = async (resource, resourceInlineThreshold) => {
-            const url = getResourceUrl(resource, this.assetsPrefix);
-            const requestKey = `file${url}`;
-            const filesCache = this.getFilesCache(url);
-            const result = filesCache.get(url);
-            if (result) {
-                return result;
-            }
-            if (!this.runningRequests.has(requestKey)) {
-                this.runningRequests.add(url);
-                try {
-                    const file = await getFile(url);
-                    if (file === undefined) {
-                        this.resourcesRegistryCache.disabledUrlsCache.set(url, true);
-                        return;
-                    }
-                    const size = file.length;
-                    if (size < resourceInlineThreshold) {
-                        filesCache.set(url, processFile(resource, file));
-                    }
-                    this.resourcesRegistryCache.sizeCache.set(url, size);
-                }
-                catch (error) {
-                    this.log.warn({
-                        event: 'file-load-failed',
-                        url,
-                        error,
-                    });
+    resourceInlineThreshold;
+    internalFilesCache = new Map();
+    resourcesRegistryCache;
+    log;
+    runningRequests = new Set();
+    assetsPrefix;
+    scheduleFileLoad = async (resource, resourceInlineThreshold) => {
+        const url = getResourceUrl(resource, this.assetsPrefix);
+        const requestKey = `file${url}`;
+        const filesCache = this.getFilesCache(url);
+        const result = filesCache.get(url);
+        if (result) {
+            return result;
+        }
+        if (!this.runningRequests.has(requestKey)) {
+            this.runningRequests.add(url);
+            try {
+                const file = await getFile(url);
+                if (file === undefined) {
+                    this.resourcesRegistryCache.disabledUrlsCache.set(url, true);
+                    return;
                 }
-                finally {
-                    this.runningRequests.delete(requestKey);
+                const size = file.length;
+                if (size < resourceInlineThreshold) {
+                    filesCache.set(url, processFile(resource, file));
                 }
+                this.resourcesRegistryCache.sizeCache.set(url, size);
             }
-        };
-        this.scheduleFileSizeLoad = async (resource, resourceInlineThreshold, waitForFileLoad) => {
-            const url = getResourceUrl(resource, this.assetsPrefix);
-            const requestKey = `size${url}`;
-            const result = this.resourcesRegistryCache.sizeCache.get(url);
-            if (result) {
-                return result;
+            catch (error) {
+                this.log.warn({
+                    event: 'file-load-failed',
+                    url,
+                    error,
+                });
             }
-            if (!this.runningRequests.has(requestKey)) {
-                this.runningRequests.add(requestKey);
-                try {
-                    const contentLength = await getFileContentLength(url);
-                    const size = isUndefined(contentLength) ? 0 : +contentLength;
-                    if (size) {
-                        this.resourcesRegistryCache.sizeCache.set(url, size);
-                    }
-                    if (size < resourceInlineThreshold) {
-                        const promise = this.scheduleFileLoad(resource, resourceInlineThreshold);
-                        if (waitForFileLoad) {
-                            await promise;
-                        }
-                    }
-                }
-                catch (error) {
-                    // If the ASSETS_PREFIX variable does not exist,
-                    // or static files weren't deployed yet, we can't get
-                    // information about files.
-                    this.log.debug({
-                        event: 'file-content-length-load-failed',
-                        url,
-                        error,
-                    });
+            finally {
+                this.runningRequests.delete(requestKey);
+            }
+        }
+    };
+    scheduleFileSizeLoad = async (resource, resourceInlineThreshold, waitForFileLoad) => {
+        const url = getResourceUrl(resource, this.assetsPrefix);
+        const requestKey = `size${url}`;
+        const result = this.resourcesRegistryCache.sizeCache.get(url);
+        if (result) {
+            return result;
+        }
+        if (!this.runningRequests.has(requestKey)) {
+            this.runningRequests.add(requestKey);
+            try {
+                const contentLength = await getFileContentLength(url);
+                const size = isUndefined(contentLength) ? 0 : +contentLength;
+                if (size) {
+                    this.resourcesRegistryCache.sizeCache.set(url, size);
                 }
-                finally {
-                    this.runningRequests.delete(requestKey);
+                if (size < resourceInlineThreshold) {
+                    const promise = this.scheduleFileLoad(resource, resourceInlineThreshold);
+                    if (waitForFileLoad) {
+                        await promise;
+                    }
                 }
             }
-        };
+            catch (error) {
+                // If the ASSETS_PREFIX variable does not exist,
+                // or static files weren't deployed yet, we can't get
+                // information about files.
+                this.log.debug({
+                    event: 'file-content-length-load-failed',
+                    url,
+                    error,
+                });
+            }
+            finally {
+                this.runningRequests.delete(requestKey);
+            }
+        }
+    };
+    constructor({ resourcesRegistryCache, resourceInlineThreshold, logger, assetsPrefixFactory }) {
         this.resourcesRegistryCache = resourcesRegistryCache;
         this.resourceInlineThreshold = resourceInlineThreshold;
         this.log = logger('resources-inliner');

package/lib/resourcesInliner/resourcesInliner.js

@@ -40,80 +40,84 @@ const removeSourceMapFromString = (file) => {
     return file.replace(/(\n\/\/# sourceMappingURL=.*)/g, '');
 };
 class ResourcesInliner {
-    constructor({ resourcesRegistryCache, resourceInlineThreshold, logger, assetsPrefixFactory }) {
-        this.internalFilesCache = new Map();
-        this.runningRequests = new Set();
-        this.scheduleFileLoad = async (resource, resourceInlineThreshold) => {
-            const url = getResourceUrl(resource, this.assetsPrefix);
-            const requestKey = `file${url}`;
-            const filesCache = this.getFilesCache(url);
-            const result = filesCache.get(url);
-            if (result) {
-                return result;
-            }
-            if (!this.runningRequests.has(requestKey)) {
-                this.runningRequests.add(url);
-                try {
-                    const file = await externalFilesHelper.getFile(url);
-                    if (file === undefined) {
-                        this.resourcesRegistryCache.disabledUrlsCache.set(url, true);
-                        return;
-                    }
-                    const size = file.length;
-                    if (size < resourceInlineThreshold) {
-                        filesCache.set(url, fileProcessor.processFile(resource, file));
-                    }
-                    this.resourcesRegistryCache.sizeCache.set(url, size);
-                }
-                catch (error) {
-                    this.log.warn({
-                        event: 'file-load-failed',
-                        url,
-                        error,
-                    });
+    resourceInlineThreshold;
+    internalFilesCache = new Map();
+    resourcesRegistryCache;
+    log;
+    runningRequests = new Set();
+    assetsPrefix;
+    scheduleFileLoad = async (resource, resourceInlineThreshold) => {
+        const url = getResourceUrl(resource, this.assetsPrefix);
+        const requestKey = `file${url}`;
+        const filesCache = this.getFilesCache(url);
+        const result = filesCache.get(url);
+        if (result) {
+            return result;
+        }
+        if (!this.runningRequests.has(requestKey)) {
+            this.runningRequests.add(url);
+            try {
+                const file = await externalFilesHelper.getFile(url);
+                if (file === undefined) {
+                    this.resourcesRegistryCache.disabledUrlsCache.set(url, true);
+                    return;
                 }
-                finally {
-                    this.runningRequests.delete(requestKey);
+                const size = file.length;
+                if (size < resourceInlineThreshold) {
+                    filesCache.set(url, fileProcessor.processFile(resource, file));
                 }
+                this.resourcesRegistryCache.sizeCache.set(url, size);
             }
-        };
-        this.scheduleFileSizeLoad = async (resource, resourceInlineThreshold, waitForFileLoad) => {
-            const url = getResourceUrl(resource, this.assetsPrefix);
-            const requestKey = `size${url}`;
-            const result = this.resourcesRegistryCache.sizeCache.get(url);
-            if (result) {
-                return result;
+            catch (error) {
+                this.log.warn({
+                    event: 'file-load-failed',
+                    url,
+                    error,
+                });
             }
-            if (!this.runningRequests.has(requestKey)) {
-                this.runningRequests.add(requestKey);
-                try {
-                    const contentLength = await externalFilesHelper.getFileContentLength(url);
-                    const size = isUndefined__default["default"](contentLength) ? 0 : +contentLength;
-                    if (size) {
-                        this.resourcesRegistryCache.sizeCache.set(url, size);
-                    }
-                    if (size < resourceInlineThreshold) {
-                        const promise = this.scheduleFileLoad(resource, resourceInlineThreshold);
-                        if (waitForFileLoad) {
-                            await promise;
-                        }
-                    }
-                }
-                catch (error) {
-                    // If the ASSETS_PREFIX variable does not exist,
-                    // or static files weren't deployed yet, we can't get
-                    // information about files.
-                    this.log.debug({
-                        event: 'file-content-length-load-failed',
-                        url,
-                        error,
-                    });
+            finally {
+                this.runningRequests.delete(requestKey);
+            }
+        }
+    };
+    scheduleFileSizeLoad = async (resource, resourceInlineThreshold, waitForFileLoad) => {
+        const url = getResourceUrl(resource, this.assetsPrefix);
+        const requestKey = `size${url}`;
+        const result = this.resourcesRegistryCache.sizeCache.get(url);
+        if (result) {
+            return result;
+        }
+        if (!this.runningRequests.has(requestKey)) {
+            this.runningRequests.add(requestKey);
+            try {
+                const contentLength = await externalFilesHelper.getFileContentLength(url);
+                const size = isUndefined__default["default"](contentLength) ? 0 : +contentLength;
+                if (size) {
+                    this.resourcesRegistryCache.sizeCache.set(url, size);
                 }
-                finally {
-                    this.runningRequests.delete(requestKey);
+                if (size < resourceInlineThreshold) {
+                    const promise = this.scheduleFileLoad(resource, resourceInlineThreshold);
+                    if (waitForFileLoad) {
+                        await promise;
+                    }
                 }
             }
-        };
+            catch (error) {
+                // If the ASSETS_PREFIX variable does not exist,
+                // or static files weren't deployed yet, we can't get
+                // information about files.
+                this.log.debug({
+                    event: 'file-content-length-load-failed',
+                    url,
+                    error,
+                });
+            }
+            finally {
+                this.runningRequests.delete(requestKey);
+            }
+        }
+    };
+    constructor({ resourcesRegistryCache, resourceInlineThreshold, logger, assetsPrefixFactory }) {
         this.resourcesRegistryCache = resourcesRegistryCache;
         this.resourceInlineThreshold = resourceInlineThreshold;
         this.log = logger('resources-inliner');

package/lib/resourcesRegistry/index.es.js

@@ -1,8 +1,9 @@
 import toArray from '@tinkoff/utils/array/toArray';
 
 class ResourcesRegistry {
+    resources = new Set();
+    resourceInliner;
     constructor({ resourceInliner }) {
-        this.resources = new Set();
         this.resourceInliner = resourceInliner;
     }
     register(resourceOrResources) {

package/lib/resourcesRegistry/index.js

@@ -9,8 +9,9 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var toArray__default = /*#__PURE__*/_interopDefaultLegacy(toArray);
 
 class ResourcesRegistry {
+    resources = new Set();
+    resourceInliner;
     constructor({ resourceInliner }) {
-        this.resources = new Set();
         this.resourceInliner = resourceInliner;
     }
     register(resourceOrResources) {

package/lib/server/PageBuilder.d.ts

@@ -9,14 +9,14 @@ export declare class PageBuilder {
     private reactRender;
     private htmlAttrs;
     private polyfillCondition;
-    private modern;
     private renderFlowAfter;
     private log;
     private fetchWebpackStats;
+    private inlineWebpackRuntime;
     private di;
     private renderMode;
     private assetsPrefixFactory;
-    constructor({ renderSlots, pageService, resourcesRegistry, context, reactRender, htmlPageSchema, polyfillCondition, htmlAttrs, modern, renderFlowAfter, logger, fetchWebpackStats, di, renderMode, assetsPrefixFactory, }: {
+    constructor({ renderSlots, pageService, resourcesRegistry, context, reactRender, htmlPageSchema, polyfillCondition, htmlAttrs, renderFlowAfter, logger, fetchWebpackStats, inlineWebpackRuntime, di, renderMode, assetsPrefixFactory, }: {
         renderSlots: any;
         pageService: any;
         resourcesRegistry: any;
@@ -25,10 +25,10 @@ export declare class PageBuilder {
         htmlPageSchema: any;
         polyfillCondition: any;
         htmlAttrs: any;
-        modern: any;
         renderFlowAfter: any;
         logger: any;
         fetchWebpackStats: any;
+        inlineWebpackRuntime: any;
         di: any;
         renderMode: any;
         assetsPrefixFactory: any;

package/lib/server/PageBuilder.es.js

@@ -20,7 +20,22 @@ const mapResourcesToSlots = (resources) => resources.reduce((acc, resource) => {
     return acc;
 }, {});
 class PageBuilder {
-    constructor({ renderSlots, pageService, resourcesRegistry, context, reactRender, htmlPageSchema, polyfillCondition, htmlAttrs, modern, renderFlowAfter, logger, fetchWebpackStats, di, renderMode, assetsPrefixFactory, }) {
+    resourcesRegistry;
+    pageService;
+    // eslint-disable-next-line react/static-property-placement
+    context;
+    htmlPageSchema;
+    reactRender;
+    htmlAttrs;
+    polyfillCondition;
+    renderFlowAfter;
+    log;
+    fetchWebpackStats;
+    inlineWebpackRuntime;
+    di;
+    renderMode;
+    assetsPrefixFactory;
+    constructor({ renderSlots, pageService, resourcesRegistry, context, reactRender, htmlPageSchema, polyfillCondition, htmlAttrs, renderFlowAfter, logger, fetchWebpackStats, inlineWebpackRuntime, di, renderMode, assetsPrefixFactory, }) {
         this.htmlAttrs = htmlAttrs;
         this.renderSlots = flatten(renderSlots || []);
         this.pageService = pageService;
@@ -29,16 +44,16 @@ class PageBuilder {
         this.reactRender = reactRender;
         this.htmlPageSchema = htmlPageSchema;
         this.polyfillCondition = polyfillCondition;
-        this.modern = modern;
         this.renderFlowAfter = renderFlowAfter || [];
         this.log = logger('page-builder');
         this.fetchWebpackStats = fetchWebpackStats;
+        this.inlineWebpackRuntime = inlineWebpackRuntime;
         this.di = di;
         this.renderMode = renderMode;
         this.assetsPrefixFactory = assetsPrefixFactory;
     }
     async flow() {
-        const stats = await this.fetchWebpackStats({ modern: this.modern });
+        const stats = await this.fetchWebpackStats();
         const extractor = new ChunkExtractor({ stats, entrypoints: [] });
         // first we render the application, because we need to extract information about the data used by the components
         await this.renderApp({ extractor, stats });
@@ -76,20 +91,19 @@ class PageBuilder {
         });
     }
     async fetchChunksInfo(extractor) {
-        const { modern, renderMode } = this;
+        const { renderMode } = this;
         const { bundle, pageComponent } = this.pageService.getConfig();
         this.resourcesRegistry.register(await bundleResource({
             bundle,
-            modern,
             extractor,
             pageComponent,
             fetchWebpackStats: this.fetchWebpackStats,
+            inlineWebpackRuntime: this.inlineWebpackRuntime,
             renderMode: this.renderMode,
             assetsPrefixFactory: this.assetsPrefixFactory,
         }));
         this.resourcesRegistry.register(await polyfillResources({
             condition: this.polyfillCondition,
-            modern,
             fetchWebpackStats: this.fetchWebpackStats,
             renderMode,
         }));
@@ -113,6 +127,7 @@ class PageBuilder {
             description: this.htmlPageSchema,
         });
     }
+    renderSlots;
     async renderApp({ extractor, stats }) {
         const html = await this.reactRender.render({ extractor, stats });
         const appHtmlAttrs = formatAttributes(this.htmlAttrs, 'app');

package/lib/server/PageBuilder.js

@@ -28,7 +28,22 @@ const mapResourcesToSlots = (resources) => resources.reduce((acc, resource) => {
     return acc;
 }, {});
 class PageBuilder {
-    constructor({ renderSlots, pageService, resourcesRegistry, context, reactRender, htmlPageSchema, polyfillCondition, htmlAttrs, modern, renderFlowAfter, logger, fetchWebpackStats, di, renderMode, assetsPrefixFactory, }) {
+    resourcesRegistry;
+    pageService;
+    // eslint-disable-next-line react/static-property-placement
+    context;
+    htmlPageSchema;
+    reactRender;
+    htmlAttrs;
+    polyfillCondition;
+    renderFlowAfter;
+    log;
+    fetchWebpackStats;
+    inlineWebpackRuntime;
+    di;
+    renderMode;
+    assetsPrefixFactory;
+    constructor({ renderSlots, pageService, resourcesRegistry, context, reactRender, htmlPageSchema, polyfillCondition, htmlAttrs, renderFlowAfter, logger, fetchWebpackStats, inlineWebpackRuntime, di, renderMode, assetsPrefixFactory, }) {
         this.htmlAttrs = htmlAttrs;
         this.renderSlots = flatten__default["default"](renderSlots || []);
         this.pageService = pageService;
@@ -37,16 +52,16 @@ class PageBuilder {
         this.reactRender = reactRender;
         this.htmlPageSchema = htmlPageSchema;
         this.polyfillCondition = polyfillCondition;
-        this.modern = modern;
         this.renderFlowAfter = renderFlowAfter || [];
         this.log = logger('page-builder');
         this.fetchWebpackStats = fetchWebpackStats;
+        this.inlineWebpackRuntime = inlineWebpackRuntime;
         this.di = di;
         this.renderMode = renderMode;
         this.assetsPrefixFactory = assetsPrefixFactory;
     }
     async flow() {
-        const stats = await this.fetchWebpackStats({ modern: this.modern });
+        const stats = await this.fetchWebpackStats();
         const extractor = new server.ChunkExtractor({ stats, entrypoints: [] });
         // first we render the application, because we need to extract information about the data used by the components
         await this.renderApp({ extractor, stats });
@@ -84,20 +99,19 @@ class PageBuilder {
         });
     }
     async fetchChunksInfo(extractor) {
-        const { modern, renderMode } = this;
+        const { renderMode } = this;
         const { bundle, pageComponent } = this.pageService.getConfig();
         this.resourcesRegistry.register(await bundleResource.bundleResource({
             bundle,
-            modern,
             extractor,
             pageComponent,
             fetchWebpackStats: this.fetchWebpackStats,
+            inlineWebpackRuntime: this.inlineWebpackRuntime,
             renderMode: this.renderMode,
             assetsPrefixFactory: this.assetsPrefixFactory,
         }));
         this.resourcesRegistry.register(await polyfill.polyfillResources({
             condition: this.polyfillCondition,
-            modern,
             fetchWebpackStats: this.fetchWebpackStats,
             renderMode,
         }));
@@ -121,6 +135,7 @@ class PageBuilder {
             description: this.htmlPageSchema,
         });
     }
+    renderSlots;
     async renderApp({ extractor, stats }) {
         const html = await this.reactRender.render({ extractor, stats });
         const appHtmlAttrs = utils.formatAttributes(this.htmlAttrs, 'app');

package/lib/server/ReactRenderServer.es.js

@@ -5,9 +5,13 @@ import { renderReact } from '../react/index.es.js';
 import { flushFiles } from './blocks/utils/flushFiles.es.js';
 
 class HtmlWritable extends Writable {
+    responseTaskManager;
+    responseStream;
+    extractor;
+    stats;
+    alreadySentChunks = null;
     constructor({ responseTaskManager, responseStream, extractor, stats, }) {
         super();
-        this.alreadySentChunks = null;
         this.responseTaskManager = responseTaskManager;
         this.responseStream = responseStream;
         this.extractor = extractor;
@@ -64,6 +68,16 @@ const Deferred = () => {
     return { promise, resolve, reject };
 };
 class ReactRenderServer {
+    customRender;
+    extendRender;
+    context;
+    deferredActions;
+    di;
+    log;
+    responseTaskManager;
+    responseStream;
+    streamingTimeout;
+    renderMode;
     // eslint-disable-next-line sort-class-members/sort-class-members
     constructor({ context, customRender, extendRender, di, renderMode, logger, responseTaskManager, responseStream, streamingTimeout, deferredActions, }) {
         this.context = context;

package/lib/server/ReactRenderServer.js

@@ -13,9 +13,13 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var each__default = /*#__PURE__*/_interopDefaultLegacy(each);
 
 class HtmlWritable extends stream.Writable {
+    responseTaskManager;
+    responseStream;
+    extractor;
+    stats;
+    alreadySentChunks = null;
     constructor({ responseTaskManager, responseStream, extractor, stats, }) {
         super();
-        this.alreadySentChunks = null;
         this.responseTaskManager = responseTaskManager;
         this.responseStream = responseStream;
         this.extractor = extractor;
@@ -72,6 +76,16 @@ const Deferred = () => {
     return { promise, resolve, reject };
 };
 class ReactRenderServer {
+    customRender;
+    extendRender;
+    context;
+    deferredActions;
+    di;
+    log;
+    responseTaskManager;
+    responseStream;
+    streamingTimeout;
+    renderMode;
     // eslint-disable-next-line sort-class-members/sort-class-members
     constructor({ context, customRender, extendRender, di, renderMode, logger, responseTaskManager, responseStream, streamingTimeout, deferredActions, }) {
         this.context = context;

package/lib/server/blocks/bundleResource/bundleResource.d.ts

@@ -1,12 +1,12 @@
 import type { ChunkExtractor } from '@loadable/server';
 import type { PageResource, FETCH_WEBPACK_STATS_TOKEN, REACT_SERVER_RENDER_MODE, ASSETS_PREFIX_TOKEN } from '@tramvai/tokens-render';
 import type { ExtractDependencyType } from '@tinkoff/dippy';
-export declare const bundleResource: ({ bundle, modern, extractor, pageComponent, fetchWebpackStats, renderMode, assetsPrefixFactory, }: {
+export declare const bundleResource: ({ bundle, extractor, pageComponent, fetchWebpackStats, inlineWebpackRuntime, renderMode, assetsPrefixFactory, }: {
     bundle: string;
-    modern: boolean;
     extractor: ChunkExtractor;
     pageComponent?: string;
     fetchWebpackStats: typeof FETCH_WEBPACK_STATS_TOKEN;
+    inlineWebpackRuntime: boolean;
     renderMode: typeof REACT_SERVER_RENDER_MODE | null;
     assetsPrefixFactory: ExtractDependencyType<typeof ASSETS_PREFIX_TOKEN>;
 }) => Promise<PageResource[]>;