@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.13 → 3.9.0-ultramodern.14

package/dist/esm-node/cloudflare/worker-manifest.mjs

@@ -1,6 +1,7 @@
 import "node:module";
 import node_path from "node:path";
 import { fs } from "@modern-js/utils";
+import { getCloudflareWorkerRouteDataEntryName } from "../cloudflare-output-contract.mjs";
 import { readRouteSpec } from "./artifacts.mjs";
 import { ASSETS_BINDING, BFF_EFFECT_WORKER_DISPATCHER_EXPORT, BFF_EFFECT_WORKER_ENTRY, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT, DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES, EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE, LOADABLE_STATS_FILE, PUBLIC_ASSETS_DIRECTORY, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, SERVER_BUNDLE_DIRECTORY, WORKER_BUNDLE_DIRECTORY, WORKER_ENTRY } from "./constants.mjs";
 import { createI18nWorkerManifest } from "./i18n-worker.mjs";
@@ -66,13 +67,18 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext, d
     const routeSpec = await readRouteSpec(outputDirectory);
     const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
         const worker = 'string' == typeof route.worker ? route.worker : void 0;
+        const routeDataWorker = route.isSSR && 'string' == typeof route.entryName ? `${WORKER_BUNDLE_DIRECTORY}/${getCloudflareWorkerRouteDataEntryName(route.entryName)}.js` : void 0;
+        const hasRouteDataWorker = routeDataWorker ? await fs.pathExists(node_path.join(outputDirectory, routeDataWorker)) : false;
         return {
             urlPath: route.urlPath,
             entryName: route.entryName,
             entryPath: route.entryPath,
             isSSR: Boolean(route.isSSR),
             worker,
-            workerExists: worker ? await fs.pathExists(node_path.join(outputDirectory, worker)) : false
+            workerExists: worker ? await fs.pathExists(node_path.join(outputDirectory, worker)) : false,
+            ...hasRouteDataWorker ? {
+                routeDataWorker
+            } : {}
         };
     }));
     const bffPrefix = modernConfig.bff?.prefix;
@@ -132,9 +138,12 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext, d
 };
 const createWorkerModuleLoaders = (manifest)=>{
     const imports = new Map();
-    for (const route of manifest.routeSpec.routes)if (route.worker && route.workerExists) {
-        const importPath = `../${String(route.worker).replace(/^\/+/u, '')}`;
-        imports.set(route.worker, `() => import(${JSON.stringify(importPath)})`);
+    for (const route of manifest.routeSpec.routes)for (const worker of [
+        route.workerExists ? route.worker : void 0,
+        route.routeDataWorker
+    ])if (worker) {
+        const importPath = `../${String(worker).replace(/^\/+/u, '')}`;
+        imports.set(worker, `() => import(${JSON.stringify(importPath)})`);
     }
     if (manifest.bff?.worker) {
         const importPath = `../${String(manifest.bff.worker).replace(/^\/+/u, '')}`;

package/dist/esm-node/cloudflare/wrangler-config.mjs

@@ -2,12 +2,16 @@ import "node:module";
 import node_path from "node:path";
 import { ASSETS_BINDING, COMPATIBILITY_DATE_PATTERN, DEFAULT_COMPATIBILITY_DATE, PUBLIC_ASSETS_DIRECTORY, REQUIRED_COMPATIBILITY_FLAGS, WORKER_ENTRY } from "./constants.mjs";
 import { isJsonRecord, normalizeRelativePath } from "./utils.mjs";
-const getCompatibilityDate = (modernConfig)=>{
-    const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
-    const compatibilityDate = configuredDate || DEFAULT_COMPATIBILITY_DATE;
-    if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`deploy.worker.compatibilityDate must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
+const assertSupportedCompatibilityDate = (compatibilityDate, label)=>{
+    if ('string' != typeof compatibilityDate) throw new Error(`${label} must be a YYYY-MM-DD string.`);
+    if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`${label} must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
+    if (compatibilityDate < DEFAULT_COMPATIBILITY_DATE) throw new Error(`${label} must be ${DEFAULT_COMPATIBILITY_DATE} or later, the date the Cloudflare worker Node.js built-in contract is verified against; received ${JSON.stringify(compatibilityDate)}.`);
     return compatibilityDate;
 };
+const getCompatibilityDate = (modernConfig, wranglerCompatibilityDate)=>{
+    if (void 0 !== wranglerCompatibilityDate) return assertSupportedCompatibilityDate(wranglerCompatibilityDate, 'deploy.worker.wrangler.compatibility_date');
+    return assertSupportedCompatibilityDate(modernConfig.deploy?.worker?.compatibilityDate?.trim() || DEFAULT_COMPATIBILITY_DATE, 'deploy.worker.compatibilityDate');
+};
 const getWorkerName = (appDirectory)=>{
     const basename = node_path.basename(appDirectory);
     return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
@@ -22,11 +26,11 @@ const getConfiguredWrangler = (modernConfig)=>{
     if (!isJsonRecord(wrangler)) throw new Error('deploy.worker.wrangler must be a JSON object.');
     return wrangler;
 };
-const createWranglerCompatibilityFlags = (configuredFlags)=>{
+const createWranglerCompatibilityFlags = (configuredFlags, label = 'deploy.worker.wrangler.compatibility_flags')=>{
     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.');
+    if (!Array.isArray(configuredFlags) || configuredFlags.some((flag)=>'string' != typeof flag)) throw new Error(`${label} must be an array of strings.`);
     return [
         ...new Set([
             ...configuredFlags,
@@ -34,6 +38,26 @@ const createWranglerCompatibilityFlags = (configuredFlags)=>{
         ])
     ];
 };
+const createWranglerEnvironments = (wranglerEnv)=>{
+    if (void 0 === wranglerEnv) return;
+    if (!isJsonRecord(wranglerEnv)) throw new Error('deploy.worker.wrangler.env must be an object.');
+    return Object.fromEntries(Object.entries(wranglerEnv).map(([name, environment])=>{
+        const label = `deploy.worker.wrangler.env.${name}`;
+        if (!isJsonRecord(environment)) throw new Error(`${label} must be an object.`);
+        return [
+            name,
+            {
+                ...environment,
+                ...void 0 === environment.compatibility_date ? {} : {
+                    compatibility_date: assertSupportedCompatibilityDate(environment.compatibility_date, `${label}.compatibility_date`)
+                },
+                ...void 0 === environment.compatibility_flags ? {} : {
+                    compatibility_flags: createWranglerCompatibilityFlags(environment.compatibility_flags, `${label}.compatibility_flags`)
+                }
+            }
+        ];
+    }));
+};
 const createWranglerAssetsConfig = (configuredAssets)=>{
     if (void 0 !== configuredAssets && !isJsonRecord(configuredAssets)) throw new Error('deploy.worker.wrangler.assets must be an object.');
     return {
@@ -130,17 +154,21 @@ const createWorkerManifestServiceBindings = (serviceBindings)=>{
 };
 const createWranglerConfig = (appDirectory, modernConfig)=>{
     const wrangler = getConfiguredWrangler(modernConfig);
+    const environments = createWranglerEnvironments(wrangler.env);
     const d1Databases = createWranglerD1Databases(modernConfig, wrangler.d1_databases);
     const serviceBindings = createWorkerServiceBindings(modernConfig, wrangler.services);
     const wranglerServices = createWranglerServices(serviceBindings);
     return {
         $schema: 'node_modules/wrangler/config-schema.json',
         name: getConfiguredWorkerName(appDirectory, modernConfig),
-        compatibility_date: getCompatibilityDate(modernConfig),
         ...wrangler,
+        compatibility_date: getCompatibilityDate(modernConfig, wrangler.compatibility_date),
         main: WORKER_ENTRY,
         compatibility_flags: createWranglerCompatibilityFlags(wrangler.compatibility_flags),
         assets: createWranglerAssetsConfig(wrangler.assets),
+        ...void 0 === environments ? {} : {
+            env: environments
+        },
         ...void 0 === d1Databases ? {} : {
             d1_databases: d1Databases
         },

package/dist/esm-node/cloudflare-builder.mjs

@@ -1,17 +1,56 @@
 import "node:module";
 import node_fs from "node:fs";
-import { createRequire } from "node:module";
+import { createRequire, isBuiltin } from "node:module";
 import node_path from "node:path";
 import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
 import { isProd } from "@modern-js/utils";
 import { provider } from "std-env";
-import { CLOUDFLARE_WORKER_NODE_BUILTINS } from "./cloudflare-output-contract.mjs";
+import { CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PLATFORM_MODULES, getCloudflareWorkerRouteDataEntryName } from "./cloudflare-output-contract.mjs";
 import { getTemplatePath } from "./read-template.mjs";
 const moduleRequire = createRequire(import.meta.url);
 const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
 const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
+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 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 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',
@@ -71,19 +110,154 @@ const resolvePackageFile = (packageName, filePath, paths)=>{
 const setAliasIfPresent = (alias, name, value)=>{
     if (value) alias.set(name, value);
 };
-const getCloudflareWorkerNodeExternals = ()=>Object.fromEntries(CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap((builtin)=>{
-        const nodeBuiltin = `node:${builtin}`;
+const getCloudflareWorkerNodeExternals = ()=>Object.fromEntries([
+        ...CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap((builtin)=>{
+            const nodeBuiltin = `node:${builtin}`;
+            const external = `module-import ${nodeBuiltin}`;
+            return isBuiltin(builtin) ? [
+                [
+                    builtin,
+                    external
+                ],
+                [
+                    nodeBuiltin,
+                    external
+                ]
+            ] : [
+                [
+                    nodeBuiltin,
+                    external
+                ]
+            ];
+        }),
+        ...CLOUDFLARE_WORKER_PLATFORM_MODULES.map((platformModule)=>[
+                platformModule,
+                `module-import ${platformModule}`
+            ])
+    ]);
+const getPackageNameFromRequest = (request)=>{
+    if (request.startsWith('.') || request.startsWith('/') || request.includes(':') || node_path.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 = node_path.join(directory, 'package.json');
+    if (node_fs.existsSync(packageJsonPath)) try {
+        manifest = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+    } catch  {
+        manifest = void 0;
+    }
+    else if (node_path.dirname(directory) !== directory) manifest = findOwningPackageManifest(node_path.dirname(directory), cache);
+    cache.set(directory, manifest);
+    return manifest;
+};
+const isPackageInstalled = (packageName, directory, moduleDirectories)=>moduleDirectories.some((moduleDirectory)=>{
+        if (node_path.isAbsolute(moduleDirectory)) return node_fs.existsSync(node_path.join(moduleDirectory, packageName));
+        let current = directory;
+        while(true){
+            if (node_fs.existsSync(node_path.join(current, moduleDirectory, packageName))) return true;
+            const parent = node_path.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 ?? {});
+                        return (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));
+                            });
+                        };
+                    },
+                    request: data.request
+                });
+                return claimed ? void 0 : false;
+            });
+        });
+    }
+}
 const normalizeWorkerOutputName = (name)=>node_path.posix.normalize(name.replace(/\\/gu, '/')).toLowerCase();
 const reserveWorkerChunkName = (baseName, reservedOutputNames)=>{
     let name = baseName;
@@ -133,6 +307,9 @@ function applyCloudflareWorkerRspackConfig(chain, workerEntryNames) {
     chain.optimization.runtimeChunk(config.optimization.runtimeChunk);
     chain.optimization.splitChunks(config.optimization.splitChunks);
 }
+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);
+}
 function applyCloudflareWorkerMfRuntimeBoundary(chain) {
     const runtimePlugin = getTemplatePath('cloudflare-worker-mf-ssr-runtime-plugin.mjs');
     chain.plugins.delete('plugin-module-federation');
@@ -204,11 +381,40 @@ const prependBundlerChain = (environment, handler)=>{
         }
     };
 };
+const createWorkerRouteDataModule = ()=>[
+        `import { routes } from './${ROUTE_SERVER_LOADERS_FILE}';`,
+        `import { createRouteDataRequestHandler } from ${JSON.stringify(getTemplatePath(WORKER_ROUTE_DATA_TEMPLATE))};`,
+        '',
+        `export const ${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 = node_path.join(internalDirectory, entryName);
+        if (!node_fs.existsSync(node_path.join(entryDirectory, SERVER_LOADER_COMBINED_FILE)) || !node_fs.existsSync(node_path.join(entryDirectory, ROUTE_SERVER_LOADERS_FILE))) return [];
+        const routeDataFile = node_path.join(entryDirectory, WORKER_ROUTE_DATA_FILE);
+        node_fs.writeFileSync(routeDataFile, createWorkerRouteDataModule());
+        return [
+            [
+                getCloudflareWorkerRouteDataEntryName(entryName),
+                [
+                    routeDataFile
+                ]
+            ]
+        ];
+    }));
+};
 const getWorkerEntries = (environment, normalizedConfig, appContext)=>{
     const configuredEntries = environment.source?.entry;
     const effectApiEntry = getEffectBffEntry(normalizedConfig, appContext);
     if (!configuredEntries && !effectApiEntry) return;
-    const entries = configuredEntries ? rewriteWorkerEntries(configuredEntries) : {};
+    const entries = configuredEntries ? {
+        ...rewriteWorkerEntries(configuredEntries),
+        ...getWorkerRouteDataEntries(appContext)
+    } : {};
     return effectApiEntry ? {
         ...entries,
         [BFF_EFFECT_WORKER_ENTRY_NAME]: [
@@ -241,6 +447,7 @@ const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
     ];
     return (chain)=>{
         applyCloudflareWorkerRspackConfig(chain, entryNames);
+        removeCloudflareWorkerDataLoaderClientTransform(chain);
         chain.output.module(true).library({
             type: 'module'
         }).publicPath('/').chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
@@ -249,10 +456,15 @@ const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
             'worker',
             'webpack',
             isProd() ? 'production' : 'development',
-            'import',
-            'require',
             'module'
         ])chain.resolve.conditionNames.add(condition);
+        for (const [dependencyType, condition] of WORKER_DEPENDENCY_CONDITIONS)chain.resolve.byDependency.set(dependencyType, {
+            conditionNames: [
+                condition,
+                '...'
+            ]
+        });
+        chain.plugin('cloudflare-worker-absent-optional-dependencies').use(AbsentOptionalDependencyPlugin);
         applyCloudflareWorkerMfRuntimeBoundary(chain);
         if (tanstackRouterSsrServerFile) {
             chain.resolve.alias.set('@tanstack/router-core/ssr/server$', tanstackRouterSsrServerFile);
@@ -335,4 +547,4 @@ const createCloudflareBuilderPlugin = (resolveDeployProvider = resolveStdEnvDepl
                 }));
         }
     });
-export { applyCloudflareBuilderEnvironments, applyCloudflareWorkerMfRuntimeBoundary, applyCloudflareWorkerRspackConfig, createCloudflareBuilderPlugin, getCloudflareBuilderEnvironments, getCloudflareWorkerRspackConfig };
+export { applyCloudflareBuilderEnvironments, applyCloudflareWorkerMfRuntimeBoundary, applyCloudflareWorkerRspackConfig, claimsByFunctionExternal, createAbsentOptionalDependencyFilter, createCloudflareBuilderPlugin, createRequestRedirectMatcher, getCloudflareBuilderEnvironments, getCloudflareWorkerRspackConfig };

package/dist/esm-node/cloudflare-output-contract.mjs

@@ -11,15 +11,30 @@ 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',
@@ -28,11 +43,17 @@ const CLOUDFLARE_WORKER_NODE_BUILTINS = [
     'http2',
     'https',
     'inspector',
+    'inspector/promises',
     'module',
     'net',
     'os',
     'path',
+    'path/posix',
+    'path/win32',
+    'perf_hooks',
     'process',
+    'punycode',
+    'querystring',
     'readline',
     'readline/promises',
     'repl',
@@ -42,6 +63,8 @@ const CLOUDFLARE_WORKER_NODE_BUILTINS = [
     'stream/promises',
     'stream/web',
     'string_decoder',
+    'sys',
+    'test',
     'timers',
     'timers/promises',
     'tls',
@@ -63,4 +86,4 @@ const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
     'nodejs_compat',
     'global_fetch_strictly_public'
 ];
-export { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_BUNDLE_FORMAT, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PACKAGE_FILE, CLOUDFLARE_WORKER_PACKAGE_TYPE, CLOUDFLARE_WORKER_PLATFORM_MODULES, CLOUDFLARE_WRANGLER_CONFIG_FILE };
+export { 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, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PACKAGE_FILE, CLOUDFLARE_WORKER_PACKAGE_TYPE, CLOUDFLARE_WORKER_PLATFORM_MODULES, CLOUDFLARE_WRANGLER_CONFIG_FILE, getCloudflareWorkerRouteDataEntryName };

package/dist/esm-node/cloudflare-output-verifier/worker-bundles.mjs

@@ -5,9 +5,9 @@ import { pathToFileURL } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
-import { CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PLATFORM_MODULES } from "../cloudflare-output-contract.mjs";
+import { CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PLATFORM_MODULES } from "../cloudflare-output-contract.mjs";
 import { addIssue } from "./issues.mjs";
-const getReferencedRouteWorkers = (manifest)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.worker && route.worker.length > 0 ? route.worker : void 0).filter((worker)=>'string' == typeof worker) : [];
+const getReferencedRouteWorkers = (manifest, field)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.[field] && route[field].length > 0 ? route[field] : void 0).filter((worker)=>'string' == typeof worker) : [];
 const getEffectBffWorker = (manifest)=>manifest?.bff?.runtimeFramework === 'effect' && 'string' == typeof manifest.bff.worker ? manifest.bff.worker : void 0;
 const getWorkerBundleReferences = (manifest)=>{
     const effectBffWorker = getEffectBffWorker(manifest);
@@ -19,9 +19,14 @@ const getWorkerBundleReferences = (manifest)=>{
                 reference: effectBffWorker
             }
         ] : [],
-        ...getReferencedRouteWorkers(manifest).map((reference)=>({
+        ...getReferencedRouteWorkers(manifest, 'worker').map((reference)=>({
                 kind: 'route',
                 reference
+            })),
+        ...getReferencedRouteWorkers(manifest, 'routeDataWorker').map((reference)=>({
+                dispatcherExport: CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
+                kind: 'route-data',
+                reference
             }))
     ];
 };
@@ -42,7 +47,7 @@ const resolveWorkerBundleReference = (issues, outputDirectory, reference, manife
         path: workerPath
     };
 };
-const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
+const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'route-data' === reference.kind ? 'Cloudflare route data worker manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
 const isAstNode = (value)=>null !== value && 'object' == typeof value && 'type' in value && 'string' == typeof value.type;
 const getNodeName = (node)=>{
     if (!isAstNode(node)) return;
@@ -286,9 +291,9 @@ const verifyWorkerModuleClosure = async (issues, entryPath, entrySource, contrac
 };
 const verifyWorkerBundleReferences = async (issues, worker, source, contract)=>{
     const entryAnalysis = await verifyWorkerModuleClosure(issues, worker.path, source, contract);
-    if ('effect-bff' === worker.kind && 'string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) addIssue(issues, {
+    if ('string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) addIssue(issues, {
         code: 'invalid-worker-bundle',
-        message: 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
+        message: 'route-data' === worker.kind ? `Cloudflare route data worker bundle must expose ${worker.dispatcherExport}.` : 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
         path: worker.path
     });
 };

package/dist/esm-node/templates/cloudflare-entry.004-rendering-css.mjs

@@ -2,9 +2,13 @@ function createNoopMonitors() {
   const noop = () => {};
 
   return {
+    counter: noop,
     debug: noop,
     error: noop,
     info: noop,
+    push: noop,
+    timing: noop,
+    trace: noop,
     warn: noop,
   };
 }

package/dist/esm-node/templates/cloudflare-entry.005-worker-dispatch.mjs

@@ -52,6 +52,52 @@ async function getRequestHandler(workerModule) {
   );
 }
 
+const ROUTE_DATA_REQUEST_PARAM = '__loader';
+
+// Route data requests (`?__loader=`) are answered by the entry's route data
+// worker, like the Node server's data handler. Without a match the request
+// falls through to page rendering, as it does on Node.
+async function dispatchRouteDataRequest(route, request) {
+  const routeDataWorkerPath = route.routeDataWorker;
+  if (
+    !routeDataWorkerPath ||
+    !new URL(request.url).searchParams.has(ROUTE_DATA_REQUEST_PARAM)
+  ) {
+    return undefined;
+  }
+
+  const routeDataWorkerModule = await loadWorkerModule(routeDataWorkerPath);
+  const handleRouteDataRequest = routeDataWorkerModule
+    ? getRuntimeModule(routeDataWorkerModule).handleRouteDataRequest
+    : undefined;
+
+  if (typeof handleRouteDataRequest !== 'function') {
+    return new Response(
+      `Route data worker bundle has no handleRouteDataRequest export: ${routeDataWorkerPath}`,
+      {
+        status: 500,
+        headers: {
+          'content-type': 'text/plain; charset=utf-8',
+          'x-modern-js-route-data-worker': routeDataWorkerPath,
+        },
+      },
+    );
+  }
+
+  return handleRouteDataRequest({
+    request,
+    serverRoutes: MODERN_WORKER_MANIFEST.routeSpec.routes,
+    context: {
+      loaderContext: new Map(),
+      monitors: createNoopMonitors(),
+      reporter: {
+        reportTiming: () => {},
+      },
+    },
+    onTiming() {},
+  });
+}
+
 async function dispatchRouteWorker(route, request, env, ctx) {
   const workerPath = route.worker;
   if (!workerPath) {

package/dist/esm-node/templates/cloudflare-entry.006-fetch-handler.mjs

@@ -62,11 +62,18 @@ export default {
     }
 
     if (route?.worker) {
-      const renderableRequest = createRenderableRequest(request);
+      // Route data requests keep their method, as on the Node server.
+      const routeDataResponse = await dispatchRouteDataRequest(route, request);
 
       return finalizeResponseForRequest(
         withAppCorsHeaders(
-          await dispatchRouteWorker(route, renderableRequest, env, ctx),
+          routeDataResponse ??
+            (await dispatchRouteWorker(
+              route,
+              createRenderableRequest(request),
+              env,
+              ctx,
+            )),
           request,
         ),
         request,