@bleedingdev/modern-js-create 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

package/dist/esm/ultramodern-workspace/bridge-config.js

@@ -1,270 +1 @@
-const ultramodernBridgeCliFlags = {
-    enabled: '--bridge',
-    parentRoot: '--bridge-parent-root',
-    workspacePackage: '--bridge-workspace-package',
-    workspacePackageName: '--bridge-workspace-package-name',
-    testAlias: '--bridge-test-alias',
-    dependency: '--bridge-dependency',
-    lockfilePolicy: '--bridge-lockfile-policy',
-    gate: '--bridge-gate',
-    gateCwd: '--bridge-gate-cwd',
-    reactSingleton: '--bridge-react-singleton'
-};
-const ultramodernBridgeCliValueFlags = [
-    ultramodernBridgeCliFlags.parentRoot,
-    ultramodernBridgeCliFlags.workspacePackage,
-    ultramodernBridgeCliFlags.workspacePackageName,
-    ultramodernBridgeCliFlags.testAlias,
-    ultramodernBridgeCliFlags.dependency,
-    ultramodernBridgeCliFlags.lockfilePolicy,
-    ultramodernBridgeCliFlags.gate,
-    ultramodernBridgeCliFlags.gateCwd,
-    ultramodernBridgeCliFlags.reactSingleton
-];
-const ultramodernBridgeCliBooleanFlags = [
-    ultramodernBridgeCliFlags.enabled
-];
-const ultramodernBridgeLockfilePolicies = [
-    'nested',
-    'parent'
-];
-const defaultReactSingletons = [
-    'react',
-    'react-dom'
-];
-function hasUltramodernBridgeCliOptions(args) {
-    return args.some((arg)=>[
-            ...ultramodernBridgeCliBooleanFlags,
-            ...ultramodernBridgeCliValueFlags
-        ].some((flag)=>arg === flag || arg.startsWith(`${flag}=`)));
-}
-function parseUltramodernBridgeCliOptions(args) {
-    rejectBooleanFlagValues(args);
-    if (!hasUltramodernBridgeCliOptions(args)) return;
-    const parentRoot = readSingleValue(args, ultramodernBridgeCliFlags.parentRoot);
-    const lockfilePolicy = readSingleValue(args, ultramodernBridgeCliFlags.lockfilePolicy) ?? 'nested';
-    const workspacePackages = readWorkspacePackages(args);
-    const gates = readBridgeGates(args);
-    const reactSingletons = readCsvOptionValues(args, ultramodernBridgeCliFlags.reactSingleton);
-    return normalizeUltramodernBridgeConfig({
-        enabled: true,
-        parentRoot: requireNonEmptyValue(parentRoot, ultramodernBridgeCliFlags.parentRoot),
-        workspacePackages,
-        dependencies: readCsvOptionValues(args, ultramodernBridgeCliFlags.dependency),
-        lockfilePolicy: parseLockfilePolicy(lockfilePolicy),
-        gates,
-        reactSingletons: reactSingletons.length > 0 ? reactSingletons : void 0
-    });
-}
-function normalizeUltramodernBridgeConfig(bridge) {
-    if (!bridge || false === bridge.enabled) return;
-    const parentRoot = requireNonEmptyValue(bridge.parentRoot, 'bridge.parentRoot');
-    const workspacePackages = normalizeWorkspacePackages(bridge.workspacePackages);
-    const dependencies = uniqueNonEmptyValues(bridge.dependencies, 'bridge.dependencies');
-    const gates = normalizeBridgeGates(bridge.gates);
-    const reactSingletons = bridge.reactSingletons && bridge.reactSingletons.length > 0 ? uniqueNonEmptyValues(bridge.reactSingletons, 'bridge.reactSingletons') : [
-        ...defaultReactSingletons
-    ];
-    if (0 === workspacePackages.length) throw new Error('Bridge mode requires at least one bridge.workspacePackages entry.');
-    if (0 === dependencies.length) throw new Error('Bridge mode requires at least one explicit bridge.dependencies package name.');
-    if (0 === gates.length) throw new Error('Bridge mode requires at least one bridge.gates delegated parent command.');
-    validateParentPackageCoverage(workspacePackages, dependencies);
-    validateReactSingletons(reactSingletons);
-    return {
-        enabled: true,
-        parentRoot,
-        workspacePackages,
-        dependencies,
-        lockfilePolicy: parseLockfilePolicy(bridge.lockfilePolicy ?? 'nested'),
-        gates,
-        reactSingletons
-    };
-}
-function rejectBooleanFlagValues(args) {
-    for (const flag of ultramodernBridgeCliBooleanFlags)if (args.some((arg)=>arg.startsWith(`${flag}=`))) throw new Error(`${flag} does not accept a value.`);
-}
-function readRepeatedOptionValues(args, flag) {
-    const values = [];
-    for(let index = 0; index < args.length; index++){
-        const arg = args[index];
-        if (arg === flag) {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) throw new Error(`${flag} requires a value.`);
-            values.push(value);
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
-    }
-    return values;
-}
-function readSingleValue(args, flag) {
-    const values = readRepeatedOptionValues(args, flag);
-    if (values.length > 1) throw new Error(`${flag} can be provided only once.`);
-    return values[0];
-}
-function readCsvOptionValues(args, flag) {
-    return readRepeatedOptionValues(args, flag).flatMap((value)=>value.split(',').map((entry)=>entry.trim()).filter(Boolean));
-}
-function requireNonEmptyValue(value, label) {
-    if ('string' != typeof value || 0 === value.trim().length) throw new Error(`${label} must be a non-empty string.`);
-    return value.trim();
-}
-function parseLockfilePolicy(value) {
-    if (!ultramodernBridgeLockfilePolicies.includes(value)) throw new Error(`${ultramodernBridgeCliFlags.lockfilePolicy} must be "nested" or "parent".`);
-    return value;
-}
-function readWorkspacePackages(args) {
-    const drafts = new Map();
-    const getDraft = (pattern)=>{
-        const normalizedPattern = requireNonEmptyValue(pattern, ultramodernBridgeCliFlags.workspacePackage);
-        const existing = drafts.get(normalizedPattern);
-        if (existing) return existing;
-        const draft = {
-            pattern: normalizedPattern,
-            packageNames: [],
-            testAliases: []
-        };
-        drafts.set(normalizedPattern, draft);
-        return draft;
-    };
-    for (const pattern of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.workspacePackage))getDraft(pattern);
-    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.workspacePackageName)){
-        const { left: pattern, right: packageNames } = splitAssignment(value, ultramodernBridgeCliFlags.workspacePackageName, '<pattern>=<package-name>[,<package-name>]');
-        getDraft(pattern).packageNames.push(...packageNames.split(',').map((packageName)=>packageName.trim()).filter(Boolean));
-    }
-    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.testAlias)){
-        const separator = value.indexOf(':');
-        if (-1 === separator) throw new Error(`${ultramodernBridgeCliFlags.testAlias} must use <pattern>:<alias>=<target>.`);
-        const pattern = value.slice(0, separator);
-        const aliasDefinition = value.slice(separator + 1);
-        const { left: alias, right: target } = splitAssignment(aliasDefinition, ultramodernBridgeCliFlags.testAlias, '<pattern>:<alias>=<target>');
-        getDraft(pattern).testAliases.push({
-            alias: requireNonEmptyValue(alias, `${ultramodernBridgeCliFlags.testAlias} alias`),
-            target: requireNonEmptyValue(target, `${ultramodernBridgeCliFlags.testAlias} target`)
-        });
-    }
-    return normalizeWorkspacePackages([
-        ...drafts.values()
-    ]);
-}
-function readBridgeGates(args) {
-    const gates = new Map();
-    const getGate = (name)=>{
-        const normalizedName = requireNonEmptyValue(name, `${ultramodernBridgeCliFlags.gate} name`);
-        const existing = gates.get(normalizedName);
-        if (existing) return existing;
-        const draft = {
-            name: normalizedName
-        };
-        gates.set(normalizedName, draft);
-        return draft;
-    };
-    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.gate)){
-        const { left: name, right: command } = splitAssignment(value, ultramodernBridgeCliFlags.gate, '<name>=<command>');
-        getGate(name).command = requireNonEmptyValue(command, `${ultramodernBridgeCliFlags.gate} command`);
-    }
-    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.gateCwd)){
-        const { left: name, right: cwd } = splitAssignment(value, ultramodernBridgeCliFlags.gateCwd, '<name>=<cwd>');
-        getGate(name).cwd = requireNonEmptyValue(cwd, `${ultramodernBridgeCliFlags.gateCwd} cwd`);
-    }
-    const missingCommand = [
-        ...gates.values()
-    ].find((gate)=>!gate.command);
-    if (missingCommand) throw new Error(`${ultramodernBridgeCliFlags.gateCwd} references "${missingCommand.name}" without a matching ${ultramodernBridgeCliFlags.gate}.`);
-    return normalizeBridgeGates([
-        ...gates.values()
-    ].map((gate)=>({
-            name: gate.name,
-            command: gate.command,
-            cwd: gate.cwd
-        })));
-}
-function splitAssignment(value, flag, usage) {
-    const separator = value.indexOf('=');
-    if (-1 === separator) throw new Error(`${flag} must use ${usage}.`);
-    return {
-        left: value.slice(0, separator),
-        right: value.slice(separator + 1)
-    };
-}
-function normalizeWorkspacePackages(workspacePackages) {
-    return workspacePackages.map((entry, index)=>{
-        const label = `bridge.workspacePackages[${index}]`;
-        const packageNames = entry.packageNames && entry.packageNames.length > 0 ? uniqueNonEmptyValues(entry.packageNames, `${label}.packageNames`) : void 0;
-        const testAliases = entry.testAliases && entry.testAliases.length > 0 ? normalizeTestAliases(entry.testAliases, label) : void 0;
-        return {
-            pattern: requireNonEmptyValue(entry.pattern, `${label}.pattern`),
-            ...packageNames ? {
-                packageNames
-            } : {},
-            ...testAliases ? {
-                testAliases
-            } : {}
-        };
-    });
-}
-function validateParentPackageCoverage(workspacePackages, dependencies) {
-    const declaredPackages = new Set();
-    for (const [index, entry] of workspacePackages.entries()){
-        const label = `bridge.workspacePackages[${index}]`;
-        const packageNames = entry.packageNames ?? [];
-        if (0 === packageNames.length && (entry.testAliases ?? []).length > 0) throw new Error(`${label}.packageNames must declare the parent package names covered by "${entry.pattern}" before testAliases can be checked.`);
-        for (const packageName of packageNames)declaredPackages.add(packageName);
-        for (const alias of entry.testAliases ?? []){
-            if (!packageNames.some((packageName)=>aliasMatchesPackage(alias.alias, packageName))) throw new Error(`${label}.testAliases entry "${alias.alias}" must match one of ${label}.packageNames.`);
-            if (pointsAtBuildOutput(alias.target)) throw new Error(`${label}.testAliases target "${alias.target}" must point at source files, not dist output.`);
-        }
-    }
-    const missingDependencies = dependencies.filter((dependency)=>!declaredPackages.has(dependency));
-    if (declaredPackages.size > 0 && missingDependencies.length > 0) throw new Error(`Bridge mode dependencies must be declared by bridge.workspacePackages[].packageNames: ${missingDependencies.join(', ')}.`);
-}
-function aliasMatchesPackage(alias, packageName) {
-    return alias === packageName || alias.startsWith(`${packageName}/`);
-}
-function pointsAtBuildOutput(target) {
-    return target.split(/[\\/]/u).includes('dist');
-}
-function validateReactSingletons(reactSingletons) {
-    const missing = defaultReactSingletons.filter((packageName)=>!reactSingletons.includes(packageName));
-    if (missing.length > 0) throw new Error(`Bridge mode React singleton/dedupe declarations must include ${defaultReactSingletons.join(' and ')}. Missing: ${missing.join(', ')}.`);
-}
-function normalizeTestAliases(testAliases, parentLabel) {
-    const aliases = new Map();
-    for (const [index, alias] of testAliases.entries()){
-        const label = `${parentLabel}.testAliases[${index}]`;
-        const normalizedAlias = requireNonEmptyValue(alias.alias, `${label}.alias`);
-        aliases.set(normalizedAlias, {
-            alias: normalizedAlias,
-            target: requireNonEmptyValue(alias.target, `${label}.target`)
-        });
-    }
-    return [
-        ...aliases.values()
-    ];
-}
-function normalizeBridgeGates(gates) {
-    const normalized = new Map();
-    for (const [index, gate] of gates.entries()){
-        const label = `bridge.gates[${index}]`;
-        const name = requireNonEmptyValue(gate.name, `${label}.name`);
-        normalized.set(name, {
-            name,
-            command: requireNonEmptyValue(gate.command, `${label}.command`),
-            ...gate.cwd ? {
-                cwd: requireNonEmptyValue(gate.cwd, `${label}.cwd`)
-            } : {}
-        });
-    }
-    return [
-        ...normalized.values()
-    ];
-}
-function uniqueNonEmptyValues(values, label) {
-    const unique = new Set();
-    for (const [index, value] of values.entries())unique.add(requireNonEmptyValue(value, `${label}[${index}]`));
-    return [
-        ...unique
-    ];
-}
-export { hasUltramodernBridgeCliOptions, normalizeUltramodernBridgeConfig, parseUltramodernBridgeCliOptions, ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeCliValueFlags, ultramodernBridgeLockfilePolicies };
+export * from "./bridge-config/index.js";

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

@@ -1,8 +1,25 @@
 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 isJsonValue(value) {
+    return void 0 !== value;
+}
+function optionalJsonEntry(key, value) {
+    return void 0 === value ? {} : {
+        [key]: value
+    };
+}
+function jsonEntries(entries) {
+    return Object.fromEntries(entries.filter((entry)=>isJsonValue(entry[1])));
+}
+function presentJsonValues(values) {
+    return values.filter(isJsonValue);
+}
 function createTopology(scope, remotes = []) {
     const shellHost = createShellHost(remotes);
     return {
@@ -14,7 +31,7 @@ function createTopology(scope, remotes = []) {
             id: shellApp.id,
             kind: 'shell',
             package: packageName(scope, shellApp.packageSuffix),
-            verticalRefs: shellHost.verticalRefs,
+            verticalRefs: shellHost.verticalRefs ?? [],
             moduleFederation: {
                 role: 'host',
                 name: shellApp.mfName,
@@ -28,7 +45,9 @@ function createTopology(scope, remotes = []) {
         verticals: remotes.map((vertical)=>({
                 id: vertical.id,
                 kind: vertical.kind,
-                domain: vertical.domain,
+                ...vertical.domain ? {
+                    domain: vertical.domain
+                } : {},
                 package: packageName(scope, vertical.packageSuffix),
                 path: vertical.directory,
                 moduleFederation: {
@@ -41,12 +60,13 @@ function createTopology(scope, remotes = []) {
                         remotes: createModuleFederationRemoteContracts(vertical)
                     } : {},
                     ssr: true,
-                    fallbackTelemetryEvent: 'modernjs:mv-runtime-parity',
                     sharedContractVersion: 'mf-ssr-contract-v1'
                 },
-                ...apiTopologyMetadata(vertical) ? {
-                    api: apiTopologyMetadata(vertical)
+                ...optionalJsonEntry('backendFederation', createBackendFederationContract(scope, vertical)),
+                ...vertical.api ? {
+                    deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, vertical))
                 } : {},
+                ...optionalJsonEntry('api', apiTopologyMetadata(vertical)),
                 cloudflare: createCloudflareDeployContract(scope, vertical),
                 ownership: vertical.ownership
             })),
@@ -99,7 +119,7 @@ function createOwnership(scope, remotes = []) {
             }))
     };
 }
-function createDevelopmentOverlay(remotes = []) {
+function createDevelopmentOverlay(scope, remotes = []) {
     return {
         schemaVersion: 1,
         environment: 'development',
@@ -115,6 +135,10 @@ function createDevelopmentOverlay(remotes = []) {
                 remote.id,
                 `http://localhost:${remote.port}/mf-manifest.json`
             ])),
+        serverExecution: jsonEntries(verticalApiApps(remotes).map((app)=>[
+                app.id,
+                createServerExecutionOverlay(scope, app)
+            ])),
         apis: Object.fromEntries(verticalApiApps(remotes).map((app)=>[
                 app.id,
                 `http://localhost:${app.port}${resolveApiPrefix(app)}`
@@ -179,7 +203,7 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                         name: app.mfName,
                         exposes: Object.keys(app.exposes ?? {}),
                         ...'shell' === app.kind ? {
-                            verticalRefs: shellHost.verticalRefs,
+                            verticalRefs: shellHost.verticalRefs ?? [],
                             remotes: createModuleFederationRemoteContracts(shellHost, remotes)
                         } : app.verticalRefs?.length ? {
                             verticalRefs: app.verticalRefs,
@@ -187,10 +211,14 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                         } : {},
                         ssr: true,
                         dts: {
-                            compilerInstance: 'tsgo',
+                            compilerInstance: 'effect-tsgo',
                             tsConfigPath: './tsconfig.mf-types.json'
                         }
                     },
+                    ...optionalJsonEntry('backendFederation', createBackendFederationContract(scope, app)),
+                    ...app.api ? {
+                        deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app))
+                    } : {},
                     ...app.api ? {
                         api: {
                             stem: app.api.stem,
@@ -234,6 +262,9 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                     hostOnly: 'shell' === app.kind && 0 === Object.keys(app.exposes ?? {}).length
                 }))
         },
+        backendFederation: {
+            apps: presentJsonValues(verticalApiApps(remotes).map((app)=>createBackendFederationSummary(scope, app)))
+        },
         agentSkills: {
             target: 'codex',
             lockfile: './.codex/skills-lock.json',
@@ -248,13 +279,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"
             }

package/dist/esm/ultramodern-workspace/delivery-unit-sync.js

@@ -0,0 +1,110 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { parseArgs } from "node:util";
+import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../ultramodern-tooling/config.js";
+import { createBackendFederationContract } from "./backend-federation.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
+import { ULTRAMODERN_CONFIG_PATH } from "./descriptors.js";
+import { createUltramodernBuildArtifactJson, createUltramodernBuildModule } from "./module-federation.js";
+const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function writeTextIfChanged(absolutePath, content) {
+    if (node_fs.existsSync(absolutePath) && node_fs.readFileSync(absolutePath, 'utf-8') === content) return false;
+    node_fs.mkdirSync(node_path.dirname(absolutePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(absolutePath, content, 'utf-8');
+    return true;
+}
+function writeJsonIfChanged(absolutePath, value) {
+    return writeTextIfChanged(absolutePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function stampDeliveryUnitIdentity(entry, scope, app) {
+    const block = deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app));
+    entry.deliveryUnit = block;
+    if (isPlainObject(entry.backendFederation)) {
+        entry.backendFederation.deliveryUnit = block;
+        if (!isPlainObject(entry.backendFederation.versionBoundary)) entry.backendFederation.versionBoundary = {};
+        entry.backendFederation.versionBoundary.identityRoot = 'deliveryUnit';
+    } else entry.backendFederation = createBackendFederationContract(scope, app);
+}
+function runSyncDeliveryUnit(args, context) {
+    const parsed = parseArgs({
+        args,
+        options: {
+            help: {
+                type: 'boolean',
+                short: 'h'
+            },
+            workspace: {
+                type: 'string'
+            }
+        },
+        strict: true,
+        allowPositionals: false
+    });
+    if (parsed.values.help) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern sync-delivery-unit [--workspace <dir>]
+
+Backfills the per-vertical delivery-unit identity blocks required by
+\`ultramodern validate\` onto an existing generated workspace, in place and
+through framework tooling only. For each full-stack vertical it writes the
+delivery-unit block into .modernjs/ultramodern.json topology.apps[] and
+topology/reference-topology.json verticals[] (plus backendFederation.deliveryUnit
+and backendFederation.versionBoundary.identityRoot) and regenerates
+verticals/<id>/shared/ultramodern-build.{json,ts}. Idempotent: a second run writes
+nothing.
+`);
+        return 0;
+    }
+    const workspaceOverride = parsed.values.workspace;
+    const workspaceRoot = workspaceOverride ? node_path.resolve(context.invocationCwd, workspaceOverride) : context.workspaceRoot;
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (!node_fs.existsSync(compactPath)) throw new Error(`Missing ${ULTRAMODERN_CONFIG_PATH}. sync-delivery-unit needs the compact UltraModern config; run \`modern-js-create ultramodern migrate-strict-effect\` first.`);
+    const config = readUltramodernConfig(workspaceRoot);
+    const scope = config.workspace.packageScope;
+    const apiApps = workspaceAppsFromToolingConfig(config).filter((app)=>Boolean(app.api));
+    const written = [];
+    const unchanged = [];
+    const track = (relativePath, changed)=>{
+        (changed ? written : unchanged).push(relativePath);
+    };
+    const appById = new Map(apiApps.map((app)=>[
+            app.id,
+            app
+        ]));
+    const compact = JSON.parse(node_fs.readFileSync(compactPath, 'utf-8'));
+    if (isPlainObject(compact) && Array.isArray(compact.topology?.apps)) for (const entry of compact.topology.apps){
+        if (!isPlainObject(entry)) continue;
+        const app = appById.get(String(entry.id));
+        if (app) stampDeliveryUnitIdentity(entry, scope, app);
+    }
+    track(ULTRAMODERN_CONFIG_PATH, writeJsonIfChanged(compactPath, compact));
+    const topologyPath = node_path.join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
+    if (node_fs.existsSync(topologyPath)) {
+        const topology = JSON.parse(node_fs.readFileSync(topologyPath, 'utf-8'));
+        if (isPlainObject(topology) && Array.isArray(topology.verticals)) for (const entry of topology.verticals){
+            if (!isPlainObject(entry)) continue;
+            const app = appById.get(String(entry.id));
+            if (app) stampDeliveryUnitIdentity(entry, scope, app);
+        }
+        track(REFERENCE_TOPOLOGY_PATH, writeJsonIfChanged(topologyPath, topology));
+    }
+    for (const app of apiApps){
+        const buildModulePath = node_path.join(app.directory, 'shared/ultramodern-build.ts');
+        const buildArtifactPath = node_path.join(app.directory, 'shared/ultramodern-build.json');
+        track(buildModulePath, writeTextIfChanged(node_path.join(workspaceRoot, buildModulePath), createUltramodernBuildModule(scope, app)));
+        track(buildArtifactPath, writeTextIfChanged(node_path.join(workspaceRoot, buildArtifactPath), createUltramodernBuildArtifactJson(scope, app)));
+    }
+    if (0 === written.length) process.stdout.write('[ultramodern] sync-delivery-unit: already in sync; no files written.\n');
+    else {
+        process.stdout.write(`[ultramodern] sync-delivery-unit: wrote ${written.length} file(s):\n`);
+        for (const relativePath of written)process.stdout.write(`  wrote    ${relativePath}\n`);
+        for (const relativePath of unchanged)process.stdout.write(`  in-sync  ${relativePath}\n`);
+    }
+    return 0;
+}
+export { runSyncDeliveryUnit };

package/dist/esm/ultramodern-workspace/delivery-unit.js

@@ -0,0 +1,21 @@
+import node_crypto from "node:crypto";
+import { DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, deliveryUnitContractBlock } from "@modern-js/utils/universal";
+import { packageName } from "./naming.js";
+const deliveryUnitGenerationSeed = `${Date.now()}:${node_crypto.randomUUID()}`;
+function createBuildMarker(scope, app) {
+    return node_crypto.createHash('sha256').update(`${deliveryUnitGenerationSeed}:${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+}
+function createDeliveryUnitRecord(scope, app) {
+    return {
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        kind: DELIVERY_UNIT_KIND,
+        unitId: `${scope}/${app.domain ?? app.id}`,
+        appId: app.id,
+        packageName: packageName(scope, app.packageSuffix),
+        version: '0.1.0',
+        sourceRevision: 'workspace',
+        buildMarker: createBuildMarker(scope, app),
+        deployProfile: DELIVERY_UNIT_DEPLOY_PROFILE
+    };
+}
+export { createBuildMarker, createDeliveryUnitRecord, deliveryUnitContractBlock };