@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/esm/cloudflare/delivery-unit.mjs

@@ -1,13 +1,21 @@
 import node_path from "node:path";
-import { ULTRAMODERN_BUILD_ARTIFACT_PATH, isUltramodernBuildArtifact, nonEmptyString, toDeliveryUnitIdentity } from "@modern-js/backend-federation-contracts";
+import { isDeepStrictEqual } from "node:util";
+import { ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, assertRendererProfileCompatibility, assertUltramodernBuildArtifact, formatBackendFederationValidationErrors, immutableRendererRouterBindings, nonEmptyString, toDeliveryUnitIdentity, validateRendererIdentity, validateRendererProfile, validateRendererRouterBindings } from "@modern-js/backend-federation-contracts";
 import { fs } from "@modern-js/utils";
 import { resolveUltramodernReleaseIdentity } from "../release-identity.mjs";
 import { isRecord } from "./utils.mjs";
-const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const TOPOLOGY_PATH = 'topology/reference-topology.json';
+const RENDERER_PROJECTION_FIELDS = [
+    'renderer',
+    'rendererIdentity',
+    'rendererIdentities',
+    'rendererProfile',
+    'routerBindings'
+];
 const findWorkspaceRoot = async (appDirectory)=>{
     let current = node_path.resolve(appDirectory);
     for(;;){
-        if (await fs.pathExists(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
+        if (await fs.pathExists(node_path.join(current, TOPOLOGY_PATH))) return current;
         const parent = node_path.dirname(current);
         if (parent === current) return;
         current = parent;
@@ -24,51 +32,83 @@ const stampReleaseIdentity = (identity, workspaceRoot)=>{
         })
     };
 };
-const resolveCompactApp = async (appDirectory)=>{
+const resolveTopologyApp = async (appDirectory)=>{
     const workspaceRoot = await findWorkspaceRoot(appDirectory);
     if (!workspaceRoot) return;
-    let compactConfig;
-    try {
-        compactConfig = await fs.readJSON(node_path.join(workspaceRoot, COMPACT_CONFIG_PATH));
-    } catch  {
-        return {
-            workspaceRoot
-        };
-    }
-    if (!isRecord(compactConfig)) return {
-        workspaceRoot
-    };
-    const topology = isRecord(compactConfig.topology) ? compactConfig.topology : void 0;
-    const apps = Array.isArray(topology?.apps) ? topology.apps : void 0;
-    if (!apps) return {
-        app: compactConfig,
-        workspaceRoot
-    };
+    const topology = await fs.readJSON(node_path.join(workspaceRoot, TOPOLOGY_PATH));
+    if (!isRecord(topology) || !isRecord(topology.shell) || !Array.isArray(topology.verticals) || void 0 !== topology.shells && !Array.isArray(topology.shells)) throw new Error('[cloudflare-delivery-unit] Invalid declared reference topology.');
+    const apps = [
+        topology.shell,
+        ...topology.verticals,
+        ...Array.isArray(topology.shells) ? topology.shells : []
+    ];
     const resolvedAppDirectory = node_path.resolve(appDirectory);
     const app = apps.find((candidate)=>{
         if (!isRecord(candidate)) return false;
         const appPath = nonEmptyString(candidate.path);
         return void 0 !== appPath && node_path.resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory;
     });
+    if (!isRecord(app)) throw new Error(`[cloudflare-delivery-unit] ${appDirectory} is missing from the declared reference topology.`);
     return {
-        ...isRecord(app) ? {
-            app
-        } : {},
+        app,
+        role: app === topology.shell || Array.isArray(topology.shells) && topology.shells.includes(app) ? 'shell' : 'microvertical',
         workspaceRoot
     };
 };
-const createDeliveryUnitStamp = (identity, app)=>{
-    const surfaceProfile = nonEmptyString(app?.surfaceProfile);
+const resolveTopologyReleaseRole = async (appDirectory)=>{
+    const resolved = await resolveTopologyApp(appDirectory);
+    if (!resolved?.app) return;
+    const kind = 'shell' === resolved.role ? 'shell' : 'vertical';
+    if (resolved.app.kind !== kind) throw new Error('[cloudflare-delivery-unit] Declared app kind disagrees with its topology membership.');
+    return resolved.role;
+};
+const createTopologyDeliveryUnitStamp = (identity, app)=>{
+    const surfaceProfile = nonEmptyString(app.surfaceProfile);
+    if (void 0 !== surfaceProfile && ![
+        'api-only',
+        'ui-only',
+        'full-stack'
+    ].includes(surfaceProfile)) throw new Error('[cloudflare-delivery-unit] Declared app has an invalid surface profile.');
     const emitsUi = 'api-only' !== surfaceProfile;
     const emitsApi = 'ui-only' !== surfaceProfile;
+    const appId = nonEmptyString(app.id);
+    if (!appId) throw new Error('[cloudflare-delivery-unit] Declared app requires an id.');
+    let ui;
+    if (emitsUi) if (RENDERER_PROJECTION_FIELDS.every((field)=>!Object.hasOwn(app, field))) ui = {
+        ...identity,
+        surface: 'ui'
+    };
+    else {
+        const routerBindings = isRecord(app.routerBindings) ? app.routerBindings : {};
+        const errors = [
+            ...validateRendererIdentity(app.rendererIdentity).errors,
+            ...validateRendererProfile(app.rendererProfile).errors,
+            ...validateRendererRouterBindings(app.routerBindings, Object.keys(routerBindings), 'routerBindings').errors
+        ];
+        if (errors.length) throw new Error(`[cloudflare-delivery-unit] ${formatBackendFederationValidationErrors(errors)}`);
+        const rendererIdentity = app.rendererIdentity;
+        const rendererProfile = app.rendererProfile;
+        if (!Object.hasOwn(routerBindings, rendererIdentity.entryName)) throw new Error('[cloudflare-delivery-unit] Topology routerBindings must include the primary renderer identity entry.');
+        const declaredIdentity = toDeliveryUnitIdentity(app.deliveryUnit);
+        if (rendererIdentity.renderer !== app.renderer || rendererIdentity.renderer !== rendererProfile.renderer || rendererIdentity.appId !== app.id || rendererIdentity.buildId !== declaredIdentity?.buildMarker) throw new Error('[cloudflare-delivery-unit] Topology UI renderer metadata must match its app and delivery-unit identity.');
+        ui = {
+            ...identity,
+            surface: 'ui',
+            rendererIdentity: {
+                ...rendererIdentity,
+                buildId: identity.buildMarker
+            },
+            rendererProfile,
+            routerBindings: immutableRendererRouterBindings(routerBindings)
+        };
+    }
+    else if (void 0 !== app.rendererIdentity || void 0 !== app.rendererProfile || void 0 !== app.routerBindings) throw new Error('[cloudflare-delivery-unit] API-only topology must not declare a UI renderer identity or profile.');
     return {
         ...identity,
+        appId,
         surfaces: {
-            ...emitsUi ? {
-                ui: {
-                    ...identity,
-                    surface: 'ui'
-                }
+            ...ui ? {
+                ui
             } : {},
             ...emitsApi ? {
                 api: {
@@ -80,22 +120,61 @@ const createDeliveryUnitStamp = (identity, app)=>{
     };
 };
 const resolveTopologyDeliveryUnit = async (appDirectory)=>{
-    const resolved = await resolveCompactApp(appDirectory);
+    const resolved = await resolveTopologyApp(appDirectory);
     if (!resolved?.app) return;
     const identity = toDeliveryUnitIdentity(resolved.app.deliveryUnit);
-    return identity ? createDeliveryUnitStamp(stampReleaseIdentity(identity, resolved.workspaceRoot), resolved.app) : void 0;
+    if (!identity) throw new Error('[cloudflare-delivery-unit] Declared app is missing a valid delivery-unit identity.');
+    return createTopologyDeliveryUnitStamp(stampReleaseIdentity(identity, resolved.workspaceRoot), resolved.app);
 };
-const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
-    const buildArtifactPath = node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
-    let identity;
-    if (await fs.pathExists(buildArtifactPath)) {
-        const artifact = await fs.readJSON(buildArtifactPath);
-        if (!isUltramodernBuildArtifact(artifact)) return;
-        identity = toDeliveryUnitIdentity(artifact.deliveryUnit);
+const resolveWorkerDeliveryUnitStamp = async (appDirectory, distDirectory)=>{
+    const buildArtifactPath = node_path.join(distDirectory, ULTRAMODERN_BUILD_ARTIFACT_FILE);
+    if (!await fs.pathExists(buildArtifactPath)) {
+        if (await fs.pathExists(node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH))) throw new Error('[cloudflare-delivery-unit] Finalized build artifact is required before worker output stamping.');
+        return;
+    }
+    const artifact = await fs.readJSON(buildArtifactPath);
+    assertUltramodernBuildArtifact(artifact);
+    const identity = {
+        unitId: artifact.deliveryUnit.unitId,
+        buildMarker: artifact.deliveryUnit.buildMarker,
+        sourceRevision: artifact.deliveryUnit.sourceRevision
+    };
+    const resolved = await resolveTopologyApp(appDirectory);
+    const stampedArtifact = artifact;
+    let emitsApi = true;
+    if (resolved?.app) {
+        if (stampedArtifact.deliveryUnit.appId !== resolved.app.id) throw new Error('[cloudflare-delivery-unit] Build artifact appId must match the declared topology app.');
+        const declaredIdentity = toDeliveryUnitIdentity(resolved.app.deliveryUnit);
+        if (!declaredIdentity) throw new Error('[cloudflare-delivery-unit] Declared app is missing a valid delivery-unit identity.');
+        const expected = createTopologyDeliveryUnitStamp(identity, resolved.app);
+        for (const field of [
+            'unitId'
+        ])if (declaredIdentity[field] !== identity[field]) throw new Error(`[cloudflare-delivery-unit] Build artifact ${field} must match the declared topology delivery-unit identity.`);
+        const ui = stampedArtifact.surfaces.ui;
+        if (Boolean(expected.surfaces.ui) !== Boolean(ui)) throw new Error('[cloudflare-delivery-unit] Build artifact UI surface must match the declared topology surface profile.');
+        if (expected.surfaces.ui?.rendererIdentity && ui) {
+            if (!isDeepStrictEqual(expected.surfaces.ui.routerBindings, ui.routerBindings)) throw new Error('[cloudflare-delivery-unit] Finalized build routerBindings must match the declared topology router bindings.');
+            for (const field of [
+                'renderer',
+                'appId',
+                'entryName',
+                'protocolVersion',
+                'buildId'
+            ])if (expected.surfaces.ui.rendererIdentity[field] !== ui.rendererIdentity[field]) throw new Error(`[cloudflare-delivery-unit] Build artifact UI rendererIdentity.${field} must match the declared topology renderer identity.`);
+            assertRendererProfileCompatibility(expected.surfaces.ui.rendererProfile, ui.rendererProfile);
+        }
+        emitsApi = void 0 !== expected.surfaces.api;
     }
-    if (!identity) return;
-    const resolved = await resolveCompactApp(appDirectory);
-    if (resolved) identity = stampReleaseIdentity(identity, resolved.workspaceRoot);
-    return createDeliveryUnitStamp(identity, resolved?.app);
+    return {
+        ...stampedArtifact.deliveryUnit,
+        surfaces: {
+            ...emitsApi ? {
+                api: stampedArtifact.surfaces.api
+            } : {},
+            ...stampedArtifact.surfaces.ui ? {
+                ui: stampedArtifact.surfaces.ui
+            } : {}
+        }
+    };
 };
-export { resolveTopologyDeliveryUnit, resolveWorkerDeliveryUnitStamp };
+export { resolveTopologyDeliveryUnit, resolveTopologyReleaseRole, resolveWorkerDeliveryUnitStamp };

package/dist/esm/cloudflare/index.mjs

@@ -1,4 +1,5 @@
 import node_path from "node:path";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE } from "@modern-js/backend-federation-contracts";
 import { fs } from "@modern-js/utils";
 import { createCloudflareOutputPlan } from "../cloudflare-output-plan.mjs";
 import { assertCloudflareOutput } from "../cloudflare-output-verifier/index.mjs";
@@ -6,7 +7,7 @@ import { readTemplate } from "../read-template.mjs";
 import { MICROVERTICAL_RELEASE_ENVELOPE_PATH, emitCloudflareStagedReleaseEnvelope, emitFrameworkMicroVerticalReleaseEnvelope, stageCloudflareReleaseEnvelope, verifyBuildOutputReleaseEnvelope, verifyCloudflareReleaseEnvelopeStaging } from "../release-envelope/framework-output.mjs";
 import { copyCloudflareArtifacts, copyCloudflareD1Migrations, copyCloudflarePublicAssets, getCloudflareArtifacts, getCloudflarePublicAssets } from "./artifacts.mjs";
 import { ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, WORKER_BUNDLE_DIRECTORY } from "./constants.mjs";
-import { resolveTopologyDeliveryUnit, resolveWorkerDeliveryUnitStamp } from "./delivery-unit.mjs";
+import { resolveWorkerDeliveryUnitStamp } from "./delivery-unit.mjs";
 import { createWorkerManifest, createWorkerModuleLoaders, getPublicAssetExcludes, shouldCopyToPublicAssets, shouldCopyToWorkerBundle } from "./worker-manifest.mjs";
 import { createWranglerConfig } from "./wrangler-config.mjs";
 const CLOUDFLARE_ENTRY_TEMPLATE_FRAGMENTS = [
@@ -31,20 +32,28 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
     const publicAssetExcludes = getPublicAssetExcludes(appDirectory, modernConfig);
     const releaseEnvelopeEnabled = api.isPluginExists('@modern-js/ultramodern-release-envelope');
     let hasReleaseEnvelope = false;
+    let declaredPublicAssets = [];
     return {
         async prepare () {
             await fs.remove(outputDirectory);
         },
         async writeOutput () {
-            if (releaseEnvelopeEnabled && await fs.pathExists(node_path.join(distDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH))) await emitFrameworkMicroVerticalReleaseEnvelope({
+            if (releaseEnvelopeEnabled) await emitFrameworkMicroVerticalReleaseEnvelope({
                 apiOnly,
+                appDirectory,
                 distDirectory,
+                role: modernConfig.deploy?.releaseEnvelopeRole,
                 target: 'cloudflare'
             });
             if (releaseEnvelopeEnabled) await verifyBuildOutputReleaseEnvelope(distDirectory, 'cloudflare');
             await fs.copy(distDirectory, publicDirectory, {
                 filter: (src)=>{
                     const relativePath = node_path.relative(distDirectory, src).replace(/\\/gu, '/');
+                    if (apiOnly && '' !== relativePath && ![
+                        BACKEND_FEDERATION_MANIFEST_FILE,
+                        BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                        ULTRAMODERN_BUILD_ARTIFACT_FILE
+                    ].includes(relativePath)) return false;
                     return 'release' !== relativePath && !relativePath.startsWith('release/') && 'public' !== relativePath && !relativePath.startsWith('public/') && shouldCopyToPublicAssets(src, distDirectory, publicAssetExcludes);
                 }
             });
@@ -68,12 +77,12 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
                 await fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
             }
             await copyCloudflareArtifacts(appDirectory, outputDirectory, cloudflareArtifacts);
-            await copyCloudflarePublicAssets(appDirectory, publicDirectory, getCloudflarePublicAssets(modernConfig));
+            declaredPublicAssets = await copyCloudflarePublicAssets(appDirectory, outputDirectory, getCloudflarePublicAssets(modernConfig));
             await copyCloudflareD1Migrations(appDirectory, outputDirectory, modernConfig);
             await fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
                 spaces: 2
             });
-            const deliveryUnitStamp = await resolveWorkerDeliveryUnitStamp(appDirectory);
+            const deliveryUnitStamp = await resolveWorkerDeliveryUnitStamp(appDirectory, distDirectory);
             await fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig, appContext, deliveryUnitStamp), {
                 spaces: 2
             });
@@ -87,7 +96,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             const template = await readCloudflareEntryTemplate();
             const manifest = await fs.readJSON(workerManifestPath);
             await fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
-            const topologyDeliveryUnit = await resolveTopologyDeliveryUnit(appDirectory);
+            const topologyDeliveryUnit = await resolveWorkerDeliveryUnitStamp(appDirectory, distDirectory);
             await assertCloudflareOutput({
                 outputDirectory,
                 importWorker: false,
@@ -97,6 +106,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             });
             if (hasReleaseEnvelope) {
                 await emitCloudflareStagedReleaseEnvelope({
+                    declaredPublicAssets,
                     distDirectory,
                     outputDirectory
                 });

package/dist/esm/cloudflare/native-renderer.mjs

@@ -0,0 +1,48 @@
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { WORKER_BUNDLE_DIRECTORY } from "./constants.mjs";
+import { isRecord } from "./utils.mjs";
+const NATIVE_RENDERER_WORKER_RESOURCES_FILE = `${WORKER_BUNDLE_DIRECTORY}/native-renderer.json`;
+const invalid = (detail)=>new Error(`Invalid native renderer worker resources (${NATIVE_RENDERER_WORKER_RESOURCES_FILE}): ${detail}. Rebuild the application with deploy.worker.ssr before deploying.`);
+function validateEntry(entryName, value) {
+    if (!isRecord(value)) throw invalid(`entry ${entryName} is not an object`);
+    const { assets, hydrationBuildId, serverConfig, csrFallbackHeader, nonce } = value;
+    if (!Array.isArray(assets) || !assets.length) throw invalid(`entry ${entryName} has no document assets`);
+    if (void 0 !== hydrationBuildId && ('string' != typeof hydrationBuildId || !hydrationBuildId.trim())) throw invalid(`entry ${entryName} has an empty hydration build ID`);
+    if (!isRecord(serverConfig) || ![
+        true,
+        false,
+        'stream'
+    ].includes(serverConfig.ssr) || void 0 !== serverConfig.ssrByRouteIds && (!Array.isArray(serverConfig.ssrByRouteIds) || serverConfig.ssrByRouteIds.some((id)=>'string' != typeof id))) throw invalid(`entry ${entryName} has an invalid server config`);
+    for (const [field, text] of [
+        [
+            'csrFallbackHeader',
+            csrFallbackHeader
+        ],
+        [
+            'nonce',
+            nonce
+        ]
+    ])if (void 0 !== text && ('string' != typeof text || !text)) throw invalid(`entry ${entryName} has an invalid ${field}`);
+}
+async function readNativeRendererWorkerResources(distDirectory, build) {
+    let bytes;
+    try {
+        bytes = await promises.readFile(node_path.join(distDirectory, NATIVE_RENDERER_WORKER_RESOURCES_FILE), 'utf8');
+    } catch (error) {
+        if (error instanceof Error && 'code' in error && 'ENOENT' === error.code) return;
+        throw error;
+    }
+    const value = JSON.parse(bytes);
+    if (!isRecord(value) || 'ultramodern-native-worker-resources' !== value.schema || 1 !== value.version || 'string' != typeof value.renderer || !value.renderer || !isRecord(value.entries)) throw invalid('unknown schema');
+    if (value.renderer !== build?.renderer.name || !build.renderer.nativeDocuments) throw invalid(`renderer ${value.renderer} is not the built native-document renderer`);
+    const entries = value.entries;
+    const nativeEntries = Object.entries(build.identities).filter(([, identity])=>identity.renderer === value.renderer);
+    for (const [entryName] of nativeEntries)if (!Object.hasOwn(entries, entryName)) throw invalid(`entry ${entryName} is missing`);
+    for (const [entryName, entry] of Object.entries(entries)){
+        if (!nativeEntries.some(([name])=>name === entryName)) throw invalid(`entry ${entryName} has no built ${value.renderer} renderer identity`);
+        validateEntry(entryName, entry);
+    }
+    return value;
+}
+export { NATIVE_RENDERER_WORKER_RESOURCES_FILE, readNativeRendererWorkerResources };

package/dist/esm/cloudflare/renderer-identity.mjs

@@ -0,0 +1,57 @@
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { formatBackendFederationValidationErrors, validateRendererIdentity, validateRendererProfile } from "@modern-js/backend-federation-contracts";
+import { isRecord } from "./utils.mjs";
+async function readWorkerRendererBuild(distDirectory, routes, deliveryUnit) {
+    let bytes;
+    try {
+        bytes = await promises.readFile(node_path.join(distDirectory, 'renderer-build.json'), 'utf8');
+    } catch (error) {
+        if (error instanceof Error && 'code' in error && 'ENOENT' === error.code) return;
+        throw error;
+    }
+    const build = JSON.parse(bytes);
+    if (!isRecord(build) || 'ultramodern-renderer-build' !== build.schema || 2 !== build.version || 'string' != typeof build.buildId || !/^[a-f0-9]{64}$/u.test(build.buildId) || !isRecord(build.profile) || build.renderer !== build.profile.renderer || !isRecord(build.worker) || 'boolean' != typeof build.worker.nativeDocuments || 'boolean' != typeof build.worker.rsc || !isRecord(build.entries) || !Object.keys(build.entries).length) throw new Error('Invalid or outdated renderer-build.json for the Cloudflare worker; rebuild the application.');
+    const { renderer, protocolVersion, compiler, hydration, router } = build.profile;
+    const validation = validateRendererProfile({
+        renderer,
+        protocolVersion,
+        compiler,
+        hydration,
+        router
+    });
+    if (!validation.ok) throw new Error(formatBackendFederationValidationErrors(validation.errors));
+    const identities = {};
+    let appId;
+    for (const [entryName, value] of Object.entries(build.entries)){
+        const validation = validateRendererIdentity(value);
+        if (!validation.ok) throw new Error(formatBackendFederationValidationErrors(validation.errors));
+        const identity = value;
+        if ('__proto__' === entryName || identity.entryName !== entryName || identity.renderer !== renderer || identity.protocolVersion !== protocolVersion || identity.buildId !== build.buildId || void 0 !== appId && identity.appId !== appId) throw new Error('Cloudflare renderer entry identity conflicts with its built manifest');
+        appId = identity.appId;
+        identities[entryName] = Object.freeze({
+            ...identity
+        });
+    }
+    for (const route of routes){
+        if (false === route.isSSR && void 0 === route.entryName && void 0 === route.worker && void 0 === route.bundle && (void 0 === route.isRSC || false === route.isRSC) && (void 0 === route.isStream || false === route.isStream) && 'string' == typeof route.entryPath && route.entryPath.startsWith('public/') && !route.entryPath.includes('\\') && node_path.posix.normalize(route.entryPath) === route.entryPath) {
+            const asset = await promises.stat(node_path.join(distDirectory, route.entryPath));
+            if (asset.isFile()) continue;
+        }
+        if (true !== route.isApi || false !== route.isSSR || void 0 !== route.entryName || '' !== route.entryPath || void 0 !== route.worker || void 0 !== route.bundle || void 0 !== route.isRSC && false !== route.isRSC || void 0 !== route.isStream && false !== route.isStream) {
+            if ('string' != typeof route.entryName || !Object.hasOwn(identities, route.entryName)) throw new Error(`Cloudflare generated route has no built renderer identity for ${String(route.entryName)}`);
+        }
+    }
+    const ui = deliveryUnit?.surfaces.ui;
+    if (ui && !isDeepStrictEqual(identities[ui.rendererIdentity.entryName], ui.rendererIdentity)) throw new Error('Cloudflare built renderer identity conflicts with its finalized delivery unit');
+    return Object.freeze({
+        renderer: Object.freeze({
+            name: renderer,
+            nativeDocuments: build.worker.nativeDocuments,
+            rsc: build.worker.rsc
+        }),
+        identities: Object.freeze(identities)
+    });
+}
+export { readWorkerRendererBuild };

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

@@ -1,11 +1,14 @@
 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";
+import { readNativeRendererWorkerResources } from "./native-renderer.mjs";
+import { readWorkerRendererBuild } from "./renderer-identity.mjs";
 import { createCloudflareWorkerSecurityPolicy } from "./security-policies.mjs";
 import { isRecord, normalizeRelativePath } from "./utils.mjs";
-import { createWorkerManifestServiceBindings, createWorkerServiceBindings } from "./wrangler-config.mjs";
+import { createWorkerManifestServiceBindings, createWorkerServiceBindings, createWorkerVpcServiceBindings, getWorkerEffectBffPrefix } from "./wrangler-config.mjs";
 const createMissingEffectBffWorkerError = (outputDirectory, worker)=>new Error(`Cloudflare Effect API runtime is configured, but the BFF worker bundle is missing: ${node_path.join(outputDirectory, worker)}. ${EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE}`);
 const createEffectBffWorkerManifest = (modernConfig)=>{
     const bff = modernConfig.bff;
@@ -56,31 +59,59 @@ const createModuleFederationWorkerManifest = async (outputDirectory)=>{
             }
         ];
     });
-    return name && exposes.length > 0 ? {
+    if (!name || 0 === exposes.length) return;
+    const routeManifestPath = node_path.join(outputDirectory, PUBLIC_ASSETS_DIRECTORY, ROUTE_MANIFEST_FILE);
+    const routeManifest = await fs.pathExists(routeManifestPath) ? await fs.readJson(routeManifestPath) : void 0;
+    const routeAssets = isRecord(routeManifest) && isRecord(routeManifest.routeAssets) ? Object.values(routeManifest.routeAssets).filter(isRecord) : [];
+    const routeCss = [
+        ...new Set(routeAssets.flatMap((routeAsset)=>[
+                routeAsset.referenceCssAssets,
+                routeAsset.assets
+            ].flatMap((value)=>Array.isArray(value) ? value : []).filter((asset)=>'string' == typeof asset && asset.endsWith('.css'))))
+    ];
+    return {
         name,
-        exposes
-    } : void 0;
+        exposes,
+        routeCss
+    };
 };
 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;
+        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
+            } : {},
+            ...route.responseHeaders && 'object' == typeof route.responseHeaders ? {
+                responseHeaders: route.responseHeaders
+            } : {}
         };
     }));
-    const bffPrefix = modernConfig.bff?.prefix;
-    const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
+    const rendererBuild = await readWorkerRendererBuild(appContext.distDirectory, routeSpec.routes, deliveryUnitStamp);
+    const rendererIdentities = rendererBuild?.identities;
+    const nativeRenderer = await readNativeRendererWorkerResources(appContext.distDirectory, rendererBuild);
+    for (const route of routes){
+        const renderer = 'string' == typeof route.entryName && rendererIdentities && Object.hasOwn(rendererIdentities, route.entryName) ? rendererIdentities[route.entryName].renderer : void 0;
+        if (void 0 !== renderer && rendererBuild?.renderer.nativeDocuments && (nativeRenderer?.renderer !== renderer || !route.workerExists)) throw new Error(`Cloudflare worker deploy of the ${renderer} renderer requires its native worker build for entry ${route.entryName}. Set deploy.worker.ssr: true and rebuild with the Cloudflare deploy target.`);
+    }
     const isEffectApi = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
+    const effectBffPrefix = getWorkerEffectBffPrefix(modernConfig);
     const effectApiWorkerExists = await fs.pathExists(node_path.join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
-    const serviceBindings = createWorkerManifestServiceBindings(createWorkerServiceBindings(modernConfig, void 0));
+    const typedServiceBindings = createWorkerServiceBindings(modernConfig, void 0);
+    const serviceBindings = createWorkerManifestServiceBindings(typedServiceBindings, createWorkerVpcServiceBindings(modernConfig, void 0, typedServiceBindings, new Set([
+        ASSETS_BINDING
+    ])));
     const moduleFederation = await createModuleFederationWorkerManifest(outputDirectory);
-    if (isEffectApi && primaryBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, BFF_EFFECT_WORKER_ENTRY);
+    if (void 0 !== effectBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, BFF_EFFECT_WORKER_ENTRY);
     const effectBffManifest = isEffectApi ? createEffectBffWorkerManifest(modernConfig) : void 0;
     return {
         version: 1,
@@ -116,11 +147,18 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext, d
         ...deliveryUnitStamp ? {
             deliveryUnit: deliveryUnitStamp
         } : {},
+        ...rendererBuild ? {
+            renderer: rendererBuild.renderer,
+            rendererIdentities
+        } : {},
+        ...nativeRenderer ? {
+            nativeRenderer
+        } : {},
         i18n: createI18nWorkerManifest(routeSpec, appContext),
-        bff: isEffectApi && primaryBffPrefix && effectApiWorkerExists ? {
+        bff: void 0 !== effectBffPrefix && effectApiWorkerExists ? {
             dispatcherExport: BFF_EFFECT_WORKER_DISPATCHER_EXPORT,
             runtimeFramework: 'effect',
-            prefix: primaryBffPrefix,
+            prefix: effectBffPrefix,
             worker: BFF_EFFECT_WORKER_ENTRY,
             effect: effectBffManifest
         } : void 0,
@@ -131,9 +169,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/cloudflare/worker-options.mjs

@@ -0,0 +1,10 @@
+function isCloudflareWorkerRequestHandlerOptions(options) {
+    if (!('platform' in options) || !('executionContext' in options)) return false;
+    const platform = options.platform;
+    if (null === platform || 'object' != typeof platform || !('kind' in platform) || 'worker' !== platform.kind || !('bindings' in platform)) return false;
+    const bindings = platform.bindings;
+    if (void 0 !== bindings && (null === bindings || 'object' != typeof bindings || Array.isArray(bindings))) return false;
+    const context = options.executionContext;
+    return void 0 === context || null !== context && 'object' == typeof context && 'waitUntil' in context && 'function' == typeof context.waitUntil && 'passThroughOnException' in context && 'function' == typeof context.passThroughOnException;
+}
+export { isCloudflareWorkerRequestHandlerOptions };