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

package/dist/cjs/cloudflare/delivery-unit.js

@@ -38,19 +38,28 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     resolveTopologyDeliveryUnit: ()=>resolveTopologyDeliveryUnit,
+    resolveTopologyReleaseRole: ()=>resolveTopologyReleaseRole,
     resolveWorkerDeliveryUnitStamp: ()=>resolveWorkerDeliveryUnitStamp
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_util_namespaceObject = require("node:util");
 const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_release_identity_js_namespaceObject = require("../release-identity.js");
 const external_utils_js_namespaceObject = require("./utils.js");
-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 = external_node_path_default().resolve(appDirectory);
     for(;;){
-        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(current, COMPACT_CONFIG_PATH))) return current;
+        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(current, TOPOLOGY_PATH))) return current;
         const parent = external_node_path_default().dirname(current);
         if (parent === current) return;
         current = parent;
@@ -67,51 +76,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 utils_namespaceObject.fs.readJSON(external_node_path_default().join(workspaceRoot, COMPACT_CONFIG_PATH));
-    } catch  {
-        return {
-            workspaceRoot
-        };
-    }
-    if (!(0, external_utils_js_namespaceObject.isRecord)(compactConfig)) return {
-        workspaceRoot
-    };
-    const topology = (0, external_utils_js_namespaceObject.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 utils_namespaceObject.fs.readJSON(external_node_path_default().join(workspaceRoot, TOPOLOGY_PATH));
+    if (!(0, external_utils_js_namespaceObject.isRecord)(topology) || !(0, external_utils_js_namespaceObject.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 = external_node_path_default().resolve(appDirectory);
     const app = apps.find((candidate)=>{
         if (!(0, external_utils_js_namespaceObject.isRecord)(candidate)) return false;
         const appPath = (0, backend_federation_contracts_namespaceObject.nonEmptyString)(candidate.path);
         return void 0 !== appPath && external_node_path_default().resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory;
     });
+    if (!(0, external_utils_js_namespaceObject.isRecord)(app)) throw new Error(`[cloudflare-delivery-unit] ${appDirectory} is missing from the declared reference topology.`);
     return {
-        ...(0, external_utils_js_namespaceObject.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 = (0, backend_federation_contracts_namespaceObject.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 = (0, backend_federation_contracts_namespaceObject.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 = (0, backend_federation_contracts_namespaceObject.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 = (0, external_utils_js_namespaceObject.isRecord)(app.routerBindings) ? app.routerBindings : {};
+        const errors = [
+            ...(0, backend_federation_contracts_namespaceObject.validateRendererIdentity)(app.rendererIdentity).errors,
+            ...(0, backend_federation_contracts_namespaceObject.validateRendererProfile)(app.rendererProfile).errors,
+            ...(0, backend_federation_contracts_namespaceObject.validateRendererRouterBindings)(app.routerBindings, Object.keys(routerBindings), 'routerBindings').errors
+        ];
+        if (errors.length) throw new Error(`[cloudflare-delivery-unit] ${(0, backend_federation_contracts_namespaceObject.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 = (0, backend_federation_contracts_namespaceObject.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: (0, backend_federation_contracts_namespaceObject.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: {
@@ -123,28 +164,69 @@ const createDeliveryUnitStamp = (identity, app)=>{
     };
 };
 const resolveTopologyDeliveryUnit = async (appDirectory)=>{
-    const resolved = await resolveCompactApp(appDirectory);
+    const resolved = await resolveTopologyApp(appDirectory);
     if (!resolved?.app) return;
     const identity = (0, backend_federation_contracts_namespaceObject.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 = external_node_path_default().join(appDirectory, backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH);
-    let identity;
-    if (await utils_namespaceObject.fs.pathExists(buildArtifactPath)) {
-        const artifact = await utils_namespaceObject.fs.readJSON(buildArtifactPath);
-        if (!(0, backend_federation_contracts_namespaceObject.isUltramodernBuildArtifact)(artifact)) return;
-        identity = (0, backend_federation_contracts_namespaceObject.toDeliveryUnitIdentity)(artifact.deliveryUnit);
+const resolveWorkerDeliveryUnitStamp = async (appDirectory, distDirectory)=>{
+    const buildArtifactPath = external_node_path_default().join(distDirectory, backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE);
+    if (!await utils_namespaceObject.fs.pathExists(buildArtifactPath)) {
+        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(appDirectory, backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH))) throw new Error('[cloudflare-delivery-unit] Finalized build artifact is required before worker output stamping.');
+        return;
+    }
+    const artifact = await utils_namespaceObject.fs.readJSON(buildArtifactPath);
+    (0, backend_federation_contracts_namespaceObject.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 = (0, backend_federation_contracts_namespaceObject.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 (!(0, external_node_util_namespaceObject.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.`);
+            (0, backend_federation_contracts_namespaceObject.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
+            } : {}
+        }
+    };
 };
 exports.resolveTopologyDeliveryUnit = __webpack_exports__.resolveTopologyDeliveryUnit;
+exports.resolveTopologyReleaseRole = __webpack_exports__.resolveTopologyReleaseRole;
 exports.resolveWorkerDeliveryUnitStamp = __webpack_exports__.resolveWorkerDeliveryUnitStamp;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "resolveTopologyDeliveryUnit",
+    "resolveTopologyReleaseRole",
     "resolveWorkerDeliveryUnitStamp"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/cloudflare/index.js

@@ -41,6 +41,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_cloudflare_output_plan_js_namespaceObject = require("../cloudflare-output-plan.js");
 const index_js_namespaceObject = require("../cloudflare-output-verifier/index.js");
@@ -73,20 +74,28 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
     const publicAssetExcludes = (0, external_worker_manifest_js_namespaceObject.getPublicAssetExcludes)(appDirectory, modernConfig);
     const releaseEnvelopeEnabled = api.isPluginExists('@modern-js/ultramodern-release-envelope');
     let hasReleaseEnvelope = false;
+    let declaredPublicAssets = [];
     return {
         async prepare () {
             await utils_namespaceObject.fs.remove(outputDirectory);
         },
         async writeOutput () {
-            if (releaseEnvelopeEnabled && await utils_namespaceObject.fs.pathExists(external_node_path_default().join(distDirectory, framework_output_js_namespaceObject.MICROVERTICAL_RELEASE_ENVELOPE_PATH))) await (0, framework_output_js_namespaceObject.emitFrameworkMicroVerticalReleaseEnvelope)({
+            if (releaseEnvelopeEnabled) await (0, framework_output_js_namespaceObject.emitFrameworkMicroVerticalReleaseEnvelope)({
                 apiOnly,
+                appDirectory,
                 distDirectory,
+                role: modernConfig.deploy?.releaseEnvelopeRole,
                 target: 'cloudflare'
             });
             if (releaseEnvelopeEnabled) await (0, framework_output_js_namespaceObject.verifyBuildOutputReleaseEnvelope)(distDirectory, 'cloudflare');
             await utils_namespaceObject.fs.copy(distDirectory, publicDirectory, {
                 filter: (src)=>{
                     const relativePath = external_node_path_default().relative(distDirectory, src).replace(/\\/gu, '/');
+                    if (apiOnly && '' !== relativePath && ![
+                        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+                        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                        backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE
+                    ].includes(relativePath)) return false;
                     return 'release' !== relativePath && !relativePath.startsWith('release/') && 'public' !== relativePath && !relativePath.startsWith('public/') && (0, external_worker_manifest_js_namespaceObject.shouldCopyToPublicAssets)(src, distDirectory, publicAssetExcludes);
                 }
             });
@@ -110,12 +119,12 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
                 await utils_namespaceObject.fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
             }
             await (0, external_artifacts_js_namespaceObject.copyCloudflareArtifacts)(appDirectory, outputDirectory, cloudflareArtifacts);
-            await (0, external_artifacts_js_namespaceObject.copyCloudflarePublicAssets)(appDirectory, publicDirectory, (0, external_artifacts_js_namespaceObject.getCloudflarePublicAssets)(modernConfig));
+            declaredPublicAssets = await (0, external_artifacts_js_namespaceObject.copyCloudflarePublicAssets)(appDirectory, outputDirectory, (0, external_artifacts_js_namespaceObject.getCloudflarePublicAssets)(modernConfig));
             await (0, external_artifacts_js_namespaceObject.copyCloudflareD1Migrations)(appDirectory, outputDirectory, modernConfig);
             await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, (0, external_wrangler_config_js_namespaceObject.createWranglerConfig)(appDirectory, modernConfig), {
                 spaces: 2
             });
-            const deliveryUnitStamp = await (0, external_delivery_unit_js_namespaceObject.resolveWorkerDeliveryUnitStamp)(appDirectory);
+            const deliveryUnitStamp = await (0, external_delivery_unit_js_namespaceObject.resolveWorkerDeliveryUnitStamp)(appDirectory, distDirectory);
             await utils_namespaceObject.fs.writeJSON(workerManifestPath, await (0, external_worker_manifest_js_namespaceObject.createWorkerManifest)(outputDirectory, modernConfig, appContext, deliveryUnitStamp), {
                 spaces: 2
             });
@@ -129,7 +138,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             const template = await readCloudflareEntryTemplate();
             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', (0, external_worker_manifest_js_namespaceObject.createWorkerModuleLoaders)(manifest)));
-            const topologyDeliveryUnit = await (0, external_delivery_unit_js_namespaceObject.resolveTopologyDeliveryUnit)(appDirectory);
+            const topologyDeliveryUnit = await (0, external_delivery_unit_js_namespaceObject.resolveWorkerDeliveryUnitStamp)(appDirectory, distDirectory);
             await (0, index_js_namespaceObject.assertCloudflareOutput)({
                 outputDirectory,
                 importWorker: false,
@@ -139,6 +148,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             });
             if (hasReleaseEnvelope) {
                 await (0, framework_output_js_namespaceObject.emitCloudflareStagedReleaseEnvelope)({
+                    declaredPublicAssets,
                     distDirectory,
                     outputDirectory
                 });

package/dist/cjs/cloudflare/native-renderer.js

@@ -0,0 +1,100 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    NATIVE_RENDERER_WORKER_RESOURCES_FILE: ()=>NATIVE_RENDERER_WORKER_RESOURCES_FILE,
+    readNativeRendererWorkerResources: ()=>readNativeRendererWorkerResources
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const NATIVE_RENDERER_WORKER_RESOURCES_FILE = `${external_constants_js_namespaceObject.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 (!(0, external_utils_js_namespaceObject.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 (!(0, external_utils_js_namespaceObject.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_default().readFile(external_node_path_default().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 (!(0, external_utils_js_namespaceObject.isRecord)(value) || 'ultramodern-native-worker-resources' !== value.schema || 1 !== value.version || 'string' != typeof value.renderer || !value.renderer || !(0, external_utils_js_namespaceObject.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;
+}
+exports.NATIVE_RENDERER_WORKER_RESOURCES_FILE = __webpack_exports__.NATIVE_RENDERER_WORKER_RESOURCES_FILE;
+exports.readNativeRendererWorkerResources = __webpack_exports__.readNativeRendererWorkerResources;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "NATIVE_RENDERER_WORKER_RESOURCES_FILE",
+    "readNativeRendererWorkerResources"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cloudflare/renderer-identity.js

@@ -0,0 +1,106 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    readWorkerRendererBuild: ()=>readWorkerRendererBuild
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_util_namespaceObject = require("node:util");
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
+const external_utils_js_namespaceObject = require("./utils.js");
+async function readWorkerRendererBuild(distDirectory, routes, deliveryUnit) {
+    let bytes;
+    try {
+        bytes = await promises_default().readFile(external_node_path_default().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 (!(0, external_utils_js_namespaceObject.isRecord)(build) || 'ultramodern-renderer-build' !== build.schema || 2 !== build.version || 'string' != typeof build.buildId || !/^[a-f0-9]{64}$/u.test(build.buildId) || !(0, external_utils_js_namespaceObject.isRecord)(build.profile) || build.renderer !== build.profile.renderer || !(0, external_utils_js_namespaceObject.isRecord)(build.worker) || 'boolean' != typeof build.worker.nativeDocuments || 'boolean' != typeof build.worker.rsc || !(0, external_utils_js_namespaceObject.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 = (0, backend_federation_contracts_namespaceObject.validateRendererProfile)({
+        renderer,
+        protocolVersion,
+        compiler,
+        hydration,
+        router
+    });
+    if (!validation.ok) throw new Error((0, backend_federation_contracts_namespaceObject.formatBackendFederationValidationErrors)(validation.errors));
+    const identities = {};
+    let appId;
+    for (const [entryName, value] of Object.entries(build.entries)){
+        const validation = (0, backend_federation_contracts_namespaceObject.validateRendererIdentity)(value);
+        if (!validation.ok) throw new Error((0, backend_federation_contracts_namespaceObject.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('\\') && external_node_path_default().posix.normalize(route.entryPath) === route.entryPath) {
+            const asset = await promises_default().stat(external_node_path_default().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 && !(0, external_node_util_namespaceObject.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)
+    });
+}
+exports.readWorkerRendererBuild = __webpack_exports__.readWorkerRendererBuild;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "readWorkerRendererBuild"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cloudflare/worker-manifest.js

@@ -46,9 +46,12 @@ __webpack_require__.d(__webpack_exports__, {
 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 external_cloudflare_output_contract_js_namespaceObject = require("../cloudflare-output-contract.js");
 const external_artifacts_js_namespaceObject = require("./artifacts.js");
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_i18n_worker_js_namespaceObject = require("./i18n-worker.js");
+const external_native_renderer_js_namespaceObject = require("./native-renderer.js");
+const external_renderer_identity_js_namespaceObject = require("./renderer-identity.js");
 const external_security_policies_js_namespaceObject = require("./security-policies.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const external_wrangler_config_js_namespaceObject = require("./wrangler-config.js");
@@ -102,31 +105,59 @@ const createModuleFederationWorkerManifest = async (outputDirectory)=>{
             }
         ];
     });
-    return name && exposes.length > 0 ? {
+    if (!name || 0 === exposes.length) return;
+    const routeManifestPath = external_node_path_default().join(outputDirectory, external_constants_js_namespaceObject.PUBLIC_ASSETS_DIRECTORY, external_constants_js_namespaceObject.ROUTE_MANIFEST_FILE);
+    const routeManifest = await utils_namespaceObject.fs.pathExists(routeManifestPath) ? await utils_namespaceObject.fs.readJson(routeManifestPath) : void 0;
+    const routeAssets = (0, external_utils_js_namespaceObject.isRecord)(routeManifest) && (0, external_utils_js_namespaceObject.isRecord)(routeManifest.routeAssets) ? Object.values(routeManifest.routeAssets).filter(external_utils_js_namespaceObject.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 (0, external_artifacts_js_namespaceObject.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 ? `${external_constants_js_namespaceObject.WORKER_BUNDLE_DIRECTORY}/${(0, external_cloudflare_output_contract_js_namespaceObject.getCloudflareWorkerRouteDataEntryName)(route.entryName)}.js` : void 0;
+        const hasRouteDataWorker = routeDataWorker ? await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, routeDataWorker)) : false;
         return {
             urlPath: route.urlPath,
             entryName: route.entryName,
             entryPath: route.entryPath,
             isSSR: Boolean(route.isSSR),
             worker,
-            workerExists: worker ? await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, worker)) : false
+            workerExists: worker ? await utils_namespaceObject.fs.pathExists(external_node_path_default().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 (0, external_renderer_identity_js_namespaceObject.readWorkerRendererBuild)(appContext.distDirectory, routeSpec.routes, deliveryUnitStamp);
+    const rendererIdentities = rendererBuild?.identities;
+    const nativeRenderer = await (0, external_native_renderer_js_namespaceObject.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 = (0, external_wrangler_config_js_namespaceObject.getWorkerEffectBffPrefix)(modernConfig);
     const effectApiWorkerExists = await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, external_constants_js_namespaceObject.BFF_EFFECT_WORKER_ENTRY));
-    const serviceBindings = (0, external_wrangler_config_js_namespaceObject.createWorkerManifestServiceBindings)((0, external_wrangler_config_js_namespaceObject.createWorkerServiceBindings)(modernConfig, void 0));
+    const typedServiceBindings = (0, external_wrangler_config_js_namespaceObject.createWorkerServiceBindings)(modernConfig, void 0);
+    const serviceBindings = (0, external_wrangler_config_js_namespaceObject.createWorkerManifestServiceBindings)(typedServiceBindings, (0, external_wrangler_config_js_namespaceObject.createWorkerVpcServiceBindings)(modernConfig, void 0, typedServiceBindings, new Set([
+        external_constants_js_namespaceObject.ASSETS_BINDING
+    ])));
     const moduleFederation = await createModuleFederationWorkerManifest(outputDirectory);
-    if (isEffectApi && primaryBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, external_constants_js_namespaceObject.BFF_EFFECT_WORKER_ENTRY);
+    if (void 0 !== effectBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, external_constants_js_namespaceObject.BFF_EFFECT_WORKER_ENTRY);
     const effectBffManifest = isEffectApi ? createEffectBffWorkerManifest(modernConfig) : void 0;
     return {
         version: 1,
@@ -162,11 +193,18 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext, d
         ...deliveryUnitStamp ? {
             deliveryUnit: deliveryUnitStamp
         } : {},
+        ...rendererBuild ? {
+            renderer: rendererBuild.renderer,
+            rendererIdentities
+        } : {},
+        ...nativeRenderer ? {
+            nativeRenderer
+        } : {},
         i18n: (0, external_i18n_worker_js_namespaceObject.createI18nWorkerManifest)(routeSpec, appContext),
-        bff: isEffectApi && primaryBffPrefix && effectApiWorkerExists ? {
+        bff: void 0 !== effectBffPrefix && effectApiWorkerExists ? {
             dispatcherExport: external_constants_js_namespaceObject.BFF_EFFECT_WORKER_DISPATCHER_EXPORT,
             runtimeFramework: 'effect',
-            prefix: primaryBffPrefix,
+            prefix: effectBffPrefix,
             worker: external_constants_js_namespaceObject.BFF_EFFECT_WORKER_ENTRY,
             effect: effectBffManifest
         } : void 0,
@@ -177,9 +215,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, '')}`;