@bleedingdev/modern-js-create 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

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

@@ -1,5 +1,28 @@
 "use strict";
-var __webpack_require__ = {};
+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)=>{
@@ -26,302 +49,14 @@ var __webpack_require__ = {};
     };
 })();
 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];
+(()=>{
+    __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
 });

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

@@ -34,9 +34,12 @@ __webpack_require__.d(__webpack_exports__, {
     createUltramodernConfig: ()=>createUltramodernConfig
 });
 const external_api_cjs_namespaceObject = require("./api.cjs");
+const external_backend_federation_cjs_namespaceObject = require("./backend-federation.cjs");
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.cjs");
 const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
 const external_naming_cjs_namespaceObject = require("./naming.cjs");
 const external_policy_cjs_namespaceObject = require("./policy.cjs");
+const external_tooling_command_catalog_cjs_namespaceObject = require("./tooling-command-catalog.cjs");
 const external_versions_cjs_namespaceObject = require("./versions.cjs");
 function createTopology(scope, remotes = []) {
     const shellHost = (0, external_descriptors_cjs_namespaceObject.createShellHost)(remotes);
@@ -79,6 +82,12 @@ function createTopology(scope, remotes = []) {
                     fallbackTelemetryEvent: 'modernjs:mv-runtime-parity',
                     sharedContractVersion: 'mf-ssr-contract-v1'
                 },
+                ...(0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, vertical) ? {
+                    backendFederation: (0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, vertical)
+                } : {},
+                ...vertical.api ? {
+                    deliveryUnit: (0, external_delivery_unit_cjs_namespaceObject.deliveryUnitContractBlock)((0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, vertical))
+                } : {},
                 ...(0, external_api_cjs_namespaceObject.apiTopologyMetadata)(vertical) ? {
                     api: (0, external_api_cjs_namespaceObject.apiTopologyMetadata)(vertical)
                 } : {},
@@ -134,7 +143,7 @@ function createOwnership(scope, remotes = []) {
             }))
     };
 }
-function createDevelopmentOverlay(remotes = []) {
+function createDevelopmentOverlay(scope, remotes = []) {
     return {
         schemaVersion: 1,
         environment: 'development',
@@ -150,6 +159,10 @@ function createDevelopmentOverlay(remotes = []) {
                 remote.id,
                 `http://localhost:${remote.port}/mf-manifest.json`
             ])),
+        serverExecution: Object.fromEntries((0, external_descriptors_cjs_namespaceObject.verticalApiApps)(remotes).map((app)=>[
+                app.id,
+                (0, external_backend_federation_cjs_namespaceObject.createServerExecutionOverlay)(scope, app)
+            ])),
         apis: Object.fromEntries((0, external_descriptors_cjs_namespaceObject.verticalApiApps)(remotes).map((app)=>[
                 app.id,
                 `http://localhost:${app.port}${(0, external_descriptors_cjs_namespaceObject.resolveApiPrefix)(app)}`
@@ -226,6 +239,12 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                             tsConfigPath: './tsconfig.mf-types.json'
                         }
                     },
+                    ...(0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, app) ? {
+                        backendFederation: (0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, app)
+                    } : {},
+                    ...app.api ? {
+                        deliveryUnit: (0, external_delivery_unit_cjs_namespaceObject.deliveryUnitContractBlock)((0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, app))
+                    } : {},
                     ...app.api ? {
                         api: {
                             stem: app.api.stem,
@@ -269,6 +288,9 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                     hostOnly: 'shell' === app.kind && 0 === Object.keys(app.exposes ?? {}).length
                 }))
         },
+        backendFederation: {
+            apps: (0, external_descriptors_cjs_namespaceObject.verticalApiApps)(remotes).map((app)=>(0, external_backend_federation_cjs_namespaceObject.createBackendFederationSummary)(scope, app))
+        },
         agentSkills: {
             target: 'codex',
             lockfile: './.codex/skills-lock.json',
@@ -283,13 +305,7 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
         tooling: {
             command: 'modern-js-create ultramodern',
             wrappers: {
-                validate: "scripts/validate-ultramodern-workspace.mts",
-                typecheck: "scripts/ultramodern-typecheck.mts",
-                mfTypes: "scripts/assert-mf-types.mts",
-                publicSurface: "scripts/generate-public-surface-assets.mts",
-                cloudflareProof: "scripts/proof-cloudflare-version.mts",
-                performanceReadiness: "scripts/ultramodern-performance-readiness.mts",
-                migrateStrictEffect: "scripts/migrate-strict-effect.mts",
+                ...(0, external_tooling_command_catalog_cjs_namespaceObject.createGeneratedToolingWrapperMap)(),
                 apiBoundaries: "scripts/check-ultramodern-api-boundaries.mts",
                 skills: "scripts/bootstrap-agent-skills.mts"
             }

package/dist/cjs/ultramodern-workspace/delivery-unit-sync.cjs

@@ -0,0 +1,159 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    runSyncDeliveryUnit: ()=>runSyncDeliveryUnit
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_util_namespaceObject = require("node:util");
+const config_cjs_namespaceObject = require("../ultramodern-tooling/config.cjs");
+const external_backend_federation_cjs_namespaceObject = require("./backend-federation.cjs");
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.cjs");
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_module_federation_cjs_namespaceObject = require("./module-federation.cjs");
+const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function writeTextIfChanged(absolutePath, content) {
+    if (external_node_fs_default().existsSync(absolutePath) && external_node_fs_default().readFileSync(absolutePath, 'utf-8') === content) return false;
+    external_node_fs_default().mkdirSync(external_node_path_default().dirname(absolutePath), {
+        recursive: true
+    });
+    external_node_fs_default().writeFileSync(absolutePath, content, 'utf-8');
+    return true;
+}
+function writeJsonIfChanged(absolutePath, value) {
+    return writeTextIfChanged(absolutePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function stampDeliveryUnitIdentity(entry, scope, app) {
+    const block = (0, external_delivery_unit_cjs_namespaceObject.deliveryUnitContractBlock)((0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, app));
+    entry.deliveryUnit = block;
+    if (isPlainObject(entry.backendFederation)) {
+        entry.backendFederation.deliveryUnit = block;
+        if (!isPlainObject(entry.backendFederation.versionBoundary)) entry.backendFederation.versionBoundary = {};
+        entry.backendFederation.versionBoundary.identityRoot = 'deliveryUnit';
+    } else entry.backendFederation = (0, external_backend_federation_cjs_namespaceObject.createBackendFederationContract)(scope, app);
+}
+function runSyncDeliveryUnit(args, context) {
+    const parsed = (0, external_node_util_namespaceObject.parseArgs)({
+        args,
+        options: {
+            help: {
+                type: 'boolean',
+                short: 'h'
+            },
+            workspace: {
+                type: 'string'
+            }
+        },
+        strict: true,
+        allowPositionals: false
+    });
+    if (parsed.values.help) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern sync-delivery-unit [--workspace <dir>]
+
+Backfills the per-vertical delivery-unit identity blocks required by
+\`ultramodern validate\` onto an existing generated workspace, in place and
+through framework tooling only. For each full-stack vertical it writes the
+delivery-unit block into .modernjs/ultramodern.json topology.apps[] and
+topology/reference-topology.json verticals[] (plus backendFederation.deliveryUnit
+and backendFederation.versionBoundary.identityRoot) and regenerates
+verticals/<id>/shared/ultramodern-build.{json,ts}. Idempotent: a second run writes
+nothing.
+`);
+        return 0;
+    }
+    const workspaceOverride = parsed.values.workspace;
+    const workspaceRoot = workspaceOverride ? external_node_path_default().resolve(context.invocationCwd, workspaceOverride) : context.workspaceRoot;
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (!external_node_fs_default().existsSync(compactPath)) throw new Error(`Missing ${external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH}. sync-delivery-unit needs the compact UltraModern config; run \`modern-js-create ultramodern migrate-strict-effect\` first.`);
+    const config = (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot);
+    const scope = config.workspace.packageScope;
+    const apiApps = (0, config_cjs_namespaceObject.workspaceAppsFromToolingConfig)(config).filter((app)=>Boolean(app.api));
+    const written = [];
+    const unchanged = [];
+    const track = (relativePath, changed)=>{
+        (changed ? written : unchanged).push(relativePath);
+    };
+    const appById = new Map(apiApps.map((app)=>[
+            app.id,
+            app
+        ]));
+    const compact = JSON.parse(external_node_fs_default().readFileSync(compactPath, 'utf-8'));
+    if (isPlainObject(compact) && Array.isArray(compact.topology?.apps)) for (const entry of compact.topology.apps){
+        if (!isPlainObject(entry)) continue;
+        const app = appById.get(String(entry.id));
+        if (app) stampDeliveryUnitIdentity(entry, scope, app);
+    }
+    track(external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH, writeJsonIfChanged(compactPath, compact));
+    const topologyPath = external_node_path_default().join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
+    if (external_node_fs_default().existsSync(topologyPath)) {
+        const topology = JSON.parse(external_node_fs_default().readFileSync(topologyPath, 'utf-8'));
+        if (isPlainObject(topology) && Array.isArray(topology.verticals)) for (const entry of topology.verticals){
+            if (!isPlainObject(entry)) continue;
+            const app = appById.get(String(entry.id));
+            if (app) stampDeliveryUnitIdentity(entry, scope, app);
+        }
+        track(REFERENCE_TOPOLOGY_PATH, writeJsonIfChanged(topologyPath, topology));
+    }
+    for (const app of apiApps){
+        const buildModulePath = external_node_path_default().join(app.directory, 'shared/ultramodern-build.ts');
+        const buildArtifactPath = external_node_path_default().join(app.directory, 'shared/ultramodern-build.json');
+        track(buildModulePath, writeTextIfChanged(external_node_path_default().join(workspaceRoot, buildModulePath), (0, external_module_federation_cjs_namespaceObject.createUltramodernBuildModule)()));
+        track(buildArtifactPath, writeTextIfChanged(external_node_path_default().join(workspaceRoot, buildArtifactPath), (0, external_module_federation_cjs_namespaceObject.createUltramodernBuildArtifactJson)(scope, app)));
+    }
+    if (0 === written.length) process.stdout.write('[ultramodern] sync-delivery-unit: already in sync; no files written.\n');
+    else {
+        process.stdout.write(`[ultramodern] sync-delivery-unit: wrote ${written.length} file(s):\n`);
+        for (const relativePath of written)process.stdout.write(`  wrote    ${relativePath}\n`);
+        for (const relativePath of unchanged)process.stdout.write(`  in-sync  ${relativePath}\n`);
+    }
+    return 0;
+}
+exports.runSyncDeliveryUnit = __webpack_exports__.runSyncDeliveryUnit;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runSyncDeliveryUnit"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/delivery-unit.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    createBuildMarker: ()=>createBuildMarker,
+    createDeliveryUnitRecord: ()=>createDeliveryUnitRecord,
+    deliveryUnitContractBlock: ()=>universal_namespaceObject.deliveryUnitContractBlock
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const deliveryUnitGenerationSeed = `${Date.now()}:${external_node_crypto_default().randomUUID()}`;
+function createBuildMarker(scope, app) {
+    return external_node_crypto_default().createHash('sha256').update(`${deliveryUnitGenerationSeed}:${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+}
+function createDeliveryUnitRecord(scope, app) {
+    return {
+        schemaVersion: universal_namespaceObject.DELIVERY_UNIT_SCHEMA_VERSION,
+        kind: universal_namespaceObject.DELIVERY_UNIT_KIND,
+        unitId: `${scope}/${app.domain ?? app.id}`,
+        appId: app.id,
+        packageName: (0, external_naming_cjs_namespaceObject.packageName)(scope, app.packageSuffix),
+        version: '0.1.0',
+        sourceRevision: 'workspace',
+        buildMarker: createBuildMarker(scope, app),
+        deployProfile: universal_namespaceObject.DELIVERY_UNIT_DEPLOY_PROFILE
+    };
+}
+exports.createBuildMarker = __webpack_exports__.createBuildMarker;
+exports.createDeliveryUnitRecord = __webpack_exports__.createDeliveryUnitRecord;
+exports.deliveryUnitContractBlock = __webpack_exports__.deliveryUnitContractBlock;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBuildMarker",
+    "createDeliveryUnitRecord",
+    "deliveryUnitContractBlock"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});