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

package/dist/cjs/ultramodern-workspace/add-vertical.cjs

@@ -42,6 +42,7 @@ __webpack_require__.d(__webpack_exports__, {
     addUltramodernVertical: ()=>addUltramodernVertical,
     assertCanCreate: ()=>assertCanCreate,
     assertValidVerticalName: ()=>assertValidVerticalName,
+    existingBridgeConfig: ()=>existingBridgeConfig,
     existingPackageSource: ()=>existingPackageSource,
     existingTailwindEnabled: ()=>existingTailwindEnabled,
     nextAvailablePort: ()=>nextAvailablePort,
@@ -60,8 +61,8 @@ var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_ultramodern_package_source_cjs_namespaceObject = require("../ultramodern-package-source.cjs");
+const config_cjs_namespaceObject = require("../ultramodern-tooling/config.cjs");
 const external_app_files_cjs_namespaceObject = require("./app-files.cjs");
-const external_contracts_cjs_namespaceObject = require("./contracts.cjs");
 const external_demo_components_cjs_namespaceObject = require("./demo-components.cjs");
 const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
 const external_effect_api_cjs_namespaceObject = require("./effect-api.cjs");
@@ -90,7 +91,12 @@ function existingPackageSource(workspaceRoot, modernVersion, packageSource) {
         modernVersion,
         packageSource
     });
-    const metadataPath = external_node_path_default().join(workspaceRoot, '.modernjs/ultramodern-package-source.json');
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (external_node_fs_default().existsSync(compactPath)) {
+        const compactConfig = (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot);
+        if (compactConfig.packageSource) return compactConfig.packageSource;
+    }
+    const metadataPath = external_node_path_default().join(workspaceRoot, PACKAGE_SOURCE_METADATA_PATH);
     if (!external_node_fs_default().existsSync(metadataPath)) return (0, external_package_source_cjs_namespaceObject.resolvePackageSource)({
         targetDir: workspaceRoot,
         packageName: external_node_path_default().basename(workspaceRoot),
@@ -113,6 +119,8 @@ function existingPackageSource(workspaceRoot, modernVersion, packageSource) {
     };
 }
 function existingTailwindEnabled(workspaceRoot) {
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (external_node_fs_default().existsSync(compactPath)) return (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot).features.tailwind;
     const contractPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.GENERATED_CONTRACT_PATH);
     if (!external_node_fs_default().existsSync(contractPath)) return true;
     const contract = (0, external_fs_io_cjs_namespaceObject.readJsonFile)(contractPath);
@@ -120,6 +128,10 @@ function existingTailwindEnabled(workspaceRoot) {
     const shell = apps.find((app)=>(0, external_types_cjs_namespaceObject.isRecord)(app) && app.id === external_descriptors_cjs_namespaceObject.shellApp.id);
     return shell?.styling && (0, external_types_cjs_namespaceObject.isRecord)(shell.styling) ? false !== shell.styling.tailwind : true;
 }
+function existingBridgeConfig(workspaceRoot) {
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    return external_node_fs_default().existsSync(compactPath) ? (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot).bridge : void 0;
+}
 function assertValidVerticalName(name) {
     const normalized = (0, external_naming_cjs_namespaceObject.toKebabCase)(name);
     if (!normalized || normalized !== name) throw new Error(`Invalid Vertical name "${name}". Use lowercase kebab-case.`);
@@ -132,17 +144,17 @@ function nextAvailablePort(ports) {
 function assertCanCreate(workspaceRoot, relativePath) {
     if (external_node_fs_default().existsSync(external_node_path_default().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 = external_node_path_default().join(workspaceRoot, 'package.json');
     const rootPackage = (0, external_fs_io_cjs_namespaceObject.readJsonFile)(packagePath);
-    const generatedRootPackage = (0, external_package_json_cjs_namespaceObject.createRootPackageJson)(scope, packageSource, remotes);
+    const generatedRootPackage = (0, external_package_json_cjs_namespaceObject.createRootPackageJson)(scope, packageSource, remotes, bridge);
     rootPackage.scripts = generatedRootPackage.scripts;
     (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(packagePath, rootPackage);
 }
-function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwind, remotes) {
+function rewriteShellAppFiles(workspaceRoot, scope, packageSource, enableTailwind, remotes, bridge) {
     const shellHost = (0, external_descriptors_cjs_namespaceObject.createShellHost)(remotes);
     const publicWeb = (0, external_public_surface_cjs_namespaceObject.createPublicWebAppArtifacts)(shellHost);
-    (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(external_node_path_default().join(workspaceRoot, `${external_descriptors_cjs_namespaceObject.shellApp.directory}/package.json`), (0, external_package_json_cjs_namespaceObject.createAppPackage)(scope, shellHost, packageSource, enableTailwind, remotes));
+    (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(external_node_path_default().join(workspaceRoot, `${external_descriptors_cjs_namespaceObject.shellApp.directory}/package.json`), (0, external_package_json_cjs_namespaceObject.createAppPackage)(scope, shellHost, packageSource, enableTailwind, remotes, bridge));
     (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(external_node_path_default().join(workspaceRoot, `${external_descriptors_cjs_namespaceObject.shellApp.directory}/tsconfig.json`), (0, external_package_json_cjs_namespaceObject.createAppTsConfig)(shellHost, remotes));
     (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(external_node_path_default().join(workspaceRoot, `${external_descriptors_cjs_namespaceObject.shellApp.directory}/tsconfig.mf-types.json`), (0, external_package_json_cjs_namespaceObject.createAppMfTypesTsConfig)(shellHost));
     (0, external_fs_io_cjs_namespaceObject.writeFileReplacing)(workspaceRoot, `${external_descriptors_cjs_namespaceObject.shellApp.directory}/src/modern-app-env.d.ts`, (0, external_app_files_cjs_namespaceObject.createAppEnvDts)(shellHost, remotes));
@@ -261,8 +273,7 @@ function prepareAddUltramodernVertical(options) {
     const topology = readRequiredJsonObject(topologyPath);
     const ownership = readRequiredJsonObject(ownershipPath);
     const overlay = readRequiredJsonObject(overlayPath);
-    readRequiredJsonObject(external_node_path_default().join(options.workspaceRoot, external_descriptors_cjs_namespaceObject.GENERATED_CONTRACT_PATH));
-    readRequiredJsonObject(external_node_path_default().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);
@@ -273,6 +284,7 @@ function prepareAddUltramodernVertical(options) {
     const scope = (0, external_naming_cjs_namespaceObject.toPackageScope)(String(rootPackage.name ?? external_node_path_default().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 = (0, external_descriptors_cjs_namespaceObject.createVerticalDescriptor)(name, port);
@@ -300,6 +312,7 @@ function prepareAddUltramodernVertical(options) {
         overlay,
         packageSource,
         enableTailwind,
+        bridge,
         vertical,
         updatedVerticals
     };
@@ -310,6 +323,12 @@ function readRequiredJsonObject(filePath) {
     if (!(0, external_types_cjs_namespaceObject.isRecord)(value)) throw new Error(`UltraModern workspace file must contain a JSON object: ${filePath}`);
     return value;
 }
+function readRequiredWorkspaceConfig(workspaceRoot) {
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (external_node_fs_default().existsSync(compactPath)) return void readRequiredJsonObject(compactPath);
+    readRequiredJsonObject(external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.GENERATED_CONTRACT_PATH));
+    readRequiredJsonObject(external_node_path_default().join(workspaceRoot, PACKAGE_SOURCE_METADATA_PATH));
+}
 function assertOptionalJsonObject(value, label, filePath) {
     if (void 0 !== value && !(0, external_types_cjs_namespaceObject.isRecord)(value)) throw new Error(`${label} in ${filePath} must be a JSON object`);
 }
@@ -414,7 +433,7 @@ function createVerticalPlan(preflight, result) {
         shellDependencyChanges: createShellDependencyChanges(scope, vertical),
         generatedContractChanges: [
             {
-                path: external_descriptors_cjs_namespaceObject.GENERATED_CONTRACT_PATH,
+                path: external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH,
                 addedAppIds: [
                     vertical.id
                 ],
@@ -501,9 +520,9 @@ function createDryRunJsonMutations(preflight, manifestUrl) {
             description: 'Keep shell Module Federation DTS compilation scoped'
         },
         {
-            path: external_descriptors_cjs_namespaceObject.GENERATED_CONTRACT_PATH,
-            pointer: '/apps',
-            description: `Regenerate contract with ${vertical.id}`
+            path: external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH,
+            pointer: '/topology/apps',
+            description: `Regenerate compact config with ${vertical.id}`
         }
     ];
 }
@@ -527,8 +546,8 @@ function createShellDependencyChanges(scope, vertical) {
 }
 function addUltramodernVertical(options) {
     const beforeFiles = (0, external_generation_result_cjs_namespaceObject.createFileSnapshot)(options.workspaceRoot);
-    const { scope, topologyPath, ownershipPath, overlayPath, topology, ownership, overlay, packageSource, enableTailwind, vertical, updatedVerticals } = prepareAddUltramodernVertical(options);
-    (0, external_write_workspace_cjs_namespaceObject.writeApp)(options.workspaceRoot, scope, vertical, packageSource, enableTailwind);
+    const { scope, topologyPath, ownershipPath, overlayPath, topology, ownership, overlay, packageSource, enableTailwind, bridge, vertical, updatedVerticals } = prepareAddUltramodernVertical(options);
+    (0, external_write_workspace_cjs_namespaceObject.writeApp)(options.workspaceRoot, scope, vertical, packageSource, enableTailwind, updatedVerticals, bridge);
     topology.shell ??= {};
     topology.shell.verticalRefs ??= [];
     topology.shell.verticalRefs.push(vertical.id);
@@ -551,18 +570,18 @@ function addUltramodernVertical(options) {
     (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(topologyPath, topology);
     (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(ownershipPath, ownership);
     (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(overlayPath, overlay);
-    (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(external_node_path_default().join(options.workspaceRoot, external_descriptors_cjs_namespaceObject.GENERATED_CONTRACT_PATH), (0, external_contracts_cjs_namespaceObject.createGeneratedContract)(scope, [
+    (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(external_node_path_default().join(options.workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH), (0, external_write_workspace_cjs_namespaceObject.createCompactUltramodernConfig)(scope, options.modernVersion, packageSource, [
         {
             ...external_descriptors_cjs_namespaceObject.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);
     (0, external_workspace_scripts_cjs_namespaceObject.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);
     (0, external_fs_io_cjs_namespaceObject.writeJsonFile)(external_node_path_default().join(options.workspaceRoot, 'tsconfig.json'), (0, external_package_json_cjs_namespaceObject.createRootTsConfig)([
         {
             ...external_descriptors_cjs_namespaceObject.shellApp,
@@ -595,6 +614,7 @@ exports.addShellZephyrDependency = __webpack_exports__.addShellZephyrDependency;
 exports.addUltramodernVertical = __webpack_exports__.addUltramodernVertical;
 exports.assertCanCreate = __webpack_exports__.assertCanCreate;
 exports.assertValidVerticalName = __webpack_exports__.assertValidVerticalName;
+exports.existingBridgeConfig = __webpack_exports__.existingBridgeConfig;
 exports.existingPackageSource = __webpack_exports__.existingPackageSource;
 exports.existingTailwindEnabled = __webpack_exports__.existingTailwindEnabled;
 exports.nextAvailablePort = __webpack_exports__.nextAvailablePort;
@@ -611,6 +631,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "addUltramodernVertical",
     "assertCanCreate",
     "assertValidVerticalName",
+    "existingBridgeConfig",
     "existingPackageSource",
     "existingTailwindEnabled",
     "nextAvailablePort",

package/dist/cjs/ultramodern-workspace/bridge-config.cjs

@@ -0,0 +1,327 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+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
+    ];
+}
+__webpack_require__.d(__webpack_exports__, {
+    hasUltramodernBridgeCliOptions: ()=>hasUltramodernBridgeCliOptions,
+    normalizeUltramodernBridgeConfig: ()=>normalizeUltramodernBridgeConfig,
+    parseUltramodernBridgeCliOptions: ()=>parseUltramodernBridgeCliOptions
+}, {
+    ultramodernBridgeCliBooleanFlags: ultramodernBridgeCliBooleanFlags,
+    ultramodernBridgeCliFlags: ultramodernBridgeCliFlags,
+    ultramodernBridgeCliValueFlags: ultramodernBridgeCliValueFlags,
+    ultramodernBridgeLockfilePolicies: ultramodernBridgeLockfilePolicies
+});
+exports.hasUltramodernBridgeCliOptions = __webpack_exports__.hasUltramodernBridgeCliOptions;
+exports.normalizeUltramodernBridgeConfig = __webpack_exports__.normalizeUltramodernBridgeConfig;
+exports.parseUltramodernBridgeCliOptions = __webpack_exports__.parseUltramodernBridgeCliOptions;
+exports.ultramodernBridgeCliBooleanFlags = __webpack_exports__.ultramodernBridgeCliBooleanFlags;
+exports.ultramodernBridgeCliFlags = __webpack_exports__.ultramodernBridgeCliFlags;
+exports.ultramodernBridgeCliValueFlags = __webpack_exports__.ultramodernBridgeCliValueFlags;
+exports.ultramodernBridgeLockfilePolicies = __webpack_exports__.ultramodernBridgeLockfilePolicies;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "hasUltramodernBridgeCliOptions",
+    "normalizeUltramodernBridgeConfig",
+    "parseUltramodernBridgeCliOptions",
+    "ultramodernBridgeCliBooleanFlags",
+    "ultramodernBridgeCliFlags",
+    "ultramodernBridgeCliValueFlags",
+    "ultramodernBridgeLockfilePolicies"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/codesmith.cjs

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