@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

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

@@ -0,0 +1,93 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    normalizeBridgeGates: ()=>normalizeBridgeGates,
+    readBridgeGates: ()=>readBridgeGates
+});
+const external_schema_cjs_namespaceObject = require("./schema.cjs");
+const external_shared_cjs_namespaceObject = require("./shared.cjs");
+function readBridgeGates(args) {
+    const gates = new Map();
+    const getGate = (name)=>{
+        const normalizedName = (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(name, `${external_schema_cjs_namespaceObject.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 (0, external_shared_cjs_namespaceObject.readRepeatedOptionValues)(args, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.gate)){
+        const { left: name, right: command } = (0, external_shared_cjs_namespaceObject.splitAssignment)(value, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.gate, '<name>=<command>');
+        getGate(name).command = (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(command, `${external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.gate} command`);
+    }
+    for (const value of (0, external_shared_cjs_namespaceObject.readRepeatedOptionValues)(args, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.gateCwd)){
+        const { left: name, right: cwd } = (0, external_shared_cjs_namespaceObject.splitAssignment)(value, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.gateCwd, '<name>=<cwd>');
+        getGate(name).cwd = (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(cwd, `${external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.gateCwd} cwd`);
+    }
+    const missingCommand = [
+        ...gates.values()
+    ].find((gate)=>!gate.command);
+    if (missingCommand) throw new Error(`${external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.gateCwd} references "${missingCommand.name}" without a matching ${external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.gate}.`);
+    return normalizeBridgeGates([
+        ...gates.values()
+    ].map((gate)=>({
+            name: gate.name,
+            command: gate.command,
+            cwd: gate.cwd
+        })));
+}
+function normalizeBridgeGates(gates) {
+    const normalized = new Map();
+    for (const [index, gate] of gates.entries()){
+        const label = `bridge.gates[${index}]`;
+        const name = (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(gate.name, `${label}.name`);
+        normalized.set(name, {
+            name,
+            command: (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(gate.command, `${label}.command`),
+            ...gate.cwd ? {
+                cwd: (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(gate.cwd, `${label}.cwd`)
+            } : {}
+        });
+    }
+    return [
+        ...normalized.values()
+    ];
+}
+exports.normalizeBridgeGates = __webpack_exports__.normalizeBridgeGates;
+exports.readBridgeGates = __webpack_exports__.readBridgeGates;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeBridgeGates",
+    "readBridgeGates"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,60 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    hasUltramodernBridgeCliOptions: ()=>external_cli_cjs_namespaceObject.hasUltramodernBridgeCliOptions,
+    normalizeUltramodernBridgeConfig: ()=>external_normalize_cjs_namespaceObject.normalizeUltramodernBridgeConfig,
+    parseUltramodernBridgeCliOptions: ()=>external_cli_cjs_namespaceObject.parseUltramodernBridgeCliOptions,
+    ultramodernBridgeCliBooleanFlags: ()=>external_schema_cjs_namespaceObject.ultramodernBridgeCliBooleanFlags,
+    ultramodernBridgeCliFlags: ()=>external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags,
+    ultramodernBridgeCliValueFlags: ()=>external_schema_cjs_namespaceObject.ultramodernBridgeCliValueFlags,
+    ultramodernBridgeLockfilePolicies: ()=>external_schema_cjs_namespaceObject.ultramodernBridgeLockfilePolicies
+});
+const external_cli_cjs_namespaceObject = require("./cli.cjs");
+const external_normalize_cjs_namespaceObject = require("./normalize.cjs");
+const external_schema_cjs_namespaceObject = require("./schema.cjs");
+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/bridge-config/normalize.cjs

@@ -0,0 +1,68 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    normalizeUltramodernBridgeConfig: ()=>normalizeUltramodernBridgeConfig
+});
+const external_defaults_cjs_namespaceObject = require("./defaults.cjs");
+const external_gates_cjs_namespaceObject = require("./gates.cjs");
+const external_shared_cjs_namespaceObject = require("./shared.cjs");
+const external_validation_cjs_namespaceObject = require("./validation.cjs");
+const external_workspace_packages_cjs_namespaceObject = require("./workspace-packages.cjs");
+function normalizeUltramodernBridgeConfig(bridge) {
+    if (!bridge || false === bridge.enabled) return;
+    const parentRoot = (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(bridge.parentRoot, 'bridge.parentRoot');
+    const workspacePackages = (0, external_workspace_packages_cjs_namespaceObject.normalizeWorkspacePackages)(bridge.workspacePackages);
+    const dependencies = (0, external_shared_cjs_namespaceObject.uniqueNonEmptyValues)(bridge.dependencies, 'bridge.dependencies');
+    const gates = (0, external_gates_cjs_namespaceObject.normalizeBridgeGates)(bridge.gates);
+    const reactSingletons = bridge.reactSingletons && bridge.reactSingletons.length > 0 ? (0, external_shared_cjs_namespaceObject.uniqueNonEmptyValues)(bridge.reactSingletons, 'bridge.reactSingletons') : [
+        ...external_defaults_cjs_namespaceObject.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.');
+    (0, external_validation_cjs_namespaceObject.validateParentPackageCoverage)(workspacePackages, dependencies);
+    (0, external_validation_cjs_namespaceObject.validateReactSingletons)(reactSingletons);
+    return {
+        enabled: true,
+        parentRoot,
+        workspacePackages,
+        dependencies,
+        lockfilePolicy: (0, external_shared_cjs_namespaceObject.parseLockfilePolicy)(bridge.lockfilePolicy ?? 'nested'),
+        gates,
+        reactSingletons
+    };
+}
+exports.normalizeUltramodernBridgeConfig = __webpack_exports__.normalizeUltramodernBridgeConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeUltramodernBridgeConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,78 @@
+"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'
+];
+__webpack_require__.d(__webpack_exports__, {}, {
+    ultramodernBridgeCliBooleanFlags: ultramodernBridgeCliBooleanFlags,
+    ultramodernBridgeCliFlags: ultramodernBridgeCliFlags,
+    ultramodernBridgeCliValueFlags: ultramodernBridgeCliValueFlags,
+    ultramodernBridgeLockfilePolicies: ultramodernBridgeLockfilePolicies
+});
+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 === [
+    "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/bridge-config/shared.cjs

@@ -0,0 +1,110 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    parseLockfilePolicy: ()=>parseLockfilePolicy,
+    readCsvOptionValues: ()=>readCsvOptionValues,
+    readRepeatedOptionValues: ()=>readRepeatedOptionValues,
+    readSingleValue: ()=>readSingleValue,
+    rejectBooleanFlagValues: ()=>rejectBooleanFlagValues,
+    requireNonEmptyValue: ()=>requireNonEmptyValue,
+    splitAssignment: ()=>splitAssignment,
+    uniqueNonEmptyValues: ()=>uniqueNonEmptyValues
+});
+const external_schema_cjs_namespaceObject = require("./schema.cjs");
+function rejectBooleanFlagValues(args) {
+    for (const flag of external_schema_cjs_namespaceObject.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 (!external_schema_cjs_namespaceObject.ultramodernBridgeLockfilePolicies.includes(value)) throw new Error(`${external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.lockfilePolicy} must be "nested" or "parent".`);
+    return value;
+}
+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 uniqueNonEmptyValues(values, label) {
+    const unique = new Set();
+    for (const [index, value] of values.entries())unique.add(requireNonEmptyValue(value, `${label}[${index}]`));
+    return [
+        ...unique
+    ];
+}
+exports.parseLockfilePolicy = __webpack_exports__.parseLockfilePolicy;
+exports.readCsvOptionValues = __webpack_exports__.readCsvOptionValues;
+exports.readRepeatedOptionValues = __webpack_exports__.readRepeatedOptionValues;
+exports.readSingleValue = __webpack_exports__.readSingleValue;
+exports.rejectBooleanFlagValues = __webpack_exports__.rejectBooleanFlagValues;
+exports.requireNonEmptyValue = __webpack_exports__.requireNonEmptyValue;
+exports.splitAssignment = __webpack_exports__.splitAssignment;
+exports.uniqueNonEmptyValues = __webpack_exports__.uniqueNonEmptyValues;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseLockfilePolicy",
+    "readCsvOptionValues",
+    "readRepeatedOptionValues",
+    "readSingleValue",
+    "rejectBooleanFlagValues",
+    "requireNonEmptyValue",
+    "splitAssignment",
+    "uniqueNonEmptyValues"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,68 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    validateParentPackageCoverage: ()=>validateParentPackageCoverage,
+    validateReactSingletons: ()=>validateReactSingletons
+});
+const external_defaults_cjs_namespaceObject = require("./defaults.cjs");
+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 = external_defaults_cjs_namespaceObject.defaultReactSingletons.filter((packageName)=>!reactSingletons.includes(packageName));
+    if (missing.length > 0) throw new Error(`Bridge mode React singleton/dedupe declarations must include ${external_defaults_cjs_namespaceObject.defaultReactSingletons.join(' and ')}. Missing: ${missing.join(', ')}.`);
+}
+exports.validateParentPackageCoverage = __webpack_exports__.validateParentPackageCoverage;
+exports.validateReactSingletons = __webpack_exports__.validateReactSingletons;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "validateParentPackageCoverage",
+    "validateReactSingletons"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,108 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    normalizeWorkspacePackages: ()=>normalizeWorkspacePackages,
+    readWorkspacePackages: ()=>readWorkspacePackages
+});
+const external_schema_cjs_namespaceObject = require("./schema.cjs");
+const external_shared_cjs_namespaceObject = require("./shared.cjs");
+function readWorkspacePackages(args) {
+    const drafts = new Map();
+    const getDraft = (pattern)=>{
+        const normalizedPattern = (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(pattern, external_schema_cjs_namespaceObject.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 (0, external_shared_cjs_namespaceObject.readRepeatedOptionValues)(args, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.workspacePackage))getDraft(pattern);
+    for (const value of (0, external_shared_cjs_namespaceObject.readRepeatedOptionValues)(args, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.workspacePackageName)){
+        const { left: pattern, right: packageNames } = (0, external_shared_cjs_namespaceObject.splitAssignment)(value, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.workspacePackageName, '<pattern>=<package-name>[,<package-name>]');
+        getDraft(pattern).packageNames.push(...packageNames.split(',').map((packageName)=>packageName.trim()).filter(Boolean));
+    }
+    for (const value of (0, external_shared_cjs_namespaceObject.readRepeatedOptionValues)(args, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.testAlias)){
+        const separator = value.indexOf(':');
+        if (-1 === separator) throw new Error(`${external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.testAlias} must use <pattern>:<alias>=<target>.`);
+        const pattern = value.slice(0, separator);
+        const aliasDefinition = value.slice(separator + 1);
+        const { left: alias, right: target } = (0, external_shared_cjs_namespaceObject.splitAssignment)(aliasDefinition, external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.testAlias, '<pattern>:<alias>=<target>');
+        getDraft(pattern).testAliases.push({
+            alias: (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(alias, `${external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.testAlias} alias`),
+            target: (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(target, `${external_schema_cjs_namespaceObject.ultramodernBridgeCliFlags.testAlias} target`)
+        });
+    }
+    return normalizeWorkspacePackages([
+        ...drafts.values()
+    ]);
+}
+function normalizeWorkspacePackages(workspacePackages) {
+    return workspacePackages.map((entry, index)=>{
+        const label = `bridge.workspacePackages[${index}]`;
+        const packageNames = entry.packageNames && entry.packageNames.length > 0 ? (0, external_shared_cjs_namespaceObject.uniqueNonEmptyValues)(entry.packageNames, `${label}.packageNames`) : void 0;
+        const testAliases = entry.testAliases && entry.testAliases.length > 0 ? normalizeTestAliases(entry.testAliases, label) : void 0;
+        return {
+            pattern: (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(entry.pattern, `${label}.pattern`),
+            ...packageNames ? {
+                packageNames
+            } : {},
+            ...testAliases ? {
+                testAliases
+            } : {}
+        };
+    });
+}
+function normalizeTestAliases(testAliases, parentLabel) {
+    const aliases = new Map();
+    for (const [index, alias] of testAliases.entries()){
+        const label = `${parentLabel}.testAliases[${index}]`;
+        const normalizedAlias = (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(alias.alias, `${label}.alias`);
+        aliases.set(normalizedAlias, {
+            alias: normalizedAlias,
+            target: (0, external_shared_cjs_namespaceObject.requireNonEmptyValue)(alias.target, `${label}.target`)
+        });
+    }
+    return [
+        ...aliases.values()
+    ];
+}
+exports.normalizeWorkspacePackages = __webpack_exports__.normalizeWorkspacePackages;
+exports.readWorkspacePackages = __webpack_exports__.readWorkspacePackages;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeWorkspacePackages",
+    "readWorkspacePackages"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_modules__ = {
+    "./bridge-config/index" (module) {
+        module.exports = require("./bridge-config/index.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+    var _bridge_config_index__rspack_import_0 = __webpack_require__("./bridge-config/index");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _bridge_config_index__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_bridge_config_index__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});