@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.12 → 3.9.0-ultramodern.14

package/dist/esm/backend-federation-build/codegen.mjs

@@ -170,8 +170,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/esm/backend-federation-build/config.mjs

@@ -3,7 +3,8 @@ import promises from "node:fs/promises";
 import node_path from "node:path";
 import { resolveUltramodernSourceRevision } from "@modern-js/app-tools-extensions/release-identity";
 import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_PATH, deliveryUnitContractBlock, isUltramodernBuildArtifact, validateDeliveryUnitRecord, validateUltramodernBuildArtifact } from "@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.readFile(filePath, 'utf8'));
@@ -31,15 +32,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 (existsSync(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
+        if (existsSync(node_path.join(current, REFERENCE_TOPOLOGY_PATH))) return current;
         const parent = node_path.dirname(current);
         if (parent === current) return;
         current = parent;
@@ -63,54 +74,90 @@ const createStampedDeliveryUnit = (input)=>{
     if (!validation.ok) return;
     return 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 (node_path.resolve(workspaceRoot, directory) !== node_path.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_MANIFEST_FILE}`;
-    const containerEntry = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.containerEntry) ?? stringValue(compactApp.serverExecution?.node?.containerEntry) ?? `http://localhost:${port}/${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_MANIFEST_FILE}`, defaultPort, publicOrigin);
+    const containerEntry = rebaseDefaultLocalUrl(stringValue(nodeOverlay?.containerEntry) ?? `http://localhost:${defaultPort}/${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_REMOTE_ENTRY_FILE}`)) throw new Error(`[backend-federation-build] Node backend federation containerEntry must end with "/${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 = node_path.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 = node_path.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 = node_path.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(node_path.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.`);
 };
-export { COMPACT_CONFIG_PATH, buildArtifactPathFor, createAppFromCompactMetadata, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, normalizeRelativePath, readBuildIdentity, resolveWorkspaceSourceRevision };
+export { DEVELOPMENT_OVERLAY_PATH, REFERENCE_TOPOLOGY_PATH, buildArtifactPathFor, createAppFromTopology, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, normalizeRelativePath, readBuildIdentity, resolveWorkspaceSourceRevision };

package/dist/esm/backend-federation-build/emit.mjs

@@ -5,7 +5,7 @@ import { resolveUltramodernReleaseIdentity } from "@modern-js/app-tools-extensio
 import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, stampUltramodernBuildArtifactIdentity } from "@modern-js/backend-federation-contracts";
 import { createBackendFederationEntryIntegrity } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
 import { createBackendManifest, createBackendRemoteEntrySource } from "./codegen.mjs";
-import { COMPACT_CONFIG_PATH, buildArtifactPathFor, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, readBuildIdentity, resolveWorkspaceSourceRevision } from "./config.mjs";
+import { REFERENCE_TOPOLOGY_PATH, buildArtifactPathFor, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, readBuildIdentity, resolveWorkspaceSourceRevision } from "./config.mjs";
 const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
     const workspaceRoot = findWorkspaceRoot(appDirectory);
     if (!workspaceRoot) return;
@@ -15,35 +15,39 @@ const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
     const app = await findBackendFederationApp(workspaceRoot, appDirectory);
     if (!app) return;
     const buildIdentity = await 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 = node_path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+        const topologyPath = node_path.join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
         const buildIdentityPath = 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 resolveWorkspaceSourceRevision(workspaceRoot);
     const buildVersion = generationBuildMarker && unitId ? 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 = createStampedDeliveryUnit({
         appId: app.id,
         unitId,

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

@@ -3,11 +3,11 @@ import { ULTRAMODERN_BUILD_ARTIFACT_PATH, isUltramodernBuildArtifact, nonEmptySt
 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 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,36 +24,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 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,
         workspaceRoot
     };
 };
@@ -80,10 +69,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 = 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 = node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
@@ -94,7 +84,7 @@ const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
         identity = 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/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";
@@ -36,7 +37,7 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             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,
                 distDirectory,
                 target: 'cloudflare'
@@ -45,6 +46,11 @@ const createCloudflarePreset = ({ api, appContext, modernConfig })=>{
             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);
                 }
             });

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

@@ -1,5 +1,6 @@
 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";
@@ -65,13 +66,18 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext, d
     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
+            } : {}
         };
     }));
     const bffPrefix = modernConfig.bff?.prefix;
@@ -131,9 +137,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/wrangler-config.mjs

@@ -1,12 +1,16 @@
 import node_path from "node:path";
 import { ASSETS_BINDING, COMPATIBILITY_DATE_PATTERN, DEFAULT_COMPATIBILITY_DATE, PUBLIC_ASSETS_DIRECTORY, REQUIRED_COMPATIBILITY_FLAGS, WORKER_ENTRY } from "./constants.mjs";
 import { isJsonRecord, normalizeRelativePath } from "./utils.mjs";
-const getCompatibilityDate = (modernConfig)=>{
-    const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
-    const compatibilityDate = configuredDate || DEFAULT_COMPATIBILITY_DATE;
-    if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`deploy.worker.compatibilityDate must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
+const assertSupportedCompatibilityDate = (compatibilityDate, label)=>{
+    if ('string' != typeof compatibilityDate) throw new Error(`${label} must be a YYYY-MM-DD string.`);
+    if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`${label} must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
+    if (compatibilityDate < DEFAULT_COMPATIBILITY_DATE) throw new Error(`${label} must be ${DEFAULT_COMPATIBILITY_DATE} or later, the date the Cloudflare worker Node.js built-in contract is verified against; received ${JSON.stringify(compatibilityDate)}.`);
     return compatibilityDate;
 };
+const getCompatibilityDate = (modernConfig, wranglerCompatibilityDate)=>{
+    if (void 0 !== wranglerCompatibilityDate) return assertSupportedCompatibilityDate(wranglerCompatibilityDate, 'deploy.worker.wrangler.compatibility_date');
+    return assertSupportedCompatibilityDate(modernConfig.deploy?.worker?.compatibilityDate?.trim() || DEFAULT_COMPATIBILITY_DATE, 'deploy.worker.compatibilityDate');
+};
 const getWorkerName = (appDirectory)=>{
     const basename = node_path.basename(appDirectory);
     return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
@@ -21,11 +25,11 @@ const getConfiguredWrangler = (modernConfig)=>{
     if (!isJsonRecord(wrangler)) throw new Error('deploy.worker.wrangler must be a JSON object.');
     return wrangler;
 };
-const createWranglerCompatibilityFlags = (configuredFlags)=>{
+const createWranglerCompatibilityFlags = (configuredFlags, label = 'deploy.worker.wrangler.compatibility_flags')=>{
     if (void 0 === configuredFlags) return [
         ...REQUIRED_COMPATIBILITY_FLAGS
     ];
-    if (!Array.isArray(configuredFlags) || configuredFlags.some((flag)=>'string' != typeof flag)) throw new Error('deploy.worker.wrangler.compatibility_flags must be an array of strings.');
+    if (!Array.isArray(configuredFlags) || configuredFlags.some((flag)=>'string' != typeof flag)) throw new Error(`${label} must be an array of strings.`);
     return [
         ...new Set([
             ...configuredFlags,
@@ -33,6 +37,26 @@ const createWranglerCompatibilityFlags = (configuredFlags)=>{
         ])
     ];
 };
+const createWranglerEnvironments = (wranglerEnv)=>{
+    if (void 0 === wranglerEnv) return;
+    if (!isJsonRecord(wranglerEnv)) throw new Error('deploy.worker.wrangler.env must be an object.');
+    return Object.fromEntries(Object.entries(wranglerEnv).map(([name, environment])=>{
+        const label = `deploy.worker.wrangler.env.${name}`;
+        if (!isJsonRecord(environment)) throw new Error(`${label} must be an object.`);
+        return [
+            name,
+            {
+                ...environment,
+                ...void 0 === environment.compatibility_date ? {} : {
+                    compatibility_date: assertSupportedCompatibilityDate(environment.compatibility_date, `${label}.compatibility_date`)
+                },
+                ...void 0 === environment.compatibility_flags ? {} : {
+                    compatibility_flags: createWranglerCompatibilityFlags(environment.compatibility_flags, `${label}.compatibility_flags`)
+                }
+            }
+        ];
+    }));
+};
 const createWranglerAssetsConfig = (configuredAssets)=>{
     if (void 0 !== configuredAssets && !isJsonRecord(configuredAssets)) throw new Error('deploy.worker.wrangler.assets must be an object.');
     return {
@@ -129,17 +153,21 @@ const createWorkerManifestServiceBindings = (serviceBindings)=>{
 };
 const createWranglerConfig = (appDirectory, modernConfig)=>{
     const wrangler = getConfiguredWrangler(modernConfig);
+    const environments = createWranglerEnvironments(wrangler.env);
     const d1Databases = createWranglerD1Databases(modernConfig, wrangler.d1_databases);
     const serviceBindings = createWorkerServiceBindings(modernConfig, wrangler.services);
     const wranglerServices = createWranglerServices(serviceBindings);
     return {
         $schema: 'node_modules/wrangler/config-schema.json',
         name: getConfiguredWorkerName(appDirectory, modernConfig),
-        compatibility_date: getCompatibilityDate(modernConfig),
         ...wrangler,
+        compatibility_date: getCompatibilityDate(modernConfig, wrangler.compatibility_date),
         main: WORKER_ENTRY,
         compatibility_flags: createWranglerCompatibilityFlags(wrangler.compatibility_flags),
         assets: createWranglerAssetsConfig(wrangler.assets),
+        ...void 0 === environments ? {} : {
+            env: environments
+        },
         ...void 0 === d1Databases ? {} : {
             d1_databases: d1Databases
         },