@bleedingdev/modern-js-create 3.5.0-ultramodern.28 → 3.5.0-ultramodern.29

package/dist/types/ultramodern-workspace/descriptors.d.ts

@@ -27,6 +27,10 @@ export declare function remoteDependencyAlias(remote: WorkspaceApp): string;
 export declare function zephyrRemoteDependency(scope: string, remote: WorkspaceApp): string;
 export declare function resolveRemoteRefs(app: WorkspaceApp, remotes?: WorkspaceApp[]): WorkspaceApp[];
 export declare function createRemoteManifestEnv(remote: WorkspaceApp): string;
+export declare function createBackendFederationManifestEnv(remote: WorkspaceApp): string;
+export declare function createBackendFederationName(app: WorkspaceApp): string;
+export declare function createBackendFederationManifestUrl(app: WorkspaceApp): string;
+export declare function createBackendFederationContainerEntry(app: WorkspaceApp): string;
 export declare function createModuleFederationRemoteContracts(app: WorkspaceApp, remotes?: WorkspaceApp[]): {
     id: string;
     alias: string;

package/dist/types/ultramodern-workspace/module-federation.d.ts

@@ -1,17 +1,12 @@
 import type { WorkspaceApp } from './types';
-export declare function createAppModernConfig(scope: string, app: WorkspaceApp): string;
+export declare function createAppModernConfig(scope: string, app: WorkspaceApp, remotes?: WorkspaceApp[]): string;
 export declare function createSharedModuleFederationConfig(): string;
 export declare function formatTsObjectLiteral(value: Record<string, string>): string;
 export declare function createModuleFederationRemoteUrlHelpers(app: WorkspaceApp, remotes?: WorkspaceApp[]): string;
 export declare function createModuleFederationRemotesConfig(scope: string, app: WorkspaceApp, remotes?: WorkspaceApp[]): string;
 export declare function createShellModuleFederationConfig(scope: string, remotes?: WorkspaceApp[]): string;
-export declare function createBuildMarker(scope: string, app: {
-    id: string;
-    packageSuffix: string;
-}): any;
-export declare function createUltramodernBuildModule(scope: string, app: {
-    id: string;
-    packageSuffix: string;
-}): string;
+export declare function createBackendModuleFederationConfig(app: WorkspaceApp): string;
+export { createBuildMarker } from './delivery-unit';
+export declare function createUltramodernBuildModule(scope: string, app: WorkspaceApp): string;
 export declare function createUltramodernBuildReexportModule(): string;
 export declare function createRemoteModuleFederationConfig(scope: string, app: WorkspaceApp, remotes?: WorkspaceApp[]): string;

package/dist/types/ultramodern-workspace/package-json.d.ts

@@ -1,6 +1,5 @@
 import type { UltramodernBridgeConfig } from './bridge-config';
 import type { JsonValue, ResolvedPackageSource, WorkspaceApp } from './types';
-export declare const createStrictTsgoTypecheckCommand: (packageDir: string) => string;
 export declare const effectDiagnostics: string[];
 export declare function appDependencies(scope: string, packageSource: ResolvedPackageSource, app: WorkspaceApp, remotes?: WorkspaceApp[], bridge?: UltramodernBridgeConfig): Record<string, string>;
 export declare function appDevDependencies(packageSource: ResolvedPackageSource, enableTailwind: boolean): Record<string, string>;

package/dist/types/ultramodern-workspace/pnpm-workspace-policy-plan.d.ts

@@ -0,0 +1,39 @@
+export declare const strictEffectPackageVersionPolicyExclusions: string[];
+export declare const moduleFederationModernJsPatchPath = "patches/@module-federation__modern-js-v3@2.6.0.patch";
+export declare const moduleFederationBridgeReactPatchPath = "patches/@module-federation__bridge-react@2.6.0.patch";
+export declare const effectDeclarationPatchPath = "patches/effect-schema-error-type-id.patch";
+export declare const drizzleOrmDeclarationPatchPath = "patches/drizzle-orm-ts7-strict-declarations.patch";
+export type PnpmWorkspaceYamlAction = {
+    kind: 'replace-line';
+    pattern: RegExp;
+    replacement: string;
+} | {
+    kind: 'ensure-scalar-map-entry';
+    key: string;
+    entryKey: string;
+    value: string;
+} | {
+    kind: 'ensure-list-item';
+    key: string;
+    item: string;
+} | {
+    kind: 'ensure-map-entry';
+    key: string;
+    entryKey: string;
+    value: string;
+} | {
+    kind: 'remove-map-entry';
+    entryKey: string;
+};
+export type GeneratedDeclarationPatchAction = {
+    kind: 'ensure' | 'remove-if-unchanged';
+    relativePatchPath: string;
+};
+export type PnpmWorkspacePolicyPlan = {
+    yamlActions: PnpmWorkspaceYamlAction[];
+    declarationPatchActions: GeneratedDeclarationPatchAction[];
+    requiresInstallOnChange: boolean;
+};
+export declare function createPnpmWorkspacePolicyPlan(options: {
+    usesDrizzleOrm: boolean;
+}): PnpmWorkspacePolicyPlan;

package/dist/types/ultramodern-workspace/tooling-command-catalog.d.ts

@@ -0,0 +1,18 @@
+export type GeneratedToolingCommandId = 'validate' | 'typecheck' | 'mfTypes' | 'publicSurface' | 'backendFederationGenerate' | 'backendFederationProof' | 'cloudflareProof' | 'cloudflareOutputVerify' | 'performanceReadiness' | 'migrateStrictEffect' | 'routesGenerate';
+export type GeneratedToolingCommandKey = GeneratedToolingCommandId;
+export interface GeneratedToolingCommand {
+    id: GeneratedToolingCommandId;
+    command: string;
+    wrapperName: string;
+    wrapperPath: `scripts/${string}.mts`;
+    contractKey: string;
+    rootScript?: string;
+    templatePath?: `templates/workspace-scripts/${string}.mjs`;
+    cwd?: 'invocation';
+}
+export declare const generatedToolingCommands: readonly [GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand, GeneratedToolingCommand];
+export declare const toolingCommandById: Record<GeneratedToolingCommandId, GeneratedToolingCommand>;
+export declare const GENERATED_TOOLING_COMMANDS: Record<GeneratedToolingCommandId, GeneratedToolingCommand>;
+export declare const generatedToolingCommandList: () => string[];
+export declare const createToolingWrapperContract: () => Record<GeneratedToolingCommandKey, GeneratedToolingCommand['wrapperPath']>;
+export declare const createGeneratedToolingWrapperMap: () => Record<GeneratedToolingCommandKey, GeneratedToolingCommand['wrapperPath']>;

package/dist/types/ultramodern-workspace/workspace-script-plan.d.ts

@@ -0,0 +1,72 @@
+import { type GeneratedToolingCommandKey } from './tooling-command-catalog';
+import type { WorkspaceApp } from './types';
+export declare const rootToolingScriptName: (key: GeneratedToolingCommandKey) => string;
+export declare const rootToolingWrapperCommand: (key: GeneratedToolingCommandKey) => string;
+export declare const packageToolingWrapperCommand: (packageDir: string, key: GeneratedToolingCommandKey) => string;
+export interface WorkspaceRootScriptPlan {
+    build: string;
+    cloudflareBuild: string;
+    cloudflareDeploy: string;
+    cloudflareProof: string;
+    cloudflareOutputVerify: string;
+    backendFederationGenerate: string;
+    nodeProof: string;
+    mfTypes: string;
+    performanceReadiness: string;
+    migrateStrictEffect: string;
+    zeropsMaterialize: string;
+    contractCheck: string;
+    typecheck: string;
+    check: string;
+}
+export declare const workspaceRootPackageScriptNames: {
+    readonly build: 'build';
+    readonly cloudflareBuild: 'cloudflare:build';
+    readonly cloudflareDeploy: 'cloudflare:deploy';
+    readonly cloudflareProof: string;
+    readonly cloudflareOutputVerify: string;
+    readonly backendFederationGenerate: string;
+    readonly nodeProof: string;
+    readonly mfTypes: string;
+    readonly performanceReadiness: string;
+    readonly migrateStrictEffect: string;
+    readonly zeropsMaterialize: 'zerops:materialize';
+    readonly contractCheck: string;
+    readonly typecheck: 'typecheck';
+    readonly check: 'check';
+};
+export type WorkspaceRootPackageScriptName = (typeof workspaceRootPackageScriptNames)[keyof typeof workspaceRootPackageScriptNames];
+export type WorkspaceRootPackageScripts = Record<WorkspaceRootPackageScriptName, string>;
+export interface WorkspaceAppScriptPlan {
+    dev: string;
+    build: string;
+    cloudflareBuild: string;
+    cloudflareDeploy: string;
+    cloudflarePreview: string;
+    cloudflareProof: string;
+    serve: string;
+    typecheck: string;
+}
+export declare const workspaceAppPackageScriptNames: {
+    readonly dev: 'dev';
+    readonly build: 'build';
+    readonly cloudflareBuild: 'cloudflare:build';
+    readonly cloudflareDeploy: 'cloudflare:deploy';
+    readonly cloudflarePreview: 'cloudflare:preview';
+    readonly cloudflareProof: 'cloudflare:proof';
+    readonly serve: 'serve';
+    readonly typecheck: 'typecheck';
+};
+export type WorkspaceAppPackageScriptName = (typeof workspaceAppPackageScriptNames)[keyof typeof workspaceAppPackageScriptNames];
+export type WorkspaceAppPackageScripts = Record<WorkspaceAppPackageScriptName, string>;
+export declare const createStrictTsgoTypecheckCommand: (packageDir: string) => string;
+export declare function createWorkspaceAppScriptPlan(app: WorkspaceApp): WorkspaceAppScriptPlan;
+export declare function createWorkspaceAppPackageScripts(app: WorkspaceApp): WorkspaceAppPackageScripts;
+export declare function createWorkspaceRootScriptPlan(remotes?: WorkspaceApp[], options?: {
+    bridgeCheck?: string;
+    typecheck?: string;
+}): WorkspaceRootScriptPlan;
+export declare function createWorkspaceRootPackageScripts(remotes?: WorkspaceApp[], options?: {
+    bridgeCheck?: string;
+    typecheck?: string;
+}): WorkspaceRootPackageScripts;

package/dist/types/ultramodern-workspace/workspace-scripts.d.ts

@@ -1,6 +1,9 @@
 import type { WorkspaceApp } from './types';
+export declare function writeGeneratedToolWrapperScripts(targetDir: string): void;
 export declare function createWorkspaceValidationScript(scope: string, enableTailwind: boolean, remotes?: WorkspaceApp[]): string;
 export declare function createWorkspaceI18nBoundaryValidationScript(): string;
 export declare function createWorkspaceApiBoundaryValidationScript(): string;
 export declare function createPerformanceReadinessConfigScript(): string;
+export declare function createNodeBackendFederationProofScript(): string;
+export declare function createZeropsRuntimeMaterializationScript(): string;
 export declare function writeGeneratedWorkspaceScripts(targetDir: string, _scope: string, _enableTailwind: boolean, _remotes?: WorkspaceApp[]): void;

package/dist/types/ultramodern-workspace/workspace-validation-contract.d.ts

@@ -0,0 +1,42 @@
+import type { WorkspaceApp } from './types';
+export type WorkspaceValidationContract = ReturnType<typeof createWorkspaceValidationContract>;
+export declare function createWorkspaceValidationContract(scope: string, enableTailwind: boolean, remotes?: WorkspaceApp[]): {
+    packageScope: string;
+    versions: {
+        cloudflareCompatibilityDate: string;
+        effect: string;
+        moduleFederation: string;
+        node: string;
+        pnpm: string;
+    };
+    tailwindEnabled: boolean;
+    fullStackVerticals: {
+        id: string;
+        domain: string | undefined;
+        stem: string;
+        group: string;
+        path: string;
+        port: number;
+        mfName: string;
+        apiPrefix: string;
+        tailwindPrefix: string;
+        zephyrAlias: string;
+        packageName: string;
+        backendFederation: import("./types").JsonValue | undefined;
+        deliveryUnit: import("./delivery-unit").DeliveryUnitRecord;
+        exposes: string[];
+        componentPaths: string[];
+        namespace: string;
+        routePagePaths: string[];
+        routeMetaPaths: string[];
+        localisedUrls: Record<string, import("./types").JsonValue>;
+        verticalRefs: string[];
+    }[];
+    shellNamespace: string;
+    oldRemotePaths: string[];
+    scripts: import("./workspace-script-plan").WorkspaceRootScriptPlan;
+    packageScripts: import("./workspace-script-plan").WorkspaceRootPackageScripts;
+    cloudflareSecurity: import("./types").JsonValue;
+    publicSurfaceManagedSourceAssetPaths: ("config/public/robots.txt" | "config/public/site.webmanifest" | "config/public/sitemap.xml")[];
+    shellRouteMetaPaths: string[];
+};

package/dist/types/ultramodern-workspace/zerops.d.ts

@@ -0,0 +1,2 @@
+import type { WorkspaceApp } from './types';
+export declare function createZeropsYaml(scope: string, apps: WorkspaceApp[]): string;

package/package.json

@@ -21,7 +21,7 @@
   "engines": {
     "node": ">=20"
   },
-  "version": "3.5.0-ultramodern.28",
+  "version": "3.5.0-ultramodern.29",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/esm-node/index.js",
   "bin": {
@@ -77,7 +77,7 @@
     "@modern-js/codesmith": "2.6.9",
     "oxfmt": "0.56.0",
     "ultracite": "7.8.3",
-    "@modern-js/i18n-utils": "npm:@bleedingdev/modern-js-i18n-utils@3.5.0-ultramodern.28"
+    "@modern-js/i18n-utils": "npm:@bleedingdev/modern-js-i18n-utils@3.5.0-ultramodern.29"
   },
   "devDependencies": {
     "@rslib/core": "0.23.1",
@@ -99,6 +99,6 @@
     "test": "rm -rf dist && rslib build -c rslibconfig.mts && rstest --passWithNoTests"
   },
   "ultramodern": {
-    "frameworkVersion": "3.5.0-ultramodern.28"
+    "frameworkVersion": "3.5.0-ultramodern.29"
   }
 }

package/template-workspace/.gitignore.handlebars

@@ -9,3 +9,4 @@ build/
 **/.mf/
 .modernjs/agent-reference-repos-tmp/
 .codex/reports/
+.zerops/runtime/

package/template-workspace/scripts/bootstrap-agent-skills.mjs

@@ -7,8 +7,14 @@ import { fileURLToPath } from 'node:url';
 const root = process.cwd();
 const scriptDir = path.dirname(fileURLToPath(import.meta.url));
 const templateWorkspaceDir = path.resolve(scriptDir, '..');
+// Vendored skills always ship under template-workspace/.codex/skills; the
+// workspace-side lockfile may live under .agents/ (agents-standard layout) or
+// .codex/ (legacy default).
 const vendoredSkillsDir = path.join(templateWorkspaceDir, '.codex/skills');
-const lockPath = path.join(root, '.codex/skills-lock.json');
+const lockRoot = fs.existsSync(path.join(root, '.agents/skills-lock.json'))
+  ? '.agents'
+  : '.codex';
+const lockPath = path.join(root, `${lockRoot}/skills-lock.json`);
 const checkOnly = process.argv.includes('--check');
 const postinstall = process.argv.includes('--postinstall');
 const truthy = value => /^(1|true|yes|on)$/i.test(String(value ?? ''));
@@ -175,12 +181,14 @@ const resolveSkillDir = (sourceRoot, skillName) => {
 };
 
 if (!fs.existsSync(lockPath)) {
-  console.error('Missing .codex/skills-lock.json');
+  console.error(
+    'Missing skills-lock.json: expected .agents/skills-lock.json or .codex/skills-lock.json',
+  );
   process.exit(1);
 }
 
 const lock = readJson(lockPath);
-const installDir = path.join(root, lock.installDir ?? '.codex/skills');
+const installDir = path.join(root, lock.installDir ?? `${lockRoot}/skills`);
 const sources = lock.sources ?? [];
 const vendoredSources = sources.filter(source => source.install === 'vendored');
 const cloneSources = sources.filter(source => source.install === 'clone');

package/templates/workspace-scripts/check-ultramodern-api-boundaries.mts

@@ -189,6 +189,7 @@ if (exists('apps/shell-super-app') && verticalDirectories.length > 0) {
 
 function assertApiSurface(appPath) {
   const apiEntry = `${appPath}/api/index.ts`;
+  const backendEffectExpose = `${appPath}/api/effect-api.ts`;
   const sharedApi = `${appPath}/shared/api.ts`;
   const srcApiDirectory = `${appPath}/src/api`;
   const modernConfig = `${appPath}/modern.config.ts`;
@@ -235,8 +236,45 @@ function assertApiSurface(appPath) {
       'must import the contract from ../shared/api.ts.',
     );
   }
-
-  if (exists(sharedApi)) {
+ if (exists(backendEffectExpose)) {
+ const backendExpose = readText(backendEffectExpose);
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /backendFederationContract/u,
+ 'must export backendFederationContract metadata.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /role:\s*['"]microvertical-server['"]/u,
+ 'must describe the MicroVertical server role.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /strictEffectApproach:\s*true/u,
+ 'must preserve strict Effect backend execution.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /contractVersion:\s*['"]microvertical-server-effect-v1['"]/u,
+ 'must preserve the MicroVertical server contract version.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /runtime\s*=\s*apiRuntime/u,
+ 'must export the generated Effect BFF runtime.',
+ );
+ assert(
+ !/\b(request|handler)\s*:\s*async\s*\(/u.test(backendExpose),
+ `${backendEffectExpose}: must not expose raw request handlers.`,
+ );
+ }
+
+ if (exists(sharedApi)) {
     const contract = readText(sharedApi);
     assertContains(
       sharedApi,

package/templates/workspace-scripts/generate-node-backend-federation.mjs

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const workspaceRoot = path.resolve(
+  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
+    path.join(path.dirname(fileURLToPath(import.meta.url)), '../..'),
+);
+const configPath = path.join(workspaceRoot, '.modernjs/ultramodern.json');
+const contractVersion = 'microvertical-server-effect-v1';
+const nodeAdapterVersion = 'backend-mf-effect-v1';
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+function readBuildIdentity(app) {
+  const buildModulePath = path.join(
+    workspaceRoot,
+    app.path,
+    'shared/ultramodern-build.ts',
+  );
+  if (!fs.existsSync(buildModulePath)) {
+    return {};
+  }
+
+  const source = fs.readFileSync(buildModulePath, 'utf8');
+  return {
+    buildVersion: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+    packageName: source.match(/\bpackageName:\s*['"]([^'"]+)['"]/u)?.[1],
+    version: source.match(/\bversion:\s*['"]([^'"]+)['"]/u)?.[1],
+    unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+    sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1],
+  };
+}
+
+function parseArgs(argv) {
+  const options = {
+    app: undefined,
+    target: 'dist',
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--app') {
+      options.app = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--target') {
+      options.target = argv[index + 1] ?? options.target;
+      index += 1;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      console.log(
+        'Usage: node scripts/generate-node-backend-federation.mts [--app <id>] [--target dist|dist-cloudflare]',
+      );
+      process.exit(0);
+    }
+  }
+  return options;
+}
+
+function backendApps(config, appFilter) {
+  return (config.topology?.apps ?? []).filter(app => {
+    if (app.kind !== 'vertical') {
+      return false;
+    }
+    if (!backendFederationMetadata(app)) {
+      return false;
+    }
+    return appFilter ? app.id === appFilter : true;
+  });
+}
+
+function backendFederationMetadata(app) {
+  return app.backendFederation ?? app.api?.backendFederation;
+}
+
+function backendFederationExposes(app) {
+  const backend = backendFederationMetadata(app);
+  const exposes = Array.isArray(backend.exposes)
+    ? backend.exposes.filter(expose => typeof expose === 'string')
+    : backend.exposes &&
+        typeof backend.exposes === 'object' &&
+        !Array.isArray(backend.exposes)
+      ? Object.keys(backend.exposes)
+    : [];
+
+  if (exposes.length > 0) {
+    return exposes;
+  }
+
+  if (typeof backend.expose === 'string') {
+    return [backend.expose];
+  }
+
+  throw new Error(`${app.id} backend federation expose metadata is missing`);
+}
+
+function normalizeBackendFederation(app) {
+  const backend = backendFederationMetadata(app);
+  const nodeSurface = backend.executionSurfaces?.node ?? {};
+  const exposes = backendFederationExposes(app);
+
+  return {
+    ...backend,
+    name: backend.name ?? nodeSurface.remoteName,
+    remoteType: backend.remoteType ?? nodeSurface.remoteType ?? 'module',
+    manifestUrl: backend.manifestUrl ?? nodeSurface.manifestUrl,
+    containerEntry: backend.containerEntry ?? nodeSurface.containerEntry,
+    runtimePackage: backend.runtimePackage ?? nodeSurface.runtimePackage,
+    contractVersion:
+      backend.contractVersion ??
+      backend.compatibility?.contractVersion ??
+      contractVersion,
+    nodeAdapterVersion:
+      backend.nodeAdapterVersion ?? nodeSurface.adapterVersion ?? nodeAdapterVersion,
+    expose:
+      typeof backend.expose === 'string'
+        ? backend.expose
+        : (nodeSurface.expose ?? exposes[0]),
+    exposes,
+  };
+}
+
+function createRemoteEntrySource(app) {
+  const exposes = backendFederationExposes(app);
+  return `const factories = {
+${exposes
+  .map(
+    expose => `${JSON.stringify(expose)}: async () =>
+  import(new URL('../api/backend-federation.ts', import.meta.url).href),
+`,
+  )
+  .join('')}
+};
+
+export async function init() {}
+
+export function get(id) {
+  const factory = factories[id];
+  if (!factory) {
+    throw new Error(\`Unknown backend federation expose \${id}\`);
+  }
+  return factory;
+}
+
+export default { init, get };
+`;
+}
+
+function createManifest(app) {
+  const backend = normalizeBackendFederation(app);
+  const buildIdentity = readBuildIdentity(app);
+  const compactDeliveryUnit =
+    app.deliveryUnit && typeof app.deliveryUnit === 'object'
+      ? app.deliveryUnit
+      : undefined;
+  const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
+  const sourceRevision =
+    compactDeliveryUnit?.sourceRevision ?? buildIdentity.sourceRevision;
+  return {
+    schemaVersion: 1,
+    name: backend.name,
+    id: backend.name,
+    version: buildIdentity.version,
+    buildVersion: buildIdentity.buildVersion,
+    type: backend.remoteType,
+    entry: {
+      url: backend.containerEntry,
+      type: backend.remoteType,
+    },
+    metaData: {
+      name: backend.name,
+      type: backend.remoteType,
+      buildInfo: {
+        buildName: buildIdentity.packageName,
+        buildVersion: buildIdentity.buildVersion,
+      },
+      remoteEntry: {
+        name: 'backendRemoteEntry.mjs',
+        path: '',
+        type: backend.remoteType,
+      },
+        exposes: backend.exposes.map(expose => ({
+          id: expose,
+          name: expose,
+        path: expose,
+      })),
+    },
+    exposes: backend.exposes.map(expose => ({
+      id: expose,
+      name: expose,
+      path: expose,
+    })),
+    backendFederation: {
+      role: backend.role ?? 'microvertical-server',
+      name: backend.name,
+      runtimeFramework: backend.runtimeFramework ?? 'effect',
+      strictEffectApproach: backend.strictEffectApproach ?? true,
+      contractVersion: backend.contractVersion,
+      nodeAdapterVersion: backend.nodeAdapterVersion,
+      manifestUrl: backend.manifestUrl,
+      containerEntry: backend.containerEntry,
+      expose: backend.expose,
+      runtimePackage: backend.runtimePackage,
+      ...(unitId && buildIdentity.buildVersion
+        ? {
+            deliveryUnit: {
+              schemaVersion: 1,
+              kind: 'microvertical-delivery-unit',
+              unitId,
+              packageName: buildIdentity.packageName,
+              version: buildIdentity.version,
+              buildMarker: buildIdentity.buildVersion,
+              sourceRevision,
+            },
+          }
+        : {}),
+      versionBoundary: {
+        packageName: buildIdentity.packageName,
+        version: buildIdentity.version,
+        buildVersion: buildIdentity.buildVersion,
+        ...(unitId && buildIdentity.buildVersion
+          ? {
+              deliveryUnit: {
+                unitId,
+                buildMarker: buildIdentity.buildVersion,
+              },
+            }
+          : {}),
+      },
+    },
+  };
+}
+
+const options = parseArgs(process.argv.slice(2));
+const config = readJson(configPath);
+const apps = backendApps(config, options.app);
+
+if (options.app && apps.length === 0) {
+  throw new Error(`No generated backend federation app matched ${options.app}`);
+}
+
+for (const app of apps) {
+  const outputDir = path.join(workspaceRoot, app.path, options.target);
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(outputDir, 'backendRemoteEntry.mjs'),
+    createRemoteEntrySource(app),
+    'utf-8',
+  );
+  fs.writeFileSync(
+    path.join(outputDir, 'backend-mf-manifest.json'),
+    `${JSON.stringify(createManifest(app), null, 2)}\n`,
+    'utf-8',
+  );
+  console.log(
+    `[ultramodern] generated backend federation artifacts for ${app.id} in ${path.relative(
+      workspaceRoot,
+      outputDir,
+    )}`,
+  );
+}
+
+if (apps.length === 0) {
+  console.log('[ultramodern] no backend federation apps to generate');
+}