@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm/cloudflare-builder.mjs

@@ -1,16 +1,52 @@
 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 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',
@@ -70,19 +106,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;
@@ -132,11 +303,8 @@ function applyCloudflareWorkerRspackConfig(chain, workerEntryNames) {
     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);
+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;
@@ -147,18 +315,6 @@ const getEffectBffEntry = (normalizedConfig, appContext)=>{
     }
     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;
@@ -203,11 +359,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;
-    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]: [
@@ -220,9 +405,6 @@ const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
         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);
@@ -232,62 +414,49 @@ const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
         ...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);
+        removeCloudflareWorkerDataLoaderClientTransform(chain);
         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',
             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');
         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];
+function getCloudflareBuilderEnvironments({ appContext, environments, normalizedConfig }) {
+    if (appContext.deployTarget?.target !== 'cloudflare') return environments;
+    const workerEnvironment = environments[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;
@@ -303,6 +472,9 @@ function getCloudflareBuilderEnvironments({ appContext, environments, normalized
             entry: workerEntries
         }
     }, createCloudflareBundlerChain(appContext, Object.keys(workerEntries)));
+    if (appContext.apiOnly) return {
+        [SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment
+    };
     return {
         ...environments,
         [SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment
@@ -313,15 +485,14 @@ 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()
                 }));
         }
     });
-export { applyCloudflareBuilderEnvironments, applyCloudflareWorkerMfRuntimeBoundary, applyCloudflareWorkerRspackConfig, createCloudflareBuilderPlugin, getCloudflareBuilderEnvironments, getCloudflareWorkerRspackConfig };
+export { applyCloudflareBuilderEnvironments, applyCloudflareWorkerRspackConfig, claimsByFunctionExternal, createAbsentOptionalDependencyFilter, createCloudflareBuilderPlugin, createRequestRedirectMatcher, getCloudflareBuilderEnvironments, getCloudflareWorkerRspackConfig };

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

@@ -10,22 +10,79 @@ 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',
+    'sqlite',
     'stream',
+    'stream/consumers',
+    'stream/promises',
+    'stream/web',
     'string_decoder',
+    'sys',
+    'test',
+    'timers',
+    'timers/promises',
+    'tls',
+    'trace_events',
+    'tty',
     'url',
-    'util'
+    'util',
+    'util/types',
+    'v8',
+    'vm',
+    'wasi',
+    'worker_threads',
+    'zlib'
+];
+const CLOUDFLARE_WORKER_PLATFORM_MODULES = [
+    'cloudflare:sockets'
 ];
 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 };
+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/cloudflare-output-verifier/identity.mjs

@@ -1,4 +1,4 @@
-import { DELIVERY_UNIT_IDENTITY_FIELDS, deliveryUnitIdentityFieldValue } from "@modern-js/utils/universal";
+import { DELIVERY_UNIT_IDENTITY_FIELDS, deliveryUnitIdentityFieldValue } from "@modern-js/backend-federation-contracts";
 import { addIssue, assertEqual } from "./issues.mjs";
 const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
     const stamped = manifest?.deliveryUnit;
@@ -24,30 +24,32 @@ const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
     ]){
         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
-            });
+        if (expected || marker) {
+            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
+                });
+            }
         }
     }
 };

package/dist/esm/cloudflare-output-verifier/index.mjs

@@ -72,6 +72,16 @@ const verifyCloudflareOutput = async (options)=>{
         }
     }
     if (wrangler) {
+        if ('string' != typeof wrangler.name || 0 === wrangler.name.trim().length) addIssue(issues, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json name must be a non-empty worker name.',
+            path: wranglerPath
+        });
+        if ('string' != typeof wrangler.compatibility_date || !/^\d{4}-\d{2}-\d{2}$/u.test(wrangler.compatibility_date)) addIssue(issues, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json compatibility_date must use YYYY-MM-DD.',
+            path: wranglerPath
+        });
         assertEqual(issues, wrangler.main, outputPlan.wrangler.main, {
             code: 'invalid-wrangler',
             message: `wrangler.json main must be ${outputPlan.wrangler.main}.`,

package/dist/esm/cloudflare-output-verifier/manifest.mjs

@@ -42,6 +42,52 @@ const verifyManifestShape = (issues, manifest, manifestPath)=>{
         message: 'Cloudflare output manifest routeSpec.routes must be array.',
         path: manifestPath
     });
+    const security = manifest.security;
+    if (security && 'object' == typeof security && 'boolean' == typeof security.enabled) {
+        const cors = security.cors;
+        if (!cors || 'object' != typeof cors || 'boolean' != typeof cors.assets || !Array.isArray(cors.allowedOrigins) || !Array.isArray(cors.allowedMethods) || !Array.isArray(cors.allowedHeaders)) addIssue(issues, {
+            code: 'invalid-manifest',
+            message: 'Cloudflare output manifest security.cors is incomplete.',
+            path: manifestPath
+        });
+        if (security.enabled) {
+            const headers = security.headers;
+            const csp = security.contentSecurityPolicy;
+            const noindex = security.noindex;
+            if (!headers || 'object' != typeof headers || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.referrerPolicy) || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.contentTypeOptions) || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.permissionsPolicy)) addIssue(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.headers is incomplete.',
+                path: manifestPath
+            });
+            if (!csp || ![
+                'off',
+                'report-only',
+                'enforce'
+            ].includes(csp.mode) || !csp.directives || 'object' != typeof csp.directives || Array.isArray(csp.directives) || Object.values(csp.directives).some((value)=>!Array.isArray(value) || value.some((entry)=>'string' != typeof entry))) addIssue(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.contentSecurityPolicy is invalid.',
+                path: manifestPath
+            });
+            if (!noindex || 'boolean' != typeof noindex.workersDev || 'boolean' != typeof noindex.localhost || !Array.isArray(noindex.previewHostnames)) addIssue(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.noindex is incomplete.',
+                path: manifestPath
+            });
+        }
+    } else addIssue(issues, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest security.enabled must be a boolean.',
+        path: manifestPath
+    });
     if (manifest.bff?.runtimeFramework === 'effect') assertEqual(issues, manifest.bff.dispatcherExport, BFF_EFFECT_WORKER_DISPATCHER_EXPORT, {
         code: 'invalid-manifest',
         message: `Cloudflare Effect BFF manifest dispatcherExport must be ${BFF_EFFECT_WORKER_DISPATCHER_EXPORT}.`,

package/dist/esm/cloudflare-output-verifier/mutation-policy.mjs

@@ -84,7 +84,13 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
     const files = (await Promise.all(options.scanRoots.map((scanRoot)=>walkFiles(node_path.resolve(scanRoot))))).flat();
     for (const file of files){
         if (excludedFiles.has(file)) continue;
-        const source = await promises.readFile(file, 'utf-8');
+        let source;
+        try {
+            source = await promises.readFile(file, 'utf-8');
+        } catch (error) {
+            if ('ENOENT' === error.code) continue;
+            throw error;
+        }
         for (const forbidden of FORBIDDEN_MUTATION_PATTERNS)if (forbidden.pattern.test(source)) addIssue(issues, {
             code: forbidden.code,
             message: forbidden.message,