@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.3 → 3.5.0-ultramodern.30

package/dist/cjs/plugins/deploy/platforms/cloudflare.js

@@ -43,17 +43,19 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const utils_namespaceObject = require("@modern-js/utils");
 const index_js_namespaceObject = require("../utils/index.js");
-const WORKER_ENTRY = 'server/index.mjs';
-const WORKER_MANIFEST = 'server/modern-worker-manifest.json';
-const WRANGLER_CONFIG_FILE = 'wrangler.json';
-const OUTPUT_PACKAGE_FILE = 'package.json';
-const ASSETS_BINDING = 'ASSETS';
+const external_cloudflare_output_contract_js_namespaceObject = require("./cloudflare-output-contract.js");
+const external_cloudflare_output_plan_js_namespaceObject = require("./cloudflare-output-plan.js");
+const external_cloudflare_output_verifier_js_namespaceObject = require("./cloudflare-output-verifier.js");
+const WORKER_ENTRY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY;
+const WRANGLER_CONFIG_FILE = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WRANGLER_CONFIG_FILE;
+const OUTPUT_PACKAGE_FILE = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+const ASSETS_BINDING = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ASSETS_BINDING;
 const ROUTE_SPEC_FILE = 'route.json';
 const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
 const LOADABLE_STATS_FILE = 'loadable-stats.json';
 const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
-const PUBLIC_ASSETS_DIRECTORY = 'public';
-const WORKER_BUNDLE_DIRECTORY = 'worker';
+const PUBLIC_ASSETS_DIRECTORY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+const WORKER_BUNDLE_DIRECTORY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
 const SERVER_BUNDLE_DIRECTORY = 'bundles';
 const SERVER_OUTPUT_DIRECTORY = 'server';
 const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
@@ -64,10 +66,7 @@ const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.
 const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
 const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
 const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
-const REQUIRED_COMPATIBILITY_FLAGS = [
-    'nodejs_compat',
-    'global_fetch_strictly_public'
-];
+const REQUIRED_COMPATIBILITY_FLAGS = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
 const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
     WRANGLER_CONFIG_FILE,
     OUTPUT_PACKAGE_FILE
@@ -151,6 +150,102 @@ const DEFAULT_CSP_DIRECTIVES = {
         'blob:'
     ]
 };
+const I18N_SERVER_PLUGIN_NAME = 'plugin-i18n/server';
+const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
+    order: [
+        'querystring',
+        'cookie',
+        'localStorage',
+        'header',
+        'navigator',
+        'htmlTag',
+        'path',
+        'subdomain'
+    ],
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupHeader: 'accept-language'
+};
+const SERVER_SIDE_I18N_DETECTORS = new Set([
+    'querystring',
+    'cookie',
+    'header'
+]);
+const isRecord = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+const toStringArray = (value)=>Array.isArray(value) ? value.filter((entry)=>'string' == typeof entry) : [];
+const getI18nServerPlugin = (appContext)=>appContext.serverPlugins?.find((plugin)=>plugin.name.includes(I18N_SERVER_PLUGIN_NAME));
+const removeLocaleDetectionByEntry = (config)=>{
+    const { localeDetectionByEntry: _localeDetectionByEntry, ...rest } = config;
+    return rest;
+};
+const getEntryLocaleDetection = (entryName, localeDetection)=>{
+    const byEntry = isRecord(localeDetection.localeDetectionByEntry) ? localeDetection.localeDetectionByEntry : void 0;
+    const entryConfig = byEntry?.[entryName];
+    const globalConfig = removeLocaleDetectionByEntry(localeDetection);
+    return isRecord(entryConfig) ? {
+        ...globalConfig,
+        ...entryConfig
+    } : globalConfig;
+};
+const normalizeI18nDetection = (detection)=>{
+    const configured = isRecord(detection) ? detection : {};
+    const rawOrder = Array.isArray(configured.order) ? configured.order : DEFAULT_I18NEXT_DETECTION_OPTIONS.order;
+    const order = rawOrder.filter((entry)=>'string' == typeof entry && SERVER_SIDE_I18N_DETECTORS.has(entry));
+    return {
+        order: order.length > 0 ? order : [
+            'querystring',
+            'cookie',
+            'header'
+        ],
+        lookupQuerystring: 'string' == typeof configured.lookupQuerystring && configured.lookupQuerystring ? configured.lookupQuerystring : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring,
+        lookupCookie: 'string' == typeof configured.lookupCookie && configured.lookupCookie ? configured.lookupCookie : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie,
+        lookupHeader: 'string' == typeof configured.lookupHeader && configured.lookupHeader ? configured.lookupHeader : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader
+    };
+};
+const normalizeLocalisedUrls = (localisedUrls)=>{
+    if (!isRecord(localisedUrls) || 0 === Object.keys(localisedUrls).length) return;
+    const normalized = {};
+    for (const [canonicalPath, languageMap] of Object.entries(localisedUrls)){
+        if (!isRecord(languageMap)) continue;
+        const normalizedLanguageMap = Object.fromEntries(Object.entries(languageMap).filter((entry)=>'string' == typeof entry[1] && entry[1].length > 0));
+        if (Object.keys(normalizedLanguageMap).length > 0) normalized[canonicalPath] = normalizedLanguageMap;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : void 0;
+};
+const normalizeWorkerI18nEntry = (entryName, localeDetection, staticRoutePrefixes)=>{
+    const entryConfig = getEntryLocaleDetection(entryName, localeDetection);
+    const languages = toStringArray(entryConfig.languages);
+    if (true !== entryConfig.localePathRedirect || 0 === languages.length) return;
+    const fallbackLanguage = 'string' == typeof entryConfig.fallbackLanguage && entryConfig.fallbackLanguage ? entryConfig.fallbackLanguage : 'en';
+    const ignoreRedirectRoutes = Array.isArray(entryConfig.ignoreRedirectRoutes) ? toStringArray(entryConfig.ignoreRedirectRoutes) : [];
+    const localisedUrls = normalizeLocalisedUrls(entryConfig.localisedUrls);
+    return {
+        i18nextDetector: false !== entryConfig.i18nextDetector,
+        languages,
+        fallbackLanguage,
+        detection: normalizeI18nDetection(entryConfig.detection),
+        ignoreRedirectRoutes,
+        staticRoutePrefixes,
+        ...localisedUrls ? {
+            localisedUrls
+        } : {}
+    };
+};
+const createI18nWorkerManifest = (routeSpec, appContext)=>{
+    const i18nServerPlugin = getI18nServerPlugin(appContext);
+    const localeDetection = i18nServerPlugin?.options?.localeDetection;
+    if (!isRecord(localeDetection)) return;
+    const staticRoutePrefixes = toStringArray(i18nServerPlugin?.options?.staticRoutePrefixes);
+    const entries = {};
+    for (const route of routeSpec.routes){
+        if ('string' != typeof route.entryName || entries[route.entryName]) continue;
+        const entry = normalizeWorkerI18nEntry(route.entryName, localeDetection, staticRoutePrefixes);
+        if (entry) entries[route.entryName] = entry;
+    }
+    return Object.keys(entries).length > 0 ? {
+        entries
+    } : void 0;
+};
 const getCompatibilityDate = (modernConfig)=>{
     const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
     const compatibilityDate = configuredDate || DEFAULT_COMPATIBILITY_DATE;
@@ -165,11 +260,12 @@ const getConfiguredWorkerName = (appDirectory, modernConfig)=>{
     const configuredName = modernConfig.deploy?.worker?.name?.trim();
     return configuredName || getWorkerName(appDirectory);
 };
-const normalizeRelativePath = (value, label, scope = 'app output')=>{
+const normalizeRelativePath = (value, label, scope = 'app output', options = {})=>{
     if ('string' != typeof value) throw new Error(`${label} must be a relative path inside the ${scope}.`);
     const normalized = value.trim().replace(/\\/g, '/').replace(/^\.\/+/u, '').replace(/\/+$/u, '');
     const segments = normalized.split('/');
-    if (!normalized || external_node_path_default().isAbsolute(normalized) || '.' === normalized || segments.includes('..')) throw new Error(`${label} must be a relative path inside the ${scope}.`);
+    const isRootDestination = '.' === normalized;
+    if (!normalized || external_node_path_default().isAbsolute(normalized) || !options.allowRoot && isRootDestination || segments.includes('..')) throw new Error(`${label} must be a relative path inside the ${scope}.`);
     return normalized;
 };
 const normalizeDirectiveValues = (value)=>{
@@ -324,9 +420,48 @@ const createWranglerD1Databases = (modernConfig, configuredWranglerD1)=>{
     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`);
+    return {
+        binding,
+        service: serviceName,
+        ...void 0 === prefix ? {} : {
+            prefix
+        }
+    };
+};
+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, ...wranglerService } = service;
+        return wranglerService;
+    });
+};
+const createWorkerManifestServiceBindings = (serviceBindings)=>{
+    if (!Array.isArray(serviceBindings)) return;
+    const dispatchBindings = serviceBindings.filter((service)=>isJsonRecord(service) && 'string' == typeof service.binding && 'string' == typeof service.service && 'string' == typeof service.prefix).map((service)=>({
+            binding: service.binding,
+            service: service.service,
+            prefix: service.prefix,
+            interface: 'fetch'
+        }));
+    return dispatchBindings.length > 0 ? dispatchBindings : 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),
@@ -337,6 +472,9 @@ const createWranglerConfig = (appDirectory, modernConfig)=>{
         assets: createWranglerAssetsConfig(wrangler.assets),
         ...void 0 === d1Databases ? {} : {
             d1_databases: d1Databases
+        },
+        ...void 0 === wranglerServices ? {} : {
+            services: wranglerServices
         }
     };
 };
@@ -353,6 +491,18 @@ const normalizeCloudflareArtifact = (artifact, index)=>{
     };
 };
 const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
+const normalizeCloudflarePublicAsset = (asset, index)=>{
+    const from = normalizeRelativePath(asset.from, `deploy.worker.publicAssets[${index}].from`, 'app root');
+    const to = normalizeRelativePath(asset.to, `deploy.worker.publicAssets[${index}].to`, 'Cloudflare public output', {
+        allowRoot: true
+    });
+    return {
+        from,
+        to,
+        index
+    };
+};
+const getCloudflarePublicAssets = (modernConfig)=>(modernConfig.deploy?.worker?.publicAssets ?? []).map(normalizeCloudflarePublicAsset);
 const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
     for (const artifact of artifacts){
         const sourcePath = external_node_path_default().join(appDirectory, artifact.from);
@@ -360,6 +510,13 @@ const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)
         await utils_namespaceObject.fs.copy(sourcePath, external_node_path_default().join(outputDirectory, artifact.to));
     }
 };
+const copyCloudflarePublicAssets = async (appDirectory, publicDirectory, publicAssets)=>{
+    for (const asset of publicAssets){
+        const sourcePath = external_node_path_default().join(appDirectory, asset.from);
+        if (!await utils_namespaceObject.fs.pathExists(sourcePath)) throw new Error(`deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`);
+        await utils_namespaceObject.fs.copy(sourcePath, external_node_path_default().join(publicDirectory, asset.to));
+    }
+};
 const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
     for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
         if (!database.migrationsDir) continue;
@@ -380,8 +537,79 @@ const readRouteSpec = async (outputDirectory)=>{
         routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
     };
 };
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const ULTRAMODERN_BUILD_MODULE = 'shared/ultramodern-build.ts';
+const nonEmptyString = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+const toDeliveryUnitIdentity = (value)=>{
+    if (!isRecord(value)) return;
+    const unitId = nonEmptyString(value.unitId);
+    const buildMarker = nonEmptyString(value.buildMarker);
+    const sourceRevision = nonEmptyString(value.sourceRevision);
+    if (!unitId || !buildMarker || !sourceRevision) return;
+    return {
+        unitId,
+        buildMarker,
+        sourceRevision
+    };
+};
+const findWorkspaceRoot = async (appDirectory)=>{
+    let current = external_node_path_default().resolve(appDirectory);
+    for(;;){
+        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = external_node_path_default().dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const resolveTopologyDeliveryUnit = async (appDirectory)=>{
+    const workspaceRoot = await findWorkspaceRoot(appDirectory);
+    if (!workspaceRoot) return;
+    let compactConfig;
+    try {
+        compactConfig = await utils_namespaceObject.fs.readJSON(external_node_path_default().join(workspaceRoot, COMPACT_CONFIG_PATH));
+    } catch  {
+        return;
+    }
+    if (!isRecord(compactConfig)) return;
+    const topology = isRecord(compactConfig.topology) ? compactConfig.topology : void 0;
+    const apps = Array.isArray(topology?.apps) ? topology.apps : [];
+    const resolvedAppDirectory = external_node_path_default().resolve(appDirectory);
+    for (const app of apps){
+        if (!isRecord(app)) continue;
+        const appPath = nonEmptyString(app.path);
+        if (appPath && external_node_path_default().resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory) return toDeliveryUnitIdentity(app.deliveryUnit);
+    }
+    return toDeliveryUnitIdentity(compactConfig.deliveryUnit);
+};
+const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
+    const buildModulePath = external_node_path_default().join(appDirectory, ULTRAMODERN_BUILD_MODULE);
+    if (!await utils_namespaceObject.fs.pathExists(buildModulePath)) return;
+    const source = await utils_namespaceObject.fs.readFile(buildModulePath, 'utf8');
+    const buildMarker = source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1];
+    const unitId = source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1];
+    const sourceRevision = source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1];
+    if (!buildMarker || !unitId || !sourceRevision) return;
+    const identity = {
+        unitId,
+        buildMarker,
+        sourceRevision
+    };
+    return {
+        ...identity,
+        surfaces: {
+            ui: {
+                ...identity,
+                surface: 'ui'
+            },
+            api: {
+                ...identity,
+                surface: 'api'
+            }
+        }
+    };
+};
 const createMissingEffectBffWorkerError = (outputDirectory, worker)=>new Error(`Cloudflare Effect API runtime is configured, but the BFF worker bundle is missing: ${external_node_path_default().join(outputDirectory, worker)}. ${EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE}`);
-const createWorkerManifest = async (outputDirectory, modernConfig)=>{
+const createWorkerManifest = async (outputDirectory, modernConfig, appContext, deliveryUnitStamp)=>{
     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;
@@ -398,11 +626,12 @@ const createWorkerManifest = async (outputDirectory, modernConfig)=>{
     const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
     const isEffectApi = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
     const effectApiWorkerExists = await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
+    const serviceBindings = createWorkerManifestServiceBindings(createWorkerServiceBindings(modernConfig, void 0));
     if (isEffectApi && primaryBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, BFF_EFFECT_WORKER_ENTRY);
     return {
         version: 1,
         runtime: {
-            type: 'cloudflare-module-worker',
+            type: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_RUNTIME_TYPE,
             entry: WORKER_ENTRY,
             fetchExport: true,
             nodeListen: false
@@ -418,7 +647,7 @@ const createWorkerManifest = async (outputDirectory, modernConfig)=>{
         },
         workerBundles: {
             directory: WORKER_BUNDLE_DIRECTORY,
-            format: 'commonjs',
+            format: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_FORMAT,
             importableFromModuleWorker: true,
             requestHandlerExport: 'requestHandler'
         },
@@ -427,11 +656,18 @@ const createWorkerManifest = async (outputDirectory, modernConfig)=>{
             routeManifest: ROUTE_MANIFEST_FILE
         },
         security: createCloudflareWorkerSecurityPolicy(modernConfig),
+        ...deliveryUnitStamp ? {
+            deliveryUnit: deliveryUnitStamp
+        } : {},
+        i18n: createI18nWorkerManifest(routeSpec, appContext),
         bff: isEffectApi && primaryBffPrefix && effectApiWorkerExists ? {
             runtimeFramework: 'effect',
             prefix: primaryBffPrefix,
             worker: BFF_EFFECT_WORKER_ENTRY
-        } : void 0
+        } : void 0,
+        ...void 0 === serviceBindings ? {} : {
+            serviceBindings
+        }
     };
 };
 const createWorkerModuleLoaders = (manifest)=>{
@@ -483,11 +719,12 @@ const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
 const createCloudflarePreset = ({ appContext, modernConfig })=>{
     const { appDirectory, distDirectory } = appContext;
     const outputDirectory = external_node_path_default().join(appDirectory, '.output');
-    const publicDirectory = external_node_path_default().join(outputDirectory, PUBLIC_ASSETS_DIRECTORY);
-    const workerEntryPath = external_node_path_default().join(outputDirectory, WORKER_ENTRY);
-    const workerManifestPath = external_node_path_default().join(outputDirectory, WORKER_MANIFEST);
+    const outputPlan = (0, external_cloudflare_output_plan_js_namespaceObject.createCloudflareOutputPlan)(outputDirectory);
+    const publicDirectory = outputPlan.paths.publicAssets;
+    const workerEntryPath = outputPlan.paths.workerEntry;
+    const workerManifestPath = outputPlan.paths.workerManifest;
     const routeSpecOutputPath = external_node_path_default().join(outputDirectory, ROUTE_SPEC_OUTPUT);
-    const wranglerConfigPath = external_node_path_default().join(outputDirectory, WRANGLER_CONFIG_FILE);
+    const wranglerConfigPath = outputPlan.paths.wranglerConfig;
     const cloudflareArtifacts = getCloudflareArtifacts(modernConfig);
     const publicAssetExcludes = getPublicAssetExcludes(appDirectory, modernConfig);
     return {
@@ -503,31 +740,37 @@ const createCloudflarePreset = ({ appContext, modernConfig })=>{
             const routeSpecSourcePath = external_node_path_default().join(distDirectory, ROUTE_SPEC_FILE);
             if (await utils_namespaceObject.fs.pathExists(routeSpecSourcePath)) await utils_namespaceObject.fs.copy(routeSpecSourcePath, routeSpecOutputPath);
             const workerBundleSourceDirectory = external_node_path_default().join(distDirectory, WORKER_BUNDLE_DIRECTORY);
-            const workerBundleOutputDirectory = external_node_path_default().join(outputDirectory, WORKER_BUNDLE_DIRECTORY);
+            const workerBundleOutputDirectory = outputPlan.paths.workerBundle;
             if (await utils_namespaceObject.fs.pathExists(workerBundleSourceDirectory)) {
                 await utils_namespaceObject.fs.copy(workerBundleSourceDirectory, workerBundleOutputDirectory, {
                     filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
                 });
-                await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(workerBundleOutputDirectory, 'package.json'), {
-                    type: 'commonjs'
-                });
+                await utils_namespaceObject.fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
             }
             await copyCloudflareArtifacts(appDirectory, outputDirectory, cloudflareArtifacts);
+            await copyCloudflarePublicAssets(appDirectory, publicDirectory, getCloudflarePublicAssets(modernConfig));
             await copyCloudflareD1Migrations(appDirectory, outputDirectory, modernConfig);
             await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
                 spaces: 2
             });
-            await utils_namespaceObject.fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig), {
+            const deliveryUnitStamp = await resolveWorkerDeliveryUnitStamp(appDirectory);
+            await utils_namespaceObject.fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig, appContext, deliveryUnitStamp), {
                 spaces: 2
             });
-            await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(outputDirectory, OUTPUT_PACKAGE_FILE), {
-                type: 'module'
-            });
+            await utils_namespaceObject.fs.writeJSON(outputPlan.paths.outputPackage, outputPlan.packages.output);
         },
         async genEntry () {
             const template = await (0, index_js_namespaceObject.readTemplate)('cloudflare-entry.mjs');
             const manifest = await utils_namespaceObject.fs.readJSON(workerManifestPath);
             await utils_namespaceObject.fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
+            const topologyDeliveryUnit = await resolveTopologyDeliveryUnit(appDirectory);
+            await (0, external_cloudflare_output_verifier_js_namespaceObject.assertCloudflareOutput)({
+                outputDirectory,
+                importWorker: false,
+                ...topologyDeliveryUnit ? {
+                    deliveryUnit: topologyDeliveryUnit
+                } : {}
+            });
         }
     };
 };