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

package/dist/esm-node/ultramodern-workspace/app-files.js

@@ -0,0 +1,151 @@
+import "node:module";
+import { appEmitsBrowserUi, appI18nNamespace, remoteDependencyAlias, resolveRemoteRefs } from "./descriptors.js";
+import { readFileTemplate, renderFileTemplate } from "./fs-io.js";
+import { packageName, tailwindPrefixForApp } from "./naming.js";
+function createBoundaryDebugMetadata(scope, shell, remotes = []) {
+    return {
+        appId: shell.id,
+        boundaries: [
+            shell,
+            ...remotes
+        ].map((app)=>({
+                appId: app.id,
+                label: app.displayName,
+                mfName: app.mfName,
+                ownerTeam: app.ownership.team,
+                packageName: packageName(scope, app.packageSuffix),
+                role: 'shell' === app.kind ? 'host' : 'vertical'
+            })),
+        schemaVersion: 1
+    };
+}
+function createAppEnvDts(app, remotes, scope) {
+    const remoteModuleDeclarations = resolveRemoteRefs(app, remotes).flatMap((remote)=>Object.keys(remote.exposes ?? {}).filter((expose)=>'./Route' !== expose).map((expose)=>{
+            const moduleName = `${remoteDependencyAlias(remote)}/${expose.replace(/^\.\//u, '')}`;
+            const workspaceModuleName = `${packageName(scope, remote.packageSuffix)}/${expose.replace(/^\.\//u, '')}`;
+            return `declare module '${moduleName}' {
+  export { default } from '${workspaceModuleName}';
+}
+`;
+        })).join('\n');
+    return [
+        '/// <reference types="@modern-js/app-tools/types" />',
+        'declare const ULTRAMODERN_SITE_URL: string;',
+        remoteModuleDeclarations.trimEnd()
+    ].filter((section)=>section.length > 0).join('\n\n').concat('\n');
+}
+function createAppRuntimeConfig(app, scope, remotes = [], emitsUi = appEmitsBrowserUi(app)) {
+    const pluginsConfig = 'shell' === app.kind ? `  plugins: [
+    ultramodernBoundaryDebuggerPlugin({
+      metadata: ${JSON.stringify(createBoundaryDebugMetadata(scope, app, remotes), null, 6).split('\n').join('\n      ')},
+    }),
+  ],
+` : '';
+    const routeMetadataImport = emitsUi ? "import { ultramodernRouteNamespace } from './routes/ultramodern-route-metadata';\n" : '';
+    const routeNamespace = emitsUi ? 'ultramodernRouteNamespace' : "'api'";
+    return `import { defineRuntimeConfig } from '@modern-js/runtime';
+${'shell' === app.kind ? "import { ultramodernBoundaryDebuggerPlugin } from '@modern-js/runtime/boundary-debugger';\n" : ''}import type { I18nInstance } from '@modern-js/plugin-i18n/runtime';
+import { createInstance } from 'i18next';
+import csResource from '../locales/cs/${appI18nNamespace(app)}.json';
+import enResource from '../locales/en/${appI18nNamespace(app)}.json';
+${routeMetadataImport}
+
+type LocaleResource = string | { readonly [key: string]: LocaleResource };
+
+const flattenLocaleResource = (
+  resource: LocaleResource,
+  prefix = '',
+): Record<string, string> => {
+  if (typeof resource === 'string') {
+    return prefix.length > 0 ? { [prefix]: resource } : {};
+  }
+
+  return Object.fromEntries(
+    Object.entries(resource).flatMap(([key, value]) => {
+      const nextKey = prefix.length > 0 ? \`\${prefix}.\${key}\` : key;
+      return typeof value === 'string'
+        ? [[nextKey, value]]
+        : Object.entries(flattenLocaleResource(value, nextKey));
+    }),
+  );
+};
+
+const i18nInstance = createInstance();
+const resources = {
+  cs: { [${routeNamespace}]: flattenLocaleResource(csResource) },
+  en: { [${routeNamespace}]: flattenLocaleResource(enResource) },
+} as const;
+
+export default defineRuntimeConfig({
+  i18n: {
+    i18nInstance: i18nInstance as I18nInstance,
+    initOptions: {
+      defaultNS: ${routeNamespace},
+      fallbackLng: 'en',
+      interpolation: {
+        escapeValue: false,
+      },
+      ns: [${routeNamespace}, 'translation'],
+      resources,
+      supportedLngs: ['en', 'cs'],
+    },
+  },
+${pluginsConfig}
+  router: {
+    framework: 'tanstack',
+  },
+});
+`;
+}
+function createCssTokenImport(scope) {
+    return `@import '${packageName(scope, 'shared-design-tokens')}/tokens.css';\n`;
+}
+function createTailwindImport(prefix) {
+    return `@import 'tailwindcss' prefix(${prefix}) source(none);\n@source '..';\n`;
+}
+function createShellStyles(enableTailwind, scope, shell) {
+    return `${enableTailwind ? createTailwindImport(tailwindPrefixForApp(shell)) : ''}${createCssTokenImport(scope)}`;
+}
+function createRemoteStyles(enableTailwind, scope, app) {
+    return `${enableTailwind ? createTailwindImport(tailwindPrefixForApp(app)) : ''}${createCssTokenImport(scope)}`;
+}
+function createAppStyles(enableTailwind, scope, app) {
+    return 'shell' === app.kind ? createShellStyles(enableTailwind, scope, app) : createRemoteStyles(enableTailwind, scope, app);
+}
+function createTailwindConfig() {
+    return renderFileTemplate('workspace/tailwind.config.ts', {});
+}
+function createSharedDesignTokensCss() {
+    return renderFileTemplate('workspace/packages/shared-design-tokens/tokens.css', {});
+}
+function createRouteHeadModule(app) {
+    return renderFileTemplate('app/ultramodern-route-head.tsx', {
+        appDisplayNameJson: JSON.stringify(app.displayName)
+    });
+}
+function createShellFrameComponent(shell) {
+    const source = readFileTemplate('app/shell-frame.tsx');
+    const prefix = tailwindPrefixForApp(shell ?? {
+        kind: 'shell',
+        id: 'shell-super-app',
+        directory: 'apps/shell-super-app',
+        packageSuffix: 'shell-super-app',
+        displayName: 'Shell Super App',
+        portEnv: 'SHELL_SUPER_APP_PORT',
+        port: 3020,
+        mfName: 'shellSuperApp',
+        ownership: {
+            team: 'super-app-platform',
+            slack: '#super-app-platform',
+            pagerDuty: 'pd-super-app-platform',
+            runbookRef: 'runbooks/wave2/shell-super-app.md',
+            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#shell-super-app',
+            blastRadius: {
+                tier: 'tier-0-shell',
+                references: []
+            }
+        }
+    });
+    return 'shell' === prefix ? source : source.replace(/\bshell:/gu, `${prefix}:`);
+}
+export { createAppEnvDts, createAppRuntimeConfig, createAppStyles, createRouteHeadModule, createSharedDesignTokensCss, createShellFrameComponent, createTailwindConfig };

package/dist/esm-node/ultramodern-workspace/backend-federation.js

@@ -0,0 +1,291 @@
+import "node:module";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, formatBackendFederationValidationErrors, validateBackendFederationMetadata } from "@modern-js/utils/universal";
+import { verticalApiExport, verticalApiGroupName } from "./api.js";
+import { rpcPath, verticalRpcContractExport, verticalRpcGroupExport } from "./api/rpc.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
+import { appEmitsBrowserUi, appHasApi, createBackendFederationContainerEntry, createBackendFederationManifestEnv, createBackendFederationManifestUrl, createBackendFederationName, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createRemoteManifestEnv, resolveApiPrefix, resolveApiProtocol, resolveApiStem } from "./descriptors.js";
+import { packageName, toEnvSegment } from "./naming.js";
+import { EFFECT_VERSION, MODULE_FEDERATION_VERSION } from "./versions.js";
+function createZephyrEnv(app, suffix) {
+    return `ZEPHYR_${toEnvSegment(app.domain ?? app.id)}_${suffix}`;
+}
+function createWorkerBindingName(app) {
+    return `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_WORKER`;
+}
+function createWorkerBindingEnv(app) {
+    return `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_WORKER_BINDING`;
+}
+function createDispatchNamespaceEnv(app) {
+    return `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_DISPATCH_NAMESPACE`;
+}
+function createDispatchWorkerNameEnv(app) {
+    return `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_WORKER_NAME`;
+}
+function createEffectExpose(app) {
+    const apiStem = resolveApiStem(app);
+    if ('rpc' === resolveApiProtocol(app)) return {
+        contract: `${app.directory}/shared/rpc.ts`,
+        runtime: `${app.directory}/api/index.ts`,
+        client: `${app.directory}/src/api/${app.api.stem}-rpc-client.ts`,
+        rpc: rpcPath(app),
+        serialization: 'json'
+    };
+    return {
+        contract: `${app.directory}/shared/api.ts`,
+        runtime: `${app.directory}/api/index.ts`,
+        client: `${app.directory}/src/api/${app.api.stem}-client.ts`,
+        openapi: `${app.api.prefix}/openapi.json`,
+        readiness: `${app.api.prefix}/${apiStem}/readiness`
+    };
+}
+function createCloudflareExecutionSurface(scope, app) {
+    const workerRuntime = {
+        workerEntry: '.output/server/index.mjs',
+        workerManifest: '.output/server/modern-worker-manifest.json',
+        effectBffBundle: '.output/worker/__modern_bff_effect.js'
+    };
+    return {
+        kind: 'cloudflare-worker-snapshot',
+        workerName: createCloudflareWorkerName(scope, app),
+        publicUrlEnv: createCloudflarePublicUrlEnv(app),
+        ...appEmitsBrowserUi(app) ? {
+            ssr: {
+                ...workerRuntime,
+                routeManifest: '.output/server/route.json',
+                ssrBundle: '.output/worker/index.js',
+                assetsBinding: 'ASSETS'
+            }
+        } : {
+            api: workerRuntime
+        },
+        zephyr: {
+            runtime: appEmitsBrowserUi(app) ? 'ssr-worker' : 'api-worker',
+            integration: 'managed-cloudflare',
+            snapshotIdEnv: createZephyrEnv(app, 'SNAPSHOT_ID'),
+            versionIdEnv: createZephyrEnv(app, 'VERSION_ID'),
+            applicationUidEnv: createZephyrEnv(app, 'APPLICATION_UID')
+        },
+        workerDispatch: {
+            preferred: 'service-binding',
+            serviceBinding: createWorkerBindingName(app),
+            serviceBindingEnv: createWorkerBindingEnv(app),
+            dispatchNamespaceEnv: createDispatchNamespaceEnv(app),
+            dispatchWorkerNameEnv: createDispatchWorkerNameEnv(app),
+            requestInterface: 'fetch'
+        }
+    };
+}
+function createNodeExecutionSurface(app, deliveryUnit) {
+    return {
+        kind: 'node-mf-runtime',
+        adapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        remoteName: createBackendFederationName(app),
+        manifestEnv: createBackendFederationManifestEnv(app),
+        manifestUrl: createBackendFederationManifestUrl(app),
+        containerEntry: createBackendFederationContainerEntry(app),
+        remoteType: 'commonjs-module',
+        expose: BACKEND_FEDERATION_EFFECT_EXPOSE,
+        runtimePackage: '@modern-js/plugin-bff/effect',
+        ...deliveryUnit ? {
+            expected: {
+                unitId: deliveryUnit.unitId,
+                buildMarker: deliveryUnit.buildMarker
+            }
+        } : {}
+    };
+}
+function createServerExecutionOverlay(scope, app) {
+    if (!appHasApi(app)) return;
+    const deliveryUnit = createDeliveryUnitRecord(scope, app);
+    return {
+        apiBaseUrl: `http://localhost:${app.port}${'rpc' === resolveApiProtocol(app) ? rpcPath(app) : resolveApiPrefix(app)}`,
+        versionBoundary: 'web-and-api-same-build',
+        deliveryUnit: {
+            unitId: deliveryUnit.unitId,
+            buildMarker: deliveryUnit.buildMarker
+        },
+        cloudflare: createCloudflareExecutionSurface(scope, app),
+        node: createNodeExecutionSurface(app, deliveryUnit)
+    };
+}
+function createBackendFederationContract(scope, app) {
+    if (!appHasApi(app)) return;
+    const readiness = `${app.api.prefix}/${resolveApiStem(app)}/readiness`;
+    const rpc = 'rpc' === resolveApiProtocol(app);
+    const deliveryUnit = createDeliveryUnitRecord(scope, app);
+    const contract = {
+        role: 'microvertical-server',
+        name: createBackendFederationName(app),
+        runtimeFramework: 'effect',
+        strictEffectApproach: true,
+        deliveryUnit: deliveryUnitContractBlock(deliveryUnit),
+        exposes: {
+            [BACKEND_FEDERATION_EFFECT_EXPOSE]: createEffectExpose(app)
+        },
+        versionBoundary: {
+            invariant: 'web-and-api-same-build',
+            identityRoot: 'deliveryUnit',
+            packageName: packageName(scope, app.packageSuffix),
+            ...appEmitsBrowserUi(app) ? {
+                ui: {
+                    manifestEnv: createRemoteManifestEnv(app),
+                    manifestUrl: `http://localhost:${app.port}/mf-manifest.json`,
+                    buildMarker: `${app.directory}/src/routes/ultramodern-route-metadata.ts`
+                }
+            } : {},
+            api: {
+                ...rpc ? {
+                    rpc: rpcPath(app),
+                    serialization: 'json'
+                } : {
+                    readiness
+                },
+                buildMarker: `${app.directory}/shared/ultramodern-build.ts`,
+                publicUrlEnv: createCloudflarePublicUrlEnv(app)
+            }
+        },
+        executionSurfaces: {
+            cloudflare: createCloudflareExecutionSurface(scope, app),
+            node: createNodeExecutionSurface(app, deliveryUnit)
+        },
+        compatibility: {
+            contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+            packageName: packageName(scope, app.packageSuffix),
+            effectVersion: EFFECT_VERSION,
+            moduleFederationVersion: MODULE_FEDERATION_VERSION
+        },
+        cache: {
+            cloudflareSnapshot: 'immutable',
+            nodeManifest: 'no-store',
+            nodeVersionedContainer: 'immutable',
+            nodeUnpinnedContainer: 'revalidate'
+        },
+        fallback: {
+            timeoutMs: 1500,
+            failureEvent: 'modernjs:microvertical-server-fallback',
+            strategy: 'typed-effect-error'
+        }
+    };
+    const validation = validateBackendFederationMetadata(contract, {
+        path: `${app.id}.backendFederation`,
+        requireEffectExpose: true,
+        requireEffectRuntime: true,
+        requireVersionFields: true
+    });
+    if (!validation.ok) throw new Error(`Backend federation contract invalid for ${app.id}: ${formatBackendFederationValidationErrors(validation.errors)}.`);
+    return contract;
+}
+function createBackendFederationMetadata(scope, app) {
+    if (!appHasApi(app)) return;
+    const rpc = 'rpc' === resolveApiProtocol(app);
+    return {
+        contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+        deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app)),
+        executionSurfaces: [
+            'node-mf-runtime'
+        ],
+        exposes: [
+            BACKEND_FEDERATION_EFFECT_EXPOSE
+        ],
+        name: createBackendFederationName(app),
+        nodeAdapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        ...rpc ? {
+            rpcPath: rpcPath(app),
+            rpcSerialization: 'json'
+        } : {
+            openapiPath: `${app.api.prefix}/openapi.json`,
+            readinessPath: `${app.api.prefix}/${resolveApiStem(app)}/readiness`
+        },
+        role: 'microvertical-server',
+        runtimeFramework: 'effect',
+        strictEffectApproach: true
+    };
+}
+function createBackendFederationContractFile(app) {
+    if (!app.api) throw new Error(`App ${app.id} does not define an Effect API.`);
+    if ('rpc' === resolveApiProtocol(app)) {
+        const groupExport = verticalRpcGroupExport(app);
+        const contractExport = verticalRpcContractExport(app);
+        return `import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+
+export const backendFederationContract = {
+  compatibility: {
+    build: ultramodernApiMarker.build,
+    contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
+    nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
+    packageName: ultramodernApiMarker.packageName,
+    sourceRevision: ultramodernApiMarker.sourceRevision,
+    unitId: ultramodernApiMarker.unitId,
+  },
+  contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
+  executionSurfaces: ['node-mf-runtime'],
+  exposes: ['${BACKEND_FEDERATION_EFFECT_EXPOSE}'],
+  name: '${createBackendFederationName(app)}',
+  nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
+  rpcPath: '${rpcPath(app)}',
+  rpcSerialization: 'json',
+  role: 'microvertical-server',
+  runtimeFramework: 'effect',
+  strictEffectApproach: true,
+} as const;
+
+export { default, default as runtime } from './index.ts';
+export {
+  ${groupExport} as api,
+  ${contractExport} as contract,
+} from '../shared/rpc.ts';
+`;
+    }
+    const apiExport = verticalApiExport(app);
+    const groupName = verticalApiGroupName(app);
+    const readinessPath = `${app.api.prefix}/${resolveApiStem(app)}/readiness`;
+    return `import { ultramodernApiMarker } from '../shared/ultramodern-build.ts';
+
+export const backendFederationContract = {
+  compatibility: {
+    build: ultramodernApiMarker.build,
+    contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
+    nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
+    packageName: ultramodernApiMarker.packageName,
+    sourceRevision: ultramodernApiMarker.sourceRevision,
+    unitId: ultramodernApiMarker.unitId,
+  },
+  contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
+  executionSurfaces: ['node-mf-runtime'],
+  exposes: ['${BACKEND_FEDERATION_EFFECT_EXPOSE}'],
+  name: '${createBackendFederationName(app)}',
+  nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
+  openapiPath: '${app.api.prefix}/openapi.json',
+  readinessPath: '${readinessPath}',
+  role: 'microvertical-server',
+  runtimeFramework: 'effect',
+  strictEffectApproach: true,
+} as const;
+
+export { default, default as runtime } from './index.ts';
+export {
+  ${apiExport} as api,
+  ${groupName}ApiContract as contract,
+  ${groupName}OperationContexts as operationContexts,
+} from '../shared/api.ts';
+`;
+}
+function createBackendFederationSummary(scope, app) {
+    if (!appHasApi(app)) return;
+    const deliveryUnit = createDeliveryUnitRecord(scope, app);
+    return {
+        id: app.id,
+        path: app.directory,
+        role: 'microvertical-server',
+        name: createBackendFederationName(app),
+        runtimeFramework: 'effect',
+        strictEffectApproach: true,
+        contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+        deliveryUnit: deliveryUnitContractBlock(deliveryUnit),
+        executionSurfaces: {
+            cloudflare: createCloudflareExecutionSurface(scope, app),
+            node: createNodeExecutionSurface(app, deliveryUnit)
+        }
+    };
+}
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, createBackendFederationContract, createBackendFederationContractFile, createBackendFederationMetadata, createBackendFederationSummary, createDispatchWorkerNameEnv, createServerExecutionOverlay, createWorkerBindingEnv, createWorkerBindingName };

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

@@ -0,0 +1,31 @@
+import "node:module";
+import { readBridgeGates } from "./gates.js";
+import { normalizeUltramodernBridgeConfig } from "./normalize.js";
+import { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeCliValueFlags } from "./schema.js";
+import { parseLockfilePolicy, readCsvOptionValues, readSingleValue, rejectBooleanFlagValues, requireNonEmptyValue } from "./shared.js";
+import { readWorkspacePackages } from "./workspace-packages.js";
+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
+    });
+}
+export { hasUltramodernBridgeCliOptions, parseUltramodernBridgeCliOptions };

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

@@ -0,0 +1,7 @@
+import "node:module";
+const defaultReactSingletons = [
+    'react',
+    'react-dom',
+    'react-dom/client'
+];
+export { defaultReactSingletons };

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

@@ -0,0 +1,53 @@
+import "node:module";
+import { ultramodernBridgeCliFlags } from "./schema.js";
+import { readRepeatedOptionValues, requireNonEmptyValue, splitAssignment } from "./shared.js";
+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 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()
+    ];
+}
+export { normalizeBridgeGates, readBridgeGates };

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

@@ -0,0 +1,4 @@
+import "node:module";
+export { hasUltramodernBridgeCliOptions, parseUltramodernBridgeCliOptions } from "./cli.js";
+export { normalizeUltramodernBridgeConfig } from "./normalize.js";
+export { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeCliValueFlags, ultramodernBridgeLockfilePolicies } from "./schema.js";

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

@@ -0,0 +1,31 @@
+import "node:module";
+import { defaultReactSingletons } from "./defaults.js";
+import { normalizeBridgeGates } from "./gates.js";
+import { parseLockfilePolicy, requireNonEmptyValue, uniqueNonEmptyValues } from "./shared.js";
+import { validateParentPackageCoverage, validateReactSingletons } from "./validation.js";
+import { normalizeWorkspacePackages } from "./workspace-packages.js";
+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
+    };
+}
+export { normalizeUltramodernBridgeConfig };

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

@@ -0,0 +1,32 @@
+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'
+];
+export { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeCliValueFlags, ultramodernBridgeLockfilePolicies };

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

@@ -0,0 +1,52 @@
+import "node:module";
+import { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeLockfilePolicies } from "./schema.js";
+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 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
+    ];
+}
+export { parseLockfilePolicy, readCsvOptionValues, readRepeatedOptionValues, readSingleValue, rejectBooleanFlagValues, requireNonEmptyValue, splitAssignment, uniqueNonEmptyValues };