@bleedingdev/modern-js-app-tools 3.4.0-ultramodern.2 → 3.4.0-ultramodern.20

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

@@ -137,13 +137,53 @@ function getCloudflareWorkerNodeExternals() {
 function getEffectBffEntry(normalizedConfig, appContext) {
     if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
     const configuredEntry = normalizedConfig.bff.effect?.entry;
-    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);
+    if (configuredEntry) {
+        const entryWithoutOrWithExtension = external_node_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_node_path_default().resolve(appContext.appDirectory, configuredEntry);
+        return resolveJsOrTsEntry(entryWithoutOrWithExtension);
+    }
+    return resolveJsOrTsEntry(external_node_path_default().resolve(appContext.apiDirectory, 'index'));
 }
 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){
@@ -190,7 +230,7 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
     const useWorkerTarget = (0, utils_namespaceObject.isServiceWorker)(normalizedConfig);
     if (useWorkerTarget) {
         const useCloudflareModuleWorker = isCloudflareWorkerDeploy(normalizedConfig);
-        const effectBffEntry = useCloudflareModuleWorker ? getEffectBffEntry(normalizedConfig, appContext) : void 0;
+        const effectApiEntry = useCloudflareModuleWorker ? getEffectBffEntry(normalizedConfig, appContext) : void 0;
         const tanstackRouterSsrServerFile = useCloudflareModuleWorker ? resolvePackageFile('@tanstack/router-core', 'dist/esm/ssr/ssr-server.js', [
             appContext.appDirectory,
             process.cwd()
@@ -232,10 +272,10 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
         const fsPromisesWorkerFile = useCloudflareModuleWorker ? getCloudflareWorkerCompatFile('cloudflare-worker-fs-promises.mjs') : void 0;
         const pathWorkerFile = useCloudflareModuleWorker ? getCloudflareWorkerCompatFile('cloudflare-worker-path.mjs') : void 0;
         const baseWorkerEntries = useCloudflareModuleWorker ? cloudflareWorkerServerEntries : serverEntries;
-        const workerEntries = effectBffEntry ? {
+        const workerEntries = effectApiEntry ? {
             ...baseWorkerEntries,
             [BFF_EFFECT_WORKER_ENTRY_NAME]: [
-                `${effectBffEntry}?${BFF_EFFECT_WORKER_RUNTIME_QUERY}`
+                `${effectApiEntry}?${BFF_EFFECT_WORKER_RUNTIME_QUERY}`
             ]
         } : baseWorkerEntries;
         environments[builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME] = {

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/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

@@ -45,6 +45,8 @@ const utils_namespaceObject = require("@modern-js/utils");
 const index_js_namespaceObject = require("../utils/index.js");
 const WORKER_ENTRY = 'server/index.mjs';
 const WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const WRANGLER_CONFIG_FILE = 'wrangler.json';
+const OUTPUT_PACKAGE_FILE = 'package.json';
 const ASSETS_BINDING = 'ASSETS';
 const ROUTE_SPEC_FILE = 'route.json';
 const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
@@ -53,10 +55,28 @@ const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
 const PUBLIC_ASSETS_DIRECTORY = 'public';
 const WORKER_BUNDLE_DIRECTORY = 'worker';
 const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const SERVER_OUTPUT_DIRECTORY = 'server';
+const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
+    'api',
+    'shared'
+];
 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 EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect API entry exists at api/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 REQUIRED_COMPATIBILITY_FLAGS = [
+    'nodejs_compat',
+    'global_fetch_strictly_public'
+];
+const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
+    WRANGLER_CONFIG_FILE,
+    OUTPUT_PACKAGE_FILE
+]);
+const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES = new Set([
+    PUBLIC_ASSETS_DIRECTORY,
+    SERVER_OUTPUT_DIRECTORY,
+    WORKER_BUNDLE_DIRECTORY
+]);
 const DEFAULT_SECURITY_HEADERS = {
     referrerPolicy: 'strict-origin-when-cross-origin',
     contentTypeOptions: 'nosniff',
@@ -145,6 +165,13 @@ const getConfiguredWorkerName = (appDirectory, modernConfig)=>{
     const configuredName = modernConfig.deploy?.worker?.name?.trim();
     return configuredName || getWorkerName(appDirectory);
 };
+const normalizeRelativePath = (value, label, scope = 'app output')=>{
+    if ('string' != typeof value) throw new Error(`${label} must be a relative path inside the ${scope}.`);
+    const normalized = value.trim().replace(/\\/g, '/').replace(/^\.\/+/u, '').replace(/\/+$/u, '');
+    const segments = normalized.split('/');
+    if (!normalized || external_node_path_default().isAbsolute(normalized) || '.' === normalized || segments.includes('..')) throw new Error(`${label} must be a relative path inside the ${scope}.`);
+    return normalized;
+};
 const normalizeDirectiveValues = (value)=>{
     const values = Array.isArray(value) ? value : [
         value
@@ -237,6 +264,66 @@ const createCloudflareWorkerSecurityPolicy = (modernConfig)=>{
         reason: security?.reason
     };
 };
+const isJsonRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const getConfiguredWrangler = (modernConfig)=>{
+    const wrangler = modernConfig.deploy?.worker?.wrangler;
+    if (void 0 === wrangler) return {};
+    if (!isJsonRecord(wrangler)) throw new Error('deploy.worker.wrangler must be a JSON object.');
+    return wrangler;
+};
+const createWranglerCompatibilityFlags = (configuredFlags)=>{
+    if (void 0 === configuredFlags) return [
+        ...REQUIRED_COMPATIBILITY_FLAGS
+    ];
+    if (!Array.isArray(configuredFlags) || configuredFlags.some((flag)=>'string' != typeof flag)) throw new Error('deploy.worker.wrangler.compatibility_flags must be an array of strings.');
+    return [
+        ...new Set([
+            ...configuredFlags,
+            ...REQUIRED_COMPATIBILITY_FLAGS
+        ])
+    ];
+};
+const createWranglerAssetsConfig = (configuredAssets)=>{
+    if (void 0 !== configuredAssets && !isJsonRecord(configuredAssets)) throw new Error('deploy.worker.wrangler.assets must be an object.');
+    return {
+        ...isJsonRecord(configuredAssets) ? configuredAssets : {},
+        directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
+        binding: ASSETS_BINDING,
+        run_worker_first: true
+    };
+};
+const createWranglerConfig = (appDirectory, modernConfig)=>{
+    const wrangler = getConfiguredWrangler(modernConfig);
+    return {
+        $schema: 'node_modules/wrangler/config-schema.json',
+        name: getConfiguredWorkerName(appDirectory, modernConfig),
+        compatibility_date: getCompatibilityDate(modernConfig),
+        ...wrangler,
+        main: WORKER_ENTRY,
+        compatibility_flags: createWranglerCompatibilityFlags(wrangler.compatibility_flags),
+        assets: createWranglerAssetsConfig(wrangler.assets)
+    };
+};
+const normalizeCloudflareArtifact = (artifact, index)=>{
+    const from = normalizeRelativePath(artifact.from, `deploy.worker.artifacts[${index}].from`, 'app root');
+    const to = normalizeRelativePath(artifact.to, `deploy.worker.artifacts[${index}].to`, 'Cloudflare output');
+    const [topLevelDestination] = to.split('/');
+    const reservedDestination = RESERVED_ARTIFACT_DESTINATION_FILES.has(to) ? to : topLevelDestination;
+    if (RESERVED_ARTIFACT_DESTINATION_FILES.has(to) || RESERVED_ARTIFACT_DESTINATION_DIRECTORIES.has(topLevelDestination)) throw new Error(`deploy.worker.artifacts[${index}].to must not target generated Cloudflare output path ${JSON.stringify(reservedDestination)}.`);
+    return {
+        from,
+        to,
+        index
+    };
+};
+const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
+const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
+    for (const artifact of artifacts){
+        const sourcePath = external_node_path_default().join(appDirectory, artifact.from);
+        if (!await utils_namespaceObject.fs.pathExists(sourcePath)) throw new Error(`deploy.worker.artifacts[${artifact.index}].from does not exist: ${artifact.from}`);
+        await utils_namespaceObject.fs.copy(sourcePath, external_node_path_default().join(outputDirectory, artifact.to));
+    }
+};
 const readRouteSpec = async (outputDirectory)=>{
     const routeSpecPath = external_node_path_default().join(outputDirectory, ROUTE_SPEC_OUTPUT);
     if (!await utils_namespaceObject.fs.pathExists(routeSpecPath)) return {
@@ -248,7 +335,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 createMissingEffectBffWorkerError = (outputDirectory, worker)=>new Error(`Cloudflare Effect API runtime 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,9 +351,9 @@ const createWorkerManifest = async (outputDirectory, modernConfig)=>{
     }));
     const bffPrefix = modernConfig.bff?.prefix;
     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);
+    const isEffectApi = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
+    const effectApiWorkerExists = await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
+    if (isEffectApi && primaryBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, BFF_EFFECT_WORKER_ENTRY);
     return {
         version: 1,
         runtime: {
@@ -295,7 +382,7 @@ const createWorkerManifest = async (outputDirectory, modernConfig)=>{
             routeManifest: ROUTE_MANIFEST_FILE
         },
         security: createCloudflareWorkerSecurityPolicy(modernConfig),
-        bff: isEffectBff && primaryBffPrefix && effectBffWorkerExists ? {
+        bff: isEffectApi && primaryBffPrefix && effectApiWorkerExists ? {
             runtimeFramework: 'effect',
             prefix: primaryBffPrefix,
             worker: BFF_EFFECT_WORKER_ENTRY
@@ -318,12 +405,22 @@ const createWorkerModuleLoaders = (manifest)=>{
     ].map(([worker, loader])=>`${JSON.stringify(worker)}: ${loader}`);
     return `{\n${loaders.join(',\n')}\n}`;
 };
-const shouldCopyToPublicAssets = (src, distDirectory)=>{
+const getPublicAssetExcludes = (appDirectory, modernConfig)=>[
+        ...DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES.filter((directory)=>{
+            try {
+                return utils_namespaceObject.fs.statSync(external_node_path_default().join(appDirectory, directory)).isDirectory();
+            } catch  {
+                return false;
+            }
+        }),
+        ...modernConfig.deploy?.worker?.publicAssetExcludes ?? []
+    ].map((entry)=>normalizeRelativePath(entry, 'deploy.worker.publicAssetExcludes'));
+const shouldCopyToPublicAssets = (src, distDirectory, publicAssetExcludes)=>{
     const relativePath = external_node_path_default().relative(distDirectory, src);
     if (!relativePath) return true;
     const normalizedRelativePath = relativePath.replace(/\\/g, '/');
     const [topLevelDirectory] = normalizedRelativePath.split('/');
-    return normalizedRelativePath !== ROUTE_SPEC_FILE && topLevelDirectory !== WORKER_BUNDLE_DIRECTORY && topLevelDirectory !== SERVER_BUNDLE_DIRECTORY;
+    return normalizedRelativePath !== ROUTE_SPEC_FILE && topLevelDirectory !== WORKER_BUNDLE_DIRECTORY && topLevelDirectory !== SERVER_BUNDLE_DIRECTORY && !publicAssetExcludes.some((exclude)=>normalizedRelativePath === exclude || normalizedRelativePath.startsWith(`${exclude}/`));
 };
 const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
     const relativePath = external_node_path_default().relative(workerBundleDirectory, src);
@@ -345,15 +442,16 @@ const createCloudflarePreset = ({ appContext, modernConfig })=>{
     const workerEntryPath = external_node_path_default().join(outputDirectory, WORKER_ENTRY);
     const workerManifestPath = external_node_path_default().join(outputDirectory, WORKER_MANIFEST);
     const routeSpecOutputPath = external_node_path_default().join(outputDirectory, ROUTE_SPEC_OUTPUT);
-    const wranglerConfigPath = external_node_path_default().join(outputDirectory, 'wrangler.json');
-    const workerName = getConfiguredWorkerName(appDirectory, modernConfig);
+    const wranglerConfigPath = external_node_path_default().join(outputDirectory, WRANGLER_CONFIG_FILE);
+    const cloudflareArtifacts = getCloudflareArtifacts(modernConfig);
+    const publicAssetExcludes = getPublicAssetExcludes(appDirectory, modernConfig);
     return {
         async prepare () {
             await utils_namespaceObject.fs.remove(outputDirectory);
         },
         async writeOutput () {
             await utils_namespaceObject.fs.copy(distDirectory, publicDirectory, {
-                filter: (src)=>shouldCopyToPublicAssets(src, distDirectory)
+                filter: (src)=>shouldCopyToPublicAssets(src, distDirectory, publicAssetExcludes)
             });
             await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(workerEntryPath));
             await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(workerManifestPath));
@@ -369,27 +467,14 @@ const createCloudflarePreset = ({ appContext, modernConfig })=>{
                     type: 'commonjs'
                 });
             }
-            await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, {
-                $schema: 'node_modules/wrangler/config-schema.json',
-                name: workerName,
-                main: WORKER_ENTRY,
-                compatibility_date: getCompatibilityDate(modernConfig),
-                compatibility_flags: [
-                    'nodejs_compat',
-                    'global_fetch_strictly_public'
-                ],
-                assets: {
-                    directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
-                    binding: ASSETS_BINDING,
-                    run_worker_first: true
-                }
-            }, {
+            await copyCloudflareArtifacts(appDirectory, outputDirectory, cloudflareArtifacts);
+            await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
                 spaces: 2
             });
             await utils_namespaceObject.fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig), {
                 spaces: 2
             });
-            await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(outputDirectory, 'package.json'), {
+            await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(outputDirectory, OUTPUT_PACKAGE_FILE), {
                 type: 'module'
             });
         },

package/dist/cjs/plugins/deploy/platforms/templates/cloudflare-entry.mjs

@@ -312,6 +312,19 @@ function getRemoteManifestUrl(remote, request) {
     if ('string' != typeof entry || 0 === entry.length) return;
     return new URL(entry, request.url).toString();
 }
+function ensureTrailingSlash(value) {
+    return value.endsWith('/') ? value : `${value}/`;
+}
+function getRemoteAssetBase(remoteManifest, manifestUrl) {
+    const publicPath = 'string' == typeof remoteManifest?.metaData?.publicPath ? remoteManifest.metaData.publicPath : void 0;
+    const fallbackBase = new URL('.', manifestUrl).toString();
+    if (!publicPath || 'auto' === publicPath) return fallbackBase;
+    try {
+        return new URL(ensureTrailingSlash(publicPath), manifestUrl).toString();
+    } catch  {
+        return fallbackBase;
+    }
+}
 async function fetchRemoteJson(jsonUrl) {
     if (!remoteJsonPromises.has(jsonUrl)) remoteJsonPromises.set(jsonUrl, fetch(jsonUrl).then((response)=>{
         if (!response.ok) {
@@ -374,7 +387,7 @@ async function collectRenderedRemoteCssHrefs(html, request, env) {
         if (!manifestUrl) return;
         const remoteManifest = await fetchRemoteJson(manifestUrl);
         const remoteExpose = findRemoteExpose(remoteManifest, expose);
-        const publicPath = 'string' == typeof remoteManifest?.metaData?.publicPath ? remoteManifest.metaData.publicPath : manifestUrl;
+        const publicPath = getRemoteAssetBase(remoteManifest, manifestUrl);
         const remoteRouteManifest = await fetchRemoteJson(new URL('routes-manifest.json', publicPath).toString());
         for (const asset of collectCssAssetEntries(remoteExpose?.assets))hrefs.add(new URL(asset, publicPath).toString());
         for (const asset of collectRouteManifestCssAssets(remoteRouteManifest))hrefs.add(new URL(asset, publicPath).toString());

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: [],