@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

package/dist/cjs/backend-federation-build/codegen.js

@@ -213,8 +213,13 @@ const createBackendManifest = (workspaceRoot, distDirectory, app, entryIntegrity
             source: {
                 module: sourceModule
             },
-            readinessPath: `${app.apiPrefix}/${app.apiStem}/readiness`,
-            openapiPath: `${app.apiPrefix}/openapi.json`,
+            ...'rpc' === app.apiProtocol ? {
+                rpcPath: app.rpcPath,
+                rpcSerialization: 'json'
+            } : {
+                readinessPath: `${app.apiPrefix}/${app.apiStem}/readiness`,
+                openapiPath: `${app.apiPrefix}/openapi.json`
+            },
             ...app.deliveryUnit ? {
                 deliveryUnit: app.deliveryUnit
             } : {},

package/dist/cjs/backend-federation-build/config.js

@@ -37,9 +37,10 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    COMPACT_CONFIG_PATH: ()=>COMPACT_CONFIG_PATH,
+    DEVELOPMENT_OVERLAY_PATH: ()=>DEVELOPMENT_OVERLAY_PATH,
+    REFERENCE_TOPOLOGY_PATH: ()=>REFERENCE_TOPOLOGY_PATH,
     buildArtifactPathFor: ()=>buildArtifactPathFor,
-    createAppFromCompactMetadata: ()=>createAppFromCompactMetadata,
+    createAppFromTopology: ()=>createAppFromTopology,
     createStampedDeliveryUnit: ()=>createStampedDeliveryUnit,
     findBackendFederationApp: ()=>findBackendFederationApp,
     findWorkspaceRoot: ()=>findWorkspaceRoot,
@@ -54,7 +55,8 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const release_identity_namespaceObject = require("@modern-js/app-tools-extensions/release-identity");
 const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
-const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+const DEVELOPMENT_OVERLAY_PATH = 'topology/local-overlays/development.json';
 const normalizeRelativePath = (value)=>value.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
 const isRecord = (value)=>'object' == typeof value && null !== value;
 const readJsonFile = async (filePath)=>JSON.parse(await promises_default().readFile(filePath, 'utf8'));
@@ -82,15 +84,25 @@ const readBuildIdentity = async (appDirectory)=>{
 const toPascalCase = (value)=>value.split(/[^a-zA-Z0-9]+/u).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
 const stringValue = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
 const createBackendName = (app, id)=>{
-    const configuredName = stringValue(app.backendFederation?.name) ?? stringValue(app.backendFederation?.executionSurfaces?.node?.remoteName) ?? stringValue(app.serverExecution?.node?.remoteName);
+    const configuredName = stringValue(app.backendFederation?.name) ?? stringValue(app.backendFederation?.executionSurfaces?.node?.remoteName);
     if (configuredName) return configuredName;
     const mfName = stringValue(app.moduleFederation?.name);
     return mfName ? `${mfName}Backend` : `vertical${toPascalCase(id)}Backend`;
 };
+const rebaseDefaultLocalUrl = (value, defaultPort, publicOrigin)=>{
+    let url;
+    try {
+        url = new URL(value);
+    } catch  {
+        return value;
+    }
+    if ('http:' !== url.protocol || 'localhost' !== url.hostname || Number(url.port) !== defaultPort || url.username || url.password) return value;
+    return `${publicOrigin}${url.pathname}${url.search}${url.hash}`;
+};
 const findWorkspaceRoot = (appDirectory)=>{
     let current = appDirectory;
     while(true){
-        if ((0, external_node_fs_namespaceObject.existsSync)(external_node_path_default().join(current, COMPACT_CONFIG_PATH))) return current;
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_node_path_default().join(current, REFERENCE_TOPOLOGY_PATH))) return current;
         const parent = external_node_path_default().dirname(current);
         if (parent === current) return;
         current = parent;
@@ -114,59 +126,96 @@ const createStampedDeliveryUnit = (input)=>{
     if (!validation.ok) return;
     return (0, backend_federation_contracts_namespaceObject.deliveryUnitContractBlock)(record);
 };
-const createAppFromCompactMetadata = (workspaceRoot, appDirectory, compactApp)=>{
-    const id = stringValue(compactApp.id);
-    const appPath = stringValue(compactApp.path);
-    if (!id || 'vertical' !== compactApp.kind || !isRecord(compactApp.api)) return;
-    const directory = appPath ? normalizeRelativePath(appPath) : `verticals/${id}`;
+const createAppFromTopology = (workspaceRoot, appDirectory, topologyApp, overlay, packageManifest)=>{
+    const id = stringValue(topologyApp.id);
+    const appPath = stringValue(topologyApp.path);
+    if (!id || !appPath || 'vertical' !== topologyApp.kind || !isRecord(topologyApp.api) || !isRecord(topologyApp.backendFederation)) return;
+    const directory = normalizeRelativePath(appPath);
     if (external_node_path_default().resolve(workspaceRoot, directory) !== external_node_path_default().resolve(appDirectory)) return;
-    const port = 'number' == typeof compactApp.port ? compactApp.port : void 0;
-    if (void 0 === port) return;
-    const apiPrefix = stringValue(compactApp.api.prefix) ?? `/${id}-api`;
-    const apiStem = stringValue(compactApp.api.stem) ?? id;
-    const backendName = createBackendName(compactApp, id);
-    const manifestUrl = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.manifestUrl) ?? stringValue(compactApp.serverExecution?.node?.manifestUrl) ?? `http://localhost:${port}/${backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE}`;
-    const containerEntry = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.containerEntry) ?? stringValue(compactApp.serverExecution?.node?.containerEntry) ?? `http://localhost:${port}/${backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`;
-    const configuredRemoteType = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.remoteType) ?? stringValue(compactApp.serverExecution?.node?.remoteType);
+    const defaultPort = overlay.ports?.[id];
+    if ('number' != typeof defaultPort || !Number.isInteger(defaultPort) || defaultPort < 1 || defaultPort > 65535) throw new Error(`[backend-federation-build] Invalid development port for ${id}.`);
+    const portEnv = stringValue(topologyApp.portEnv) ?? `VERTICAL_${(stringValue(topologyApp.domain) ?? id).replace(/[^a-zA-Z0-9]/gu, '_').toUpperCase()}_PORT`;
+    const port = Number(process.env[portEnv] ?? defaultPort);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`[backend-federation-build] Invalid ${portEnv} development port for ${id}.`);
+    const publicUrlEnv = stringValue(topologyApp.cloudflare?.publicUrlEnv);
+    const configuredPublicUrl = publicUrlEnv ? process.env[publicUrlEnv]?.trim() : void 0;
+    let publicOrigin = `http://localhost:${port}`;
+    if (configuredPublicUrl) {
+        let url;
+        try {
+            url = new URL(configuredPublicUrl);
+        } catch  {
+            throw new Error(`[backend-federation-build] Invalid ${publicUrlEnv} public URL for ${id}.`);
+        }
+        if (![
+            'http:',
+            'https:'
+        ].includes(url.protocol) || url.username || url.password) throw new Error(`[backend-federation-build] Invalid ${publicUrlEnv} public URL for ${id}.`);
+        publicOrigin = url.origin;
+    }
+    const apiPrefix = stringValue(topologyApp.api.bff?.prefix) ?? `/${id}-api`;
+    const apiProtocol = topologyApp.api.protocol ?? 'rest';
+    if ('rest' !== apiProtocol && 'rpc' !== apiProtocol) throw new Error(`[backend-federation-build] Unsupported API protocol for ${id}.`);
+    const rpcPath = 'rpc' === apiProtocol ? stringValue(topologyApp.api.rpcPath) : void 0;
+    if ('rpc' === apiProtocol && (!rpcPath || 'json' !== topologyApp.api.rpcSerialization)) throw new Error(`[backend-federation-build] Missing JSON RPC route metadata for ${id}.`);
+    const apiStem = stringValue(topologyApp.api.stem) ?? id;
+    const backendName = createBackendName(topologyApp, id);
+    const nodeOverlay = overlay.serverExecution?.[id]?.node;
+    if (!isRecord(nodeOverlay)) throw new Error(`[backend-federation-build] Missing declared Node server execution for ${id}.`);
+    const manifestUrl = rebaseDefaultLocalUrl(stringValue(nodeOverlay?.manifestUrl) ?? `http://localhost:${defaultPort}/${backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE}`, defaultPort, publicOrigin);
+    const containerEntry = rebaseDefaultLocalUrl(stringValue(nodeOverlay?.containerEntry) ?? `http://localhost:${defaultPort}/${backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`, defaultPort, publicOrigin);
+    const configuredRemoteType = stringValue(nodeOverlay?.remoteType) ?? stringValue(topologyApp.backendFederation?.executionSurfaces?.node?.remoteType);
     if (void 0 !== configuredRemoteType && 'commonjs-module' !== configuredRemoteType) throw new Error(`[backend-federation-build] Node backend federation remoteType must be "commonjs-module"; received "${configuredRemoteType}" for ${id}.`);
     if (!new URL(containerEntry).pathname.endsWith(`/${backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`)) throw new Error(`[backend-federation-build] Node backend federation containerEntry must end with "/${backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE}"; received "${containerEntry}" for ${id}.`);
     const remoteType = 'commonjs-module';
-    const packageName = stringValue(compactApp.package);
-    const uiManifestUrl = stringValue(compactApp.backendFederation?.versionBoundary?.ui?.manifestUrl) ?? stringValue(compactApp.moduleFederation?.manifestUrl);
-    const compactDeliveryUnit = isRecord(compactApp.deliveryUnit) ? {
-        unitId: stringValue(compactApp.deliveryUnit.unitId),
-        buildMarker: stringValue(compactApp.deliveryUnit.buildMarker),
-        sourceRevision: stringValue(compactApp.deliveryUnit.sourceRevision),
-        packageName: stringValue(compactApp.deliveryUnit.packageName),
-        version: stringValue(compactApp.deliveryUnit.version)
+    const packageName = stringValue(packageManifest.name);
+    const version = stringValue(packageManifest.version);
+    if (stringValue(topologyApp.package) !== packageName || !version) throw new Error(`[backend-federation-build] Topology package identity must match package.json for ${id}.`);
+    const declaredUiManifestUrl = stringValue(overlay.manifests?.[id]);
+    const uiManifestUrl = declaredUiManifestUrl ? rebaseDefaultLocalUrl(declaredUiManifestUrl, defaultPort, publicOrigin) : void 0;
+    const topologyDeliveryUnit = isRecord(topologyApp.deliveryUnit) ? {
+        unitId: stringValue(topologyApp.deliveryUnit.unitId),
+        buildMarker: stringValue(topologyApp.deliveryUnit.buildMarker),
+        sourceRevision: stringValue(topologyApp.deliveryUnit.sourceRevision),
+        packageName: stringValue(topologyApp.deliveryUnit.packageName),
+        version: stringValue(topologyApp.deliveryUnit.version)
     } : void 0;
     return {
         id,
         directory,
         packageName,
+        version,
         port,
         apiPrefix,
+        apiProtocol,
+        rpcPath,
         apiStem,
         backendName,
         manifestUrl,
         containerEntry,
         remoteType,
         uiManifestUrl,
-        compactDeliveryUnit
+        topologyDeliveryUnit
     };
 };
 const findBackendFederationApp = async (workspaceRoot, appDirectory)=>{
-    const compactConfigPath = external_node_path_default().join(workspaceRoot, COMPACT_CONFIG_PATH);
-    const compactConfig = await readJsonFile(compactConfigPath);
-    const apps = Array.isArray(compactConfig.topology?.apps) ? compactConfig.topology.apps : [];
-    for (const app of apps){
-        const resolved = createAppFromCompactMetadata(workspaceRoot, appDirectory, app);
+    const topologyPath = external_node_path_default().join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
+    const topology = await readJsonFile(topologyPath);
+    if (!isRecord(topology) || !Array.isArray(topology.verticals)) throw new Error(`[backend-federation-build] Invalid declared topology at ${topologyPath}.`);
+    const overlayPath = external_node_path_default().join(workspaceRoot, DEVELOPMENT_OVERLAY_PATH);
+    const overlay = await readJsonFile(overlayPath);
+    if (!isRecord(overlay) || !isRecord(overlay.ports)) throw new Error(`[backend-federation-build] Invalid development overlay at ${overlayPath}.`);
+    const packageManifest = await readJsonFile(external_node_path_default().join(appDirectory, 'package.json'));
+    for (const app of topology.verticals){
+        const resolved = createAppFromTopology(workspaceRoot, appDirectory, app, overlay, packageManifest);
         if (resolved) return resolved;
     }
+    throw new Error(`[backend-federation-build] ${appDirectory} is missing from the declared reference topology.`);
 };
-exports.COMPACT_CONFIG_PATH = __webpack_exports__.COMPACT_CONFIG_PATH;
+exports.DEVELOPMENT_OVERLAY_PATH = __webpack_exports__.DEVELOPMENT_OVERLAY_PATH;
+exports.REFERENCE_TOPOLOGY_PATH = __webpack_exports__.REFERENCE_TOPOLOGY_PATH;
 exports.buildArtifactPathFor = __webpack_exports__.buildArtifactPathFor;
-exports.createAppFromCompactMetadata = __webpack_exports__.createAppFromCompactMetadata;
+exports.createAppFromTopology = __webpack_exports__.createAppFromTopology;
 exports.createStampedDeliveryUnit = __webpack_exports__.createStampedDeliveryUnit;
 exports.findBackendFederationApp = __webpack_exports__.findBackendFederationApp;
 exports.findWorkspaceRoot = __webpack_exports__.findWorkspaceRoot;
@@ -174,9 +223,10 @@ exports.normalizeRelativePath = __webpack_exports__.normalizeRelativePath;
 exports.readBuildIdentity = __webpack_exports__.readBuildIdentity;
 exports.resolveWorkspaceSourceRevision = __webpack_exports__.resolveWorkspaceSourceRevision;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "COMPACT_CONFIG_PATH",
+    "DEVELOPMENT_OVERLAY_PATH",
+    "REFERENCE_TOPOLOGY_PATH",
     "buildArtifactPathFor",
-    "createAppFromCompactMetadata",
+    "createAppFromTopology",
     "createStampedDeliveryUnit",
     "findBackendFederationApp",
     "findWorkspaceRoot",

package/dist/cjs/backend-federation-build/emit.js

@@ -59,35 +59,39 @@ const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
     const app = await (0, external_config_js_namespaceObject.findBackendFederationApp)(workspaceRoot, appDirectory);
     if (!app) return;
     const buildIdentity = await (0, external_config_js_namespaceObject.readBuildIdentity)(appDirectory);
-    const compactDeliveryUnit = app.compactDeliveryUnit;
-    const hasCompactDeliveryUnit = void 0 !== compactDeliveryUnit && (void 0 !== compactDeliveryUnit.unitId || void 0 !== compactDeliveryUnit.buildMarker || void 0 !== compactDeliveryUnit.packageName || void 0 !== compactDeliveryUnit.version);
+    const topologyDeliveryUnit = app.topologyDeliveryUnit;
+    const hasTopologyDeliveryUnit = void 0 !== topologyDeliveryUnit && (void 0 !== topologyDeliveryUnit.unitId || void 0 !== topologyDeliveryUnit.buildMarker || void 0 !== topologyDeliveryUnit.packageName || void 0 !== topologyDeliveryUnit.version);
     const hasBuildIdentity = void 0 !== buildIdentity.unitId || void 0 !== buildIdentity.buildVersion || void 0 !== buildIdentity.packageName || void 0 !== buildIdentity.version;
     if (hasBuildIdentity) {
-        const compactConfigPath = external_node_path_default().join(workspaceRoot, external_config_js_namespaceObject.COMPACT_CONFIG_PATH);
+        const topologyPath = external_node_path_default().join(workspaceRoot, external_config_js_namespaceObject.REFERENCE_TOPOLOGY_PATH);
         const buildIdentityPath = (0, external_config_js_namespaceObject.buildArtifactPathFor)(appDirectory);
         const mismatches = [];
         const compare = (label, a, b, leftLabel = 'deliveryUnit')=>{
             if (void 0 !== a && void 0 !== b && a !== b) mismatches.push(`${label}: ${leftLabel}=${a} vs ultramodern-build=${b}`);
         };
         compare('appId', app.id, buildIdentity.appId, 'topology');
-        if (hasCompactDeliveryUnit) {
-            compare('unitId', compactDeliveryUnit?.unitId, buildIdentity.unitId);
-            compare('buildMarker/build', compactDeliveryUnit?.buildMarker, buildIdentity.buildVersion);
-            compare('packageName', compactDeliveryUnit?.packageName, buildIdentity.packageName);
-            compare('version', compactDeliveryUnit?.version, buildIdentity.version);
+        if (hasTopologyDeliveryUnit) {
+            compare('unitId', topologyDeliveryUnit?.unitId, buildIdentity.unitId);
+            compare('buildMarker/build', topologyDeliveryUnit?.buildMarker, buildIdentity.buildVersion);
+            compare('packageName', topologyDeliveryUnit?.packageName, buildIdentity.packageName);
+            compare('version', topologyDeliveryUnit?.version, buildIdentity.version);
         }
-        if (mismatches.length > 0) throw new Error(`[backend-federation-build] Delivery-unit identity drift between ${compactConfigPath} (topology) and ${buildIdentityPath}: ${mismatches.join('; ')}`);
+        compare('packageName', app.packageName, buildIdentity.packageName, 'package.json');
+        compare('packageName', topologyDeliveryUnit?.packageName, app.packageName, 'topology');
+        compare('version', app.version, buildIdentity.version, 'package.json');
+        compare('version', topologyDeliveryUnit?.version, app.version, 'topology');
+        if (mismatches.length > 0) throw new Error(`[backend-federation-build] Delivery-unit identity drift between ${topologyPath}, package.json and ${buildIdentityPath}: ${mismatches.join('; ')}`);
     }
-    const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
-    const generationBuildMarker = compactDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
+    const unitId = topologyDeliveryUnit?.unitId ?? buildIdentity.unitId;
+    const generationBuildMarker = topologyDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
     const sourceRevision = await (0, external_config_js_namespaceObject.resolveWorkspaceSourceRevision)(workspaceRoot);
     const buildVersion = generationBuildMarker && unitId ? (0, release_identity_namespaceObject.resolveUltramodernReleaseIdentity)({
         generationBuildMarker,
         unitId,
         workspaceRoot
     }).buildMarker : void 0;
-    const packageName = compactDeliveryUnit?.packageName ?? buildIdentity.packageName ?? app.packageName;
-    const version = compactDeliveryUnit?.version ?? buildIdentity.version;
+    const packageName = app.packageName;
+    const version = app.version;
     const deliveryUnit = (0, external_config_js_namespaceObject.createStampedDeliveryUnit)({
         appId: app.id,
         unitId,

package/dist/cjs/build-config/remote-address.js

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    createRemoteManifestUrl: ()=>createRemoteManifestUrl
+});
+const surface_resolution_namespaceObject = require("@modern-js/surface-resolution");
+const external_build_environment_js_namespaceObject = require("./build-environment.js");
+function createRemoteManifestUrl(options) {
+    const env = Object.fromEntries([
+        options.manifestEnv,
+        options.publicUrlEnv,
+        'MODERNJS_DEPLOY',
+        'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN',
+        'ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS'
+    ].map((name)=>[
+            name,
+            (0, external_build_environment_js_namespaceObject.getBuildConfigEnvironment)(name)
+        ]));
+    const address = (0, surface_resolution_namespaceObject.resolveBrowserManifestAddress)(env, options, (0, external_build_environment_js_namespaceObject.getBuildConfigEnvironment)('NODE_ENV') ?? 'production');
+    if (!address.ok) throw new Error(`Remote ${options.mfName}: ${address.reason}`);
+    return env[options.manifestEnv]?.trim() || `${options.mfName}@${address.manifestUrl}`;
+}
+exports.createRemoteManifestUrl = __webpack_exports__.createRemoteManifestUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRemoteManifestUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -46,11 +46,11 @@ const backend_federation_contracts_namespaceObject = require("@modern-js/backend
 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 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,36 +67,25 @@ 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,
         workspaceRoot
     };
 };
@@ -123,10 +112,11 @@ 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 createDeliveryUnitStamp(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);
@@ -137,7 +127,7 @@ const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
         identity = (0, backend_federation_contracts_namespaceObject.toDeliveryUnitIdentity)(artifact.deliveryUnit);
     }
     if (!identity) return;
-    const resolved = await resolveCompactApp(appDirectory);
+    const resolved = await resolveTopologyApp(appDirectory);
     if (resolved) identity = stampReleaseIdentity(identity, resolved.workspaceRoot);
     return createDeliveryUnitStamp(identity, resolved?.app);
 };

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");
@@ -78,7 +79,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             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,
                 distDirectory,
                 target: 'cloudflare'
@@ -87,6 +88,11 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             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);
                 }
             });

package/dist/cjs/cloudflare-builder.js

@@ -256,9 +256,9 @@ const prependBundlerChain = (environment, handler)=>{
 };
 const getWorkerEntries = (environment, normalizedConfig, appContext)=>{
     const configuredEntries = environment.source?.entry;
-    if (!configuredEntries) return;
-    const entries = rewriteWorkerEntries(configuredEntries);
     const effectApiEntry = getEffectBffEntry(normalizedConfig, appContext);
+    if (!configuredEntries && !effectApiEntry) return;
+    const entries = configuredEntries ? rewriteWorkerEntries(configuredEntries) : {};
     return effectApiEntry ? {
         ...entries,
         [BFF_EFFECT_WORKER_ENTRY_NAME]: [
@@ -338,7 +338,14 @@ const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
 };
 function getCloudflareBuilderEnvironments({ appContext, environments, normalizedConfig, resolveDeployProvider = resolveStdEnvDeployProvider }) {
     if (!isCloudflareWorkerDeploy(normalizedConfig, resolveDeployProvider)) return environments;
-    const workerEnvironment = environments[builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME];
+    const workerEnvironment = environments[builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME] ?? (appContext.apiOnly ? {
+        output: {
+            target: 'web-worker'
+        },
+        source: {
+            entry: {}
+        }
+    } : void 0);
     if (!workerEnvironment) return environments;
     const workerEntries = getWorkerEntries(workerEnvironment, normalizedConfig, appContext);
     if (!workerEntries) return environments;
@@ -354,6 +361,9 @@ function getCloudflareBuilderEnvironments({ appContext, environments, normalized
             entry: workerEntries
         }
     }, createCloudflareBundlerChain(appContext, Object.keys(workerEntries)));
+    if (appContext.apiOnly) return {
+        [builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment
+    };
     return {
         ...environments,
         [builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment

package/dist/cjs/cloudflare-output-contract.js

@@ -54,6 +54,7 @@ const CLOUDFLARE_WORKER_NODE_BUILTINS = [
     'fs/promises',
     'http',
     'http2',
+    'https',
     'inspector',
     'module',
     'net',

package/dist/cjs/cloudflare-output-verifier/identity.js

@@ -56,30 +56,32 @@ const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
     ]){
         const marker = stamped.surfaces[surface];
         const expected = declared?.surfaces?.[surface];
-        if (declared?.surfaces && !expected) {
-            if (marker) (0, external_issues_js_namespaceObject.addIssue)(issues, {
-                code: 'delivery-unit-drift',
-                message: `Cloudflare worker manifest declares an unexpected ${surface} delivery-unit surface for this topology profile.`,
-                path: manifestPath
-            });
-            continue;
-        }
-        if (!marker || 'object' != typeof marker) {
-            (0, external_issues_js_namespaceObject.addIssue)(issues, {
-                code: 'missing-delivery-unit',
-                message: `Cloudflare worker manifest is missing the ${surface} delivery-unit surface marker.`,
-                path: manifestPath
-            });
-            continue;
-        }
-        for (const field of backend_federation_contracts_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
-            const markerValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(marker, field);
-            const stampedValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
-            (0, external_issues_js_namespaceObject.assertEqual)(issues, markerValue, stampedValue, {
-                code: 'delivery-unit-drift',
-                message: `Cloudflare worker manifest ${surface} surface deliveryUnit.${field} must derive from one delivery-unit record (expected ${stampedValue ?? 'undefined'}, received ${markerValue ?? 'undefined'}).`,
-                path: manifestPath
-            });
+        if (expected || marker) {
+            if (declared?.surfaces && !expected) {
+                if (marker) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'delivery-unit-drift',
+                    message: `Cloudflare worker manifest declares an unexpected ${surface} delivery-unit surface for this topology profile.`,
+                    path: manifestPath
+                });
+                continue;
+            }
+            if (!marker || 'object' != typeof marker) {
+                (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'missing-delivery-unit',
+                    message: `Cloudflare worker manifest is missing the ${surface} delivery-unit surface marker.`,
+                    path: manifestPath
+                });
+                continue;
+            }
+            for (const field of backend_federation_contracts_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
+                const markerValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(marker, field);
+                const stampedValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
+                (0, external_issues_js_namespaceObject.assertEqual)(issues, markerValue, stampedValue, {
+                    code: 'delivery-unit-drift',
+                    message: `Cloudflare worker manifest ${surface} surface deliveryUnit.${field} must derive from one delivery-unit record (expected ${stampedValue ?? 'undefined'}, received ${markerValue ?? 'undefined'}).`,
+                    path: manifestPath
+                });
+            }
         }
     }
 };

package/dist/cjs/cloudflare-output-verifier/index.js

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

package/dist/cjs/cloudflare-output-verifier/manifest.js

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

package/dist/cjs/cloudflare-output-verifier/mutation-policy.js

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