@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

package/dist/esm/presetUltramodern.mjs

@@ -1,4 +1,78 @@
-import { createAppBaselineConfig, withAppBaseline } from "./baseline.mjs";
-const createPresetUltramodernConfig = (options = {})=>createAppBaselineConfig(options);
-const presetUltramodern = (config, options = {})=>withAppBaseline(config, options);
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { mergeConfig } from "@modern-js/plugin/cli";
+const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
+const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
+const resolveReactRouterPackageDir = (appDirectory)=>{
+    const resolveNodeModulePackageJson = (packageName, fromDirectory)=>{
+        let currentDirectory = node_path.resolve(fromDirectory);
+        while(true){
+            const packageJson = node_path.join(currentDirectory, 'node_modules', packageName, 'package.json');
+            if (node_fs.existsSync(packageJson)) return node_fs.realpathSync(packageJson);
+            const parentDirectory = node_path.dirname(currentDirectory);
+            if (parentDirectory === currentDirectory) return;
+            currentDirectory = parentDirectory;
+        }
+    };
+    const reactRouterPackageJson = resolveNodeModulePackageJson('react-router', appDirectory);
+    if (reactRouterPackageJson) return node_path.dirname(reactRouterPackageJson);
+    const reactRouterDomPackageJson = resolveNodeModulePackageJson('react-router-dom', appDirectory);
+    if (!reactRouterDomPackageJson) return;
+    const nestedReactRouterPackageJson = resolveNodeModulePackageJson('react-router', node_path.dirname(reactRouterDomPackageJson));
+    if (nestedReactRouterPackageJson) return node_path.dirname(nestedReactRouterPackageJson);
+};
+const setReactRouterBridgeSafeAliases = (chain, { isProd })=>{
+    const chainContext = chain.get('context');
+    const appDirectory = 'string' == typeof chainContext && chainContext.length > 0 ? chainContext : process.cwd();
+    const reactRouterPackageDir = resolveReactRouterPackageDir(appDirectory);
+    if (!reactRouterPackageDir) return;
+    const productionEntry = node_path.join(reactRouterPackageDir, 'dist/production/index.mjs');
+    const developmentEntry = node_path.join(reactRouterPackageDir, 'dist/development/index.mjs');
+    chain.resolve.alias.set('react-router$', isProd ? productionEntry : developmentEntry);
+    chain.resolve.alias.set('react-router/dist/production/index.js', productionEntry);
+    chain.resolve.alias.set('react-router/dist/development/index.js', developmentEntry);
+};
+const createPresetUltramodernConfig = (options = {})=>{
+    const { appId = 'app', enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT, victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT, telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
+    const server = {};
+    if (enableTelemetry) {
+        server.telemetry = {
+            enabled: true,
+            failLoudStartup: telemetryFailLoudStartup
+        };
+        if (false !== enableTelemetryExporters) {
+            const exporters = {};
+            if (true === enableTelemetryExporters || otlpEndpoint) exporters.otlp = {
+                enabled: true,
+                endpoint: otlpEndpoint || DEFAULT_OTLP_ENDPOINT
+            };
+            if (true === enableTelemetryExporters || victoriaMetricsEndpoint) exporters.victoriaMetrics = {
+                enabled: true,
+                endpoint: victoriaMetricsEndpoint || DEFAULT_VICTORIA_METRICS_ENDPOINT
+            };
+            if (Object.keys(exporters).length > 0) server.telemetry.exporters = exporters;
+        }
+    }
+    if (enableModuleFederationSSR) server.ssr = {
+        mode: 'stream',
+        moduleFederationAppSSR: true
+    };
+    const presetConfig = {
+        output: {
+            precompress: true
+        },
+        server,
+        tools: {
+            bundlerChain: setReactRouterBridgeSafeAliases
+        }
+    };
+    if (enableBffRequestId) presetConfig.bff = {
+        requestId: appId
+    };
+    return presetConfig;
+};
+const presetUltramodern = (config, options = {})=>mergeConfig([
+        createPresetUltramodernConfig(options),
+        config
+    ]);
 export { createPresetUltramodernConfig, presetUltramodern };

package/dist/esm/rsbuild.mjs

@@ -1,18 +1,11 @@
 import { parseRspackConfig } from "@modern-js/builder";
+import { createConfigOptions } from "@modern-js/plugin/cli";
 import { INTERNAL_RUNTIME_PLUGINS } from "@modern-js/utils";
 import { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./builder/shared/builderPlugins/index.mjs";
 import { DEFAULT_CONFIG_FILE } from "./constants.mjs";
 import { getConfigFile } from "./utils/getConfigFile.mjs";
 import { loadInternalPlugins } from "./utils/loadPlugins.mjs";
-import { __webpack_require__ } from "./rslib-runtime.mjs";
-import * as __rspack_external__modern_js_plugin_cli_caa09fa2 from "@modern-js/plugin/cli";
-__webpack_require__.add({
-    "@modern-js/plugin/cli?8936" (module) {
-        module.exports = __rspack_external__modern_js_plugin_cli_caa09fa2;
-    }
-});
 const MODERN_META_NAME = 'modern-js';
-const { createConfigOptions: createConfigOptions } = __webpack_require__("@modern-js/plugin/cli?8936");
 async function resolveModernRsbuildConfig(options) {
     const { cwd = process.cwd(), metaName = MODERN_META_NAME } = options;
     const configFile = options.configPath || getConfigFile(void 0, cwd);

package/dist/esm-node/baseline.mjs

@@ -1,79 +1,5 @@
 import "node:module";
-import { createRequire } from "node:module";
-import node_path from "node:path";
-import { mergeConfig } from "@modern-js/plugin/cli";
-const resolveReactRouterPackageDir = ()=>{
-    const localRequire = createRequire(node_path.join(process.cwd(), 'package.json'));
-    try {
-        const reactRouterDomPackageJson = localRequire.resolve('react-router-dom/package.json', {
-            paths: [
-                process.cwd()
-            ]
-        });
-        const reactRouterPackageJson = localRequire.resolve('react-router/package.json', {
-            paths: [
-                node_path.dirname(reactRouterDomPackageJson)
-            ]
-        });
-        return node_path.dirname(reactRouterPackageJson);
-    } catch  {
-        return;
-    }
-};
-const setReactRouterBridgeSafeAliases = (chain)=>{
-    const reactRouterPackageDir = resolveReactRouterPackageDir();
-    if (!reactRouterPackageDir) return;
-    const productionEntry = node_path.join(reactRouterPackageDir, 'dist/production/index.mjs');
-    const developmentEntry = node_path.join(reactRouterPackageDir, 'dist/development/index.mjs');
-    chain.resolve.alias.set('react-router$', productionEntry);
-    chain.resolve.alias.set('react-router/dist/production/index.js', productionEntry);
-    chain.resolve.alias.set('react-router/dist/development/index.js', developmentEntry);
-};
-const createAppBaselineConfig = (options = {})=>{
-    const { appId = 'app', enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters = true, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT || 'http://127.0.0.1:4318/v1/logs', victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT || 'http://127.0.0.1:8428/api/v1/import/prometheus', telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
-    const server = {};
-    if (enableTelemetry) {
-        server.telemetry = {
-            enabled: true,
-            failLoudStartup: telemetryFailLoudStartup
-        };
-        if (enableTelemetryExporters) server.telemetry.exporters = {
-            otlp: {
-                enabled: true,
-                endpoint: otlpEndpoint
-            },
-            victoriaMetrics: {
-                enabled: true,
-                endpoint: victoriaMetricsEndpoint
-            }
-        };
-    }
-    if (enableModuleFederationSSR) server.ssr = {
-        mode: 'stream',
-        moduleFederationAppSSR: true
-    };
-    const baselineConfig = {
-        output: {
-            precompress: true
-        },
-        performance: {
-            rsdoctor: {
-                enabled: 'production' === process.env.NODE_ENV,
-                disableClientServer: true
-            }
-        },
-        server,
-        tools: {
-            bundlerChain: setReactRouterBridgeSafeAliases
-        }
-    };
-    if (enableBffRequestId) baselineConfig.bff = {
-        requestId: appId
-    };
-    return baselineConfig;
-};
-const withAppBaseline = (config, options = {})=>mergeConfig([
-        createAppBaselineConfig(options),
-        config
-    ]);
+import { createPresetUltramodernConfig, presetUltramodern } from "./presetUltramodern.mjs";
+const createAppBaselineConfig = createPresetUltramodernConfig;
+const withAppBaseline = presetUltramodern;
 export { createAppBaselineConfig, withAppBaseline };

package/dist/esm-node/builder/generator/getBuilderEnvironments.mjs

@@ -17,6 +17,20 @@ const JS_OR_TS_EXTS = [
     '.mjs',
     '.cjs'
 ];
+const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+    'async_hooks',
+    'buffer',
+    'crypto',
+    'events',
+    'fs/promises',
+    'module',
+    'path',
+    'process',
+    'stream',
+    'string_decoder',
+    'url',
+    'util'
+];
 const CLOUDFLARE_WORKER_COMPAT_TEMPLATE_DIR = node_path.resolve(getBuilderEnvironments_dirname, '../../plugins/deploy/platforms/templates');
 function findExistingFile(candidates) {
     return candidates.find((candidate)=>node_fs.existsSync(candidate));
@@ -60,6 +74,21 @@ function setAliasIfPresent(alias, name, value) {
 function getCloudflareWorkerCompatFile(file) {
     return node_path.join(CLOUDFLARE_WORKER_COMPAT_TEMPLATE_DIR, file);
 }
+function getCloudflareWorkerNodeExternals() {
+    return Object.fromEntries(CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap((builtin)=>{
+        const nodeBuiltin = `node:${builtin}`;
+        return [
+            [
+                builtin,
+                `module-import ${nodeBuiltin}`
+            ],
+            [
+                nodeBuiltin,
+                `module-import ${nodeBuiltin}`
+            ]
+        ];
+    }));
+}
 function getEffectBffEntry(normalizedConfig, appContext) {
     if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
     const configuredEntry = normalizedConfig.bff.effect?.entry;
@@ -181,12 +210,13 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
                         chain.merge({
                             experiments: {
                                 outputModule: true
-                            }
+                            },
+                            externals: getCloudflareWorkerNodeExternals(),
+                            externalsType: 'module-import'
                         });
                         chain.output.module(true).library({
                             type: 'module'
                         }).chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
-                        chain.target('webworker');
                         chain.plugins.delete('plugin-module-federation');
                         if (tanstackRouterSsrServerFile) {
                             chain.resolve.alias.set('@tanstack/router-core/ssr/server$', tanstackRouterSsrServerFile);
@@ -216,8 +246,6 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
                         chain.resolve.alias.set('react-server-dom-rspack/server.node', 'react-server-dom-rspack/server.edge');
                         chain.resolve.alias.set('react-server-dom-rspack/client.node$', 'react-server-dom-rspack/client.edge');
                         chain.resolve.alias.set('react-server-dom-rspack/client.node', 'react-server-dom-rspack/client.edge');
-                        chain.resolve.fallback.set('async_hooks', false);
-                        chain.resolve.fallback.set('node:async_hooks', false);
                         chain.resolve.fallback.set('fs', false);
                         chain.resolve.fallback.set('node:fs', false);
                     }

package/dist/esm-node/builder/generator/index.mjs

@@ -17,6 +17,13 @@ async function generateBuilder(options, bundlerType) {
         else mergedEnvironments[name] = builderConfig.environments[name];
         builderConfig.environments = mergedEnvironments;
     } else builderConfig.environments = environments;
+    const hooks = appContext._internalContext.pluginAPI?.getHooks();
+    if (hooks?.modifyBuilderEnvironments) {
+        const { environments: modifiedEnvironments } = await hooks.modifyBuilderEnvironments.call({
+            environments: builderConfig.environments
+        });
+        builderConfig.environments = modifiedEnvironments;
+    }
     const builder = await createBuilder({
         cwd: appContext.appDirectory,
         rscClientRuntimePath: `@${appContext.metaName}/runtime/rsc/client`,

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

@@ -39,7 +39,7 @@ function applyBottomHtmlPlugin({ chain, options, CHAIN_ID, HtmlBundlerPlugin, ht
         const baseTemplateParams = {
             entryName,
             title: modernConfig.html.title,
-            mountId: modernConfig.html.templateParameters
+            mountId: modernConfig.html.mountId
         };
         chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).tap((args)=>[
                 {

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
@@ -72,7 +97,8 @@ function applyRouterPlugin(chain, pluginName, options, HtmlBundlerPlugin) {
             staticJsDir: normalizedConfig.output?.distPath?.js,
             disableFilenameHash: normalizedConfig.output?.filenameHash === false,
             scriptLoading: normalizedConfig.html?.scriptLoading,
-            nonce: normalizedConfig.security?.nonce
+            nonce: normalizedConfig.security?.nonce,
+            useRsc: isUseRsc(normalizedConfig)
         }
     ]);
 }

package/dist/esm-node/builder/shared/bundlerPlugins/RouterPlugin.mjs

@@ -65,6 +65,25 @@ class RouterPlugin {
                     routeAssets: {}
                 });
                 const prevManifest = JSON.parse(prevManifestStr);
+                const namedChunkGroupInstances = new Map();
+                for (const cg of compilation.chunkGroups || [])if (cg.name) namedChunkGroupInstances.set(cg.name, cg);
+                const collectDescendantCssAssets = (name)=>{
+                    const root = namedChunkGroupInstances.get(name);
+                    if (!root) return [];
+                    const cssFiles = new Set();
+                    const visited = new Set();
+                    const stack = [
+                        ...root.childrenIterable
+                    ];
+                    while(stack.length){
+                        const child = stack.pop();
+                        if (visited.has(child)) continue;
+                        visited.add(child);
+                        for (const chunk of child.chunks)for (const file of chunk.files)if (/\.css$/.test(file)) cssFiles.add(publicPath ? normalizePath(publicPath) + file : file);
+                        for (const c of child.childrenIterable)stack.push(c);
+                    }
+                    return Array.from(cssFiles);
+                };
                 const asyncEntryNames = [];
                 for (const [name, chunkGroup] of Object.entries(namedChunkGroups)){
                     if (name.startsWith('async-')) asyncEntryNames.push(name);
@@ -72,7 +91,12 @@ class RouterPlugin {
                         const filename = asset.name;
                         return publicPath ? normalizePath(publicPath) + filename : filename;
                     });
-                    const referenceCssAssets = assets.filter((asset)=>/\.css$/.test(asset));
+                    const directCssAssets = assets.filter((asset)=>/\.css$/.test(asset));
+                    const descendantCssAssets = collectDescendantCssAssets(name).filter((asset)=>!directCssAssets.includes(asset));
+                    const referenceCssAssets = [
+                        ...directCssAssets,
+                        ...descendantCssAssets
+                    ];
                     routeAssets[name] = {
                         chunkIds: chunkGroup.chunks,
                         assets,
@@ -114,10 +138,14 @@ class RouterPlugin {
                     const manifest = {
                         routeAssets: relatedAssets
                     };
+                    const { useRsc } = this;
                     const injectedContent = `
             ;(function(){
               window.${ROUTE_MANIFEST} = ${JSON.stringify(manifest, (k, v)=>{
-                        if (('assets' === k || 'referenceCssAssets' === k) && Array.isArray(v)) return v.map((item)=>item.replace(publicPath, ''));
+                        if (('assets' === k || 'referenceCssAssets' === k) && Array.isArray(v)) {
+                            if (!useRsc) return;
+                            return v.map((item)=>item.replace(publicPath, ''));
+                        }
                         return v;
                     })};
             })();
@@ -145,7 +173,7 @@ class RouterPlugin {
             });
         });
     }
-    constructor({ staticJsDir = 'static/js', HtmlBundlerPlugin, enableInlineRouteManifests, disableFilenameHash = false, scriptLoading = 'defer', nonce }){
+    constructor({ staticJsDir = 'static/js', HtmlBundlerPlugin, enableInlineRouteManifests, disableFilenameHash = false, scriptLoading = 'defer', nonce, useRsc = false }){
         this.name = 'RouterPlugin';
         this.HtmlBundlerPlugin = HtmlBundlerPlugin;
         this.enableInlineRouteManifests = enableInlineRouteManifests;
@@ -153,6 +181,7 @@ class RouterPlugin {
         this.disableFilenameHash = disableFilenameHash;
         this.scriptLoading = scriptLoading;
         this.nonce = nonce;
+        this.useRsc = useRsc;
     }
 }
 export { RouterPlugin };

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/commands/index.mjs

@@ -1,6 +1,5 @@
 import "node:module";
 import { i18n, localeKeys } from "../locale/index.mjs";
-import { runtimeCommand } from "./runtime.mjs";
 const devCommand = async (program, api)=>{
     program.command('dev').alias('start').usage('[options]').description(i18n.t(localeKeys.command.dev.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-e --entry [entry...]', i18n.t(localeKeys.command.dev.entry)).option('--analyze', i18n.t(localeKeys.command.shared.analyze)).option('--api-only', i18n.t(localeKeys.command.dev.apiOnly)).option('--web-only', i18n.t(localeKeys.command.dev.webOnly)).action(async (options)=>{
         const { dev } = await import("./dev.mjs");
@@ -42,7 +41,5 @@ const infoCommand = (program, api)=>{
         await info(api, options);
     });
 };
-const runtimeOperationsCommand = async (program, api)=>{
-    await runtimeCommand(program, api);
-};
-export { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, runtimeOperationsCommand, serverCommand };
+export { runtimeCommand } from "./runtime.mjs";
+export { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand };

package/dist/esm-node/commands/runtime.mjs

@@ -55,9 +55,39 @@ const parseResponseBody = async (response)=>{
         };
     }
 };
+const INDENT_STEP = '  ';
+const formatScalar = (value)=>'string' == typeof value ? value : JSON.stringify(value) ?? 'undefined';
+const formatHumanReadableLines = (value, indent)=>{
+    if (Array.isArray(value)) {
+        if (0 === value.length) return [
+            `${indent}(empty)`
+        ];
+        return value.flatMap((entry)=>null !== entry && 'object' == typeof entry ? [
+                `${indent}-`,
+                ...formatHumanReadableLines(entry, indent + INDENT_STEP)
+            ] : [
+                `${indent}- ${formatScalar(entry)}`
+            ]);
+    }
+    if (null !== value && 'object' == typeof value) {
+        const entries = Object.entries(value);
+        if (0 === entries.length) return [
+            `${indent}(empty)`
+        ];
+        return entries.flatMap(([key, entry])=>null !== entry && 'object' == typeof entry ? [
+                `${indent}${key}:`,
+                ...formatHumanReadableLines(entry, indent + INDENT_STEP)
+            ] : [
+                `${indent}${key}: ${formatScalar(entry)}`
+            ]);
+    }
+    return [
+        `${indent}${formatScalar(value)}`
+    ];
+};
+const formatRuntimeOutput = (payload, jsonOnly)=>jsonOnly ? JSON.stringify(payload, null, 2) : formatHumanReadableLines(payload, '').join('\n');
 const printOutput = (payload, jsonOnly)=>{
-    if (jsonOnly) return void console.log(JSON.stringify(payload, null, 2));
-    console.log(JSON.stringify(payload, null, 2));
+    console.log(formatRuntimeOutput(payload, jsonOnly));
 };
 const createRuntimeFallbackSignalPayload = (options)=>{
     const payload = {
@@ -114,4 +144,4 @@ const runtimeCommand = async (program, _api)=>{
         printOutput(responsePayload, options.json);
     });
 };
-export { createRuntimeFallbackSignalPayload, resolveRuntimeEndpoint, resolveToken, runtimeCommand };
+export { createRuntimeFallbackSignalPayload, formatRuntimeOutput, resolveRuntimeEndpoint, resolveToken, runtimeCommand };

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/index.mjs

@@ -5,7 +5,7 @@ import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
 import { createAsyncHook } from "@modern-js/plugin";
 import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
 import path from "path";
-import { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, runtimeOperationsCommand, serverCommand } from "./commands/index.mjs";
+import { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, runtimeCommand, serverCommand } from "./commands/index.mjs";
 import { compatPlugin } from "./compat/index.mjs";
 import { DEFAULT_RUNTIME_CONFIG_FILE } from "./constants.mjs";
 import { i18n } from "./locale/index.mjs";
@@ -45,6 +45,7 @@ const appTools = ()=>({
             deploy: createAsyncHook(),
             checkEntryPoint: createAsyncHook(),
             modifyEntrypoints: createAsyncHook(),
+            modifyBuilderEnvironments: createAsyncHook(),
             modifyFileSystemRoutes: createAsyncHook(),
             generateEntryCode: createAsyncHook(),
             onBeforeGenerateRoutes: createAsyncHook(),
@@ -73,7 +74,7 @@ const appTools = ()=>({
                 deployCommand(program, api);
                 inspectCommand(program, api);
                 infoCommand(program, api);
-                await runtimeOperationsCommand(program, api);
+                await runtimeCommand(program, api);
                 deprecatedCommands(program);
             });
             api.onPrepare(async ()=>{

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/analyze/isDefaultExportFunction.mjs

@@ -21,7 +21,7 @@ const isDefaultExportFunction = (file)=>{
             [
                 'pipelineOperator',
                 {
-                    proposal: 'minimal'
+                    proposal: 'fsharp'
                 }
             ],
             'optionalChaining',