@bleedingdev/modern-js-create 3.4.0-ultramodern.12 → 3.4.0-ultramodern.14

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

@@ -0,0 +1,132 @@
+import { spawnSync } from "node:child_process";
+import node_fs from "node:fs";
+import node_os from "node:os";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveCreatePackageRoot } from "../create-package-root.js";
+import { validateModuleFederationTypes } from "../ultramodern-workspace/mf-validation.js";
+import { createWorkspaceValidationScript } from "../ultramodern-workspace/workspace-scripts.js";
+import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "./config.js";
+const commands_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const createPackageRoot = resolveCreatePackageRoot(commands_dirname);
+function printHelp() {
+    process.stdout.write(`Usage:
+  modern-js-create ultramodern <command> [args]
+
+Commands:
+  validate
+  typecheck
+  mf-types
+  public-surface
+  cloudflare-proof
+  performance-readiness
+  skills install
+  skills check
+`);
+}
+function spawnNodeScript(relativeScriptPath, args, context, options = {}) {
+    const scriptPath = node_path.join(createPackageRoot, relativeScriptPath);
+    const result = spawnSync(process.execPath, [
+        scriptPath,
+        ...args
+    ], {
+        cwd: options.cwd ?? context.workspaceRoot,
+        env: {
+            ...process.env,
+            ULTRAMODERN_WORKSPACE_ROOT: context.workspaceRoot
+        },
+        stdio: 'inherit'
+    });
+    if (result.error) throw result.error;
+    return result.status ?? 1;
+}
+function runRenderedModule(source, context) {
+    const tempDir = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-tool-'));
+    const tempFile = node_path.join(tempDir, 'command.mjs');
+    try {
+        node_fs.writeFileSync(tempFile, source, 'utf-8');
+        const result = spawnSync(process.execPath, [
+            tempFile
+        ], {
+            cwd: context.workspaceRoot,
+            stdio: 'inherit'
+        });
+        if (result.error) throw result.error;
+        return result.status ?? 1;
+    } finally{
+        node_fs.rmSync(tempDir, {
+            force: true,
+            recursive: true
+        });
+    }
+}
+function runValidate(context) {
+    const config = readUltramodernConfig(context.workspaceRoot);
+    const apps = workspaceAppsFromToolingConfig(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    const source = createWorkspaceValidationScript(config.workspace.packageScope, config.features.tailwind, remotes);
+    return runRenderedModule(source, context);
+}
+function runMfTypes(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern mf-types [app-dir...]
+
+Checks real Module Federation config files and DTS archives for exposed apps.
+`);
+        return 0;
+    }
+    validateModuleFederationTypes({
+        workspaceRoot: context.workspaceRoot,
+        appDirs: args.length > 0 ? args : void 0
+    });
+    return 0;
+}
+function runSkills(args, context) {
+    const [subcommand, ...rest] = args;
+    if ('install' === subcommand) return spawnNodeScript("template-workspace/scripts/bootstrap-agent-skills.mjs", rest, context);
+    if ('check' === subcommand) return spawnNodeScript("template-workspace/scripts/bootstrap-agent-skills.mjs", [
+        '--check',
+        ...rest
+    ], context);
+    throw new Error('Usage: modern-js-create ultramodern skills <install|check>');
+}
+async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd()) {
+    try {
+        const [command, ...rest] = args;
+        const context = {
+            workspaceRoot: node_path.resolve(workspaceRoot),
+            invocationCwd: process.cwd()
+        };
+        switch(command){
+            case void 0:
+            case '--help':
+            case '-h':
+                printHelp();
+                return 0;
+            case 'validate':
+                return runValidate(context);
+            case 'typecheck':
+                return spawnNodeScript("templates/workspace-scripts/ultramodern-typecheck.mjs", rest, context, {
+                    cwd: context.invocationCwd
+                });
+            case 'mf-types':
+                return runMfTypes(rest, context);
+            case 'public-surface':
+                return spawnNodeScript("templates/workspace-scripts/generate-public-surface-assets.mjs", rest, context);
+            case 'cloudflare-proof':
+                return spawnNodeScript("templates/workspace-scripts/proof-cloudflare-version.mjs", rest, context);
+            case 'performance-readiness':
+                return spawnNodeScript("templates/workspace-scripts/ultramodern-performance-readiness.mjs", rest, context);
+            case 'skills':
+                return runSkills(rest, context);
+            default:
+                throw new Error(`Unknown UltraModern command: ${command}`);
+        }
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[ultramodern] ${message}\n`);
+        return 1;
+    }
+}
+export { runUltramodernToolingCli };

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

@@ -0,0 +1,196 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { normalizeUltramodernBridgeConfig } from "../ultramodern-workspace/bridge-config.js";
+import { GENERATED_CONTRACT_PATH, ULTRAMODERN_CONFIG_PATH, createNeutralOwnership, shellApp } from "../ultramodern-workspace/descriptors.js";
+import { toKebabCase } from "../ultramodern-workspace/naming.js";
+const PACKAGE_SOURCE_METADATA_PATH = '.modernjs/ultramodern-package-source.json';
+const 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}`);
+    return value;
+}
+function readOptionalJsonObject(filePath) {
+    return node_fs.existsSync(filePath) ? readJsonObject(filePath) : {};
+}
+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 packageSourceFromMetadata(workspaceRoot) {
+    const metadataPath = node_path.join(workspaceRoot, PACKAGE_SOURCE_METADATA_PATH);
+    if (!node_fs.existsSync(metadataPath)) return;
+    const metadata = readJsonObject(metadataPath);
+    const aliases = metadata.modernPackages?.aliases ?? {};
+    const firstAlias = Object.values(aliases).find((value)=>'string' == typeof value);
+    const firstPackage = Object.keys(aliases)[0];
+    const aliasScope = firstAlias?.match(/^@([^/]+)\//)?.[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, 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:*',
+        registry: 'string' == typeof config.packageSource.registry ? config.packageSource.registry : void 0,
+        aliasScope: 'string' == typeof config.packageSource.aliasScope ? config.packageSource.aliasScope : void 0,
+        aliasPackageNamePrefix: 'string' == typeof config.packageSource.aliasPackageNamePrefix ? config.packageSource.aliasPackageNamePrefix : void 0
+    } : packageSourceFromMetadata(workspaceRoot);
+    return {
+        schemaVersion: 'number' == typeof config.schemaVersion ? config.schemaVersion : 1,
+        profile: 'string' == typeof config.profile ? config.profile : void 0,
+        source: 'compact',
+        sourcePath,
+        workspace: {
+            packageScope: 'string' == typeof config.workspace?.packageScope ? config.workspace.packageScope : packageScopeFromRoot(workspaceRoot)
+        },
+        packageSource,
+        features: {
+            tailwind: config.features?.tailwind !== false
+        },
+        bridge: normalizeUltramodernBridgeConfig(config.bridge),
+        topology: {
+            apps: Array.isArray(config.topology?.apps) ? config.topology.apps.map((app)=>({
+                    id: String(app.id),
+                    kind: 'vertical' === app.kind ? 'vertical' : 'shell',
+                    path: 'string' == typeof app.path ? app.path : '.',
+                    package: 'string' == typeof app.package ? app.package : void 0,
+                    packageSuffix: 'string' == typeof app.packageSuffix ? app.packageSuffix : void 0,
+                    displayName: 'string' == typeof app.displayName ? app.displayName : void 0,
+                    domain: 'string' == typeof app.domain ? app.domain : void 0,
+                    port: 'number' == typeof app.port ? app.port : void 0,
+                    portEnv: 'string' == typeof app.portEnv ? app.portEnv : void 0,
+                    moduleFederation: app.moduleFederation && 'object' == typeof app.moduleFederation ? {
+                        role: 'remote' === app.moduleFederation.role ? 'remote' : 'host',
+                        name: 'string' == typeof app.moduleFederation.name ? app.moduleFederation.name : void 0,
+                        exposes: Array.isArray(app.moduleFederation.exposes) ? app.moduleFederation.exposes.filter((expose)=>'string' == typeof expose) : void 0,
+                        verticalRefs: Array.isArray(app.moduleFederation.verticalRefs) ? app.moduleFederation.verticalRefs.filter((ref)=>'string' == typeof ref) : void 0,
+                        hostOnly: true === app.moduleFederation.hostOnly,
+                        noExposes: true === app.moduleFederation.noExposes
+                    } : void 0,
+                    effectApi: app.effectApi && 'object' == typeof app.effectApi ? {
+                        stem: 'string' == typeof app.effectApi.stem ? app.effectApi.stem : String(app.id),
+                        prefix: 'string' == typeof app.effectApi.prefix ? app.effectApi.prefix : `/${String(app.id)}-api`,
+                        consumedBy: Array.isArray(app.effectApi.consumedBy) ? app.effectApi.consumedBy.filter((consumer)=>'string' == typeof consumer) : [
+                            shellApp.id,
+                            String(app.id)
+                        ]
+                    } : void 0
+                })) : []
+        }
+    };
+}
+function adaptLegacyContract(workspaceRoot, sourcePath, contract) {
+    const ports = readOverlayPorts(workspaceRoot);
+    const apps = Array.isArray(contract.apps) ? contract.apps : [];
+    const shell = apps.find((app)=>app?.id === shellApp.id);
+    return {
+        schemaVersion: 'number' == typeof contract.schemaVersion ? contract.schemaVersion : 1,
+        profile: 'string' == typeof contract.profile ? contract.profile : void 0,
+        source: 'legacy',
+        sourcePath,
+        workspace: {
+            packageScope: packageScopeFromRoot(workspaceRoot)
+        },
+        packageSource: packageSourceFromMetadata(workspaceRoot),
+        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);
+                return {
+                    id,
+                    kind: 'vertical' === app.kind ? 'vertical' : 'shell',
+                    path: appPath,
+                    package: 'string' == typeof app.package ? app.package : void 0,
+                    packageSuffix: 'string' == typeof app.package ? app.package.split('/').at(-1) : appPath.split('/').at(-1),
+                    displayName: id === shellApp.id ? shellApp.displayName : void 0,
+                    domain,
+                    port: ports[id],
+                    moduleFederation: app.moduleFederation && 'object' == typeof app.moduleFederation ? {
+                        role: 'vertical' === app.kind ? 'remote' : 'host',
+                        name: 'string' == typeof app.moduleFederation.name ? app.moduleFederation.name : void 0,
+                        exposes: Array.isArray(app.moduleFederation.exposes) ? app.moduleFederation.exposes.filter((expose)=>'string' == typeof expose) : void 0,
+                        verticalRefs: Array.isArray(app.moduleFederation.verticalRefs) ? app.moduleFederation.verticalRefs.filter((ref)=>'string' == typeof ref) : void 0,
+                        hostOnly: 'vertical' !== app.kind
+                    } : void 0,
+                    effectApi: 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
+                };
+            })
+        },
+        legacyContract: contract
+    };
+}
+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));
+    const legacyPath = node_path.join(workspaceRoot, GENERATED_CONTRACT_PATH);
+    if (node_fs.existsSync(legacyPath)) return adaptLegacyContract(workspaceRoot, legacyPath, readJsonObject(legacyPath));
+    throw new Error(`Missing UltraModern config. Expected ${ULTRAMODERN_CONFIG_PATH} or ${GENERATED_CONTRACT_PATH}.`);
+}
+function workspaceAppsFromToolingConfig(config) {
+    return config.topology.apps.map((app)=>{
+        if ('shell' === app.kind) return {
+            ...shellApp,
+            directory: app.path,
+            packageSuffix: app.packageSuffix ?? shellApp.packageSuffix,
+            displayName: app.displayName ?? shellApp.displayName,
+            port: app.port ?? shellApp.port,
+            portEnv: app.portEnv ?? shellApp.portEnv,
+            mfName: app.moduleFederation?.name ?? shellApp.mfName,
+            verticalRefs: app.moduleFederation?.verticalRefs ?? []
+        };
+        const domain = app.domain ?? app.id;
+        const packageSuffix = app.packageSuffix ?? domain;
+        const exposes = Object.fromEntries((app.moduleFederation?.exposes ?? []).map((expose)=>[
+                expose,
+                './Route' === expose ? './src/federation-entry.tsx' : './Widget' === expose ? `./src/components/${domain}-widget.tsx` : ''
+            ]));
+        return {
+            id: app.id,
+            directory: app.path,
+            packageSuffix,
+            displayName: app.displayName ?? `${domain} Vertical`,
+            kind: 'vertical',
+            domain,
+            portEnv: app.portEnv ?? `VERTICAL_${domain.replace(/[^a-zA-Z0-9]+/g, '_').toUpperCase()}_PORT`,
+            port: app.port ?? 0,
+            mfName: app.moduleFederation?.name ?? app.id,
+            exposes,
+            ...app.moduleFederation?.verticalRefs ? {
+                verticalRefs: app.moduleFederation.verticalRefs
+            } : {},
+            ...app.effectApi ? {
+                effectApi: app.effectApi
+            } : {},
+            ownership: createNeutralOwnership(app.id)
+        };
+    });
+}
+export { readUltramodernConfig, workspaceAppsFromToolingConfig };

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

@@ -2,12 +2,12 @@ import node_fs from "node:fs";
 import node_os from "node:os";
 import node_path from "node:path";
 import { WORKSPACE_PACKAGE_VERSION } from "../ultramodern-package-source.js";
+import { readUltramodernConfig } from "../ultramodern-tooling/config.js";
 import { createAppEnvDts, createAppRuntimeConfig, createShellFrameComponent } from "./app-files.js";
-import { createGeneratedContract } from "./contracts.js";
 import { createShellPage, createShellRemoteComponents } from "./demo-components.js";
-import { GENERATED_CONTRACT_PATH, appHasEffectApi, appI18nNamespace, createModuleFederationRemoteContracts, createNeutralOwnership, createRemoteManifestEnv, createShellHost, createVerticalDescriptor, effectApiPrefix, remoteDependencyAlias, shellApp, zephyrRemoteDependency } from "./descriptors.js";
+import { GENERATED_CONTRACT_PATH, ULTRAMODERN_CONFIG_PATH, appHasEffectApi, appI18nNamespace, createModuleFederationRemoteContracts, createNeutralOwnership, createRemoteManifestEnv, createShellHost, createVerticalDescriptor, effectApiPrefix, remoteDependencyAlias, shellApp, zephyrRemoteDependency } from "./descriptors.js";
 import { createShellEffectClient, effectApiTopologyMetadata } from "./effect-api.js";
-import { readJsonFile, writeFileReplacing, writeJsonFile } from "./fs-io.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";
@@ -19,7 +19,7 @@ import { createCloudflareDeployContract } from "./policy.js";
 import { createPublicWebAppArtifacts, rewriteWorkspaceAssetsForApp } from "./public-surface.js";
 import { isRecord } from "./types.js";
 import { writeGeneratedWorkspaceScripts } from "./workspace-scripts.js";
-import { writeApp } from "./write-workspace.js";
+import { createCompactUltramodernConfig, writeApp } from "./write-workspace.js";
 const FIRST_VERTICAL_PORT = 4101;
 const TOPOLOGY_PATH = 'topology/reference-topology.json';
 const OWNERSHIP_PATH = 'topology/ownership.json';
@@ -32,7 +32,12 @@ function existingPackageSource(workspaceRoot, modernVersion, packageSource) {
         modernVersion,
         packageSource
     });
-    const metadataPath = node_path.join(workspaceRoot, '.modernjs/ultramodern-package-source.json');
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (node_fs.existsSync(compactPath)) {
+        const compactConfig = readUltramodernConfig(workspaceRoot);
+        if (compactConfig.packageSource) return compactConfig.packageSource;
+    }
+    const metadataPath = node_path.join(workspaceRoot, PACKAGE_SOURCE_METADATA_PATH);
     if (!node_fs.existsSync(metadataPath)) return resolvePackageSource({
         targetDir: workspaceRoot,
         packageName: node_path.basename(workspaceRoot),
@@ -55,6 +60,8 @@ function existingPackageSource(workspaceRoot, modernVersion, packageSource) {
     };
 }
 function existingTailwindEnabled(workspaceRoot) {
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (node_fs.existsSync(compactPath)) return readUltramodernConfig(workspaceRoot).features.tailwind;
     const contractPath = node_path.join(workspaceRoot, GENERATED_CONTRACT_PATH);
     if (!node_fs.existsSync(contractPath)) return true;
     const contract = readJsonFile(contractPath);
@@ -62,6 +69,10 @@ function existingTailwindEnabled(workspaceRoot) {
     const shell = apps.find((app)=>isRecord(app) && app.id === shellApp.id);
     return shell?.styling && isRecord(shell.styling) ? false !== shell.styling.tailwind : true;
 }
+function existingBridgeConfig(workspaceRoot) {
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    return node_fs.existsSync(compactPath) ? readUltramodernConfig(workspaceRoot).bridge : void 0;
+}
 function assertValidVerticalName(name) {
     const normalized = toKebabCase(name);
     if (!normalized || normalized !== name) throw new Error(`Invalid Vertical name "${name}". Use lowercase kebab-case.`);
@@ -74,17 +85,17 @@ function nextAvailablePort(ports) {
 function assertCanCreate(workspaceRoot, relativePath) {
     if (node_fs.existsSync(node_path.join(workspaceRoot, relativePath))) throw new Error(`Refusing to overwrite existing path: ${relativePath}`);
 }
-function updateRootWorkspaceScripts(workspaceRoot, scope, packageSource, remotes) {
+function updateRootWorkspaceScripts(workspaceRoot, scope, packageSource, remotes, bridge) {
     const packagePath = node_path.join(workspaceRoot, 'package.json');
     const rootPackage = readJsonFile(packagePath);
-    const generatedRootPackage = createRootPackageJson(scope, packageSource, remotes);
+    const generatedRootPackage = createRootPackageJson(scope, packageSource, remotes, bridge);
     rootPackage.scripts = generatedRootPackage.scripts;
     writeJsonFile(packagePath, rootPackage);
 }
-function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwind, remotes) {
+function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwind, remotes, bridge) {
     const shellHost = createShellHost(remotes);
     const publicWeb = createPublicWebAppArtifacts(shellHost);
-    writeJsonFile(node_path.join(workspaceRoot, `${shellApp.directory}/package.json`), createAppPackage(scope, shellHost, packageSource, enableTailwind, remotes));
+    writeJsonFile(node_path.join(workspaceRoot, `${shellApp.directory}/package.json`), createAppPackage(scope, shellHost, packageSource, enableTailwind, remotes, bridge));
     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));
@@ -203,8 +214,7 @@ function prepareAddUltramodernVertical(options) {
     const topology = readRequiredJsonObject(topologyPath);
     const ownership = readRequiredJsonObject(ownershipPath);
     const overlay = readRequiredJsonObject(overlayPath);
-    readRequiredJsonObject(node_path.join(options.workspaceRoot, GENERATED_CONTRACT_PATH));
-    readRequiredJsonObject(node_path.join(options.workspaceRoot, PACKAGE_SOURCE_METADATA_PATH));
+    readRequiredWorkspaceConfig(options.workspaceRoot);
     assertOptionalJsonObject(topology.shell, 'topology.shell', topologyPath);
     assertOptionalJsonArray(topology.verticals, 'topology.verticals', topologyPath);
     assertOptionalJsonArray(ownership.owners, 'ownership.owners', ownershipPath);
@@ -215,6 +225,7 @@ function prepareAddUltramodernVertical(options) {
     const scope = toPackageScope(String(rootPackage.name ?? node_path.basename(options.workspaceRoot)));
     const packageSource = existingPackageSource(options.workspaceRoot, options.modernVersion, options.packageSource);
     const enableTailwind = options.enableTailwind ?? existingTailwindEnabled(options.workspaceRoot);
+    const bridge = existingBridgeConfig(options.workspaceRoot);
     const existingVerticals = verticalsFromTopology(topology, overlay.ports);
     const port = nextAvailablePort(overlay.ports);
     const vertical = createVerticalDescriptor(name, port);
@@ -242,6 +253,7 @@ function prepareAddUltramodernVertical(options) {
         overlay,
         packageSource,
         enableTailwind,
+        bridge,
         vertical,
         updatedVerticals
     };
@@ -252,6 +264,12 @@ function readRequiredJsonObject(filePath) {
     if (!isRecord(value)) throw new Error(`UltraModern workspace file must contain a JSON object: ${filePath}`);
     return value;
 }
+function readRequiredWorkspaceConfig(workspaceRoot) {
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (node_fs.existsSync(compactPath)) return void readRequiredJsonObject(compactPath);
+    readRequiredJsonObject(node_path.join(workspaceRoot, GENERATED_CONTRACT_PATH));
+    readRequiredJsonObject(node_path.join(workspaceRoot, PACKAGE_SOURCE_METADATA_PATH));
+}
 function assertOptionalJsonObject(value, label, filePath) {
     if (void 0 !== value && !isRecord(value)) throw new Error(`${label} in ${filePath} must be a JSON object`);
 }
@@ -356,7 +374,7 @@ function createVerticalPlan(preflight, result) {
         shellDependencyChanges: createShellDependencyChanges(scope, vertical),
         generatedContractChanges: [
             {
-                path: GENERATED_CONTRACT_PATH,
+                path: ULTRAMODERN_CONFIG_PATH,
                 addedAppIds: [
                     vertical.id
                 ],
@@ -443,9 +461,9 @@ function createDryRunJsonMutations(preflight, manifestUrl) {
             description: 'Keep shell Module Federation DTS compilation scoped'
         },
         {
-            path: GENERATED_CONTRACT_PATH,
-            pointer: '/apps',
-            description: `Regenerate contract with ${vertical.id}`
+            path: ULTRAMODERN_CONFIG_PATH,
+            pointer: '/topology/apps',
+            description: `Regenerate compact config with ${vertical.id}`
         }
     ];
 }
@@ -469,8 +487,8 @@ function createShellDependencyChanges(scope, vertical) {
 }
 function addUltramodernVertical(options) {
     const beforeFiles = createFileSnapshot(options.workspaceRoot);
-    const { scope, topologyPath, ownershipPath, overlayPath, topology, ownership, overlay, packageSource, enableTailwind, vertical, updatedVerticals } = prepareAddUltramodernVertical(options);
-    writeApp(options.workspaceRoot, scope, vertical, packageSource, enableTailwind);
+    const { scope, topologyPath, ownershipPath, overlayPath, topology, ownership, overlay, packageSource, enableTailwind, bridge, vertical, updatedVerticals } = prepareAddUltramodernVertical(options);
+    writeApp(options.workspaceRoot, scope, vertical, packageSource, enableTailwind, updatedVerticals, bridge);
     topology.shell ??= {};
     topology.shell.verticalRefs ??= [];
     topology.shell.verticalRefs.push(vertical.id);
@@ -493,18 +511,18 @@ function addUltramodernVertical(options) {
     writeJsonFile(topologyPath, topology);
     writeJsonFile(ownershipPath, ownership);
     writeJsonFile(overlayPath, overlay);
-    writeJsonFile(node_path.join(options.workspaceRoot, GENERATED_CONTRACT_PATH), createGeneratedContract(scope, [
+    writeJsonFile(node_path.join(options.workspaceRoot, ULTRAMODERN_CONFIG_PATH), createCompactUltramodernConfig(scope, options.modernVersion, packageSource, [
         {
             ...shellApp,
             verticalRefs: updatedVerticals.map((vertical)=>vertical.id)
         },
         ...updatedVerticals
-    ], enableTailwind));
-    rewriteShellAppFiles(options.workspaceRoot, scope, packageSource, enableTailwind, updatedVerticals);
+    ], enableTailwind, bridge));
+    rewriteShellAppFiles(options.workspaceRoot, scope, packageSource, enableTailwind, updatedVerticals, bridge);
     writeGeneratedWorkspaceScripts(options.workspaceRoot, scope, enableTailwind, updatedVerticals);
     addShellZephyrDependency(options.workspaceRoot, scope, vertical);
     addShellWorkspaceDependency(options.workspaceRoot, scope, vertical);
-    updateRootWorkspaceScripts(options.workspaceRoot, scope, packageSource, updatedVerticals);
+    updateRootWorkspaceScripts(options.workspaceRoot, scope, packageSource, updatedVerticals, bridge);
     writeJsonFile(node_path.join(options.workspaceRoot, 'tsconfig.json'), createRootTsConfig([
         {
             ...shellApp,
@@ -512,9 +530,9 @@ function addUltramodernVertical(options) {
         },
         ...updatedVerticals
     ]));
-    const afterFiles = createFileSnapshot(options.workspaceRoot);
-    const { createdPaths, rewrittenPaths } = diffFileSnapshots(beforeFiles, afterFiles);
-    const result = createGenerationResult({
+    const preliminaryAfterFiles = createFileSnapshot(options.workspaceRoot);
+    const preliminaryDiff = diffFileSnapshots(beforeFiles, preliminaryAfterFiles);
+    const preliminaryResult = createGenerationResult({
         operation: 'vertical',
         workspaceRoot: options.workspaceRoot,
         packageScope: scope,
@@ -522,14 +540,32 @@ function addUltramodernVertical(options) {
         createdApps: [
             vertical
         ],
-        createdPaths,
-        rewrittenPaths
+        createdPaths: preliminaryDiff.createdPaths,
+        rewrittenPaths: preliminaryDiff.rewrittenPaths
     });
     runCodeSmithOverlays({
         workspaceRoot: options.workspaceRoot,
         overlays: options.overlays,
-        result
+        result: preliminaryResult
+    });
+    const afterOverlaysFiles = createFileSnapshot(options.workspaceRoot);
+    const changedPaths = diffFileSnapshots(beforeFiles, afterOverlaysFiles);
+    formatGeneratedWorkspaceFiles(options.workspaceRoot, [
+        ...changedPaths.createdPaths,
+        ...changedPaths.rewrittenPaths
+    ]);
+    const afterFiles = createFileSnapshot(options.workspaceRoot);
+    const { createdPaths, rewrittenPaths } = diffFileSnapshots(beforeFiles, afterFiles);
+    return createGenerationResult({
+        operation: 'vertical',
+        workspaceRoot: options.workspaceRoot,
+        packageScope: scope,
+        packageSource,
+        createdApps: [
+            vertical
+        ],
+        createdPaths,
+        rewrittenPaths
     });
-    return result;
 }
-export { addShellWorkspaceDependency, addShellZephyrDependency, addUltramodernVertical, assertCanCreate, assertValidVerticalName, existingPackageSource, existingTailwindEnabled, nextAvailablePort, ownershipEntry, planUltramodernVertical, prepareAddUltramodernVertical, rewriteShellAppFiles, updateRootWorkspaceScripts, verticalTopologyEntry, verticalsFromTopology };
+export { addShellWorkspaceDependency, addShellZephyrDependency, addUltramodernVertical, assertCanCreate, assertValidVerticalName, existingBridgeConfig, existingPackageSource, existingTailwindEnabled, nextAvailablePort, ownershipEntry, planUltramodernVertical, prepareAddUltramodernVertical, rewriteShellAppFiles, updateRootWorkspaceScripts, verticalTopologyEntry, verticalsFromTopology };