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

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

@@ -0,0 +1,197 @@
+import "node:module";
+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-node/ultramodern-workspace/add-vertical.js

@@ -3,10 +3,10 @@ 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 { createFileSnapshot, createGenerationResult, diffFileSnapshots } from "./generation-result.js";
@@ -20,7 +20,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';
@@ -33,7 +33,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),
@@ -56,6 +61,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);
@@ -63,6 +70,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.`);
@@ -75,17 +86,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));
@@ -204,8 +215,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);
@@ -216,6 +226,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);
@@ -243,6 +254,7 @@ function prepareAddUltramodernVertical(options) {
         overlay,
         packageSource,
         enableTailwind,
+        bridge,
         vertical,
         updatedVerticals
     };
@@ -253,6 +265,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`);
 }
@@ -357,7 +375,7 @@ function createVerticalPlan(preflight, result) {
         shellDependencyChanges: createShellDependencyChanges(scope, vertical),
         generatedContractChanges: [
             {
-                path: GENERATED_CONTRACT_PATH,
+                path: ULTRAMODERN_CONFIG_PATH,
                 addedAppIds: [
                     vertical.id
                 ],
@@ -444,9 +462,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}`
         }
     ];
 }
@@ -470,8 +488,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);
@@ -494,18 +512,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,
@@ -533,4 +551,4 @@ function addUltramodernVertical(options) {
     });
     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 };

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

@@ -0,0 +1,271 @@
+import "node:module";
+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 };

package/dist/esm-node/ultramodern-workspace/codesmith.js

@@ -15,6 +15,7 @@ async function ultramodernCodeSmithAdapter(context, runtime) {
         packageName: name,
         modernVersion,
         enableTailwind,
+        bridge: config.bridge,
         overlays: config.overlays,
         packageSource
     }) : runVerticalMode({