@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.4

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/toolchain-pins.js

@@ -1,10 +1,15 @@
 import node_fs from "node:fs";
 import node_path from "node:path";
+import { semver } from "@modern-js/utils";
 import { ULTRAMODERN_PACKAGE_PINS, ULTRAMODERN_WORKSPACE_POLICY } from "../../../ultramodern-workspace/policy.js";
 const { toolchain: toolchain } = ULTRAMODERN_WORKSPACE_POLICY;
 const retiredRootToolingDependencies = [
     "@typescript/typescript6"
 ];
+function migrationPnpmVersion(value) {
+    const baseline = toolchain.packageManager.version;
+    return 'string' == typeof value && semver.valid(value) && semver.major(value) === semver.major(baseline) && semver.gte(value, baseline) ? value : baseline;
+}
 function isRecord(value) {
     return Boolean(value) && 'object' == typeof value && !Array.isArray(value);
 }
@@ -22,22 +27,24 @@ function updateUltramodernConfigToolchain(config) {
     const workspace = ensureRecord(config, 'workspace', 'workspace');
     const packageManager = ensureRecord(workspace, 'packageManager', 'workspace.packageManager');
     packageManager.name = toolchain.packageManager.name;
-    packageManager.version = toolchain.packageManager.version;
+    packageManager.version = migrationPnpmVersion(packageManager.version);
     const node = ensureRecord(workspace, 'node', 'workspace.node');
     node.version = toolchain.node.version;
     node.engineRange = toolchain.node.engineRange;
 }
 function updateRootPackageToolchain(packageJson) {
-    packageJson.packageManager = `${toolchain.packageManager.name}@${toolchain.packageManager.version}`;
+    const currentVersion = 'string' == typeof packageJson.packageManager ? packageJson.packageManager.match(/^pnpm@([^+]+)(?:\+.*)?$/u)?.[1] : void 0;
+    packageJson.packageManager = `${toolchain.packageManager.name}@${migrationPnpmVersion(currentVersion)}`;
     const engines = ensureRecord(packageJson, 'engines', 'package.json engines');
     engines.node = toolchain.node.engineRange;
     engines.pnpm = toolchain.packageManager.engineRange;
     const devDependencies = ensureRecord(packageJson, 'devDependencies', 'package.json devDependencies');
     for (const packageName of retiredRootToolingDependencies)delete devDependencies[packageName];
     devDependencies["@typescript/native"] = ULTRAMODERN_PACKAGE_PINS.rootDevDependencies["@typescript/native"];
+    devDependencies['@types/node'] = ULTRAMODERN_PACKAGE_PINS.rootDevDependencies["@types/node"];
     devDependencies.miniflare = ULTRAMODERN_PACKAGE_PINS.rootDevDependencies.miniflare;
 }
-function updateMiseTools(content) {
+function updateMiseTools(content, pnpmVersion) {
     const lines = content.replace(/\r\n/gu, '\n').split('\n');
     if ('' === lines.at(-1)) lines.pop();
     let toolsStart = lines.findIndex((line)=>/^\s*\[tools\]\s*(?:#.*)?$/u.test(line));
@@ -64,13 +71,15 @@ function updateMiseTools(content) {
         lines[index] = line;
     };
     upsertTool('node', toolchain.node.version);
-    upsertTool('pnpm', toolchain.packageManager.version);
+    upsertTool('pnpm', pnpmVersion);
     return `${lines.join('\n')}\n`;
 }
 function updateGeneratedToolchainFiles(io) {
     const misePath = node_path.join(io.workspaceRoot, '.mise.toml');
     const miseContent = node_fs.existsSync(misePath) ? node_fs.readFileSync(misePath, 'utf-8') : '';
-    io.write(misePath, updateMiseTools(miseContent));
+    const packageJson = JSON.parse(node_fs.readFileSync(node_path.join(io.workspaceRoot, 'package.json'), 'utf8'));
+    const pnpmVersion = migrationPnpmVersion(packageJson.packageManager?.match(/^pnpm@([^+]+)(?:\+.*)?$/u)?.[1]);
+    io.write(misePath, updateMiseTools(miseContent, pnpmVersion));
     const workflowPath = node_path.join(io.workspaceRoot, '.github/workflows/ultramodern-workspace-gates.yml');
     if (!node_fs.existsSync(workflowPath)) return;
     const workflow = node_fs.readFileSync(workflowPath, 'utf-8');

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/workspace-artifact-ownership.js

@@ -0,0 +1,166 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { parse } from "@babel/parser";
+import { formatGeneratedSourceCandidates } from "../../../ultramodern-workspace/fs-io.js";
+function isLiteralData(node, literalIdentifiers) {
+    if (!node) return false;
+    if ('Identifier' === node.type) return literalIdentifiers?.has(node.name) ?? false;
+    if ([
+        'StringLiteral',
+        'NumericLiteral',
+        'BooleanLiteral',
+        'NullLiteral'
+    ].includes(node.type)) return true;
+    if ('UnaryExpression' === node.type) return '-' === node.operator && 'NumericLiteral' === node.argument.type;
+    if ('ArrayExpression' === node.type) return node.elements.every((element)=>isLiteralData(element, literalIdentifiers));
+    return 'ObjectExpression' === node.type && node.properties.every((property)=>'ObjectProperty' === property.type && !property.computed && !property.shorthand && [
+            'Identifier',
+            'StringLiteral',
+            'NumericLiteral'
+        ].includes(property.key.type) && isLiteralData(property.value, literalIdentifiers));
+}
+function withoutGeneratedData(source, binding) {
+    if (!binding) return source;
+    const parsed = parse(source, {
+        sourceType: 'module',
+        plugins: [
+            "typescript"
+        ]
+    });
+    for (const statement of parsed.program.body)if ('VariableDeclaration' === statement.type && 'const' === statement.kind) {
+        for (const declaration of statement.declarations)if ('Identifier' === declaration.id.type && declaration.id.name === binding && declaration.init && isLiteralData(declaration.init)) return source.slice(0, declaration.init.start) + '{}' + source.slice(declaration.init.end);
+    }
+    return source;
+}
+function staticPropertyValue(node, name) {
+    if (node?.type !== 'ObjectExpression') return;
+    const keys = new Set();
+    let value;
+    for (const property of node.properties){
+        if ('ObjectProperty' !== property.type || property.computed || property.shorthand || ![
+            'Identifier',
+            'StringLiteral'
+        ].includes(property.key.type)) return;
+        const key = property.key.name ?? property.key.value;
+        if (keys.has(key)) return;
+        keys.add(key);
+        if (key === name) value = property.value;
+    }
+    return value;
+}
+function refreshValidatorReleaseCohort(source, releaseCohort) {
+    try {
+        const parsed = parse(source, {
+            sourceType: 'module',
+            plugins: [
+                "typescript"
+            ],
+            tokens: true
+        });
+        const constants = parsed.program.body.flatMap((statement)=>'VariableDeclaration' === statement.type && 'const' === statement.kind ? statement.declarations : []);
+        const matches = [];
+        for (const statement of parsed.program.body)if ('VariableDeclaration' === statement.type && 'const' === statement.kind) for (const declaration of statement.declarations){
+            const kind = staticPropertyValue(declaration.init, 'kind');
+            if (kind?.type !== 'StringLiteral' || 'modernjs.ultramodern-workspace-validation-contract' !== kind.value) continue;
+            const cohort = staticPropertyValue(staticPropertyValue(declaration.init, 'cohort'), 'releaseCohort');
+            const schema = staticPropertyValue(cohort, 'schema');
+            const schemaVersion = staticPropertyValue(cohort, 'schemaVersion');
+            const version = staticPropertyValue(staticPropertyValue(cohort, 'release'), 'version');
+            const versionConstant = version?.type === 'Identifier' ? constants.find((declaration)=>'Identifier' === declaration.id.type && declaration.id.name === version.name && declaration.init?.type === 'StringLiteral') : void 0;
+            if (schema?.type === 'StringLiteral' && 'bleedingdev.ultramodern.release-cohort' === schema.value && schemaVersion?.type === 'NumericLiteral' && 1 === schemaVersion.value && isLiteralData(cohort, versionConstant ? new Set([
+                version.name
+            ]) : void 0)) matches.push({
+                cohort,
+                version,
+                versionConstant
+            });
+        }
+        if (1 !== matches.length) return source;
+        const { cohort, version, versionConstant } = matches[0];
+        let content = JSON.stringify(releaseCohort, null, 2);
+        const edits = [];
+        if (versionConstant && !parsed.tokens?.some((token)=>'name' === token.type.label && token.value === version.name && token.start !== versionConstant.id.start && (token.start < cohort.start || token.end > cohort.end))) {
+            content = content.replaceAll(`"version": ${JSON.stringify(releaseCohort.release.version)}`, `"version": ${version.name}`);
+            edits.push({
+                start: versionConstant.init.start,
+                end: versionConstant.init.end,
+                content: JSON.stringify(releaseCohort.release.version)
+            });
+        }
+        edits.push({
+            start: cohort.start,
+            end: cohort.end,
+            content
+        });
+        for (const edit of edits.toSorted((left, right)=>right.start - left.start))source = source.slice(0, edit.start) + edit.content + source.slice(edit.end);
+        return source;
+    } catch  {
+        return source;
+    }
+}
+function preserveConsumerWorkspaceArtifacts(io, candidates) {
+    const preservedPaths = new Set();
+    const physicalRoot = node_fs.realpathSync(io.workspaceRoot);
+    const canonicalSources = formatGeneratedSourceCandidates(candidates.map((candidate, index)=>[
+            `canonical/${index}/${candidate.relativePath}`,
+            withoutGeneratedData(candidate.content, candidate.generatedDataBinding)
+        ]));
+    for (const [index, candidate] of candidates.entries()){
+        const paths = [
+            candidate.relativePath,
+            candidate.legacyPath
+        ].filter((value)=>void 0 !== value);
+        for (const relativePath of paths){
+            const filePath = node_path.join(io.workspaceRoot, relativePath);
+            if (!node_fs.existsSync(filePath)) continue;
+            const physicalRelative = node_path.relative(physicalRoot, node_fs.realpathSync(filePath));
+            if ('..' === physicalRelative || physicalRelative.startsWith(`..${node_path.sep}`) || node_path.isAbsolute(physicalRelative)) throw new Error(`Refusing to inspect an artifact outside the workspace: ${relativePath}`);
+            const source = node_fs.readFileSync(filePath, 'utf8');
+            let recognized = source === candidate.content;
+            if (!recognized) try {
+                const normalized = withoutGeneratedData(source, candidate.generatedDataBinding);
+                const canonical = canonicalSources[index];
+                recognized = normalized === canonical || formatGeneratedSourceCandidates([
+                    [
+                        relativePath,
+                        normalized
+                    ]
+                ])[0] === canonical;
+            } catch  {}
+            if (!recognized) for (const pairedPath of paths)preservedPaths.add(pairedPath);
+        }
+    }
+    const reported = new Set();
+    const isPreserved = (filePath)=>{
+        const relativePath = node_path.relative(io.workspaceRoot, filePath).split(node_path.sep).join('/');
+        if (!preservedPaths.has(relativePath)) return false;
+        if (!reported.has(relativePath)) {
+            io.log(`${relativePath} preserved consumer-owned artifact: its canonical generated source does not match.`);
+            reported.add(relativePath);
+        }
+        return true;
+    };
+    return {
+        preservedPaths,
+        refreshReleaseCohort (releaseCohort) {
+            if (!releaseCohort) return;
+            for (const candidate of candidates)if ('workspaceValidationContract' === candidate.generatedDataBinding) for (const relativePath of [
+                candidate.relativePath,
+                candidate.legacyPath
+            ]){
+                if (!relativePath || !preservedPaths.has(relativePath)) continue;
+                const filePath = node_path.join(io.workspaceRoot, relativePath);
+                if (!node_fs.existsSync(filePath)) continue;
+                const source = node_fs.readFileSync(filePath, 'utf8');
+                io.write(filePath, refreshValidatorReleaseCohort(source, releaseCohort));
+            }
+        },
+        io: {
+            ...io,
+            write: (filePath, content)=>isPreserved(filePath) ? false : io.write(filePath, content),
+            writeGenerated: (filePath, content)=>isPreserved(filePath) ? false : io.writeGenerated(filePath, content),
+            remove: (filePath)=>isPreserved(filePath) ? false : io.remove(filePath)
+        }
+    };
+}
+export { preserveConsumerWorkspaceArtifacts };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect.js

@@ -1,11 +1,13 @@
 import node_fs from "node:fs";
 import node_path from "node:path";
 import { RELEASE_COHORT_PROJECTION_PATH, readCreateReleaseCohort } from "../../ultramodern-release-cohort.js";
+import { createAppEnvDts } from "../../ultramodern-workspace/app-files.js";
 import { createDevelopmentOverlay, createTopology, createUltramodernConfig } from "../../ultramodern-workspace/contracts.js";
 import { stampDeliveryUnitIdentity } from "../../ultramodern-workspace/delivery-unit-stamp.js";
 import { ULTRAMODERN_WORKSPACE_POLICY } from "../../ultramodern-workspace/policy.js";
 import { createAdditionalShellConfigEntry } from "../../ultramodern-workspace/shells.js";
-import { createWorkspaceValidationScript, migratedWorkspaceScriptArtifacts } from "../../ultramodern-workspace/workspace-scripts.js";
+import { createWorkspaceValidationScript, createZeropsRuntimeMaterializationScript, migratedWorkspaceScriptArtifacts } from "../../ultramodern-workspace/workspace-scripts.js";
+import { createZeropsYaml } from "../../ultramodern-workspace/zerops.js";
 import { additionalShellsFromToolingConfig, allWorkspaceAppsFromToolingConfig, normalizeCompactUltramodernConfig, synthesizeCompactUltramodernConfig, workspaceAppsFromToolingConfig } from "../config.js";
 import { reconcileCompactPackageSourceMetadata, reconcilePackageSourceMetadata, updateReferenceTopology, updateUltramodernConfig } from "./migrate-strict-effect/api-metadata.js";
 import { ensureGeneratedDeclarationPatches } from "./migrate-strict-effect/declaration-patches.js";
@@ -18,7 +20,9 @@ import { ensureBffEffectDependencies, updateGeneratedPackageScripts, updateGener
 import { createMigrationPackageSource } from "./migrate-strict-effect/package-source.js";
 import { updateGeneratedPnpmWorkspacePolicy, validateGeneratedPnpmLockReleaseAgePolicy } from "./migrate-strict-effect/pnpm-policy.js";
 import { ensureGeneratedModuleFederationBridgeRouterOptOut, preflightModuleFederationBridgeRouter, removeRetiredReactRouterDependency } from "./migrate-strict-effect/react-router-retirement.js";
+import { ensureSharedApiInfrastructure } from "./migrate-strict-effect/shared-api-infrastructure.js";
 import { updateGeneratedToolchainFiles, updateRootPackageToolchain } from "./migrate-strict-effect/toolchain-pins.js";
+import { preserveConsumerWorkspaceArtifacts } from "./migrate-strict-effect/workspace-artifact-ownership.js";
 import { hasFlag } from "./options.js";
 const retiredMetadataPaths = [
     '.modernjs/ultramodern-generated-contract.json',
@@ -74,10 +78,24 @@ function synchronizeMigrationDeliveryUnitMetadata(io, raw, packageSource) {
         'schemaVersion',
         'id',
         "description",
-        'preset',
-        'sharedPackages',
-        'validation'
-    ])topology[key] = canonicalTopology[key];
+        'preset'
+    ])if ('id' === key || "description" === key) topology[key] ??= canonicalTopology[key];
+    else topology[key] = canonicalTopology[key];
+    const existingSharedPackages = Array.isArray(topology.sharedPackages) ? topology.sharedPackages : [];
+    topology.sharedPackages = [
+        ...existingSharedPackages,
+        ...canonicalTopology.sharedPackages.filter((candidate)=>!existingSharedPackages.some((existing)=>existing.id === candidate.id))
+    ];
+    topology.validation = {
+        ...canonicalTopology.validation,
+        ...topology.validation,
+        commands: [
+            ...new Set([
+                ...topology.validation?.commands ?? [],
+                ...canonicalTopology.validation.commands
+            ])
+        ]
+    };
     const canonicalTopologyApps = new Map([
         canonicalTopology.shell,
         ...canonicalTopology.verticals ?? []
@@ -100,8 +118,21 @@ function synchronizeMigrationDeliveryUnitMetadata(io, raw, packageSource) {
                 'api',
                 'cloudflare',
                 'ownership'
-            ])if (Object.hasOwn(canonicalEntry, key)) entry[key] = canonicalEntry[key];
-            else delete entry[key];
+            ])if (Object.hasOwn(canonicalEntry, key)) {
+                const canonicalValue = canonicalEntry[key];
+                if ('api' === key && entry.api && canonicalValue && 'object' == typeof canonicalValue) {
+                    const nextApi = {
+                        ...entry.api,
+                        ...canonicalValue
+                    };
+                    if (!Object.hasOwn(entry.api, 'domainOperations')) delete nextApi.domainOperations;
+                    entry.api = nextApi;
+                } else if ('cloudflare' === key && entry.cloudflare && canonicalValue && 'object' == typeof canonicalValue) entry.cloudflare = {
+                    ...canonicalValue,
+                    ...entry.cloudflare
+                };
+                else entry[key] = canonicalValue;
+            } else delete entry[key];
         }
     }
     writeJsonFile(io, topologyPath, topology);
@@ -122,7 +153,10 @@ function synchronizeMigrationCompactPolicy(io, raw, packageSource) {
     const apps = workspaceAppsFromToolingConfig(migrated);
     apps.filter((app)=>'shell' !== app.kind);
     const canonical = requireRecord(createUltramodernConfig(migrated.workspace.packageScope, packageSource.modernPackageVersion, packageSource, apps, migrated.features.tailwind, migrated.bridge, additionalShellsFromToolingConfig(migrated), apps.find((app)=>'shell' === app.kind)), 'Generated compact policy');
-    for (const key of compactPolicyKeys)raw[key] = canonical[key];
+    for (const key of compactPolicyKeys){
+        if ('workspace' === key) canonical.workspace.packageManager.version = raw.workspace.packageManager.version;
+        raw[key] = canonical[key];
+    }
     writeJsonFile(io, node_path.join(io.workspaceRoot, '.modernjs/ultramodern.json'), raw);
 }
 function reconcileRootPackageSourceMetadata(packageJson, packageSource) {
@@ -262,6 +296,33 @@ function migrateStrictEffect(args, context, io, dryRun, skipInstall) {
             version: packageSource.modernPackageVersion
         });
     const releaseCohort = 'install' === packageSource.strategy ? readCreateReleaseCohort() : void 0;
+    const currentApps = workspaceAppsFromToolingConfig(current);
+    const allCurrentApps = allWorkspaceAppsFromToolingConfig(current);
+    const artifactOwnership = preserveConsumerWorkspaceArtifacts(io, [
+        ...allCurrentApps.map((app)=>({
+                relativePath: `${app.directory}/src/modern-app-env.d.ts`,
+                content: createAppEnvDts(app, allCurrentApps.filter((remote)=>'shell' !== remote.kind), current.workspace.packageScope)
+            })),
+        ...migratedWorkspaceScriptArtifacts({
+            shellOnly: false,
+            hasBackendSurface: true
+        }).filter((artifact)=>"scripts/validate-ultramodern-workspace.mts" !== artifact.relativePath),
+        {
+            relativePath: "scripts/validate-ultramodern-workspace.mts",
+            legacyPath: "scripts/validate-ultramodern-workspace.mjs",
+            generatedDataBinding: 'workspaceValidationContract',
+            content: createWorkspaceValidationScript(current.workspace.packageScope, current.features.tailwind, currentApps.filter((app)=>'shell' !== app.kind), void 0, additionalShellsFromToolingConfig(current), currentApps.find((app)=>'shell' === app.kind))
+        },
+        {
+            relativePath: 'zerops.yaml',
+            content: `${createZeropsYaml(current.workspace.packageScope, allWorkspaceAppsFromToolingConfig(current))}\n`
+        },
+        {
+            relativePath: "scripts/materialize-zerops-runtime.mjs",
+            content: createZeropsRuntimeMaterializationScript()
+        }
+    ]);
+    io = artifactOwnership.io;
     reconcileCompactPackageSourceMetadata(raw.packageSource, packageSource);
     reconcileRootPackageSourceMetadata(readJsonFile(node_path.join(io.workspaceRoot, 'package.json')), packageSource);
     updateGeneratedPnpmWorkspacePolicy(createMigrationIo(io.workspaceRoot, true), packageSource, {
@@ -282,6 +343,7 @@ function migrateStrictEffect(args, context, io, dryRun, skipInstall) {
     const verticalApps = migrated.topology.apps.filter((app)=>'shell' !== app.kind);
     const hasBackendSurface = verticalApps.some((app)=>app.api);
     const shellOnly = 0 === verticalApps.length;
+    if (hasBackendSurface) ensureSharedApiInfrastructure(io, migrated.workspace.packageScope, packageSource);
     if (shellOnly) {
         io.log('Shell-only workspace: skipping backend-federation and Zerops runtime stages.');
         for (const relativePath of [
@@ -312,6 +374,7 @@ function migrateStrictEffect(args, context, io, dryRun, skipInstall) {
         io.writeGenerated(node_path.join(io.workspaceRoot, artifact.relativePath), artifact.content);
     }
     io.writeGenerated(node_path.join(io.workspaceRoot, "scripts/validate-ultramodern-workspace.mts"), createWorkspaceValidationScript(validationContractInputs.scope, validationContractInputs.enableTailwind, validationContractInputs.remotes, releaseCohort, validationContractInputs.additionalShells, validationContractInputs.primaryShell, raw, node_fs.existsSync(node_path.join(io.workspaceRoot, 'topology/ownership.json')) ? requireRecord(readJsonFile(node_path.join(io.workspaceRoot, 'topology/ownership.json')), 'Ownership topology') : void 0, developmentOverlay));
+    artifactOwnership.refreshReleaseCohort(releaseCohort);
     for (const relativePath of retiredMetadataPaths)io.remove(node_path.join(io.workspaceRoot, relativePath));
     updateGeneratedBuildIdentityModules(io, migrated);
     updateGeneratedTypeScriptSurfaces(io, migrated);
@@ -326,7 +389,7 @@ function migrateStrictEffect(args, context, io, dryRun, skipInstall) {
             reconcileRootPackageSourceMetadata(packageJson, packageSource);
             updateRootPackageToolchain(packageJson);
         }
-        updateModernDependencies(packageJson, packageSource);
+        updateModernDependencies(packageJson, packageSource, releaseCohort);
         const ownsGeneratedScripts = 'package.json' === relativePackageFile || allMigratedApps.some((app)=>`${app.directory}/package.json` === relativePackageFile);
         updateGeneratedToolingDependencies(packageJson, {
             ownsGeneratedScripts
@@ -336,6 +399,7 @@ function migrateStrictEffect(args, context, io, dryRun, skipInstall) {
         if ('preserved' === retiredReactRouter) io.log(`${relativePackageFile} keeps its react-router dependency: authored source imports React Router directly, so its generated Module Federation config keeps bridge.enableBridgeRouter: true.`);
         else if ('removed' === retiredReactRouter) io.log(`${relativePackageFile} dropped its obsolete react-router dependency: no authored source imports React Router.`);
         updateGeneratedPackageScripts(packageJson, {
+            preservedArtifacts: artifactOwnership.preservedPaths,
             relativePackageFile,
             apps: allMigratedApps,
             shellOnly,

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

@@ -2,7 +2,7 @@ import { resolveApiProtocol, resolveApiStem, verticalApiApps } from "../descript
 import { packageName, toPascalCase } from "../naming.js";
 import { createCheckoutCartClientExports, serviceHasCheckoutCartState } from "./checkout-cart.js";
 import { verticalApiErrorStem, verticalApiExport, verticalApiGroupName, verticalApiNotFoundErrorExport } from "./names.js";
-function createApiClient(service, contractImportPath) {
+function createApiClient(service, contractImportPath, options) {
     const apiExport = verticalApiExport(service);
     const contractExport = verticalApiGroupName(service);
     const stem = resolveApiStem(service);
@@ -118,7 +118,7 @@ export const ${readinessName} = (
     operationContext:
       options.operationContext ?? ${groupName}OperationContexts.readiness,
   }).pipe(
-    Effect.flatMap(client => client.${groupName}.readiness({})),
+    Effect.flatMap(client => client.${options ? 'foundation' : groupName}.readiness({})),
   );
 
 export const ${getName} = (

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

@@ -4,23 +4,22 @@ import { packageName } from "../naming.js";
 import { createCheckoutCartServerHandlers, createCheckoutCartServerState } from "./checkout-cart.js";
 import { verticalApiExport, verticalApiGroupName, verticalApiNotFoundErrorExport } from "./names.js";
 import { createRpcApiServiceEntry, rpcPath, verticalRpcContractExport, verticalRpcGroupExport } from "./rpc.js";
-function createApiServiceEntry(service, contractImportPath) {
+function createApiServiceEntry(service, contractImportPath, options) {
     if ((service.api?.protocol ?? 'rest') === 'rpc') return createRpcApiServiceEntry(service);
     const apiExport = verticalApiExport(service);
     const groupName = verticalApiGroupName(service);
     const notFoundErrorExport = verticalApiNotFoundErrorExport(service);
     const stem = resolveApiStem(service);
-    return `import {
-  defineEffectBff,
+    const assemblyImport = options ? `import { assembleEffectBffRuntime } from '${packageName(options.scope, 'shared-contracts')}/server/effect-bff-runtime';\n` : '';
+    return `${assemblyImport}import {
+  ${options ? '' : 'defineEffectBff,'}
   Effect,
   HttpApiBuilder,
   Layer,
 } from '@modern-js/plugin-bff/effect-edge';
-import type {
-  EffectBffDefinition,
-  EffectBffRuntime,
+${options ? '' : `import type {
   EffectRuntimeLayer,
-} from '@modern-js/plugin-bff/effect-edge';
+} from '@modern-js/plugin-bff/effect-edge';`}
 import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
 import {
   ${apiExport},
@@ -50,6 +49,31 @@ const operationAttributes = (operationContext: OperationContext) => ({
       : {}),
   });
 
+${options ? `const ${groupName}ReadinessLayer = HttpApiBuilder.group(
+  ${apiExport},
+  'foundation',
+  handlers => handlers
+      .handle('readiness', () =>
+        Effect.succeed({
+          checks: {
+            api: 'ready' as const,
+            moduleFederation: 'ready' as const,
+            ssr: 'ready' as const,
+            translations: 'ready' as const,
+          },
+          marker: ultramodernApiMarker,
+          status: 'ready' as const,
+          versionSkew: 'none' as const,
+        }).pipe(
+          Effect.withSpan('ultramodern.api.${groupName}.readiness', {
+            attributes: operationAttributes(${groupName}OperationContexts.readiness),
+            kind: 'server',
+          }),
+        ),
+      )
+,
+);` : ''}
+
 const ${groupName}Layer = HttpApiBuilder.group(
   ${apiExport},
   '${groupName}',
@@ -68,7 +92,7 @@ const ${groupName}Layer = HttpApiBuilder.group(
           }),
         ),
       )
-      .handle('readiness', () =>
+${options ? '' : `      .handle('readiness', () =>
         Effect.succeed({
           checks: {
             api: 'ready' as const,
@@ -86,6 +110,7 @@ const ${groupName}Layer = HttpApiBuilder.group(
           }),
         ),
       )
+`}
       .handle('get', ({ params }) => {
         const matchedItem = ${groupName}Items.find(
           candidate => candidate.id === params.id,
@@ -125,14 +150,18 @@ const ${groupName}Layer = HttpApiBuilder.group(
       )${createCheckoutCartServerHandlers(service)},
 );
 
-const layer = HttpApiBuilder.layer(${apiExport}).pipe(
-  Layer.provide(${groupName}Layer),
-) satisfies EffectRuntimeLayer;
-const apiRuntime: EffectBffDefinition<typeof ${apiExport}, EffectRuntimeLayer> &
-  EffectBffRuntime<typeof ${apiExport}, EffectRuntimeLayer> = defineEffectBff({
-  api: ${apiExport},
-  layer,
-});
+${options ? `const apiHandlersLive = Layer.mergeAll(${groupName}Layer, ${groupName}ReadinessLayer);
+export const make${apiExport[0].toUpperCase()}${apiExport.slice(1)}Runtime = () =>
+  assembleEffectBffRuntime({
+    api: ${apiExport},
+    handlers: apiHandlersLive,
+  });` : `export const make${apiExport[0].toUpperCase()}${apiExport.slice(1)}Runtime = () => {
+  const layer = HttpApiBuilder.layer(${apiExport}).pipe(
+    Layer.provide(${groupName}Layer),
+  ) satisfies EffectRuntimeLayer;
+  return defineEffectBff({ api: ${apiExport}, layer });
+};`}
+const apiRuntime = make${apiExport[0].toUpperCase()}${apiExport.slice(1)}Runtime();
 
 export default apiRuntime;
 `;

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

@@ -1,6 +1,6 @@
 import { resolveApiPrefix, resolveApiStem } from "../descriptors.js";
 import { renderTemplate } from "../fs-io.js";
-import { toPascalCase } from "../naming.js";
+import { packageName, toPascalCase } from "../naming.js";
 import { createCheckoutCartApiContractFields, createCheckoutCartEndpointDefinitions, createCheckoutCartOperationContexts, createCheckoutCartSharedSchemas } from "./checkout-cart.js";
 import { verticalApiCreatePayloadSchemaExport, verticalApiExport, verticalApiGroupName, verticalApiMarkerSchemaExport, verticalApiName, verticalApiNotFoundErrorExport, verticalApiNotFoundSchemaExport, verticalApiReadinessSchemaExport, verticalApiSchemaExport } from "./names.js";
 function createSharedApiImports() {
@@ -13,7 +13,7 @@ function createSharedApiImports() {
 } from '@modern-js/plugin-bff/effect-client';
 `;
 }
-function createSharedApiContract(service) {
+function createSharedApiContract(service, shared = false) {
     const schemaExport = verticalApiSchemaExport(service);
     const markerSchemaExport = verticalApiMarkerSchemaExport(service);
     const readinessSchemaExport = verticalApiReadinessSchemaExport(service);
@@ -70,7 +70,7 @@ function createSharedApiContract(service) {
         listOperationContext,
         readinessOperationContext
     }).trim();
-    return `export interface ${markerType} {
+    return `${shared ? `export type ${markerType} = MicroVerticalBuildMarker;` : `export interface ${markerType} {
   readonly appId: string;
   readonly build: string;
   readonly buildMarker: string;
@@ -80,7 +80,7 @@ function createSharedApiContract(service) {
   readonly surface: string;
   readonly unitId: string;
   readonly version: string;
-}
+}`}
 
 export interface ${itemType} {
   readonly id: string;
@@ -88,7 +88,7 @@ export interface ${itemType} {
   readonly title: string;
 }
 
-export interface ${readinessType} {
+${shared ? `export type ${readinessType} = MicroVerticalReadiness;` : `export interface ${readinessType} {
   readonly checks: {
     readonly api: 'ready';
     readonly moduleFederation: 'ready';
@@ -98,7 +98,7 @@ export interface ${readinessType} {
   readonly marker: ${markerType};
   readonly status: 'ready';
   readonly versionSkew: 'none';
-}
+}`}
 
 export interface ${createPayloadType} {
   readonly title: string;
@@ -117,7 +117,7 @@ export interface ${notFoundErrorExport} {
   readonly id: string;
 }
 
-export const ${markerSchemaExport}: Schema.Codec<${markerType}> = Schema.Struct({
+${shared ? `export const ${markerSchemaExport}: Schema.Codec<${markerType}> = MicroVerticalBuildMarkerSchema;` : `export const ${markerSchemaExport}: Schema.Codec<${markerType}> = Schema.Struct({
   appId: Schema.String,
   build: Schema.String,
   buildMarker: Schema.String,
@@ -127,7 +127,7 @@ export const ${markerSchemaExport}: Schema.Codec<${markerType}> = Schema.Struct(
   surface: Schema.String,
   unitId: Schema.String,
   version: Schema.String,
-});
+});`}
 
 export const ${schemaExport}: Schema.Codec<${itemType}> = Schema.Struct({
   id: Schema.String,
@@ -135,7 +135,7 @@ export const ${schemaExport}: Schema.Codec<${itemType}> = Schema.Struct({
   title: Schema.String,
 });
 
-export const ${readinessSchemaExport}: Schema.Codec<${readinessType}> = Schema.Struct({
+${shared ? `export const ${readinessSchemaExport}: Schema.Codec<${readinessType}> = MicroVerticalReadinessSchema;` : `export const ${readinessSchemaExport}: Schema.Codec<${readinessType}> = Schema.Struct({
   checks: Schema.Struct({
     api: Schema.Literal('ready'),
     moduleFederation: Schema.Literal('ready'),
@@ -145,7 +145,7 @@ export const ${readinessSchemaExport}: Schema.Codec<${readinessType}> = Schema.S
   marker: ${markerSchemaExport},
   status: Schema.Literal('ready'),
   versionSkew: Schema.Literal('none'),
-});
+});`}
 
 export const ${createPayloadSchemaExport}: Schema.Codec<${createPayloadType}> = Schema.Struct({
   title: Schema.String,
@@ -157,7 +157,7 @@ ${checkoutCartSharedSchemaSection}export const ${notFoundSchemaExport}: Schema.C
   HttpApiSchema.status(404),
 );
 
-export interface OperationContext {
+${shared ? 'export type OperationContext = MicroVerticalOperationContext;' : `export interface OperationContext {
   method: string;
   operationId: string;
   routePath: string;
@@ -169,9 +169,14 @@ export interface OperationContext {
     | 'data-platform'
     | 'unknown';
   traceId?: string;
-}
+}`}
 
-export const ${apiExport} = HttpApi.make('${apiName}').add(
+${shared ? `export const ${groupName}FoundationApi = HttpApi.make('${apiName}Foundation').add(
+  HttpApiGroup.make('foundation').add(
+    HttpApiEndpoint.get('readiness', '/${stem}/readiness', { success: ${readinessSchemaExport} }),
+  ),
+);` : ''}
+export const ${apiExport} = HttpApi.make('${apiName}')${shared ? `.addHttpApi(${groupName}FoundationApi)` : ''}.add(
   HttpApiGroup.make('${groupName}')
     .add(
       HttpApiEndpoint.get('list', '/${stem}', {
@@ -183,11 +188,12 @@ export const ${apiExport} = HttpApi.make('${apiName}').add(
         }),
       }),
     )
-    .add(
+${shared ? '' : `    .add(
       HttpApiEndpoint.get('readiness', '/${stem}/readiness', {
         success: ${readinessSchemaExport},
       }),
     )
+`}
     .add(
       HttpApiEndpoint.get('get', '/${stem}/:id', {
         error: ${notFoundSchemaExport},
@@ -208,7 +214,7 @@ export const ${apiExport} = HttpApi.make('${apiName}').add(
 );
 
 export const ${groupName}OperationContexts = {
-${operationContextEntries}
+${shared ? operationContextEntries.replaceAll(/(\w+: )\{([\s\S]*?)\},/gu, (_, key, fields)=>`${key}createMicroVerticalOperationContext({${fields.replace(/\n\s*source: 'generated-client',/u, '')}}),`) : operationContextEntries}
 } satisfies Record<string, OperationContext>;
 
 export const ${groupName}ApiContract = {
@@ -219,8 +225,12 @@ ${createCheckoutCartApiContractFields(service)}  ownerId: '${service.id}',
 } as const;
 `;
 }
-function createSharedApi(service) {
+function createSharedApi(service, options) {
+    const imports = options ? `import { MicroVerticalBuildMarkerSchema, MicroVerticalReadinessSchema, createMicroVerticalOperationContext } from '${packageName(options.scope, 'shared-contracts')}/microvertical-api-baseline';
+import type { MicroVerticalBuildMarker, MicroVerticalReadiness, MicroVerticalOperationContext } from '${packageName(options.scope, 'shared-contracts')}/microvertical-api-baseline';
+` : '';
     return `${createSharedApiImports()}
-${createSharedApiContract(service)}`;
+${imports}
+${createSharedApiContract(service, void 0 !== options)}`;
 }
 export { createSharedApi };