@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/cjs/cloudflare-builder.js

@@ -41,9 +41,11 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     applyCloudflareBuilderEnvironments: ()=>applyCloudflareBuilderEnvironments,
-    applyCloudflareWorkerMfRuntimeBoundary: ()=>applyCloudflareWorkerMfRuntimeBoundary,
     applyCloudflareWorkerRspackConfig: ()=>applyCloudflareWorkerRspackConfig,
+    claimsByFunctionExternal: ()=>claimsByFunctionExternal,
+    createAbsentOptionalDependencyFilter: ()=>createAbsentOptionalDependencyFilter,
     createCloudflareBuilderPlugin: ()=>createCloudflareBuilderPlugin,
+    createRequestRedirectMatcher: ()=>createRequestRedirectMatcher,
     getCloudflareBuilderEnvironments: ()=>getCloudflareBuilderEnvironments,
     getCloudflareWorkerRspackConfig: ()=>getCloudflareWorkerRspackConfig
 });
@@ -54,14 +56,50 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const builder_namespaceObject = require("@modern-js/builder");
 const utils_namespaceObject = require("@modern-js/utils");
-const external_std_env_namespaceObject = require("std-env");
 const external_cloudflare_output_contract_js_namespaceObject = require("./cloudflare-output-contract.js");
 const external_read_template_js_namespaceObject = require("./read-template.js");
 const moduleRequire = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
 const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
 const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
-const MF_SSR_DATA_FETCH_RUNTIME_PLUGIN = '@module-federation/modern-js-v3/ssr-inject-data-fetch-function-plugin';
-const MF_SSR_DEV_RUNTIME_PLUGIN = '@module-federation/modern-js-v3/ssr-dev-plugin';
+const SERVER_LOADER_COMBINED_FILE = 'server-loader-combined.js';
+const ROUTE_SERVER_LOADERS_FILE = 'route-server-loaders.js';
+const WORKER_ROUTE_DATA_FILE = 'cloudflare-worker-route-data.js';
+const WORKER_ROUTE_DATA_TEMPLATE = 'cloudflare-worker-route-data.mjs';
+const DATA_LOADER_CLIENT_TRANSFORM = /plugin-data-loader[\\/](?:.+[\\/])?loader\.[cm]?js$/u;
+const WORKER_DEPENDENCY_CONDITIONS = [
+    [
+        'esm',
+        'import'
+    ],
+    [
+        'wasm',
+        'import'
+    ],
+    [
+        'loaderImport',
+        'import'
+    ],
+    [
+        'worker',
+        'import'
+    ],
+    [
+        'commonjs',
+        'require'
+    ],
+    [
+        'amd',
+        'require'
+    ],
+    [
+        'loader',
+        'require'
+    ],
+    [
+        'unknown',
+        'require'
+    ]
+];
 const JS_OR_TS_EXTENSIONS = new Set([
     '.js',
     '.jsx',
@@ -121,19 +159,155 @@ const resolvePackageFile = (packageName, filePath, paths)=>{
 const setAliasIfPresent = (alias, name, value)=>{
     if (value) alias.set(name, value);
 };
-const getCloudflareWorkerNodeExternals = ()=>Object.fromEntries(external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap((builtin)=>{
-        const nodeBuiltin = `node:${builtin}`;
+const getCloudflareWorkerNodeExternals = ()=>Object.fromEntries([
+        ...external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap((builtin)=>{
+            const nodeBuiltin = `node:${builtin}`;
+            const external = `module-import ${nodeBuiltin}`;
+            return (0, external_node_module_namespaceObject.isBuiltin)(builtin) ? [
+                [
+                    builtin,
+                    external
+                ],
+                [
+                    nodeBuiltin,
+                    external
+                ]
+            ] : [
+                [
+                    nodeBuiltin,
+                    external
+                ]
+            ];
+        }),
+        ...external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_PLATFORM_MODULES.map((platformModule)=>[
+                platformModule,
+                `module-import ${platformModule}`
+            ])
+    ]);
+const getPackageNameFromRequest = (request)=>{
+    if (request.startsWith('.') || request.startsWith('/') || request.includes(':') || external_node_path_default().isAbsolute(request)) return;
+    const segments = request.split('/');
+    return request.startsWith('@') ? segments.length > 1 ? `${segments[0]}/${segments[1]}` : void 0 : segments[0];
+};
+const isRedirectedByAliasField = (manifest, aliasFields, request)=>aliasFields.some((field)=>{
+        let value = manifest;
+        for (const key of 'string' == typeof field ? [
+            field
+        ] : field)value = value && 'object' == typeof value ? value[key] : void 0;
+        return 'object' == typeof value && null !== value && Object.hasOwn(value, request);
+    });
+const findOwningPackageManifest = (directory, cache)=>{
+    if (cache.has(directory)) return cache.get(directory);
+    let manifest;
+    const packageJsonPath = external_node_path_default().join(directory, 'package.json');
+    if (external_node_fs_default().existsSync(packageJsonPath)) try {
+        manifest = JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, 'utf-8'));
+    } catch  {
+        manifest = void 0;
+    }
+    else if (external_node_path_default().dirname(directory) !== directory) manifest = findOwningPackageManifest(external_node_path_default().dirname(directory), cache);
+    cache.set(directory, manifest);
+    return manifest;
+};
+const isPackageInstalled = (packageName, directory, moduleDirectories)=>moduleDirectories.some((moduleDirectory)=>{
+        if (external_node_path_default().isAbsolute(moduleDirectory)) return external_node_fs_default().existsSync(external_node_path_default().join(moduleDirectory, packageName));
+        let current = directory;
+        while(true){
+            if (external_node_fs_default().existsSync(external_node_path_default().join(current, moduleDirectory, packageName))) return true;
+            const parent = external_node_path_default().dirname(current);
+            if (parent === current) return false;
+            current = parent;
+        }
+    });
+const createAbsentOptionalDependencyFilter = (isRedirected = ()=>false, moduleDirectories = [
+    'node_modules'
+], aliasFields = [])=>{
+    const manifests = new Map();
+    return (request, context)=>{
+        const packageName = getPackageNameFromRequest(request);
+        if (!packageName || !context || isRedirected(request)) return false;
+        const manifest = findOwningPackageManifest(context, manifests);
+        if (!manifest) return false;
+        const optional = manifest.peerDependenciesMeta?.[packageName]?.optional === true || Object.hasOwn(manifest.optionalDependencies ?? {}, packageName);
+        return optional && !isRedirectedByAliasField(manifest, aliasFields, request) && !isPackageInstalled(packageName, context, moduleDirectories);
+    };
+};
+const getAliasNames = (alias)=>alias ? Array.isArray(alias) ? alias.map((entry)=>entry.onlyModule ? `${entry.name}$` : entry.name) : Object.keys(alias) : [];
+const getExternalMatchers = (externals)=>{
+    if (Array.isArray(externals)) return externals.flatMap(getExternalMatchers);
+    if ('string' == typeof externals) return [
+        (request)=>request === externals
+    ];
+    if (externals instanceof RegExp) return [
+        (request)=>{
+            externals.lastIndex = 0;
+            return externals.test(request);
+        }
+    ];
+    if (externals && 'object' == typeof externals) {
+        const names = new Set(Object.entries(externals).filter(([, value])=>false !== value).map(([name])=>name));
         return [
-            [
-                builtin,
-                `module-import ${nodeBuiltin}`
-            ],
-            [
-                nodeBuiltin,
-                `module-import ${nodeBuiltin}`
-            ]
+            (request)=>names.has(request)
         ];
-    }));
+    }
+    return [];
+};
+const createRequestRedirectMatcher = (options)=>{
+    const aliasNames = [
+        ...getAliasNames(options.resolve?.alias),
+        ...getAliasNames(options.resolve?.fallback)
+    ];
+    const externalMatchers = getExternalMatchers(options.externals);
+    return (request)=>externalMatchers.some((matches)=>matches(request)) || aliasNames.some((name)=>name.endsWith('$') ? request === name.slice(0, -1) : request === name || request.startsWith(`${name}/`));
+};
+const getFunctionExternals = (externals)=>Array.isArray(externals) ? externals.flatMap(getFunctionExternals) : 'function' == typeof externals ? [
+        externals
+    ] : [];
+const callFunctionExternal = (external, data)=>new Promise((resolve, reject)=>{
+        const returned = external(data, (error, result)=>error ? reject(error) : resolve(result));
+        if (null !== returned && 'object' == typeof returned && 'function' == typeof returned.then) returned.then(resolve, reject);
+        else if (1 === external.length) resolve(returned);
+    });
+const claimsByFunctionExternal = async (externals, data)=>{
+    for (const external of externals)try {
+        const result = await callFunctionExternal(external, data);
+        if (null != result && false !== result) return true;
+    } catch  {
+        return true;
+    }
+    return false;
+};
+const PLUGIN_NAME = 'AbsentOptionalDependencyPlugin';
+class AbsentOptionalDependencyPlugin {
+    apply(compiler) {
+        const isAbsent = createAbsentOptionalDependencyFilter(createRequestRedirectMatcher(compiler.options), compiler.options.resolve.modules, compiler.options.resolve.aliasFields);
+        const functionExternals = getFunctionExternals(compiler.options.externals);
+        compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (factory)=>{
+            factory.hooks.beforeResolve.tapPromise(PLUGIN_NAME, async (data)=>{
+                if (!isAbsent(data.request, data.context)) return;
+                const claimed = await claimsByFunctionExternal(functionExternals, {
+                    context: data.context,
+                    contextInfo: {
+                        issuer: data.contextInfo.issuer,
+                        issuerLayer: data.contextInfo.issuerLayer ?? null
+                    },
+                    getResolve: (options)=>{
+                        const resolver = factory.getResolver('normal', options ?? {});
+                        function resolveRequest(context, request, callback) {
+                            if (callback) return void resolver.resolve({}, context, request, {}, callback);
+                            return new Promise((resolve, reject)=>{
+                                resolver.resolve({}, context, request, {}, (error, result)=>error ? reject(error) : resolve(result || void 0));
+                            });
+                        }
+                        return resolveRequest;
+                    },
+                    request: data.request
+                });
+                return claimed ? void 0 : false;
+            });
+        });
+    }
+}
 const normalizeWorkerOutputName = (name)=>external_node_path_default().posix.normalize(name.replace(/\\/gu, '/')).toLowerCase();
 const reserveWorkerChunkName = (baseName, reservedOutputNames)=>{
     let name = baseName;
@@ -183,11 +357,8 @@ function applyCloudflareWorkerRspackConfig(chain, workerEntryNames) {
     chain.optimization.runtimeChunk(config.optimization.runtimeChunk);
     chain.optimization.splitChunks(config.optimization.splitChunks);
 }
-function applyCloudflareWorkerMfRuntimeBoundary(chain) {
-    const runtimePlugin = (0, external_read_template_js_namespaceObject.getTemplatePath)('cloudflare-worker-mf-ssr-runtime-plugin.mjs');
-    chain.plugins.delete('plugin-module-federation');
-    chain.resolve.alias.set(`${MF_SSR_DATA_FETCH_RUNTIME_PLUGIN}$`, runtimePlugin);
-    chain.resolve.alias.set(`${MF_SSR_DEV_RUNTIME_PLUGIN}$`, runtimePlugin);
+function removeCloudflareWorkerDataLoaderClientTransform(chain) {
+    for (const [name, rule] of Object.entries(chain.module.rules.entries() ?? {}))if (rule.uses.values().some((use)=>DATA_LOADER_CLIENT_TRANSFORM.test(String(use.get('loader'))))) chain.module.rules.delete(name);
 }
 const getEffectBffEntry = (normalizedConfig, appContext)=>{
     if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
@@ -198,18 +369,6 @@ const getEffectBffEntry = (normalizedConfig, appContext)=>{
     }
     return resolveJsOrTsEntry(external_node_path_default().resolve(appContext.apiDirectory, 'index'));
 };
-const CLOUDFLARE_DEPLOY_PROVIDERS = new Set([
-    'cloudflare',
-    'cloudflare_pages',
-    'cloudflare_workers'
-]);
-const resolveStdEnvDeployProvider = ()=>external_std_env_namespaceObject.provider;
-const isCloudflareWorkerDeploy = (normalizedConfig, resolveDeployProvider)=>{
-    const explicitTarget = normalizedConfig.deploy?.target || process.env.MODERNJS_DEPLOY;
-    if (explicitTarget) return 'cloudflare' === explicitTarget;
-    const detectedProvider = resolveDeployProvider();
-    return detectedProvider ? CLOUDFLARE_DEPLOY_PROVIDERS.has(detectedProvider) : false;
-};
 const rewriteWorkerEntryPath = (entry)=>entry.replace('index.jsx', 'index.server.jsx').replace('bootstrap.server.jsx', 'index.server.jsx').replace('bootstrap.jsx', 'index.server.jsx');
 const rewriteWorkerEntryDescription = (description)=>{
     const entryImport = description.import;
@@ -237,28 +396,60 @@ const rewriteWorkerEntries = (entries)=>Object.fromEntries(Object.entries(entrie
             rewriteWorkerEntryDescription(value)
         ];
     }));
-const prependBundlerChain = (environment, handler)=>{
+const prependBundlerChain = (environment, handler, finalHandler)=>{
     const bundlerChain = environment.tools?.bundlerChain;
+    const handlers = [
+        handler,
+        ...bundlerChain ? Array.isArray(bundlerChain) ? bundlerChain : [
+            bundlerChain
+        ] : [],
+        ...finalHandler ? [
+            finalHandler
+        ] : []
+    ];
     return {
         ...environment,
         tools: {
             ...environment.tools,
             htmlPlugin: false,
-            bundlerChain: bundlerChain ? Array.isArray(bundlerChain) ? [
-                handler,
-                ...bundlerChain
-            ] : [
-                handler,
-                bundlerChain
-            ] : handler
+            bundlerChain: handlers
         }
     };
 };
+const createWorkerRouteDataModule = ()=>[
+        `import { routes } from './${ROUTE_SERVER_LOADERS_FILE}';`,
+        `import { createRouteDataRequestHandler } from ${JSON.stringify((0, external_read_template_js_namespaceObject.getTemplatePath)(WORKER_ROUTE_DATA_TEMPLATE))};`,
+        '',
+        `export const ${external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT} =`,
+        '  createRouteDataRequestHandler(routes);',
+        ''
+    ].join('\n');
+const getWorkerRouteDataEntries = (appContext)=>{
+    const { entrypoints, internalDirectory } = appContext;
+    if (!entrypoints || !internalDirectory) return {};
+    return Object.fromEntries(entrypoints.flatMap(({ entryName })=>{
+        const entryDirectory = external_node_path_default().join(internalDirectory, entryName);
+        if (!external_node_fs_default().existsSync(external_node_path_default().join(entryDirectory, SERVER_LOADER_COMBINED_FILE)) || !external_node_fs_default().existsSync(external_node_path_default().join(entryDirectory, ROUTE_SERVER_LOADERS_FILE))) return [];
+        const routeDataFile = external_node_path_default().join(entryDirectory, WORKER_ROUTE_DATA_FILE);
+        external_node_fs_default().writeFileSync(routeDataFile, createWorkerRouteDataModule());
+        return [
+            [
+                (0, external_cloudflare_output_contract_js_namespaceObject.getCloudflareWorkerRouteDataEntryName)(entryName),
+                [
+                    routeDataFile
+                ]
+            ]
+        ];
+    }));
+};
 const getWorkerEntries = (environment, normalizedConfig, appContext)=>{
     const configuredEntries = environment.source?.entry;
-    if (!configuredEntries) return;
-    const entries = rewriteWorkerEntries(configuredEntries);
     const effectApiEntry = getEffectBffEntry(normalizedConfig, appContext);
+    if (!configuredEntries && !effectApiEntry) return;
+    const entries = configuredEntries ? {
+        ...rewriteWorkerEntries(configuredEntries),
+        ...getWorkerRouteDataEntries(appContext)
+    } : {};
     return effectApiEntry ? {
         ...entries,
         [BFF_EFFECT_WORKER_ENTRY_NAME]: [
@@ -266,14 +457,11 @@ const getWorkerEntries = (environment, normalizedConfig, appContext)=>{
         ]
     } : entries;
 };
-const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
+const createCloudflareBundlerChain = (appContext, workerEntryNames, rscEnabled)=>{
     const resolvePaths = [
         appContext.appDirectory,
         process.cwd()
     ];
-    const tanstackRouterSsrServerFile = resolvePackageFile('@tanstack/router-core', 'dist/esm/ssr/ssr-server.js', resolvePaths);
-    const runtimeRscWorkerFile = resolvePackageFile('@modern-js/runtime', 'dist/esm/rsc/server.worker.mjs', resolvePaths);
-    const renderRscWorkerFile = resolvePackageFile('@modern-js/render', 'dist/esm/rscWorker.mjs', resolvePaths);
     const reactFile = resolvePackageFile('react', 'index.js', resolvePaths);
     const reactJsxRuntimeFile = resolvePackageFile('react', 'jsx-runtime.js', resolvePaths);
     const reactJsxDevRuntimeFile = resolvePackageFile('react', 'jsx-dev-runtime.js', resolvePaths);
@@ -283,62 +471,52 @@ const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
         ...resolvePaths,
         (0, external_read_template_js_namespaceObject.getTemplatePath)('')
     ]);
-    const loadableServerWorkerFile = (0, external_read_template_js_namespaceObject.getTemplatePath)('cloudflare-worker-loadable-server.mjs');
-    const fsPromisesWorkerFile = (0, external_read_template_js_namespaceObject.getTemplatePath)('cloudflare-worker-fs-promises.mjs');
-    const pathWorkerFile = (0, external_read_template_js_namespaceObject.getTemplatePath)('cloudflare-worker-path.mjs');
     const entryNames = [
         ...workerEntryNames
     ];
     return (chain)=>{
         applyCloudflareWorkerRspackConfig(chain, entryNames);
+        removeCloudflareWorkerDataLoaderClientTransform(chain);
+        if (rscEnabled) chain.optimization.runtimeChunk(false);
         chain.output.module(true).library({
             type: 'module'
         }).publicPath('/').chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
+        chain.node.set('__dirname', 'mock').set('__filename', 'mock');
         for (const condition of [
             'workerd',
             'worker',
             'webpack',
             (0, utils_namespaceObject.isProd)() ? 'production' : 'development',
-            'import',
-            'require',
             'module'
         ])chain.resolve.conditionNames.add(condition);
-        applyCloudflareWorkerMfRuntimeBoundary(chain);
-        if (tanstackRouterSsrServerFile) {
-            chain.resolve.alias.set('@tanstack/router-core/ssr/server$', tanstackRouterSsrServerFile);
-            chain.resolve.alias.set('@tanstack/router-core/ssr/server', tanstackRouterSsrServerFile);
-        }
-        if (runtimeRscWorkerFile) {
-            chain.resolve.alias.set('@modern-js/runtime/rsc/server$', runtimeRscWorkerFile);
-            chain.resolve.alias.set('@modern-js/runtime/rsc/server', runtimeRscWorkerFile);
-        }
-        if (renderRscWorkerFile) {
-            chain.resolve.alias.set('@modern-js/render/rsc$', renderRscWorkerFile);
-            chain.resolve.alias.set('@modern-js/render/rsc', renderRscWorkerFile);
-            chain.resolve.alias.set('@modern-js/render/rsc-worker$', renderRscWorkerFile);
+        for (const [dependencyType, condition] of WORKER_DEPENDENCY_CONDITIONS)chain.resolve.byDependency.set(dependencyType, {
+            conditionNames: [
+                condition,
+                '...'
+            ]
+        });
+        chain.plugin('cloudflare-worker-absent-optional-dependencies').use(AbsentOptionalDependencyPlugin);
+        chain.plugins.delete('plugin-module-federation');
+        if (!rscEnabled) {
+            setAliasIfPresent(chain.resolve.alias, 'react$', reactFile);
+            setAliasIfPresent(chain.resolve.alias, 'react/jsx-runtime$', reactJsxRuntimeFile);
+            setAliasIfPresent(chain.resolve.alias, 'react/jsx-dev-runtime$', reactJsxDevRuntimeFile);
+            setAliasIfPresent(chain.resolve.alias, 'react-dom$', reactDomFile);
+            setAliasIfPresent(chain.resolve.alias, 'react-dom/server.edge$', reactDomServerEdgeFile);
         }
-        setAliasIfPresent(chain.resolve.alias, 'react$', reactFile);
-        setAliasIfPresent(chain.resolve.alias, 'react/jsx-runtime$', reactJsxRuntimeFile);
-        setAliasIfPresent(chain.resolve.alias, 'react/jsx-dev-runtime$', reactJsxDevRuntimeFile);
-        setAliasIfPresent(chain.resolve.alias, 'react-dom$', reactDomFile);
-        setAliasIfPresent(chain.resolve.alias, 'react-dom/server.edge$', reactDomServerEdgeFile);
         setAliasIfPresent(chain.resolve.alias, '@loadable/component$', loadableComponentFile);
-        setAliasIfPresent(chain.resolve.alias, '@loadable/server$', loadableServerWorkerFile);
-        setAliasIfPresent(chain.resolve.alias, 'fs/promises$', fsPromisesWorkerFile);
-        setAliasIfPresent(chain.resolve.alias, 'node:fs/promises$', fsPromisesWorkerFile);
-        setAliasIfPresent(chain.resolve.alias, 'path$', pathWorkerFile);
-        setAliasIfPresent(chain.resolve.alias, 'node:path$', pathWorkerFile);
-        chain.resolve.alias.set('react-server-dom-rspack/server.node$', 'react-server-dom-rspack/server.edge');
-        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('fs', false);
-        chain.resolve.fallback.set('node:fs', false);
     };
 };
-function getCloudflareBuilderEnvironments({ appContext, environments, normalizedConfig, resolveDeployProvider = resolveStdEnvDeployProvider }) {
-    if (!isCloudflareWorkerDeploy(normalizedConfig, resolveDeployProvider)) return environments;
-    const workerEnvironment = environments[builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME];
+function getCloudflareBuilderEnvironments({ appContext, environments, normalizedConfig }) {
+    if (appContext.deployTarget?.target !== 'cloudflare') return environments;
+    const workerEnvironment = environments[builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME] ?? (appContext.apiOnly ? {
+        output: {
+            target: 'web-worker'
+        },
+        source: {
+            entry: {}
+        }
+    } : void 0);
     if (!workerEnvironment) return environments;
     const workerEntries = getWorkerEntries(workerEnvironment, normalizedConfig, appContext);
     if (!workerEntries) return environments;
@@ -353,7 +531,44 @@ function getCloudflareBuilderEnvironments({ appContext, environments, normalized
             ...workerEnvironment.source,
             entry: workerEntries
         }
-    }, createCloudflareBundlerChain(appContext, Object.keys(workerEntries)));
+    }, createCloudflareBundlerChain(appContext, Object.keys(workerEntries), Boolean(normalizedConfig.server?.rsc)), normalizedConfig.server?.rsc ? (chain)=>{
+        for (const [name, packageName, file] of [
+            [
+                'react$',
+                'react',
+                'index.js'
+            ],
+            [
+                'react/jsx-runtime$',
+                'react',
+                'jsx-runtime.js'
+            ],
+            [
+                'react/jsx-dev-runtime$',
+                'react',
+                'jsx-dev-runtime.js'
+            ],
+            [
+                'react-dom$',
+                'react-dom',
+                'index.js'
+            ],
+            [
+                'react-dom/server.edge$',
+                'react-dom',
+                'server.edge.js'
+            ]
+        ]){
+            const target = resolvePackageFile(packageName, file, [
+                appContext.appDirectory,
+                process.cwd()
+            ]);
+            if (target && chain.resolve.alias.get(name) === target) chain.resolve.alias.delete(name);
+        }
+    } : void 0);
+    if (appContext.apiOnly) return {
+        [builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment
+    };
     return {
         ...environments,
         [builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment
@@ -364,28 +579,31 @@ function applyCloudflareBuilderEnvironments(options) {
         environments: getCloudflareBuilderEnvironments(options)
     };
 }
-const createCloudflareBuilderPlugin = (resolveDeployProvider = resolveStdEnvDeployProvider)=>({
+const createCloudflareBuilderPlugin = ()=>({
         name: '@modern-js/cloudflare-builder',
         setup (api) {
             api.modifyBuilderEnvironments(({ environments })=>applyCloudflareBuilderEnvironments({
                     appContext: api.getAppContext(),
                     environments,
-                    normalizedConfig: api.getNormalizedConfig(),
-                    resolveDeployProvider
+                    normalizedConfig: api.getNormalizedConfig()
                 }));
         }
     });
 exports.applyCloudflareBuilderEnvironments = __webpack_exports__.applyCloudflareBuilderEnvironments;
-exports.applyCloudflareWorkerMfRuntimeBoundary = __webpack_exports__.applyCloudflareWorkerMfRuntimeBoundary;
 exports.applyCloudflareWorkerRspackConfig = __webpack_exports__.applyCloudflareWorkerRspackConfig;
+exports.claimsByFunctionExternal = __webpack_exports__.claimsByFunctionExternal;
+exports.createAbsentOptionalDependencyFilter = __webpack_exports__.createAbsentOptionalDependencyFilter;
 exports.createCloudflareBuilderPlugin = __webpack_exports__.createCloudflareBuilderPlugin;
+exports.createRequestRedirectMatcher = __webpack_exports__.createRequestRedirectMatcher;
 exports.getCloudflareBuilderEnvironments = __webpack_exports__.getCloudflareBuilderEnvironments;
 exports.getCloudflareWorkerRspackConfig = __webpack_exports__.getCloudflareWorkerRspackConfig;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "applyCloudflareBuilderEnvironments",
-    "applyCloudflareWorkerMfRuntimeBoundary",
     "applyCloudflareWorkerRspackConfig",
+    "claimsByFunctionExternal",
+    "createAbsentOptionalDependencyFilter",
     "createCloudflareBuilderPlugin",
+    "createRequestRedirectMatcher",
     "getCloudflareBuilderEnvironments",
     "getCloudflareWorkerRspackConfig"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/cloudflare-output-contract.js

@@ -39,27 +39,49 @@ const CLOUDFLARE_RUNTIME_TYPE = 'cloudflare-module-worker';
 const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = 'module';
 const CLOUDFLARE_WORKER_PACKAGE_TYPE = 'commonjs';
 const CLOUDFLARE_WORKER_BUNDLE_FORMAT = 'commonjs';
+const CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT = 'handleRouteDataRequest';
+const getCloudflareWorkerRouteDataEntryName = (entryName)=>`${entryName}-server-loaders`;
 const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+    '_http_agent',
+    '_http_client',
+    '_http_common',
+    '_http_incoming',
+    '_http_outgoing',
+    '_http_server',
+    '_tls_common',
+    '_tls_wrap',
     'assert',
     'assert/strict',
     'async_hooks',
     'buffer',
     'child_process',
+    'cluster',
+    'console',
+    'constants',
     'crypto',
     'dgram',
+    'diagnostics_channel',
     'dns',
+    'dns/promises',
     'domain',
     'events',
     'fs',
     'fs/promises',
     'http',
     'http2',
+    'https',
     'inspector',
+    'inspector/promises',
     'module',
     'net',
     'os',
     'path',
+    'path/posix',
+    'path/win32',
+    'perf_hooks',
     'process',
+    'punycode',
+    'querystring',
     'readline',
     'readline/promises',
     'repl',
@@ -69,6 +91,8 @@ const CLOUDFLARE_WORKER_NODE_BUILTINS = [
     'stream/promises',
     'stream/web',
     'string_decoder',
+    'sys',
+    'test',
     'timers',
     'timers/promises',
     'tls',
@@ -84,11 +108,13 @@ const CLOUDFLARE_WORKER_NODE_BUILTINS = [
     'zlib'
 ];
 const CLOUDFLARE_WORKER_PLATFORM_MODULES = [
-    'cloudflare:sockets'
+    'cloudflare:sockets',
+    'cloudflare:workers'
 ];
 const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
     'nodejs_compat',
-    'global_fetch_strictly_public'
+    'global_fetch_strictly_public',
+    'enable_request_signal'
 ];
 __webpack_require__.d(__webpack_exports__, {}, {
     CLOUDFLARE_ASSETS_BINDING: CLOUDFLARE_ASSETS_BINDING,
@@ -96,6 +122,7 @@ __webpack_require__.d(__webpack_exports__, {}, {
     CLOUDFLARE_OUTPUT_PACKAGE_TYPE: CLOUDFLARE_OUTPUT_PACKAGE_TYPE,
     CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY: CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY,
     CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS: CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS,
+    CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT: CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
     CLOUDFLARE_RUNTIME_TYPE: CLOUDFLARE_RUNTIME_TYPE,
     CLOUDFLARE_WORKER_BUNDLE_DIRECTORY: CLOUDFLARE_WORKER_BUNDLE_DIRECTORY,
     CLOUDFLARE_WORKER_BUNDLE_FORMAT: CLOUDFLARE_WORKER_BUNDLE_FORMAT,
@@ -105,13 +132,15 @@ __webpack_require__.d(__webpack_exports__, {}, {
     CLOUDFLARE_WORKER_PACKAGE_FILE: CLOUDFLARE_WORKER_PACKAGE_FILE,
     CLOUDFLARE_WORKER_PACKAGE_TYPE: CLOUDFLARE_WORKER_PACKAGE_TYPE,
     CLOUDFLARE_WORKER_PLATFORM_MODULES: CLOUDFLARE_WORKER_PLATFORM_MODULES,
-    CLOUDFLARE_WRANGLER_CONFIG_FILE: CLOUDFLARE_WRANGLER_CONFIG_FILE
+    CLOUDFLARE_WRANGLER_CONFIG_FILE: CLOUDFLARE_WRANGLER_CONFIG_FILE,
+    getCloudflareWorkerRouteDataEntryName: getCloudflareWorkerRouteDataEntryName
 });
 exports.CLOUDFLARE_ASSETS_BINDING = __webpack_exports__.CLOUDFLARE_ASSETS_BINDING;
 exports.CLOUDFLARE_OUTPUT_PACKAGE_FILE = __webpack_exports__.CLOUDFLARE_OUTPUT_PACKAGE_FILE;
 exports.CLOUDFLARE_OUTPUT_PACKAGE_TYPE = __webpack_exports__.CLOUDFLARE_OUTPUT_PACKAGE_TYPE;
 exports.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = __webpack_exports__.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
 exports.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = __webpack_exports__.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+exports.CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT = __webpack_exports__.CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT;
 exports.CLOUDFLARE_RUNTIME_TYPE = __webpack_exports__.CLOUDFLARE_RUNTIME_TYPE;
 exports.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = __webpack_exports__.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
 exports.CLOUDFLARE_WORKER_BUNDLE_FORMAT = __webpack_exports__.CLOUDFLARE_WORKER_BUNDLE_FORMAT;
@@ -122,12 +151,14 @@ exports.CLOUDFLARE_WORKER_PACKAGE_FILE = __webpack_exports__.CLOUDFLARE_WORKER_P
 exports.CLOUDFLARE_WORKER_PACKAGE_TYPE = __webpack_exports__.CLOUDFLARE_WORKER_PACKAGE_TYPE;
 exports.CLOUDFLARE_WORKER_PLATFORM_MODULES = __webpack_exports__.CLOUDFLARE_WORKER_PLATFORM_MODULES;
 exports.CLOUDFLARE_WRANGLER_CONFIG_FILE = __webpack_exports__.CLOUDFLARE_WRANGLER_CONFIG_FILE;
+exports.getCloudflareWorkerRouteDataEntryName = __webpack_exports__.getCloudflareWorkerRouteDataEntryName;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CLOUDFLARE_ASSETS_BINDING",
     "CLOUDFLARE_OUTPUT_PACKAGE_FILE",
     "CLOUDFLARE_OUTPUT_PACKAGE_TYPE",
     "CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY",
     "CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS",
+    "CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT",
     "CLOUDFLARE_RUNTIME_TYPE",
     "CLOUDFLARE_WORKER_BUNDLE_DIRECTORY",
     "CLOUDFLARE_WORKER_BUNDLE_FORMAT",
@@ -137,7 +168,8 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CLOUDFLARE_WORKER_PACKAGE_FILE",
     "CLOUDFLARE_WORKER_PACKAGE_TYPE",
     "CLOUDFLARE_WORKER_PLATFORM_MODULES",
-    "CLOUDFLARE_WRANGLER_CONFIG_FILE"
+    "CLOUDFLARE_WRANGLER_CONFIG_FILE",
+    "getCloudflareWorkerRouteDataEntryName"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true