@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.2

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

@@ -0,0 +1,152 @@
+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)}.`);
+    return compatibilityDate;
+};
+const getWorkerName = (appDirectory)=>{
+    const basename = node_path.basename(appDirectory);
+    return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
+};
+const getConfiguredWorkerName = (appDirectory, modernConfig)=>{
+    const configuredName = modernConfig.deploy?.worker?.name?.trim();
+    return configuredName || getWorkerName(appDirectory);
+};
+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 assertNonEmptyString = (value, label)=>{
+    if ('string' != typeof value || 0 === value.trim().length) throw new Error(`${label} must be a non-empty string.`);
+    return value.trim();
+};
+const normalizeD1Database = (database, index)=>{
+    const binding = assertNonEmptyString(database.binding, `deploy.worker.d1Databases[${index}].binding`);
+    const databaseName = assertNonEmptyString(database.databaseName, `deploy.worker.d1Databases[${index}].databaseName`);
+    const databaseId = assertNonEmptyString(database.databaseId, `deploy.worker.d1Databases[${index}].databaseId`);
+    const migrationsDir = void 0 === database.migrationsDir ? void 0 : normalizeRelativePath(database.migrationsDir, `deploy.worker.d1Databases[${index}].migrationsDir`, 'app root');
+    const previewDatabaseId = void 0 === database.previewDatabaseId ? void 0 : assertNonEmptyString(database.previewDatabaseId, `deploy.worker.d1Databases[${index}].previewDatabaseId`);
+    return {
+        binding,
+        database_name: databaseName,
+        database_id: databaseId,
+        ...void 0 === migrationsDir ? {} : {
+            migrations_dir: migrationsDir
+        },
+        ...void 0 === previewDatabaseId ? {} : {
+            preview_database_id: previewDatabaseId
+        },
+        ...void 0 === database.remote ? {} : {
+            remote: database.remote
+        }
+    };
+};
+const createWranglerD1Databases = (modernConfig, configuredWranglerD1)=>{
+    const d1Databases = modernConfig.deploy?.worker?.d1Databases;
+    if (void 0 === d1Databases) return configuredWranglerD1;
+    if (void 0 !== configuredWranglerD1) throw new Error('Use deploy.worker.d1Databases or deploy.worker.wrangler.d1_databases, not both.');
+    if (!Array.isArray(d1Databases)) throw new Error('deploy.worker.d1Databases must be an array.');
+    return d1Databases.map(normalizeD1Database);
+};
+const normalizeServiceBinding = (service, index)=>{
+    const binding = assertNonEmptyString(service.binding, `deploy.worker.services[${index}].binding`);
+    const serviceName = assertNonEmptyString(service.service, `deploy.worker.services[${index}].service`);
+    const prefix = void 0 === service.prefix ? void 0 : assertNonEmptyString(service.prefix, `deploy.worker.services[${index}].prefix`);
+    if (void 0 !== service.fragments && !Array.isArray(service.fragments)) throw new Error(`deploy.worker.services[${index}].fragments must be an array.`);
+    const fragments = void 0 === service.fragments ? void 0 : service.fragments.map((fragment, fragmentIndex)=>({
+            remote: assertNonEmptyString(fragment.remote, `deploy.worker.services[${index}].fragments[${fragmentIndex}].remote`),
+            expose: assertNonEmptyString(fragment.expose, `deploy.worker.services[${index}].fragments[${fragmentIndex}].expose`),
+            boundaryId: assertNonEmptyString(fragment.boundaryId, `deploy.worker.services[${index}].fragments[${fragmentIndex}].boundaryId`),
+            path: assertNonEmptyString(fragment.path, `deploy.worker.services[${index}].fragments[${fragmentIndex}].path`)
+        }));
+    return {
+        binding,
+        service: serviceName,
+        ...void 0 === prefix ? {} : {
+            prefix
+        },
+        ...void 0 === fragments ? {} : {
+            fragments
+        }
+    };
+};
+const createWorkerServiceBindings = (modernConfig, configuredWranglerServices)=>{
+    const services = modernConfig.deploy?.worker?.services;
+    if (void 0 === services) return configuredWranglerServices;
+    if (void 0 !== configuredWranglerServices) throw new Error('Use deploy.worker.services or deploy.worker.wrangler.services, not both.');
+    if (!Array.isArray(services)) throw new Error('deploy.worker.services must be an array.');
+    return services.map(normalizeServiceBinding);
+};
+const createWranglerServices = (serviceBindings)=>{
+    if (!Array.isArray(serviceBindings)) return serviceBindings;
+    if (!serviceBindings.every(isJsonRecord)) return serviceBindings;
+    return serviceBindings.map((service)=>{
+        const { prefix, fragments, ...wranglerService } = service;
+        return wranglerService;
+    });
+};
+const createWorkerManifestServiceBindings = (serviceBindings)=>{
+    if (!Array.isArray(serviceBindings)) return;
+    const bindings = serviceBindings;
+    const manifestBindings = bindings.filter((service)=>isJsonRecord(service) && 'string' == typeof service.binding && 'string' == typeof service.service && ('string' == typeof service.prefix || Array.isArray(service.fragments) && service.fragments.length > 0)).map((service)=>({
+            binding: service.binding,
+            service: service.service,
+            interface: 'fetch',
+            ...void 0 === service.prefix ? {} : {
+                prefix: service.prefix
+            },
+            ...void 0 === service.fragments ? {} : {
+                fragments: service.fragments
+            }
+        }));
+    return manifestBindings.length > 0 ? manifestBindings : void 0;
+};
+const createWranglerConfig = (appDirectory, modernConfig)=>{
+    const wrangler = getConfiguredWrangler(modernConfig);
+    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,
+        main: WORKER_ENTRY,
+        compatibility_flags: createWranglerCompatibilityFlags(wrangler.compatibility_flags),
+        assets: createWranglerAssetsConfig(wrangler.assets),
+        ...void 0 === d1Databases ? {} : {
+            d1_databases: d1Databases
+        },
+        ...void 0 === wranglerServices ? {} : {
+            services: wranglerServices
+        }
+    };
+};
+export { createWorkerManifestServiceBindings, createWorkerServiceBindings, createWranglerConfig };

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

@@ -0,0 +1,328 @@
+import "node:module";
+import node_fs from "node:fs";
+import { createRequire } 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 { 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 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 JS_OR_TS_EXTENSIONS = new Set([
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+]);
+const findExistingFile = (candidates)=>candidates.find((candidate)=>node_fs.existsSync(candidate));
+const resolveJsOrTsEntry = (entryWithoutOrWithExtension)=>{
+    if (JS_OR_TS_EXTENSIONS.has(node_path.extname(entryWithoutOrWithExtension))) return node_fs.existsSync(entryWithoutOrWithExtension) ? entryWithoutOrWithExtension : void 0;
+    return findExistingFile([
+        ...JS_OR_TS_EXTENSIONS
+    ].map((extension)=>`${entryWithoutOrWithExtension}${extension}`));
+};
+const resolvePackageEntry = (packageName, paths)=>{
+    try {
+        return node_fs.realpathSync(moduleRequire.resolve(packageName, {
+            paths
+        }));
+    } catch  {
+        return;
+    }
+};
+const findPackageRoot = (entryFile, packageName)=>{
+    let directory = node_path.dirname(entryFile);
+    while(directory !== node_path.dirname(directory)){
+        const packageJsonPath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+            if ('object' == typeof packageJson && null !== packageJson && 'name' in packageJson && packageJson.name === packageName) return directory;
+        } catch  {}
+        directory = node_path.dirname(directory);
+    }
+};
+const resolvePackageFile = (packageName, filePath, paths)=>{
+    try {
+        return node_fs.realpathSync(moduleRequire.resolve(`${packageName}/${filePath}`, {
+            paths
+        }));
+    } catch  {
+        try {
+            const packageJsonPath = moduleRequire.resolve(`${packageName}/package.json`, {
+                paths
+            });
+            const packageFile = node_path.join(node_path.dirname(packageJsonPath), filePath);
+            if (node_fs.existsSync(packageFile)) return node_fs.realpathSync(packageFile);
+        } catch  {}
+        const packageEntry = resolvePackageEntry(packageName, paths);
+        const packageRoot = packageEntry ? findPackageRoot(packageEntry, packageName) : void 0;
+        const packageFile = packageRoot ? node_path.join(packageRoot, filePath) : void 0;
+        return packageFile && node_fs.existsSync(packageFile) ? node_fs.realpathSync(packageFile) : void 0;
+    }
+};
+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}`;
+        return [
+            [
+                builtin,
+                `module-import ${nodeBuiltin}`
+            ],
+            [
+                nodeBuiltin,
+                `module-import ${nodeBuiltin}`
+            ]
+        ];
+    }));
+const normalizeWorkerOutputName = (name)=>node_path.posix.normalize(name.replace(/\\/gu, '/')).toLowerCase();
+const reserveWorkerChunkName = (baseName, reservedOutputNames)=>{
+    let name = baseName;
+    while(reservedOutputNames.has(normalizeWorkerOutputName(name)))name = `${name}_`;
+    return name;
+};
+function getCloudflareWorkerRspackConfig(workerEntryNames) {
+    const entryNames = [
+        ...workerEntryNames
+    ];
+    for (const entryName of entryNames){
+        const slashName = entryName.replace(/\\/gu, '/');
+        const normalizedName = node_path.posix.normalize(slashName);
+        if (entryName !== slashName || normalizedName !== slashName || '.' === normalizedName || normalizedName.startsWith('../') || node_path.posix.isAbsolute(normalizedName) || node_path.win32.isAbsolute(slashName) || /^[A-Za-z]:/u.test(slashName)) throw new Error(`Cloudflare worker entry name "${entryName}" must be a canonical relative output path without dot segments or backslashes.`);
+    }
+    const reservedNames = new Set(entryNames.map(normalizeWorkerOutputName));
+    const runtimeName = reserveWorkerChunkName('__modern_worker_runtime', reservedNames);
+    reservedNames.add(normalizeWorkerOutputName(runtimeName));
+    const sharedName = reserveWorkerChunkName('__modern_worker_shared', reservedNames);
+    return {
+        externals: getCloudflareWorkerNodeExternals(),
+        externalsType: 'module-import',
+        module: {
+            parser: {
+                javascript: {
+                    dynamicImportMode: 'eager'
+                }
+            }
+        },
+        optimization: {
+            runtimeChunk: {
+                name: runtimeName
+            },
+            splitChunks: {
+                chunks: 'all',
+                minSize: 0,
+                name: sharedName
+            }
+        }
+    };
+}
+function applyCloudflareWorkerRspackConfig(chain, workerEntryNames) {
+    const config = getCloudflareWorkerRspackConfig(workerEntryNames);
+    chain.externals(config.externals);
+    chain.externalsType(config.externalsType);
+    chain.module.parser.merge(config.module.parser);
+    chain.optimization.runtimeChunk(config.optimization.runtimeChunk);
+    chain.optimization.splitChunks(config.optimization.splitChunks);
+}
+function applyCloudflareWorkerMfRuntimeBoundary(chain) {
+    const runtimePlugin = 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);
+}
+const getEffectBffEntry = (normalizedConfig, appContext)=>{
+    if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
+    const configuredEntry = normalizedConfig.bff.effect?.entry;
+    if (configuredEntry) {
+        const entryWithoutOrWithExtension = node_path.isAbsolute(configuredEntry) ? configuredEntry : node_path.resolve(appContext.appDirectory, configuredEntry);
+        return resolveJsOrTsEntry(entryWithoutOrWithExtension);
+    }
+    return resolveJsOrTsEntry(node_path.resolve(appContext.apiDirectory, 'index'));
+};
+const CLOUDFLARE_DEPLOY_PROVIDERS = new Set([
+    'cloudflare',
+    'cloudflare_pages',
+    'cloudflare_workers'
+]);
+const resolveStdEnvDeployProvider = ()=>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;
+    if ('string' == typeof entryImport) return {
+        ...description,
+        import: rewriteWorkerEntryPath(entryImport)
+    };
+    if (Array.isArray(entryImport)) return {
+        ...description,
+        import: entryImport.map(rewriteWorkerEntryPath)
+    };
+    return description;
+};
+const rewriteWorkerEntries = (entries)=>Object.fromEntries(Object.entries(entries).map(([name, value])=>{
+        if ('string' == typeof value) return [
+            name,
+            rewriteWorkerEntryPath(value)
+        ];
+        if (Array.isArray(value)) return [
+            name,
+            value.map(rewriteWorkerEntryPath)
+        ];
+        return [
+            name,
+            rewriteWorkerEntryDescription(value)
+        ];
+    }));
+const prependBundlerChain = (environment, handler)=>{
+    const bundlerChain = environment.tools?.bundlerChain;
+    return {
+        ...environment,
+        tools: {
+            ...environment.tools,
+            htmlPlugin: false,
+            bundlerChain: bundlerChain ? Array.isArray(bundlerChain) ? [
+                handler,
+                ...bundlerChain
+            ] : [
+                handler,
+                bundlerChain
+            ] : handler
+        }
+    };
+};
+const getWorkerEntries = (environment, normalizedConfig, appContext)=>{
+    const configuredEntries = environment.source?.entry;
+    if (!configuredEntries) return;
+    const entries = rewriteWorkerEntries(configuredEntries);
+    const effectApiEntry = getEffectBffEntry(normalizedConfig, appContext);
+    return effectApiEntry ? {
+        ...entries,
+        [BFF_EFFECT_WORKER_ENTRY_NAME]: [
+            `${effectApiEntry}?${BFF_EFFECT_WORKER_RUNTIME_QUERY}`
+        ]
+    } : entries;
+};
+const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
+    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);
+    const reactDomFile = resolvePackageFile('react-dom', 'index.js', resolvePaths);
+    const reactDomServerEdgeFile = resolvePackageFile('react-dom', 'server.edge.js', resolvePaths);
+    const loadableComponentFile = resolvePackageFile('@loadable/component', 'dist/esm/loadable.esm.mjs', [
+        ...resolvePaths,
+        getTemplatePath('')
+    ]);
+    const loadableServerWorkerFile = getTemplatePath('cloudflare-worker-loadable-server.mjs');
+    const fsPromisesWorkerFile = getTemplatePath('cloudflare-worker-fs-promises.mjs');
+    const pathWorkerFile = getTemplatePath('cloudflare-worker-path.mjs');
+    const entryNames = [
+        ...workerEntryNames
+    ];
+    return (chain)=>{
+        applyCloudflareWorkerRspackConfig(chain, entryNames);
+        chain.output.module(true).library({
+            type: 'module'
+        }).publicPath('/').chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
+        for (const condition of [
+            'workerd',
+            'worker',
+            'webpack',
+            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);
+        }
+        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[SERVICE_WORKER_ENVIRONMENT_NAME];
+    if (!workerEnvironment) return environments;
+    const workerEntries = getWorkerEntries(workerEnvironment, normalizedConfig, appContext);
+    if (!workerEntries) return environments;
+    const cloudflareWorkerEnvironment = prependBundlerChain({
+        ...workerEnvironment,
+        output: {
+            ...workerEnvironment.output,
+            module: true,
+            target: 'web'
+        },
+        source: {
+            ...workerEnvironment.source,
+            entry: workerEntries
+        }
+    }, createCloudflareBundlerChain(appContext, Object.keys(workerEntries)));
+    return {
+        ...environments,
+        [SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment
+    };
+}
+function applyCloudflareBuilderEnvironments(options) {
+    return {
+        environments: getCloudflareBuilderEnvironments(options)
+    };
+}
+const createCloudflareBuilderPlugin = (resolveDeployProvider = resolveStdEnvDeployProvider)=>({
+        name: '@modern-js/cloudflare-builder',
+        setup (api) {
+            api.modifyBuilderEnvironments(({ environments })=>applyCloudflareBuilderEnvironments({
+                    appContext: api.getAppContext(),
+                    environments,
+                    normalizedConfig: api.getNormalizedConfig(),
+                    resolveDeployProvider
+                }));
+        }
+    });
+export { applyCloudflareBuilderEnvironments, applyCloudflareWorkerMfRuntimeBoundary, applyCloudflareWorkerRspackConfig, createCloudflareBuilderPlugin, getCloudflareBuilderEnvironments, getCloudflareWorkerRspackConfig };

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

@@ -0,0 +1,32 @@
+import "node:module";
+const CLOUDFLARE_WORKER_ENTRY = 'server/index.mjs';
+const CLOUDFLARE_WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const CLOUDFLARE_WRANGLER_CONFIG_FILE = 'wrangler.json';
+const CLOUDFLARE_OUTPUT_PACKAGE_FILE = 'package.json';
+const CLOUDFLARE_WORKER_PACKAGE_FILE = 'worker/package.json';
+const CLOUDFLARE_ASSETS_BINDING = 'ASSETS';
+const CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = 'public';
+const CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = 'worker';
+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_WORKER_NODE_BUILTINS = [
+    'async_hooks',
+    'buffer',
+    'crypto',
+    'events',
+    'fs/promises',
+    'module',
+    'path',
+    'process',
+    'stream',
+    'string_decoder',
+    'url',
+    'util'
+];
+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_WRANGLER_CONFIG_FILE };

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

@@ -0,0 +1,46 @@
+import "node:module";
+import node_path from "node:path";
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WORKER_PACKAGE_FILE, CLOUDFLARE_WORKER_PACKAGE_TYPE, CLOUDFLARE_WRANGLER_CONFIG_FILE } from "./cloudflare-output-contract.mjs";
+const resolveOutput = (outputDirectory, relativePath)=>node_path.join(outputDirectory, relativePath);
+function createCloudflareOutputPlan(outputDirectory) {
+    return {
+        outputDirectory,
+        requiredFiles: [
+            CLOUDFLARE_WORKER_ENTRY,
+            CLOUDFLARE_WORKER_MANIFEST,
+            CLOUDFLARE_WRANGLER_CONFIG_FILE,
+            CLOUDFLARE_OUTPUT_PACKAGE_FILE
+        ],
+        publicLeakDirectories: [
+            'server',
+            CLOUDFLARE_WORKER_BUNDLE_DIRECTORY
+        ],
+        paths: {
+            workerEntry: resolveOutput(outputDirectory, CLOUDFLARE_WORKER_ENTRY),
+            workerManifest: resolveOutput(outputDirectory, CLOUDFLARE_WORKER_MANIFEST),
+            wranglerConfig: resolveOutput(outputDirectory, CLOUDFLARE_WRANGLER_CONFIG_FILE),
+            outputPackage: resolveOutput(outputDirectory, CLOUDFLARE_OUTPUT_PACKAGE_FILE),
+            workerPackage: resolveOutput(outputDirectory, CLOUDFLARE_WORKER_PACKAGE_FILE),
+            publicAssets: resolveOutput(outputDirectory, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY),
+            workerBundle: resolveOutput(outputDirectory, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY)
+        },
+        packages: {
+            output: {
+                type: CLOUDFLARE_OUTPUT_PACKAGE_TYPE
+            },
+            worker: {
+                type: CLOUDFLARE_WORKER_PACKAGE_TYPE
+            }
+        },
+        wrangler: {
+            main: CLOUDFLARE_WORKER_ENTRY,
+            assets: {
+                binding: CLOUDFLARE_ASSETS_BINDING,
+                directory: `./${CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`,
+                run_worker_first: true
+            },
+            requiredCompatibilityFlags: CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS
+        }
+    };
+}
+export { createCloudflareOutputPlan };

package/dist/esm-node/cloudflare-output-verifier/identity.mjs

@@ -0,0 +1,55 @@
+import "node:module";
+import { DELIVERY_UNIT_IDENTITY_FIELDS, deliveryUnitIdentityFieldValue } from "@modern-js/utils/universal";
+import { addIssue, assertEqual } from "./issues.mjs";
+const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
+    const stamped = manifest?.deliveryUnit;
+    const hasStamp = Boolean(stamped) && 'object' == typeof stamped;
+    if (declared) {
+        if (!hasStamp) return void addIssue(issues, {
+            code: 'missing-delivery-unit',
+            message: `Cloudflare worker manifest is missing the delivery-unit identity declared by the workspace topology (expected unitId ${declared.unitId}, buildMarker ${declared.buildMarker}).`,
+            path: manifestPath
+        });
+        for (const field of DELIVERY_UNIT_IDENTITY_FIELDS){
+            const stampedValue = deliveryUnitIdentityFieldValue(stamped, field);
+            assertEqual(issues, stampedValue, declared[field], {
+                code: 'delivery-unit-drift',
+                message: `Cloudflare worker manifest deliveryUnit.${field} must match the topology delivery-unit record (expected ${declared[field]}, received ${stampedValue ?? 'undefined'}).`,
+                path: manifestPath
+            });
+        }
+    }
+    if (hasStamp && stamped.surfaces && 'object' == typeof stamped.surfaces) for (const surface of [
+        'ui',
+        'api'
+    ]){
+        const marker = stamped.surfaces[surface];
+        const expected = declared?.surfaces?.[surface];
+        if (declared?.surfaces && !expected) {
+            if (marker) addIssue(issues, {
+                code: 'delivery-unit-drift',
+                message: `Cloudflare worker manifest declares an unexpected ${surface} delivery-unit surface for this topology profile.`,
+                path: manifestPath
+            });
+            continue;
+        }
+        if (!marker || 'object' != typeof marker) {
+            addIssue(issues, {
+                code: 'missing-delivery-unit',
+                message: `Cloudflare worker manifest is missing the ${surface} delivery-unit surface marker.`,
+                path: manifestPath
+            });
+            continue;
+        }
+        for (const field of DELIVERY_UNIT_IDENTITY_FIELDS){
+            const markerValue = deliveryUnitIdentityFieldValue(marker, field);
+            const stampedValue = deliveryUnitIdentityFieldValue(stamped, field);
+            assertEqual(issues, markerValue, stampedValue, {
+                code: 'delivery-unit-drift',
+                message: `Cloudflare worker manifest ${surface} surface deliveryUnit.${field} must derive from one delivery-unit record (expected ${stampedValue ?? 'undefined'}, received ${markerValue ?? 'undefined'}).`,
+                path: manifestPath
+            });
+        }
+    }
+};
+export { verifyDeliveryUnitIdentity };