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

package/dist/cjs/builder/generator/getBuilderEnvironments.js

@@ -48,12 +48,14 @@ const utils_namespaceObject = require("@modern-js/utils");
 const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
 const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
 const JS_OR_TS_EXTS = [
-    '.ts',
-    '.tsx',
     '.js',
     '.jsx',
+    '.ts',
+    '.tsx',
     '.mjs',
-    '.cjs'
+    '.mts',
+    '.cjs',
+    '.cts'
 ];
 const CLOUDFLARE_WORKER_NODE_BUILTINS = [
     'async_hooks',
@@ -73,6 +75,11 @@ const CLOUDFLARE_WORKER_COMPAT_TEMPLATE_DIR = external_node_path_default().resol
 function findExistingFile(candidates) {
     return candidates.find((candidate)=>external_node_fs_default().existsSync(candidate));
 }
+function resolveJsOrTsEntry(entryWithoutOrWithExt) {
+    const extension = external_node_path_default().extname(entryWithoutOrWithExt);
+    if (JS_OR_TS_EXTS.includes(extension)) return external_node_fs_default().existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
+    return findExistingFile(JS_OR_TS_EXTS.map((extension)=>`${entryWithoutOrWithExt}${extension}`));
+}
 function resolvePackageEntry(packageName, paths) {
     try {
         return external_node_fs_default().realpathSync(require.resolve(packageName, {
@@ -130,13 +137,50 @@ function getCloudflareWorkerNodeExternals() {
 function getEffectBffEntry(normalizedConfig, appContext) {
     if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
     const configuredEntry = normalizedConfig.bff.effect?.entry;
-    const entryWithoutExtension = configuredEntry ? external_node_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_node_path_default().resolve(appContext.appDirectory, configuredEntry) : external_node_path_default().resolve(appContext.apiDirectory, 'effect', 'index');
-    return findExistingFile(JS_OR_TS_EXTS.map((extension)=>`${entryWithoutExtension}${extension}`));
+    const entryWithoutOrWithExtension = configuredEntry ? external_node_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_node_path_default().resolve(appContext.appDirectory, configuredEntry) : external_node_path_default().resolve(appContext.apiDirectory, 'effect', 'index');
+    return resolveJsOrTsEntry(entryWithoutOrWithExtension);
 }
 function isCloudflareWorkerDeploy(normalizedConfig) {
     return normalizedConfig.deploy?.target === 'cloudflare' || 'cloudflare' === process.env.MODERNJS_DEPLOY;
 }
+function getConsumingReactRuntimeAliases(appContext) {
+    const resolvePaths = [
+        appContext.appDirectory,
+        process.cwd()
+    ];
+    return {
+        react$: resolvePackageFile('react', 'index.js', resolvePaths),
+        'react/jsx-runtime$': resolvePackageFile('react', 'jsx-runtime.js', resolvePaths),
+        'react/jsx-dev-runtime$': resolvePackageFile('react', 'jsx-dev-runtime.js', resolvePaths),
+        'react/compiler-runtime$': resolvePackageFile('react', 'compiler-runtime.js', resolvePaths)
+    };
+}
+function setResolvedAliases(alias, aliases) {
+    for (const [name, value] of Object.entries(aliases))setAliasIfPresent(alias, name, value);
+}
+function appendBundlerChain(config, handler) {
+    const bundlerChain = config.tools?.bundlerChain;
+    config.tools = {
+        ...config.tools,
+        bundlerChain: bundlerChain ? Array.isArray(bundlerChain) ? [
+            ...bundlerChain,
+            handler
+        ] : [
+            bundlerChain,
+            handler
+        ] : handler
+    };
+}
+function applySourceBuildReactRuntimeAliases(normalizedConfig, appContext, tempBuilderConfig) {
+    if (!normalizedConfig.experiments?.sourceBuild) return;
+    const aliases = getConsumingReactRuntimeAliases(appContext);
+    if (!Object.values(aliases).some(Boolean)) return;
+    appendBundlerChain(tempBuilderConfig, (chain)=>{
+        setResolvedAliases(chain.resolve.alias, aliases);
+    });
+}
 function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig) {
+    applySourceBuildReactRuntimeAliases(normalizedConfig, appContext, tempBuilderConfig);
     const entries = {};
     const { entrypoints = [], checkedEntries } = appContext;
     for (const { entryName, internalEntry, entry } of entrypoints){

package/dist/cjs/builder/generator/index.js

@@ -70,6 +70,7 @@ async function generateBuilder(options, bundlerType) {
 async function applyBuilderPlugins(builder, options) {
     builder.addPlugins([
         (0, index_js_namespaceObject.builderPluginAdapterBasic)(options),
+        (0, index_js_namespaceObject.builderPluginAdapterLazyCompilation)(options),
         (0, index_js_namespaceObject.builderPluginAdapterSSR)(options),
         (0, index_js_namespaceObject.builderPluginAdapterHtml)(options),
         (0, index_js_namespaceObject.builderPluginAdapterPrecompress)(options),

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

@@ -0,0 +1,74 @@
+"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__, {
+    builderPluginAdapterLazyCompilation: ()=>builderPluginAdapterLazyCompilation
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_lazyCompilation_js_namespaceObject = require("../lazyCompilation.js");
+const builderPluginAdapterLazyCompilation = (options)=>({
+        name: 'builder-plugin-adapter-modern-lazy-compilation',
+        setup (api) {
+            api.modifyRsbuildConfig((config)=>{
+                const lazyCompilation = getRouteEagerLazyCompilation(options, config);
+                if (void 0 === lazyCompilation) return config;
+                return {
+                    ...config,
+                    dev: {
+                        ...config.dev,
+                        lazyCompilation
+                    }
+                };
+            });
+        }
+    });
+function getRouteEagerLazyCompilation(options, config) {
+    const current = config.dev?.lazyCompilation;
+    if (!current || (0, utils_namespaceObject.isUseRsc)(options.normalizedConfig)) return;
+    const plan = (0, external_lazyCompilation_js_namespaceObject.planRouteEagerLazyCompilation)(current, (0, external_lazyCompilation_js_namespaceObject.aggregateEagerRouteComponentFiles)(options.eagerRouteComponentFilesByEntry));
+    if (!plan.apply) {
+        if (plan.unresolvedByEntry) warnUnresolvedRouteComponents(options.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, components])=>`${entry}: ${components.join(', ')}`).join('; ');
+    utils_namespaceObject.logger.warn(`[lazyCompilation] Skipped route-eager optimization because some route components could not be resolved to a file (${detail}). Lazy compilation may delay route rendering for these routes.`);
+}
+exports.builderPluginAdapterLazyCompilation = __webpack_exports__.builderPluginAdapterLazyCompilation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterLazyCompilation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -36,27 +36,18 @@ const core_namespaceObject = require("@rsbuild/core");
 const external_path_namespaceObject = require("path");
 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, appContext, eagerRouteComponentFilesByEntry } = options;
-            api.modifyRsbuildConfig((config)=>{
-                const merged = (0, core_namespaceObject.mergeRsbuildConfig)(config, {
+            const { normalizedConfig, appContext } = options;
+            api.modifyRsbuildConfig((config)=>(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;
@@ -92,22 +83,6 @@ 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/builderPlugins/index.js

@@ -6,6 +6,9 @@ var __webpack_modules__ = {
     "./adapterHtml" (module) {
         module.exports = require("./adapterHtml.js");
     },
+    "./adapterLazyCompilation" (module) {
+        module.exports = require("./adapterLazyCompilation.js");
+    },
     "./adapterPrecompress" (module) {
         module.exports = require("./adapterPrecompress.js");
     },
@@ -71,17 +74,21 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _adapterHtml__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterHtml__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _adapterPrecompress__rspack_import_2 = __webpack_require__("./adapterPrecompress");
+    var _adapterLazyCompilation__rspack_import_2 = __webpack_require__("./adapterLazyCompilation");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _adapterLazyCompilation__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterLazyCompilation__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _adapterPrecompress__rspack_import_3 = __webpack_require__("./adapterPrecompress");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _adapterPrecompress__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterPrecompress__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _adapterPrecompress__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterPrecompress__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _adapterSSR__rspack_import_3 = __webpack_require__("./adapterSSR");
+    var _adapterSSR__rspack_import_4 = __webpack_require__("./adapterSSR");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _adapterSSR__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterSSR__rspack_import_3[__rspack_import_key];
+    for(const __rspack_import_key in _adapterSSR__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterSSR__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _builderHooks__rspack_import_4 = __webpack_require__("./builderHooks");
+    var _builderHooks__rspack_import_5 = __webpack_require__("./builderHooks");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _builderHooks__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_builderHooks__rspack_import_4[__rspack_import_key];
+    for(const __rspack_import_key in _builderHooks__rspack_import_5)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_builderHooks__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];

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

@@ -29,9 +29,11 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     aggregateEagerRouteComponentFiles: ()=>aggregateEagerRouteComponentFiles,
+    buildRouteEagerLazyCompilationTest: ()=>buildRouteEagerLazyCompilationTest,
     buildSSRLazyCompilationTest: ()=>buildSSRLazyCompilationTest,
     collectRouteComponentFiles: ()=>utils_namespaceObject.collectRouteComponentFiles,
     normalizeModulePath: ()=>utils_namespaceObject.normalizeModulePath,
+    planRouteEagerLazyCompilation: ()=>planRouteEagerLazyCompilation,
     planSSRLazyCompilation: ()=>planSSRLazyCompilation
 });
 const utils_namespaceObject = require("@modern-js/utils");
@@ -47,7 +49,7 @@ function aggregateEagerRouteComponentFiles(byEntry) {
         unresolvedByEntry
     };
 }
-function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
+function buildRouteEagerLazyCompilationTest(eagerRouteFiles, userTest) {
     const userTestFn = 'function' == typeof userTest ? userTest : userTest instanceof RegExp ? (m)=>userTest.test(m.resource || '') : ()=>true;
     return (m)=>{
         const resource = m.resource;
@@ -56,7 +58,8 @@ function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
         return userTestFn(m);
     };
 }
-function planSSRLazyCompilation(current, info) {
+const buildSSRLazyCompilationTest = buildRouteEagerLazyCompilationTest;
+function planRouteEagerLazyCompilation(current, info) {
     if (!current) return {
         apply: false
     };
@@ -73,20 +76,25 @@ function planSSRLazyCompilation(current, info) {
         apply: true,
         lazyCompilation: {
             ...base,
-            test: buildSSRLazyCompilationTest(info.files, userTest)
+            test: buildRouteEagerLazyCompilationTest(info.files, userTest)
         }
     };
 }
+const planSSRLazyCompilation = planRouteEagerLazyCompilation;
 exports.aggregateEagerRouteComponentFiles = __webpack_exports__.aggregateEagerRouteComponentFiles;
+exports.buildRouteEagerLazyCompilationTest = __webpack_exports__.buildRouteEagerLazyCompilationTest;
 exports.buildSSRLazyCompilationTest = __webpack_exports__.buildSSRLazyCompilationTest;
 exports.collectRouteComponentFiles = __webpack_exports__.collectRouteComponentFiles;
 exports.normalizeModulePath = __webpack_exports__.normalizeModulePath;
+exports.planRouteEagerLazyCompilation = __webpack_exports__.planRouteEagerLazyCompilation;
 exports.planSSRLazyCompilation = __webpack_exports__.planSSRLazyCompilation;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "aggregateEagerRouteComponentFiles",
+    "buildRouteEagerLazyCompilationTest",
     "buildSSRLazyCompilationTest",
     "collectRouteComponentFiles",
     "normalizeModulePath",
+    "planRouteEagerLazyCompilation",
     "planSSRLazyCompilation"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/esm/register-esm.js

@@ -30,8 +30,21 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
+let registeredPathHooks;
 const registerPathsLoader = async ({ appDir, baseUrl, paths })=>{
-    const { register } = await import("node:module");
+    const { register, registerHooks } = await import("node:module");
+    if ('function' == typeof registerHooks) {
+        const loader = await import("./ts-paths-loader.js");
+        await loader.initialize({
+            appDir,
+            baseUrl,
+            paths
+        });
+        registeredPathHooks ??= registerHooks({
+            resolve: loader.resolve
+        });
+        return registeredPathHooks;
+    }
     register('./ts-paths-loader.mjs', __rslib_import_meta_url__, {
         data: {
             appDir,

package/dist/cjs/esm/register-esm.mjs

@@ -1,5 +1,18 @@
+let registeredPathHooks;
 export const registerPathsLoader = async ({ appDir, baseUrl, paths })=>{
-    const { register } = await import('node:module');
+    const { register, registerHooks } = await import('node:module');
+    if ('function' == typeof registerHooks) {
+        const loader = await import('./ts-paths-loader.mjs');
+        await loader.initialize({
+            appDir,
+            baseUrl,
+            paths
+        });
+        registeredPathHooks ??= registerHooks({
+            resolve: loader.resolve
+        });
+        return registeredPathHooks;
+    }
     register('./ts-paths-loader.mjs', import.meta.url, {
         data: {
             appDir,

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

@@ -48,7 +48,15 @@ const deployPresets = {
 };
 const getSupportedDeployTargets = ()=>Object.keys(deployPresets);
 const isDeployTarget = (target)=>Object.prototype.hasOwnProperty.call(deployPresets, target);
-const resolveDeployTarget = (modernConfig, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = external_std_env_namespaceObject.provider)=>modernConfig.deploy?.target || envDeployTarget || detectedProvider || 'node';
+const providerDeployTargets = {
+    vercel: 'vercel',
+    netlify: 'netlify',
+    cloudflare: 'cloudflare',
+    cloudflare_pages: 'cloudflare',
+    cloudflare_workers: 'cloudflare'
+};
+const normalizeDetectedProvider = (value)=>value ? providerDeployTargets[value] : void 0;
+const resolveDeployTarget = (modernConfig, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = external_std_env_namespaceObject.provider)=>modernConfig.deploy?.target || envDeployTarget || normalizeDetectedProvider(detectedProvider) || 'node';
 async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
     const { useSSR, useAPI, useWebServer } = (0, index_js_namespaceObject.getProjectUsage)(appDirectory, distDirectory, metaName);

package/dist/cjs/plugins/deploy/platforms/cloudflare.js

@@ -54,6 +54,7 @@ const PUBLIC_ASSETS_DIRECTORY = 'public';
 const WORKER_BUNDLE_DIRECTORY = 'worker';
 const SERVER_BUNDLE_DIRECTORY = 'bundles';
 const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect BFF entry exists at api/effect/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
 const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
 const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
 const DEFAULT_SECURITY_HEADERS = {
@@ -247,6 +248,7 @@ const readRouteSpec = async (outputDirectory)=>{
         routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
     };
 };
+const createMissingEffectBffWorkerError = (outputDirectory, worker)=>new Error(`Cloudflare Effect BFF is configured, but the BFF worker bundle is missing: ${external_node_path_default().join(outputDirectory, worker)}. ${EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE}`);
 const createWorkerManifest = async (outputDirectory, modernConfig)=>{
     const routeSpec = await readRouteSpec(outputDirectory);
     const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
@@ -264,6 +266,7 @@ const createWorkerManifest = async (outputDirectory, modernConfig)=>{
     const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
     const isEffectBff = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
     const effectBffWorkerExists = await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
+    if (isEffectBff && primaryBffPrefix && !effectBffWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, BFF_EFFECT_WORKER_ENTRY);
     return {
         version: 1,
         runtime: {
@@ -357,9 +360,15 @@ const createCloudflarePreset = ({ appContext, modernConfig })=>{
             const routeSpecSourcePath = external_node_path_default().join(distDirectory, ROUTE_SPEC_FILE);
             if (await utils_namespaceObject.fs.pathExists(routeSpecSourcePath)) await utils_namespaceObject.fs.copy(routeSpecSourcePath, routeSpecOutputPath);
             const workerBundleSourceDirectory = external_node_path_default().join(distDirectory, WORKER_BUNDLE_DIRECTORY);
-            if (await utils_namespaceObject.fs.pathExists(workerBundleSourceDirectory)) await utils_namespaceObject.fs.copy(workerBundleSourceDirectory, external_node_path_default().join(outputDirectory, WORKER_BUNDLE_DIRECTORY), {
-                filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
-            });
+            const workerBundleOutputDirectory = external_node_path_default().join(outputDirectory, WORKER_BUNDLE_DIRECTORY);
+            if (await utils_namespaceObject.fs.pathExists(workerBundleSourceDirectory)) {
+                await utils_namespaceObject.fs.copy(workerBundleSourceDirectory, workerBundleOutputDirectory, {
+                    filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
+                });
+                await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(workerBundleOutputDirectory, 'package.json'), {
+                    type: 'commonjs'
+                });
+            }
             await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, {
                 $schema: 'node_modules/wrangler/config-schema.json',
                 name: workerName,
@@ -381,7 +390,7 @@ const createCloudflarePreset = ({ appContext, modernConfig })=>{
                 spaces: 2
             });
             await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(outputDirectory, 'package.json'), {
-                type: 'commonjs'
+                type: 'module'
             });
         },
         async genEntry () {

package/dist/cjs/rsbuild.js

@@ -55,9 +55,13 @@ async function resolveModernRsbuildConfig(options) {
         plugins: modernConfig.builderPlugins
     };
     const appContext = getAppContext();
-    const { rsbuildConfig, rsbuildPlugins } = await (0, builder_namespaceObject.parseRspackConfig)(nonStandardConfig, {
-        cwd
-    });
+    const builderOptions = {
+        cwd,
+        ...void 0 === options.disableReactCompiler ? {} : {
+            disableReactCompiler: options.disableReactCompiler
+        }
+    };
+    const { rsbuildConfig, rsbuildPlugins } = await (0, builder_namespaceObject.parseRspackConfig)(nonStandardConfig, builderOptions);
     const adapterParams = {
         appContext,
         normalizedConfig: modernConfig

package/dist/cjs/utils/initAppContext.js

@@ -42,6 +42,17 @@ __webpack_require__.d(__webpack_exports__, {
 const utils_namespaceObject = require("@modern-js/utils");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+function isSymlinkedNodeModules(appDirectory) {
+    try {
+        return utils_namespaceObject.fs.lstatSync(external_path_default().resolve(appDirectory, 'node_modules')).isSymbolicLink();
+    } catch  {
+        return false;
+    }
+}
+function getDefaultInternalDirectory(appDirectory, metaName) {
+    if (isSymlinkedNodeModules(appDirectory)) return external_path_default().resolve(appDirectory, `.${metaName}`);
+    return external_path_default().resolve(appDirectory, `./node_modules/.${metaName}`);
+}
 const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, tempDir })=>{
     const { apiDir = 'api', sharedDir = 'shared', bffRuntimeFramework = 'hono' } = options || {};
     const pkgPath = external_path_default().resolve(appDirectory, './package.json');
@@ -55,7 +66,7 @@ const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, te
         lambdaDirectory: external_path_default().resolve(appDirectory, apiDir, 'lambda'),
         sharedDirectory: external_path_default().resolve(appDirectory, sharedDir),
         serverPlugins: [],
-        internalDirectory: external_path_default().resolve(appDirectory, tempDir || `./node_modules/.${metaName}`),
+        internalDirectory: tempDir ? external_path_default().resolve(appDirectory, tempDir) : getDefaultInternalDirectory(appDirectory, metaName),
         htmlTemplates: {},
         serverRoutes: [],
         entrypoints: [],

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

@@ -5,12 +5,14 @@ import { isProd, isSSR, isServiceWorker, isUseRsc, isUseSSRBundle } from "@moder
 const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
 const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
 const JS_OR_TS_EXTS = [
-    '.ts',
-    '.tsx',
     '.js',
     '.jsx',
+    '.ts',
+    '.tsx',
     '.mjs',
-    '.cjs'
+    '.mts',
+    '.cjs',
+    '.cts'
 ];
 const CLOUDFLARE_WORKER_NODE_BUILTINS = [
     'async_hooks',
@@ -30,6 +32,11 @@ const CLOUDFLARE_WORKER_COMPAT_TEMPLATE_DIR = node_path.resolve(__dirname, '../.
 function findExistingFile(candidates) {
     return candidates.find((candidate)=>node_fs.existsSync(candidate));
 }
+function resolveJsOrTsEntry(entryWithoutOrWithExt) {
+    const extension = node_path.extname(entryWithoutOrWithExt);
+    if (JS_OR_TS_EXTS.includes(extension)) return node_fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
+    return findExistingFile(JS_OR_TS_EXTS.map((extension)=>`${entryWithoutOrWithExt}${extension}`));
+}
 function resolvePackageEntry(packageName, paths) {
     try {
         return node_fs.realpathSync(require.resolve(packageName, {
@@ -87,13 +94,50 @@ function getCloudflareWorkerNodeExternals() {
 function getEffectBffEntry(normalizedConfig, appContext) {
     if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
     const configuredEntry = normalizedConfig.bff.effect?.entry;
-    const entryWithoutExtension = configuredEntry ? node_path.isAbsolute(configuredEntry) ? configuredEntry : node_path.resolve(appContext.appDirectory, configuredEntry) : node_path.resolve(appContext.apiDirectory, 'effect', 'index');
-    return findExistingFile(JS_OR_TS_EXTS.map((extension)=>`${entryWithoutExtension}${extension}`));
+    const entryWithoutOrWithExtension = configuredEntry ? node_path.isAbsolute(configuredEntry) ? configuredEntry : node_path.resolve(appContext.appDirectory, configuredEntry) : node_path.resolve(appContext.apiDirectory, 'effect', 'index');
+    return resolveJsOrTsEntry(entryWithoutOrWithExtension);
 }
 function isCloudflareWorkerDeploy(normalizedConfig) {
     return normalizedConfig.deploy?.target === 'cloudflare' || 'cloudflare' === process.env.MODERNJS_DEPLOY;
 }
+function getConsumingReactRuntimeAliases(appContext) {
+    const resolvePaths = [
+        appContext.appDirectory,
+        process.cwd()
+    ];
+    return {
+        react$: resolvePackageFile('react', 'index.js', resolvePaths),
+        'react/jsx-runtime$': resolvePackageFile('react', 'jsx-runtime.js', resolvePaths),
+        'react/jsx-dev-runtime$': resolvePackageFile('react', 'jsx-dev-runtime.js', resolvePaths),
+        'react/compiler-runtime$': resolvePackageFile('react', 'compiler-runtime.js', resolvePaths)
+    };
+}
+function setResolvedAliases(alias, aliases) {
+    for (const [name, value] of Object.entries(aliases))setAliasIfPresent(alias, name, value);
+}
+function appendBundlerChain(config, handler) {
+    const bundlerChain = config.tools?.bundlerChain;
+    config.tools = {
+        ...config.tools,
+        bundlerChain: bundlerChain ? Array.isArray(bundlerChain) ? [
+            ...bundlerChain,
+            handler
+        ] : [
+            bundlerChain,
+            handler
+        ] : handler
+    };
+}
+function applySourceBuildReactRuntimeAliases(normalizedConfig, appContext, tempBuilderConfig) {
+    if (!normalizedConfig.experiments?.sourceBuild) return;
+    const aliases = getConsumingReactRuntimeAliases(appContext);
+    if (!Object.values(aliases).some(Boolean)) return;
+    appendBundlerChain(tempBuilderConfig, (chain)=>{
+        setResolvedAliases(chain.resolve.alias, aliases);
+    });
+}
 function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig) {
+    applySourceBuildReactRuntimeAliases(normalizedConfig, appContext, tempBuilderConfig);
     const entries = {};
     const { entrypoints = [], checkedEntries } = appContext;
     for (const { entryName, internalEntry, entry } of entrypoints){

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

@@ -1,6 +1,6 @@
 import { createBuilder } from "@modern-js/builder";
 import { mergeRsbuildConfig } from "@rsbuild/core";
-import { builderPluginAdapterBasic, builderPluginAdapterHooks, builderPluginAdapterHtml, builderPluginAdapterPrecompress, builderPluginAdapterSSR } from "../shared/builderPlugins/index.mjs";
+import { builderPluginAdapterBasic, builderPluginAdapterHooks, builderPluginAdapterHtml, builderPluginAdapterLazyCompilation, builderPluginAdapterPrecompress, builderPluginAdapterSSR } from "../shared/builderPlugins/index.mjs";
 import { builderPluginAdapterCopy } from "./adapterCopy.mjs";
 import { createBuilderProviderConfig } from "./createBuilderProviderConfig.mjs";
 import { getBuilderEnvironments } from "./getBuilderEnvironments.mjs";
@@ -38,6 +38,7 @@ async function generateBuilder(options, bundlerType) {
 async function applyBuilderPlugins(builder, options) {
     builder.addPlugins([
         builderPluginAdapterBasic(options),
+        builderPluginAdapterLazyCompilation(options),
         builderPluginAdapterSSR(options),
         builderPluginAdapterHtml(options),
         builderPluginAdapterPrecompress(options),

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

@@ -0,0 +1,36 @@
+import { isUseRsc, logger } from "@modern-js/utils";
+import { aggregateEagerRouteComponentFiles, planRouteEagerLazyCompilation } from "../lazyCompilation.mjs";
+const builderPluginAdapterLazyCompilation = (options)=>({
+        name: 'builder-plugin-adapter-modern-lazy-compilation',
+        setup (api) {
+            api.modifyRsbuildConfig((config)=>{
+                const lazyCompilation = getRouteEagerLazyCompilation(options, config);
+                if (void 0 === lazyCompilation) return config;
+                return {
+                    ...config,
+                    dev: {
+                        ...config.dev,
+                        lazyCompilation
+                    }
+                };
+            });
+        }
+    });
+function getRouteEagerLazyCompilation(options, config) {
+    const current = config.dev?.lazyCompilation;
+    if (!current || isUseRsc(options.normalizedConfig)) return;
+    const plan = planRouteEagerLazyCompilation(current, aggregateEagerRouteComponentFiles(options.eagerRouteComponentFilesByEntry));
+    if (!plan.apply) {
+        if (plan.unresolvedByEntry) warnUnresolvedRouteComponents(options.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, components])=>`${entry}: ${components.join(', ')}`).join('; ');
+    logger.warn(`[lazyCompilation] Skipped route-eager optimization because some route components could not be resolved to a file (${detail}). Lazy compilation may delay route rendering for these routes.`);
+}
+export { builderPluginAdapterLazyCompilation };