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

package/dist/esm/ultramodern-tooling/config.js

@@ -3,6 +3,9 @@ import node_path from "node:path";
 import { normalizeUltramodernBridgeConfig } from "../ultramodern-workspace/bridge-config.js";
 import { ULTRAMODERN_CONFIG_PATH, createNeutralOwnership, shellApp } from "../ultramodern-workspace/descriptors.js";
 import { toKebabCase } from "../ultramodern-workspace/naming.js";
+const LEGACY_GENERATED_CONTRACT_PATH = '.modernjs/ultramodern-generated-contract.json';
+const LEGACY_PACKAGE_SOURCE_METADATA_PATH = '.modernjs/ultramodern-package-source.json';
+const LEGACY_DEVELOPMENT_OVERLAY_PATH = 'topology/local-overlays/development.json';
 function readJsonObject(filePath) {
     const value = JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
     if (null === value || 'object' != typeof value || Array.isArray(value)) throw new Error(`UltraModern config must contain a JSON object: ${filePath}`);
@@ -11,11 +14,39 @@ function readJsonObject(filePath) {
 function readOptionalJsonObject(filePath) {
     return node_fs.existsSync(filePath) ? readJsonObject(filePath) : {};
 }
-function packageScopeFromRoot(workspaceRoot1) {
-    const rootPackage = readOptionalJsonObject(node_path.join(workspaceRoot1, 'package.json'));
-    return 'string' == typeof rootPackage.name && rootPackage.name.length > 0 ? rootPackage.name : node_path.basename(workspaceRoot1);
+function packageScopeFromRoot(workspaceRoot) {
+    const rootPackage = readOptionalJsonObject(node_path.join(workspaceRoot, 'package.json'));
+    return 'string' == typeof rootPackage.name && rootPackage.name.length > 0 ? rootPackage.name : node_path.basename(workspaceRoot);
 }
-function normalizeCompactConfig(sourcePath, config) {
+function packageSourceFromMetadata(workspaceRoot) {
+    const metadataPath = node_path.join(workspaceRoot, LEGACY_PACKAGE_SOURCE_METADATA_PATH);
+    if (!node_fs.existsSync(metadataPath)) return;
+    const metadata = readJsonObject(metadataPath);
+    const aliases = metadata.modernPackages?.aliases ?? {};
+    const firstAliasEntry = Object.entries(aliases).find((entry)=>'string' == typeof entry[1]);
+    const firstPackage = firstAliasEntry?.[0];
+    const firstAlias = firstAliasEntry?.[1];
+    const aliasScope = firstAlias?.match(/^@([^/]+)\//u)?.[1];
+    const unscopedName = firstPackage?.split('/').at(-1) ?? '';
+    const aliasUnscopedName = firstAlias?.split('/').at(-1) ?? '';
+    const aliasPackageNamePrefix = aliasUnscopedName && unscopedName && aliasUnscopedName.endsWith(unscopedName) ? aliasUnscopedName.slice(0, -unscopedName.length) : void 0;
+    return {
+        strategy: 'install' === metadata.strategy ? 'install' : 'workspace',
+        modernPackageVersion: 'string' == typeof metadata.modernPackages?.specifier ? metadata.modernPackages.specifier : 'workspace:*',
+        registry: 'string' == typeof metadata.modernPackages?.registry ? metadata.modernPackages.registry : void 0,
+        aliasScope,
+        aliasPackageNamePrefix
+    };
+}
+function readOverlayPorts(workspaceRoot) {
+    const overlayPath = node_path.join(workspaceRoot, LEGACY_DEVELOPMENT_OVERLAY_PATH);
+    if (!node_fs.existsSync(overlayPath)) return {};
+    const overlay = readJsonObject(overlayPath);
+    const ports = overlay.ports;
+    if (null === ports || 'object' != typeof ports || Array.isArray(ports)) return {};
+    return Object.fromEntries(Object.entries(ports).filter((entry)=>'number' == typeof entry[1]));
+}
+function normalizeCompactConfig(workspaceRoot, sourcePath, config) {
     const packageSource = config.packageSource && 'object' == typeof config.packageSource ? {
         strategy: 'install' === config.packageSource.strategy ? 'install' : 'workspace',
         modernPackageVersion: 'string' == typeof config.packageSource.modernPackageVersion ? config.packageSource.modernPackageVersion : 'workspace:*',
@@ -68,10 +99,114 @@ function normalizeCompactConfig(sourcePath, config) {
         }
     };
 }
-function readUltramodernConfig(workspaceRoot1 = process.cwd()) {
-    const compactPath = node_path.join(workspaceRoot1, ULTRAMODERN_CONFIG_PATH);
-    if (node_fs.existsSync(compactPath)) return normalizeCompactConfig(compactPath, readJsonObject(compactPath));
-    throw new Error(`Missing UltraModern config. Expected ${ULTRAMODERN_CONFIG_PATH}.`);
+function normalizeCompactUltramodernConfig(workspaceRoot, compact) {
+    return normalizeCompactConfig(workspaceRoot, node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH), compact);
+}
+function synthesizeCompactUltramodernConfig(workspaceRoot) {
+    const contractPath = node_path.join(workspaceRoot, LEGACY_GENERATED_CONTRACT_PATH);
+    if (!node_fs.existsSync(contractPath)) return;
+    const contract = readJsonObject(contractPath);
+    const sources = [
+        LEGACY_GENERATED_CONTRACT_PATH
+    ];
+    const missing = [];
+    const packageSource = packageSourceFromMetadata(workspaceRoot);
+    if (packageSource) sources.push(LEGACY_PACKAGE_SOURCE_METADATA_PATH);
+    else missing.push(LEGACY_PACKAGE_SOURCE_METADATA_PATH);
+    const ports = readOverlayPorts(workspaceRoot);
+    if (node_fs.existsSync(node_path.join(workspaceRoot, LEGACY_DEVELOPMENT_OVERLAY_PATH))) sources.push(LEGACY_DEVELOPMENT_OVERLAY_PATH);
+    else missing.push(LEGACY_DEVELOPMENT_OVERLAY_PATH);
+    const apps = Array.isArray(contract.apps) ? contract.apps : [];
+    const shell = apps.find((app)=>app?.id === shellApp.id);
+    const compact = {
+        schemaVersion: 'number' == typeof contract.schemaVersion ? contract.schemaVersion : 1,
+        ...'string' == typeof contract.profile ? {
+            profile: contract.profile
+        } : {},
+        workspace: {
+            packageScope: packageScopeFromRoot(workspaceRoot)
+        },
+        ...packageSource ? {
+            packageSource: {
+                strategy: packageSource.strategy,
+                modernPackageVersion: packageSource.modernPackageVersion,
+                ...packageSource.registry ? {
+                    registry: packageSource.registry
+                } : {},
+                ...packageSource.aliasScope ? {
+                    aliasScope: packageSource.aliasScope
+                } : {},
+                ...packageSource.aliasPackageNamePrefix ? {
+                    aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
+                } : {}
+            }
+        } : {},
+        features: {
+            tailwind: shell?.styling?.tailwind !== false
+        },
+        topology: {
+            apps: apps.map((app)=>{
+                const id = String(app.id);
+                const appPath = 'string' == typeof app.path ? app.path : id === shellApp.id ? shellApp.directory : `verticals/${toKebabCase(id)}`;
+                const domain = 'string' == typeof app.i18n?.namespace && 'shell' !== app.i18n.namespace ? app.i18n.namespace : appPath.split('/').at(-1);
+                const moduleFederation = app.moduleFederation && 'object' == typeof app.moduleFederation ? {
+                    role: 'vertical' === app.kind ? 'remote' : 'host',
+                    ...'string' == typeof app.moduleFederation.name ? {
+                        name: app.moduleFederation.name
+                    } : {},
+                    ...Array.isArray(app.moduleFederation.exposes) ? {
+                        exposes: app.moduleFederation.exposes.filter((expose)=>'string' == typeof expose)
+                    } : {},
+                    ...Array.isArray(app.moduleFederation.verticalRefs) ? {
+                        verticalRefs: app.moduleFederation.verticalRefs.filter((ref)=>'string' == typeof ref)
+                    } : {}
+                } : void 0;
+                const api = app.effect && 'object' == typeof app.effect ? {
+                    stem: 'string' == typeof app.effect.prefix ? app.effect.prefix.split('/').filter(Boolean).at(-1) ?? domain ?? id : domain ?? id,
+                    prefix: 'string' == typeof app.effect.prefix ? app.effect.prefix : `/${domain ?? id}-api`,
+                    consumedBy: [
+                        shellApp.id,
+                        id
+                    ]
+                } : void 0;
+                return {
+                    id,
+                    kind: 'vertical' === app.kind ? 'vertical' : 'shell',
+                    path: appPath,
+                    ...'string' == typeof app.package ? {
+                        package: app.package
+                    } : {},
+                    packageSuffix: 'string' == typeof app.package ? app.package.split('/').at(-1) : appPath.split('/').at(-1),
+                    ...id === shellApp.id ? {
+                        displayName: shellApp.displayName
+                    } : {},
+                    ...domain ? {
+                        domain
+                    } : {},
+                    ...'number' == typeof ports[id] ? {
+                        port: ports[id]
+                    } : {},
+                    ...moduleFederation ? {
+                        moduleFederation
+                    } : {},
+                    ...api ? {
+                        api
+                    } : {}
+                };
+            })
+        }
+    };
+    return {
+        compact,
+        missing,
+        sources
+    };
+}
+function readUltramodernConfig(workspaceRoot = process.cwd()) {
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (node_fs.existsSync(compactPath)) return normalizeCompactConfig(workspaceRoot, compactPath, readJsonObject(compactPath));
+    if (node_fs.existsSync(node_path.join(workspaceRoot, LEGACY_GENERATED_CONTRACT_PATH))) throw new Error(`Missing ${ULTRAMODERN_CONFIG_PATH}. Legacy UltraModern metadata detected — run \`modern-js-create ultramodern migrate-strict-effect\` to synthesize it.`);
+    throw new Error(`Missing UltraModern config. Expected ${ULTRAMODERN_CONFIG_PATH}. Run \`modern-js-create ultramodern migrate-strict-effect\` if you have legacy UltraModern metadata to migrate.`);
 }
 function workspaceAppsFromToolingConfig(config) {
     return config.topology.apps.map((app)=>{
@@ -117,4 +252,4 @@ function workspaceAppsFromToolingConfig(config) {
         };
     });
 }
-export { readUltramodernConfig, workspaceAppsFromToolingConfig };
+export { normalizeCompactUltramodernConfig, readUltramodernConfig, synthesizeCompactUltramodernConfig, workspaceAppsFromToolingConfig };

package/dist/esm/ultramodern-workspace/add-vertical.js

@@ -5,12 +5,14 @@ import { WORKSPACE_PACKAGE_VERSION } from "../ultramodern-package-source.js";
 import { readUltramodernConfig } from "../ultramodern-tooling/config.js";
 import { apiTopologyMetadata, createShellApiClient } from "./api.js";
 import { createAppEnvDts, createAppRuntimeConfig, createShellFrameComponent } from "./app-files.js";
+import { createBackendFederationContract, createServerExecutionOverlay } from "./backend-federation.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
 import { createShellPage, createShellRemoteComponents } from "./demo-components.js";
 import { ULTRAMODERN_CONFIG_PATH, appHasApi, appI18nNamespace, createModuleFederationRemoteContracts, createNeutralOwnership, createRemoteManifestEnv, createShellHost, createVerticalDescriptor, remoteDependencyAlias, resolveApiPrefix, shellApp, zephyrRemoteDependency } from "./descriptors.js";
 import { formatGeneratedWorkspaceFiles, readJsonFile, writeFileReplacing, writeJsonFile } from "./fs-io.js";
 import { createFileSnapshot, createGenerationResult, diffFileSnapshots } from "./generation-result.js";
 import { createAppPublicLocaleMessages } from "./locales.js";
-import { createShellModuleFederationConfig } from "./module-federation.js";
+import { createAppModernConfig, createShellModuleFederationConfig } from "./module-federation.js";
 import { assertUniqueTailwindPrefixes, normalizePath, packageName, toEnvSegment, toKebabCase, toPackageScope, toPascalCase } from "./naming.js";
 import { runCodeSmithOverlays } from "./overlays.js";
 import { createAppMfTypesTsConfig, createAppPackage, createAppTsConfig, createRootPackageJson, createRootTsConfig } from "./package-json.js";
@@ -20,6 +22,7 @@ import { createPublicWebAppArtifacts, rewriteWorkspaceAssetsForApp } from "./pub
 import { isRecord } from "./types.js";
 import { writeGeneratedWorkspaceScripts } from "./workspace-scripts.js";
 import { createCompactUltramodernConfig, writeApp } from "./write-workspace.js";
+import { createZeropsYaml } from "./zerops.js";
 const FIRST_VERTICAL_PORT = 4101;
 const TOPOLOGY_PATH = 'topology/reference-topology.json';
 const OWNERSHIP_PATH = 'topology/ownership.json';
@@ -73,6 +76,7 @@ function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwin
     writeJsonFile(node_path.join(workspaceRoot, `${shellApp.directory}/tsconfig.json`), createAppTsConfig(shellHost, remotes));
     writeJsonFile(node_path.join(workspaceRoot, `${shellApp.directory}/tsconfig.mf-types.json`), createAppMfTypesTsConfig(shellHost));
     writeFileReplacing(workspaceRoot, `${shellApp.directory}/src/modern-app-env.d.ts`, createAppEnvDts(shellHost, remotes));
+    writeFileReplacing(workspaceRoot, `${shellApp.directory}/modern.config.ts`, createAppModernConfig(scope, shellHost, remotes));
     writeFileReplacing(workspaceRoot, publicWeb.jsonLdHelperFile.path, publicWeb.jsonLdHelperFile.content);
     writeFileReplacing(workspaceRoot, publicWeb.routeMetadataFile.path, publicWeb.routeMetadataFile.content);
     writeFileReplacing(workspaceRoot, publicWeb.routeHeadFile.path, publicWeb.routeHeadFile.content);
@@ -124,6 +128,12 @@ function verticalTopologyEntry(scope, vertical, remotes = []) {
             fallbackTelemetryEvent: 'modernjs:mv-runtime-parity',
             sharedContractVersion: 'mf-ssr-contract-v1'
         },
+        ...createBackendFederationContract(scope, vertical) ? {
+            backendFederation: createBackendFederationContract(scope, vertical)
+        } : {},
+        ...vertical.api ? {
+            deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, vertical))
+        } : {},
         ...apiTopologyMetadata(vertical) ? {
             api: apiTopologyMetadata(vertical)
         } : {},
@@ -364,6 +374,12 @@ function createDryRunJsonMutations(preflight, manifestUrl) {
             pointer: `/apis/${vertical.id}`,
             description: `Add local API URL for ${vertical.id}`,
             value: `http://localhost:${vertical.port}${resolveApiPrefix(vertical)}`
+        },
+        {
+            path: DEVELOPMENT_OVERLAY_PATH,
+            pointer: `/serverExecution/${vertical.id}`,
+            description: `Add local MicroVertical server execution metadata for ${vertical.id}`,
+            value: createServerExecutionOverlay(scope, vertical)
         }
     ] : [];
     return [
@@ -479,6 +495,8 @@ function addUltramodernVertical(options) {
     overlay.ports[vertical.id] = vertical.port;
     overlay.manifests ??= {};
     overlay.manifests[vertical.id] = `http://localhost:${vertical.port}/mf-manifest.json`;
+    overlay.serverExecution ??= {};
+    overlay.serverExecution[vertical.id] = createServerExecutionOverlay(scope, vertical);
     overlay.apis ??= {};
     overlay.apis[vertical.id] = `http://localhost:${vertical.port}${resolveApiPrefix(vertical)}`;
     writeJsonFile(topologyPath, topology);
@@ -491,6 +509,13 @@ function addUltramodernVertical(options) {
         },
         ...updatedVerticals
     ], enableTailwind, bridge));
+    writeFileReplacing(options.workspaceRoot, 'zerops.yaml', `${createZeropsYaml(scope, [
+        {
+            ...shellApp,
+            verticalRefs: updatedVerticals.map((vertical)=>vertical.id)
+        },
+        ...updatedVerticals
+    ])}\n`);
     rewriteShellAppFiles(options.workspaceRoot, scope, packageSource, enableTailwind, updatedVerticals, bridge);
     writeGeneratedWorkspaceScripts(options.workspaceRoot, scope, enableTailwind, updatedVerticals);
     addShellZephyrDependency(options.workspaceRoot, scope, vertical);

package/dist/esm/ultramodern-workspace/api.js

@@ -1,4 +1,5 @@
-import { appHasApi, resolveApiPrefix, resolveApiStem, verticalApiApps } from "./descriptors.js";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from "./backend-federation.js";
+import { appHasApi, createBackendFederationName, resolveApiPrefix, resolveApiStem, verticalApiApps } from "./descriptors.js";
 import { packageName, toCamelCase, toPascalCase } from "./naming.js";
 function verticalApiExport(service) {
     return `${toCamelCase(resolveApiStem(service))}Api`;
@@ -639,6 +640,46 @@ const apiRuntime: EffectBffDefinition<typeof ${apiExport}, EffectRuntimeLayer> &
   layer,
 });
 
+export default apiRuntime;
+`;
+}
+function createBackendEffectApiExpose(scope, service) {
+    const apiExport = verticalApiExport(service);
+    const groupName = verticalApiGroupName(service);
+    const apiPrefix = resolveApiPrefix(service);
+    const stem = resolveApiStem(service);
+    return `import apiRuntime from './index.ts';
+import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+import {
+  ${apiExport},
+  ${groupName}ApiContract,
+  ${groupName}OperationContexts,
+} from '../shared/api.ts';
+
+export const backendFederationContract = {
+  compatibility: {
+    build: ultramodernApiMarker.build,
+    contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
+    nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
+    packageName: '${packageName(scope, service.packageSuffix)}',
+    sourceRevision: ultramodernApiMarker.sourceRevision,
+    unitId: ultramodernApiMarker.unitId,
+  },
+  executionSurfaces: ['node-mf-runtime'],
+  exposes: ['./effect-api'],
+  name: '${createBackendFederationName(service)}',
+  openapiPath: '${apiPrefix}/openapi.json',
+  readinessPath: '${apiPrefix}/${stem}/readiness',
+  role: 'microvertical-server',
+  runtimeFramework: 'effect',
+  strictEffectApproach: true,
+} as const;
+
+export const api: unknown = ${apiExport};
+export const contract = ${groupName}ApiContract;
+export const operationContexts = ${groupName}OperationContexts;
+export const runtime = apiRuntime;
+
 export default apiRuntime;
 `;
 }
@@ -981,4 +1022,4 @@ function createApiOperationContract(target) {
         }
     };
 }
-export { apiTopologyMetadata, createApiClient, createApiDomainOperations, createApiOperationContract, createApiReadinessContract, createApiRequestContextContract, createApiServiceEntry, createSharedApi, createSharedApiContract, createSharedApiImports, createShellApiClient, verticalApiCreatePayloadSchemaExport, verticalApiErrorStem, verticalApiExport, verticalApiGroupName, verticalApiMarkerSchemaExport, verticalApiName, verticalApiNotFoundErrorExport, verticalApiNotFoundSchemaExport, verticalApiReadinessSchemaExport, verticalApiSchemaExport };
+export { apiTopologyMetadata, createApiClient, createApiDomainOperations, createApiOperationContract, createApiReadinessContract, createApiRequestContextContract, createApiServiceEntry, createBackendEffectApiExpose, createSharedApi, createSharedApiContract, createSharedApiImports, createShellApiClient, verticalApiCreatePayloadSchemaExport, verticalApiErrorStem, verticalApiExport, verticalApiGroupName, verticalApiMarkerSchemaExport, verticalApiName, verticalApiNotFoundErrorExport, verticalApiNotFoundSchemaExport, verticalApiReadinessSchemaExport, verticalApiSchemaExport };

package/dist/esm/ultramodern-workspace/app-files.js

@@ -27,17 +27,14 @@ function createAppEnvDts(app, remotes = []) {
 }
 `;
         })).join('\n');
-    const reactTypeReference = remoteModuleDeclarations ? "/// <reference types='react' />\n" : '';
-    const siteUrlDeclaration = 'declare const ULTRAMODERN_SITE_URL: string;';
-    return `${reactTypeReference}/// <reference types='@modern-js/app-tools/types' />
-
-${siteUrlDeclaration}
-declare module '*.svg' {
-  const url: string;
-  export default url;
-}
-declare module '*.css';
-${remoteModuleDeclarations ? `\n${remoteModuleDeclarations}` : ''}`;
+    const reactTypeImport = remoteModuleDeclarations ? "import type React from 'react';\n" : '';
+    return [
+        `import '@modern-js/app-tools/types';\n${reactTypeImport}`.trimEnd(),
+        `declare global {
+  const ULTRAMODERN_SITE_URL: string;
+}`,
+        remoteModuleDeclarations.trimEnd()
+    ].filter((section)=>section.length > 0).join('\n\n').concat('\n');
 }
 function createAppRuntimeConfig(app, scope, remotes = []) {
     const pluginsConfig = 'shell' === app.kind ? `  plugins: [

package/dist/esm/ultramodern-workspace/backend-federation.js

@@ -0,0 +1,217 @@
+import { verticalApiExport, verticalApiGroupName } from "./api.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
+import { appHasApi, createBackendFederationContainerEntry, createBackendFederationManifestEnv, createBackendFederationManifestUrl, createBackendFederationName, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createRemoteManifestEnv, resolveApiPrefix, resolveApiStem } from "./descriptors.js";
+import { packageName, toEnvSegment } from "./naming.js";
+import { EFFECT_VERSION, MODULE_FEDERATION_VERSION } from "./versions.js";
+const BACKEND_FEDERATION_CONTRACT_VERSION = 'microvertical-server-effect-v1';
+const BACKEND_FEDERATION_NODE_ADAPTER_VERSION = 'backend-mf-effect-v1';
+function createZephyrEnv(app, suffix) {
+    return `ZEPHYR_${toEnvSegment(app.domain ?? app.id)}_${suffix}`;
+}
+function createWorkerBindingName(app) {
+    return `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_WORKER`;
+}
+function createWorkerBindingEnv(app) {
+    return `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_WORKER_BINDING`;
+}
+function createDispatchNamespaceEnv(app) {
+    return `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_DISPATCH_NAMESPACE`;
+}
+function createDispatchWorkerNameEnv(app) {
+    return `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_WORKER_NAME`;
+}
+function createEffectExpose(app) {
+    const apiStem = resolveApiStem(app);
+    return {
+        contract: `${app.directory}/shared/api.ts`,
+        runtime: `${app.directory}/api/index.ts`,
+        client: `${app.directory}/src/api/${app.api.stem}-client.ts`,
+        openapi: `${app.api.prefix}/openapi.json`,
+        readiness: `${app.api.prefix}/${apiStem}/readiness`
+    };
+}
+function createCloudflareExecutionSurface(scope, app) {
+    return {
+        kind: 'cloudflare-worker-snapshot',
+        workerName: createCloudflareWorkerName(scope, app),
+        publicUrlEnv: createCloudflarePublicUrlEnv(app),
+        ssr: {
+            workerEntry: '.output/server/index.mjs',
+            workerManifest: '.output/server/modern-worker-manifest.json',
+            routeManifest: '.output/server/route.json',
+            ssrBundle: '.output/worker/index.js',
+            effectBffBundle: '.output/worker/__modern_bff_effect.js',
+            assetsBinding: 'ASSETS'
+        },
+        zephyr: {
+            runtime: 'ssr-worker',
+            integration: 'managed-cloudflare',
+            snapshotIdEnv: createZephyrEnv(app, 'SNAPSHOT_ID'),
+            versionIdEnv: createZephyrEnv(app, 'VERSION_ID'),
+            applicationUidEnv: createZephyrEnv(app, 'APPLICATION_UID')
+        },
+        workerDispatch: {
+            preferred: 'service-binding',
+            serviceBinding: createWorkerBindingName(app),
+            serviceBindingEnv: createWorkerBindingEnv(app),
+            dispatchNamespaceEnv: createDispatchNamespaceEnv(app),
+            dispatchWorkerNameEnv: createDispatchWorkerNameEnv(app),
+            requestInterface: 'fetch'
+        }
+    };
+}
+function createNodeExecutionSurface(app) {
+    return {
+        kind: 'node-mf-runtime',
+        adapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        remoteName: createBackendFederationName(app),
+        manifestEnv: createBackendFederationManifestEnv(app),
+        manifestUrl: createBackendFederationManifestUrl(app),
+        containerEntry: createBackendFederationContainerEntry(app),
+        remoteType: 'module',
+        expose: './effect-api',
+        runtimePackage: '@modern-js/plugin-bff/effect'
+    };
+}
+function createServerExecutionOverlay(scope, app) {
+    if (!appHasApi(app)) return;
+    const deliveryUnit = createDeliveryUnitRecord(scope, app);
+    return {
+        apiBaseUrl: `http://localhost:${app.port}${resolveApiPrefix(app)}`,
+        versionBoundary: 'web-and-api-same-build',
+        deliveryUnit: {
+            unitId: deliveryUnit.unitId,
+            buildMarker: deliveryUnit.buildMarker
+        },
+        cloudflare: createCloudflareExecutionSurface(scope, app),
+        node: createNodeExecutionSurface(app)
+    };
+}
+function createBackendFederationContract(scope, app) {
+    if (!appHasApi(app)) return;
+    const readiness = `${app.api.prefix}/${resolveApiStem(app)}/readiness`;
+    const deliveryUnit = createDeliveryUnitRecord(scope, app);
+    return {
+        role: 'microvertical-server',
+        name: createBackendFederationName(app),
+        runtimeFramework: 'effect',
+        strictEffectApproach: true,
+        deliveryUnit: deliveryUnitContractBlock(deliveryUnit),
+        exposes: {
+            './effect-api': createEffectExpose(app)
+        },
+        versionBoundary: {
+            invariant: 'web-and-api-same-build',
+            identityRoot: 'deliveryUnit',
+            packageName: packageName(scope, app.packageSuffix),
+            ui: {
+                manifestEnv: createRemoteManifestEnv(app),
+                manifestUrl: `http://localhost:${app.port}/mf-manifest.json`,
+                buildMarker: `${app.directory}/src/routes/ultramodern-route-metadata.ts`
+            },
+            api: {
+                readiness,
+                buildMarker: `${app.directory}/shared/ultramodern-build.ts`,
+                publicUrlEnv: createCloudflarePublicUrlEnv(app)
+            }
+        },
+        executionSurfaces: {
+            cloudflare: createCloudflareExecutionSurface(scope, app),
+            node: createNodeExecutionSurface(app)
+        },
+        compatibility: {
+            contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+            packageName: packageName(scope, app.packageSuffix),
+            effectVersion: EFFECT_VERSION,
+            moduleFederationVersion: MODULE_FEDERATION_VERSION
+        },
+        cache: {
+            cloudflareSnapshot: 'immutable',
+            nodeManifest: 'no-store',
+            nodeVersionedContainer: 'immutable',
+            nodeUnpinnedContainer: 'revalidate'
+        },
+        fallback: {
+            timeoutMs: 1500,
+            failureEvent: 'modernjs:microvertical-server-fallback',
+            strategy: 'typed-effect-error'
+        }
+    };
+}
+function createBackendFederationMetadata(scope, app) {
+    if (!appHasApi(app)) return;
+    return {
+        contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+        deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app)),
+        executionSurfaces: [
+            'node-mf-runtime'
+        ],
+        exposes: [
+            './effect-api'
+        ],
+        name: createBackendFederationName(app),
+        nodeAdapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        openapiPath: `${app.api.prefix}/openapi.json`,
+        readinessPath: `${app.api.prefix}/${resolveApiStem(app)}/readiness`,
+        role: 'microvertical-server',
+        runtimeFramework: 'effect',
+        strictEffectApproach: true
+    };
+}
+function createBackendFederationContractFile(app) {
+    if (!app.api) throw new Error(`App ${app.id} does not define an Effect API.`);
+    const apiExport = verticalApiExport(app);
+    const groupName = verticalApiGroupName(app);
+    const readinessPath = `${app.api.prefix}/${resolveApiStem(app)}/readiness`;
+    return `import runtime from './index.ts';
+import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+import {
+  ${apiExport} as api,
+  ${groupName}ApiContract as contract,
+  ${groupName}OperationContexts as operationContexts,
+} from '../shared/api.ts';
+
+export const backendFederationContract = {
+  compatibility: {
+    build: ultramodernApiMarker.build,
+    contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
+    nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
+    packageName: ultramodernApiMarker.packageName,
+    sourceRevision: ultramodernApiMarker.sourceRevision,
+    unitId: ultramodernApiMarker.unitId,
+  },
+  contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
+  executionSurfaces: ['node-mf-runtime'],
+  exposes: ['./effect-api'],
+  name: '${createBackendFederationName(app)}',
+  nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
+  openapiPath: '${app.api.prefix}/openapi.json',
+  readinessPath: '${readinessPath}',
+  role: 'microvertical-server',
+  runtimeFramework: 'effect',
+  strictEffectApproach: true,
+} as const;
+
+export { api, contract, operationContexts, runtime };
+
+export default runtime;
+`;
+}
+function createBackendFederationSummary(scope, app) {
+    if (!appHasApi(app)) return;
+    return {
+        id: app.id,
+        path: app.directory,
+        role: 'microvertical-server',
+        name: createBackendFederationName(app),
+        runtimeFramework: 'effect',
+        strictEffectApproach: true,
+        contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+        deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app)),
+        executionSurfaces: {
+            cloudflare: createCloudflareExecutionSurface(scope, app),
+            node: createNodeExecutionSurface(app)
+        }
+    };
+}
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationContract, createBackendFederationContractFile, createBackendFederationMetadata, createBackendFederationSummary, createDispatchWorkerNameEnv, createServerExecutionOverlay, createWorkerBindingEnv, createWorkerBindingName };

package/dist/esm/ultramodern-workspace/contracts.js

@@ -1,7 +1,10 @@
 import { apiTopologyMetadata } from "./api.js";
+import { createBackendFederationContract, createBackendFederationSummary, createServerExecutionOverlay } from "./backend-federation.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
 import { createModuleFederationRemoteContracts, createShellHost, resolveApiPrefix, sharedPackages, shellApp, verticalApiApps } from "./descriptors.js";
 import { packageName } from "./naming.js";
 import { createCloudflareDeployContract } from "./policy.js";
+import { createGeneratedToolingWrapperMap } from "./tooling-command-catalog.js";
 import { CLOUDFLARE_COMPATIBILITY_DATE, NODE_VERSION, PNPM_VERSION } from "./versions.js";
 function createTopology(scope, remotes = []) {
     const shellHost = createShellHost(remotes);
@@ -44,6 +47,12 @@ function createTopology(scope, remotes = []) {
                     fallbackTelemetryEvent: 'modernjs:mv-runtime-parity',
                     sharedContractVersion: 'mf-ssr-contract-v1'
                 },
+                ...createBackendFederationContract(scope, vertical) ? {
+                    backendFederation: createBackendFederationContract(scope, vertical)
+                } : {},
+                ...vertical.api ? {
+                    deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, vertical))
+                } : {},
                 ...apiTopologyMetadata(vertical) ? {
                     api: apiTopologyMetadata(vertical)
                 } : {},
@@ -99,7 +108,7 @@ function createOwnership(scope, remotes = []) {
             }))
     };
 }
-function createDevelopmentOverlay(remotes = []) {
+function createDevelopmentOverlay(scope, remotes = []) {
     return {
         schemaVersion: 1,
         environment: 'development',
@@ -115,6 +124,10 @@ function createDevelopmentOverlay(remotes = []) {
                 remote.id,
                 `http://localhost:${remote.port}/mf-manifest.json`
             ])),
+        serverExecution: Object.fromEntries(verticalApiApps(remotes).map((app)=>[
+                app.id,
+                createServerExecutionOverlay(scope, app)
+            ])),
         apis: Object.fromEntries(verticalApiApps(remotes).map((app)=>[
                 app.id,
                 `http://localhost:${app.port}${resolveApiPrefix(app)}`
@@ -191,6 +204,12 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                             tsConfigPath: './tsconfig.mf-types.json'
                         }
                     },
+                    ...createBackendFederationContract(scope, app) ? {
+                        backendFederation: createBackendFederationContract(scope, app)
+                    } : {},
+                    ...app.api ? {
+                        deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app))
+                    } : {},
                     ...app.api ? {
                         api: {
                             stem: app.api.stem,
@@ -234,6 +253,9 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                     hostOnly: 'shell' === app.kind && 0 === Object.keys(app.exposes ?? {}).length
                 }))
         },
+        backendFederation: {
+            apps: verticalApiApps(remotes).map((app)=>createBackendFederationSummary(scope, app))
+        },
         agentSkills: {
             target: 'codex',
             lockfile: './.codex/skills-lock.json',
@@ -248,13 +270,7 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
         tooling: {
             command: 'modern-js-create ultramodern',
             wrappers: {
-                validate: "scripts/validate-ultramodern-workspace.mts",
-                typecheck: "scripts/ultramodern-typecheck.mts",
-                mfTypes: "scripts/assert-mf-types.mts",
-                publicSurface: "scripts/generate-public-surface-assets.mts",
-                cloudflareProof: "scripts/proof-cloudflare-version.mts",
-                performanceReadiness: "scripts/ultramodern-performance-readiness.mts",
-                migrateStrictEffect: "scripts/migrate-strict-effect.mts",
+                ...createGeneratedToolingWrapperMap(),
                 apiBoundaries: "scripts/check-ultramodern-api-boundaries.mts",
                 skills: "scripts/bootstrap-agent-skills.mts"
             }