@modern-js/app-tools 3.2.2 → 3.3.0

package/dist/cjs/builder/shared/builderPlugins/adapterSSR.js

@@ -36,18 +36,27 @@ const utils_namespaceObject = require("@modern-js/utils");
 const core_namespaceObject = require("@rsbuild/core");
 const utils_js_namespaceObject = require("../../../plugins/analyze/utils.js");
 const index_js_namespaceObject = require("../bundlerPlugins/index.js");
+const external_lazyCompilation_js_namespaceObject = require("../lazyCompilation.js");
 const builderPluginAdapterSSR = (options)=>({
         name: 'builder-plugin-adapter-modern-ssr',
         setup (api) {
-            const { normalizedConfig } = options;
-            api.modifyRsbuildConfig((config)=>(0, core_namespaceObject.mergeRsbuildConfig)(config, {
+            const { normalizedConfig, appContext, eagerRouteComponentFilesByEntry } = options;
+            api.modifyRsbuildConfig((config)=>{
+                const merged = (0, core_namespaceObject.mergeRsbuildConfig)(config, {
                     html: {
                         inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
                     },
                     server: {
                         compress: isStreamingSSR(normalizedConfig) || (0, utils_namespaceObject.isUseRsc)(normalizedConfig) ? false : void 0
                     }
-                }));
+                });
+                const lazyCompilation = getSSRLazyCompilation(merged.dev?.lazyCompilation, normalizedConfig, appContext, eagerRouteComponentFilesByEntry);
+                if (void 0 !== lazyCompilation) merged.dev = {
+                    ...merged.dev,
+                    lazyCompilation
+                };
+                return merged;
+            });
             api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
                 const builderConfig = environment.config;
                 const { normalizedConfig } = options;
@@ -83,6 +92,22 @@ const isStreamingSSR = (userConfig)=>{
     }
     return false;
 };
+function getSSRLazyCompilation(current, normalizedConfig, appContext, eagerRouteComponentFilesByEntry) {
+    if (!current || (0, utils_namespaceObject.isUseRsc)(normalizedConfig) || !isStreamingSSR(normalizedConfig)) return;
+    const plan = (0, external_lazyCompilation_js_namespaceObject.planSSRLazyCompilation)(current, (0, external_lazyCompilation_js_namespaceObject.aggregateEagerRouteComponentFiles)(eagerRouteComponentFilesByEntry));
+    if (!plan.apply) {
+        if (plan.unresolvedByEntry) warnUnresolvedRouteComponents(appContext.appDirectory, plan.unresolvedByEntry);
+        return;
+    }
+    return plan.lazyCompilation;
+}
+const warnedLazyApps = new Set();
+function warnUnresolvedRouteComponents(appDirectory, unresolvedByEntry) {
+    if (warnedLazyApps.has(appDirectory)) return;
+    warnedLazyApps.add(appDirectory);
+    const detail = Array.from(unresolvedByEntry).map(([entry, comps])=>`${entry}: ${comps.join(', ')}`).join('; ');
+    utils_namespaceObject.logger.warn(`[lazyCompilation] Skipped stream SSR route-eager optimization because some route components could not be resolved to a file (${detail}). Lazy compilation may break first-screen CSS/JS for these routes.`);
+}
 function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
     if (isStreamingSSR(modernConfig) || (0, utils_namespaceObject.isUseRsc)(modernConfig)) chain.plugin('html-async-chunk').use(index_js_namespaceObject.HtmlAsyncChunkPlugin, [
         HtmlBundlerPlugin

package/dist/cjs/builder/shared/lazyCompilation.js

@@ -0,0 +1,94 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    aggregateEagerRouteComponentFiles: ()=>aggregateEagerRouteComponentFiles,
+    buildSSRLazyCompilationTest: ()=>buildSSRLazyCompilationTest,
+    collectRouteComponentFiles: ()=>utils_namespaceObject.collectRouteComponentFiles,
+    normalizeModulePath: ()=>utils_namespaceObject.normalizeModulePath,
+    planSSRLazyCompilation: ()=>planSSRLazyCompilation
+});
+const utils_namespaceObject = require("@modern-js/utils");
+function aggregateEagerRouteComponentFiles(byEntry) {
+    const files = new Set();
+    const unresolvedByEntry = new Map();
+    if (byEntry) for (const [entryName, collection] of byEntry){
+        for (const file of collection.resolvedFiles)files.add(file);
+        if (collection.unresolvedSpecifiers.length > 0) unresolvedByEntry.set(entryName, collection.unresolvedSpecifiers);
+    }
+    return {
+        files,
+        unresolvedByEntry
+    };
+}
+function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
+    const userTestFn = 'function' == typeof userTest ? userTest : userTest instanceof RegExp ? (m)=>userTest.test(m.resource || '') : ()=>true;
+    return (m)=>{
+        const resource = m.resource;
+        if (!resource) return userTestFn(m);
+        if (eagerRouteFiles.has((0, utils_namespaceObject.normalizeModulePath)(resource))) return false;
+        return userTestFn(m);
+    };
+}
+function planSSRLazyCompilation(current, info) {
+    if (!current) return {
+        apply: false
+    };
+    if (info.unresolvedByEntry.size > 0) return {
+        apply: false,
+        unresolvedByEntry: info.unresolvedByEntry
+    };
+    if (0 === info.files.size) return {
+        apply: false
+    };
+    const base = 'object' == typeof current ? current : {};
+    const userTest = current.test;
+    return {
+        apply: true,
+        lazyCompilation: {
+            ...base,
+            test: buildSSRLazyCompilationTest(info.files, userTest)
+        }
+    };
+}
+exports.aggregateEagerRouteComponentFiles = __webpack_exports__.aggregateEagerRouteComponentFiles;
+exports.buildSSRLazyCompilationTest = __webpack_exports__.buildSSRLazyCompilationTest;
+exports.collectRouteComponentFiles = __webpack_exports__.collectRouteComponentFiles;
+exports.normalizeModulePath = __webpack_exports__.normalizeModulePath;
+exports.planSSRLazyCompilation = __webpack_exports__.planSSRLazyCompilation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "aggregateEagerRouteComponentFiles",
+    "buildSSRLazyCompilationTest",
+    "collectRouteComponentFiles",
+    "normalizeModulePath",
+    "planSSRLazyCompilation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/config/default.js

@@ -28,7 +28,8 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createDefaultConfig: ()=>createDefaultConfig
+    createDefaultConfig: ()=>createDefaultConfig,
+    isLazyCompilationSafeByDefault: ()=>isLazyCompilationSafeByDefault
 });
 const utils_namespaceObject = require("@modern-js/utils");
 const env_js_namespaceObject = require("../utils/env.js");
@@ -120,9 +121,24 @@ function createDefaultConfig(appContext) {
         builderPlugins: []
     };
 }
+const isStreamSSRConfig = (ssr)=>{
+    if (!ssr) return false;
+    if ('boolean' == typeof ssr) return ssr;
+    return 'string' !== ssr.mode;
+};
+function isLazyCompilationSafeByDefault(userConfig) {
+    const { server, output } = userConfig;
+    if (output?.ssg || output?.ssgByEntries && Object.keys(output.ssgByEntries).length > 0) return false;
+    if (server?.rsc) return false;
+    if (server?.ssr && !isStreamSSRConfig(server.ssr)) return false;
+    if (server?.ssrByEntries && 'object' == typeof server.ssrByEntries && Object.values(server.ssrByEntries).some((ssr)=>Boolean(ssr) && !isStreamSSRConfig(ssr))) return false;
+    return true;
+}
 exports.createDefaultConfig = __webpack_exports__.createDefaultConfig;
+exports.isLazyCompilationSafeByDefault = __webpack_exports__.isLazyCompilationSafeByDefault;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createDefaultConfig"
+    "createDefaultConfig",
+    "isLazyCompilationSafeByDefault"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/plugins/analyze/index.js

@@ -154,10 +154,12 @@ const analyze = ()=>({
                         entrypoints
                     });
                     const normalizedConfig = api.getNormalizedConfig();
+                    const { eagerRouteComponentFilesByEntry } = api.getAppContext();
                     const createBuilderForModern = await (0, index_js_namespaceObject.createBuilderGenerator)();
                     const builder = await createBuilderForModern({
                         normalizedConfig: normalizedConfig,
-                        appContext: appContext
+                        appContext: appContext,
+                        eagerRouteComponentFilesByEntry
                     });
                     builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch })=>{
                         if (!isFirstCompile) return;

package/dist/cjs/plugins/initialize/index.js

@@ -43,7 +43,16 @@ const initialize = ()=>({
         setup (api) {
             api.config(()=>{
                 const appContext = api.getAppContext();
-                return (0, index_js_namespaceObject.createDefaultConfig)(appContext);
+                const userConfig = api.getConfig();
+                const defaultConfig = (0, index_js_namespaceObject.createDefaultConfig)(appContext);
+                if (userConfig.dev?.lazyCompilation === void 0 && (0, index_js_namespaceObject.isLazyCompilationSafeByDefault)(userConfig)) defaultConfig.dev = {
+                    ...defaultConfig.dev,
+                    lazyCompilation: {
+                        imports: true,
+                        entries: false
+                    }
+                };
+                return defaultConfig;
             });
             api.modifyResolvedConfig(async (resolved)=>{
                 let appContext = api.getAppContext();

package/dist/esm/builder/shared/builderPlugins/adapterSSR.mjs

@@ -1,21 +1,30 @@
 import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/builder";
-import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+import { fs, isUseRsc, isUseSSRBundle, logger } from "@modern-js/utils";
 import { mergeRsbuildConfig } from "@rsbuild/core";
 import { getServerCombinedModuleFile } from "../../../plugins/analyze/utils.mjs";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import { aggregateEagerRouteComponentFiles, planSSRLazyCompilation } from "../lazyCompilation.mjs";
 import * as __rspack_external_path from "path";
 const builderPluginAdapterSSR = (options)=>({
         name: 'builder-plugin-adapter-modern-ssr',
         setup (api) {
-            const { normalizedConfig } = options;
-            api.modifyRsbuildConfig((config)=>mergeRsbuildConfig(config, {
+            const { normalizedConfig, appContext, eagerRouteComponentFilesByEntry } = options;
+            api.modifyRsbuildConfig((config)=>{
+                const merged = mergeRsbuildConfig(config, {
                     html: {
                         inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
                     },
                     server: {
                         compress: isStreamingSSR(normalizedConfig) || isUseRsc(normalizedConfig) ? false : void 0
                     }
-                }));
+                });
+                const lazyCompilation = getSSRLazyCompilation(merged.dev?.lazyCompilation, normalizedConfig, appContext, eagerRouteComponentFilesByEntry);
+                if (void 0 !== lazyCompilation) merged.dev = {
+                    ...merged.dev,
+                    lazyCompilation
+                };
+                return merged;
+            });
             api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
                 const builderConfig = environment.config;
                 const { normalizedConfig } = options;
@@ -51,6 +60,22 @@ const isStreamingSSR = (userConfig)=>{
     }
     return false;
 };
+function getSSRLazyCompilation(current, normalizedConfig, appContext, eagerRouteComponentFilesByEntry) {
+    if (!current || isUseRsc(normalizedConfig) || !isStreamingSSR(normalizedConfig)) return;
+    const plan = planSSRLazyCompilation(current, aggregateEagerRouteComponentFiles(eagerRouteComponentFilesByEntry));
+    if (!plan.apply) {
+        if (plan.unresolvedByEntry) warnUnresolvedRouteComponents(appContext.appDirectory, plan.unresolvedByEntry);
+        return;
+    }
+    return plan.lazyCompilation;
+}
+const warnedLazyApps = new Set();
+function warnUnresolvedRouteComponents(appDirectory, unresolvedByEntry) {
+    if (warnedLazyApps.has(appDirectory)) return;
+    warnedLazyApps.add(appDirectory);
+    const detail = Array.from(unresolvedByEntry).map(([entry, comps])=>`${entry}: ${comps.join(', ')}`).join('; ');
+    logger.warn(`[lazyCompilation] Skipped stream SSR route-eager optimization because some route components could not be resolved to a file (${detail}). Lazy compilation may break first-screen CSS/JS for these routes.`);
+}
 function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
     if (isStreamingSSR(modernConfig) || isUseRsc(modernConfig)) chain.plugin('html-async-chunk').use(HtmlAsyncChunkPlugin, [
         HtmlBundlerPlugin

package/dist/esm/builder/shared/lazyCompilation.mjs

@@ -0,0 +1,44 @@
+import { collectRouteComponentFiles, normalizeModulePath } from "@modern-js/utils";
+function aggregateEagerRouteComponentFiles(byEntry) {
+    const files = new Set();
+    const unresolvedByEntry = new Map();
+    if (byEntry) for (const [entryName, collection] of byEntry){
+        for (const file of collection.resolvedFiles)files.add(file);
+        if (collection.unresolvedSpecifiers.length > 0) unresolvedByEntry.set(entryName, collection.unresolvedSpecifiers);
+    }
+    return {
+        files,
+        unresolvedByEntry
+    };
+}
+function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
+    const userTestFn = 'function' == typeof userTest ? userTest : userTest instanceof RegExp ? (m)=>userTest.test(m.resource || '') : ()=>true;
+    return (m)=>{
+        const resource = m.resource;
+        if (!resource) return userTestFn(m);
+        if (eagerRouteFiles.has(normalizeModulePath(resource))) return false;
+        return userTestFn(m);
+    };
+}
+function planSSRLazyCompilation(current, info) {
+    if (!current) return {
+        apply: false
+    };
+    if (info.unresolvedByEntry.size > 0) return {
+        apply: false,
+        unresolvedByEntry: info.unresolvedByEntry
+    };
+    if (0 === info.files.size) return {
+        apply: false
+    };
+    const base = 'object' == typeof current ? current : {};
+    const userTest = current.test;
+    return {
+        apply: true,
+        lazyCompilation: {
+            ...base,
+            test: buildSSRLazyCompilationTest(info.files, userTest)
+        }
+    };
+}
+export { aggregateEagerRouteComponentFiles, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };

package/dist/esm/config/default.mjs

@@ -88,4 +88,17 @@ function createDefaultConfig(appContext) {
         builderPlugins: []
     };
 }
-export { createDefaultConfig };
+const isStreamSSRConfig = (ssr)=>{
+    if (!ssr) return false;
+    if ('boolean' == typeof ssr) return ssr;
+    return 'string' !== ssr.mode;
+};
+function isLazyCompilationSafeByDefault(userConfig) {
+    const { server, output } = userConfig;
+    if (output?.ssg || output?.ssgByEntries && Object.keys(output.ssgByEntries).length > 0) return false;
+    if (server?.rsc) return false;
+    if (server?.ssr && !isStreamSSRConfig(server.ssr)) return false;
+    if (server?.ssrByEntries && 'object' == typeof server.ssrByEntries && Object.values(server.ssrByEntries).some((ssr)=>Boolean(ssr) && !isStreamSSRConfig(ssr))) return false;
+    return true;
+}
+export { createDefaultConfig, isLazyCompilationSafeByDefault };

package/dist/esm/plugins/analyze/index.mjs

@@ -122,10 +122,12 @@ const analyze = ()=>({
                         entrypoints
                     });
                     const normalizedConfig = api.getNormalizedConfig();
+                    const { eagerRouteComponentFilesByEntry } = api.getAppContext();
                     const createBuilderForModern = await createBuilderGenerator();
                     const builder = await createBuilderForModern({
                         normalizedConfig: normalizedConfig,
-                        appContext: appContext
+                        appContext: appContext,
+                        eagerRouteComponentFilesByEntry
                     });
                     builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch })=>{
                         if (!isFirstCompile) return;

package/dist/esm/plugins/initialize/index.mjs

@@ -1,5 +1,5 @@
 import { ensureAbsolutePath, getPort, isDev, isDevCommand } from "@modern-js/utils";
-import { createDefaultConfig } from "../../config/index.mjs";
+import { createDefaultConfig, isLazyCompilationSafeByDefault } from "../../config/index.mjs";
 const initialize = ()=>({
         name: '@modern-js/plugin-initialize',
         post: [
@@ -11,7 +11,16 @@ const initialize = ()=>({
         setup (api) {
             api.config(()=>{
                 const appContext = api.getAppContext();
-                return createDefaultConfig(appContext);
+                const userConfig = api.getConfig();
+                const defaultConfig = createDefaultConfig(appContext);
+                if (userConfig.dev?.lazyCompilation === void 0 && isLazyCompilationSafeByDefault(userConfig)) defaultConfig.dev = {
+                    ...defaultConfig.dev,
+                    lazyCompilation: {
+                        imports: true,
+                        entries: false
+                    }
+                };
+                return defaultConfig;
             });
             api.modifyResolvedConfig(async (resolved)=>{
                 let appContext = api.getAppContext();

package/dist/esm-node/builder/shared/builderPlugins/adapterSSR.mjs

@@ -1,23 +1,32 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
 import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/builder";
-import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+import { fs, isUseRsc, isUseSSRBundle, logger } from "@modern-js/utils";
 import { mergeRsbuildConfig } from "@rsbuild/core";
 import { getServerCombinedModuleFile } from "../../../plugins/analyze/utils.mjs";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import { aggregateEagerRouteComponentFiles, planSSRLazyCompilation } from "../lazyCompilation.mjs";
 import * as __rspack_external_path from "path";
 const builderPluginAdapterSSR = (options)=>({
         name: 'builder-plugin-adapter-modern-ssr',
         setup (api) {
-            const { normalizedConfig } = options;
-            api.modifyRsbuildConfig((config)=>mergeRsbuildConfig(config, {
+            const { normalizedConfig, appContext, eagerRouteComponentFilesByEntry } = options;
+            api.modifyRsbuildConfig((config)=>{
+                const merged = mergeRsbuildConfig(config, {
                     html: {
                         inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
                     },
                     server: {
                         compress: isStreamingSSR(normalizedConfig) || isUseRsc(normalizedConfig) ? false : void 0
                     }
-                }));
+                });
+                const lazyCompilation = getSSRLazyCompilation(merged.dev?.lazyCompilation, normalizedConfig, appContext, eagerRouteComponentFilesByEntry);
+                if (void 0 !== lazyCompilation) merged.dev = {
+                    ...merged.dev,
+                    lazyCompilation
+                };
+                return merged;
+            });
             api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
                 const builderConfig = environment.config;
                 const { normalizedConfig } = options;
@@ -53,6 +62,22 @@ const isStreamingSSR = (userConfig)=>{
     }
     return false;
 };
+function getSSRLazyCompilation(current, normalizedConfig, appContext, eagerRouteComponentFilesByEntry) {
+    if (!current || isUseRsc(normalizedConfig) || !isStreamingSSR(normalizedConfig)) return;
+    const plan = planSSRLazyCompilation(current, aggregateEagerRouteComponentFiles(eagerRouteComponentFilesByEntry));
+    if (!plan.apply) {
+        if (plan.unresolvedByEntry) warnUnresolvedRouteComponents(appContext.appDirectory, plan.unresolvedByEntry);
+        return;
+    }
+    return plan.lazyCompilation;
+}
+const warnedLazyApps = new Set();
+function warnUnresolvedRouteComponents(appDirectory, unresolvedByEntry) {
+    if (warnedLazyApps.has(appDirectory)) return;
+    warnedLazyApps.add(appDirectory);
+    const detail = Array.from(unresolvedByEntry).map(([entry, comps])=>`${entry}: ${comps.join(', ')}`).join('; ');
+    logger.warn(`[lazyCompilation] Skipped stream SSR route-eager optimization because some route components could not be resolved to a file (${detail}). Lazy compilation may break first-screen CSS/JS for these routes.`);
+}
 function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
     if (isStreamingSSR(modernConfig) || isUseRsc(modernConfig)) chain.plugin('html-async-chunk').use(HtmlAsyncChunkPlugin, [
         HtmlBundlerPlugin

package/dist/esm-node/builder/shared/lazyCompilation.mjs

@@ -0,0 +1,45 @@
+import "node:module";
+import { collectRouteComponentFiles, normalizeModulePath } from "@modern-js/utils";
+function aggregateEagerRouteComponentFiles(byEntry) {
+    const files = new Set();
+    const unresolvedByEntry = new Map();
+    if (byEntry) for (const [entryName, collection] of byEntry){
+        for (const file of collection.resolvedFiles)files.add(file);
+        if (collection.unresolvedSpecifiers.length > 0) unresolvedByEntry.set(entryName, collection.unresolvedSpecifiers);
+    }
+    return {
+        files,
+        unresolvedByEntry
+    };
+}
+function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
+    const userTestFn = 'function' == typeof userTest ? userTest : userTest instanceof RegExp ? (m)=>userTest.test(m.resource || '') : ()=>true;
+    return (m)=>{
+        const resource = m.resource;
+        if (!resource) return userTestFn(m);
+        if (eagerRouteFiles.has(normalizeModulePath(resource))) return false;
+        return userTestFn(m);
+    };
+}
+function planSSRLazyCompilation(current, info) {
+    if (!current) return {
+        apply: false
+    };
+    if (info.unresolvedByEntry.size > 0) return {
+        apply: false,
+        unresolvedByEntry: info.unresolvedByEntry
+    };
+    if (0 === info.files.size) return {
+        apply: false
+    };
+    const base = 'object' == typeof current ? current : {};
+    const userTest = current.test;
+    return {
+        apply: true,
+        lazyCompilation: {
+            ...base,
+            test: buildSSRLazyCompilationTest(info.files, userTest)
+        }
+    };
+}
+export { aggregateEagerRouteComponentFiles, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };

package/dist/esm-node/config/default.mjs

@@ -89,4 +89,17 @@ function createDefaultConfig(appContext) {
         builderPlugins: []
     };
 }
-export { createDefaultConfig };
+const isStreamSSRConfig = (ssr)=>{
+    if (!ssr) return false;
+    if ('boolean' == typeof ssr) return ssr;
+    return 'string' !== ssr.mode;
+};
+function isLazyCompilationSafeByDefault(userConfig) {
+    const { server, output } = userConfig;
+    if (output?.ssg || output?.ssgByEntries && Object.keys(output.ssgByEntries).length > 0) return false;
+    if (server?.rsc) return false;
+    if (server?.ssr && !isStreamSSRConfig(server.ssr)) return false;
+    if (server?.ssrByEntries && 'object' == typeof server.ssrByEntries && Object.values(server.ssrByEntries).some((ssr)=>Boolean(ssr) && !isStreamSSRConfig(ssr))) return false;
+    return true;
+}
+export { createDefaultConfig, isLazyCompilationSafeByDefault };

package/dist/esm-node/plugins/analyze/index.mjs

@@ -123,10 +123,12 @@ const analyze = ()=>({
                         entrypoints
                     });
                     const normalizedConfig = api.getNormalizedConfig();
+                    const { eagerRouteComponentFilesByEntry } = api.getAppContext();
                     const createBuilderForModern = await createBuilderGenerator();
                     const builder = await createBuilderForModern({
                         normalizedConfig: normalizedConfig,
-                        appContext: appContext
+                        appContext: appContext,
+                        eagerRouteComponentFilesByEntry
                     });
                     builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch })=>{
                         if (!isFirstCompile) return;

package/dist/esm-node/plugins/initialize/index.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { ensureAbsolutePath, getPort, isDev, isDevCommand } from "@modern-js/utils";
-import { createDefaultConfig } from "../../config/index.mjs";
+import { createDefaultConfig, isLazyCompilationSafeByDefault } from "../../config/index.mjs";
 const initialize = ()=>({
         name: '@modern-js/plugin-initialize',
         post: [
@@ -12,7 +12,16 @@ const initialize = ()=>({
         setup (api) {
             api.config(()=>{
                 const appContext = api.getAppContext();
-                return createDefaultConfig(appContext);
+                const userConfig = api.getConfig();
+                const defaultConfig = createDefaultConfig(appContext);
+                if (userConfig.dev?.lazyCompilation === void 0 && isLazyCompilationSafeByDefault(userConfig)) defaultConfig.dev = {
+                    ...defaultConfig.dev,
+                    lazyCompilation: {
+                        imports: true,
+                        entries: false
+                    }
+                };
+                return defaultConfig;
             });
             api.modifyResolvedConfig(async (resolved)=>{
                 let appContext = api.getAppContext();

package/dist/types/builder/shared/lazyCompilation.d.ts

@@ -0,0 +1,43 @@
+import { type EagerRouteComponentFilesByEntry } from '@modern-js/utils';
+export { type EagerRouteComponentFilesByEntry, type RouteComponentFileCollection, collectRouteComponentFiles, normalizeModulePath, } from '@modern-js/utils';
+type ModuleLike = {
+    resource?: string;
+};
+type LazyCompilationTestFn = (m: ModuleLike) => boolean;
+/** Matches Rspack's `LazyCompilationOptions['test']`. */
+type LazyCompilationTest = RegExp | LazyCompilationTestFn | undefined;
+export type EagerRouteComponentInfo = {
+    files: Set<string>;
+    /** Specifiers that could not be resolved, keyed by entry name. */
+    unresolvedByEntry: Map<string, string[]>;
+};
+/**
+ * Aggregate the per-entry route component data (collected by the router plugin
+ * during route generation and threaded in as
+ * `BuilderOptions.eagerRouteComponentFilesByEntry`) into the flat shape
+ * {@link planSSRLazyCompilation} expects: one Set of all route files plus the
+ * unresolved specifiers keyed by entry.
+ */
+export declare function aggregateEagerRouteComponentFiles(byEntry: EagerRouteComponentFilesByEntry | undefined): EagerRouteComponentInfo;
+/**
+ * Build a `lazyCompilation.test` that forces route component modules to compile
+ * eagerly (so SSR first-screen chunk/CSS injection has the assets it needs at
+ * render time), while delegating all other modules to the user's `test`
+ * (defaulting to lazy when the user did not provide one).
+ */
+export declare function buildSSRLazyCompilationTest(eagerRouteFiles: Set<string>, userTest?: LazyCompilationTest): LazyCompilationTestFn;
+export type SSRLazyPlan = {
+    apply: false;
+    unresolvedByEntry?: Map<string, string[]>;
+} | {
+    apply: true;
+    lazyCompilation: Record<string, unknown>;
+};
+/**
+ * Decide whether to apply the route-eager lazy compilation for an SSR project.
+ * Checks unresolved route components FIRST: if any exist we cannot guarantee
+ * they are eager, so we skip the optimization (and surface them so the caller
+ * can warn) rather than silently leaving a route lazy. `current` is the
+ * existing `dev.lazyCompilation` value (lazy must be enabled for this to apply).
+ */
+export declare function planSSRLazyCompilation(current: unknown, info: EagerRouteComponentInfo): SSRLazyPlan;

package/dist/types/builder/shared/types.d.ts

@@ -1,6 +1,16 @@
+import type { EagerRouteComponentFilesByEntry } from '@modern-js/utils';
 import type { AppNormalizedConfig } from '../../types';
 import type { AppToolsContext } from '../../types/plugin';
 export type BuilderOptions = {
     normalizedConfig: AppNormalizedConfig;
     appContext: AppToolsContext;
+    /**
+     * Route component files collected from the FINAL file-system routes (after
+     * all `modifyFileSystemRoutes` consumers ran), keyed by entry name. Populated
+     * by the router plugin during route generation and threaded in here (read
+     * FRESH from the app context AFTER `generateEntryCode` runs) so the SSR
+     * builder plugin can force route component chunks eager under lazy
+     * compilation. Explicit param instead of a direct `_internalContext` read.
+     */
+    eagerRouteComponentFilesByEntry?: EagerRouteComponentFilesByEntry;
 };

package/dist/types/config/default.d.ts

@@ -1,3 +1,9 @@
 import type { AppUserConfig } from '../types';
 import type { AppToolsContext } from '../types/plugin';
 export declare function createDefaultConfig(appContext: AppToolsContext): AppUserConfig;
+/**
+ * Default-enable lazy compilation for pure CSR and stream SSR. Stream SSR keeps
+ * first-screen route assets correct via the route-eager lazyCompilation.test
+ * injected by the SSR builder plugin. String SSR, RSC and SSG stay disabled.
+ */
+export declare function isLazyCompilationSafeByDefault(userConfig: Pick<AppUserConfig, 'server' | 'output'>): boolean;

package/dist/types/types/plugin.d.ts

@@ -1,6 +1,7 @@
 import type { AppContext, AsyncHook, InternalContext, PluginHook, PluginHookTap, TransformFunction } from '@modern-js/plugin';
 import type { Hooks } from '@modern-js/plugin/cli';
 import type { Entrypoint, HtmlPartials, HtmlTemplates, NestedRouteForCli, PageRoute, RouteLegacy, ServerPlugin, ServerRoute } from '@modern-js/types';
+import type { EagerRouteComponentFilesByEntry } from '@modern-js/utils';
 import type { AppTools } from '.';
 import type { getHookRunners } from '../compat/hooks';
 import type { AppToolsNormalizedConfig, AppToolsUserConfig } from './config';
@@ -109,6 +110,19 @@ export interface AppToolsExtendContext {
      * @private
      */
     bffRuntimeFramework?: string;
+    /**
+     * Route component files collected from the FINAL file-system routes (after all
+     * `modifyFileSystemRoutes` consumers ran), keyed by entry name. Populated by
+     * the router plugin during route generation and consumed (currently by stream
+     * SSR lazy compilation) to force route component chunks eager.
+     *
+     * Published via the app context (`api.updateAppContext`) by the router plugin,
+     * then read fresh when assembling the builder options and threaded into
+     * `BuilderOptions.eagerRouteComponentFilesByEntry`; the SSR builder plugin
+     * reads it from those options (not from the context directly).
+     * @private
+     */
+    eagerRouteComponentFilesByEntry?: EagerRouteComponentFilesByEntry;
 }
 export type AppToolsContext = AppContext<AppTools> & AppToolsExtendContext;
 export type AppToolsHooks = Hooks<AppToolsUserConfig, AppToolsNormalizedConfig, {}, {}> & AppToolsExtendHooks;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.2.2",
+  "version": "3.3.0",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -84,7 +84,7 @@
     "@babel/traverse": "^7.29.7",
     "@babel/types": "^7.29.7",
     "@rsbuild/core": "2.0.10",
-    "@swc/core": "1.15.33",
+    "@swc/core": "1.15.40",
     "@swc/helpers": "^0.5.17",
     "es-module-lexer": "^1.7.0",
     "flatted": "^3.4.2",
@@ -93,19 +93,19 @@
     "ndepe": "^0.1.13",
     "pkg-types": "^1.3.1",
     "std-env": "^3.10.0",
-    "@modern-js/builder": "3.2.2",
-    "@modern-js/i18n-utils": "3.2.2",
-    "@modern-js/plugin-data-loader": "3.2.2",
-    "@modern-js/prod-server": "3.2.2",
-    "@modern-js/server": "3.2.2",
-    "@modern-js/plugin": "3.2.2",
-    "@modern-js/server-core": "3.2.2",
-    "@modern-js/types": "3.2.2",
-    "@modern-js/server-utils": "3.2.2",
-    "@modern-js/utils": "3.2.2"
+    "@modern-js/i18n-utils": "3.3.0",
+    "@modern-js/plugin": "3.3.0",
+    "@modern-js/builder": "3.3.0",
+    "@modern-js/plugin-data-loader": "3.3.0",
+    "@modern-js/prod-server": "3.3.0",
+    "@modern-js/server": "3.3.0",
+    "@modern-js/server-core": "3.3.0",
+    "@modern-js/server-utils": "3.3.0",
+    "@modern-js/types": "3.3.0",
+    "@modern-js/utils": "3.3.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.21.5",
+    "@rslib/core": "0.22.0",
     "@types/babel__traverse": "7.28.0",
     "@types/node": "^20",
     "ts-node": "^10.9.2",