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

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/api-metadata.cjs

@@ -0,0 +1,212 @@
+"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__, {
+    reconcileCompactPackageSourceMetadata: ()=>reconcileCompactPackageSourceMetadata,
+    reconcilePackageSourceMetadata: ()=>reconcilePackageSourceMetadata,
+    updateReferenceTopology: ()=>updateReferenceTopology,
+    updateUltramodernConfig: ()=>updateUltramodernConfig
+});
+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_io_cjs_namespaceObject = require("./io.cjs");
+const external_toolchain_pins_cjs_namespaceObject = require("./toolchain-pins.cjs");
+const packageSourceOwnedKeys = [
+    'strategy',
+    'modernPackageVersion',
+    'registry',
+    'aliasScope',
+    'aliasPackageNamePrefix'
+];
+const retiredPackageSourceKeys = [
+    'generatedWorkspacePackages',
+    'metadata',
+    'modernPackages'
+];
+function requireObject(value, label) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) throw new Error(`${label} must be an object.`);
+    return value;
+}
+function reconcilePackageSourceMetadata(value, { canonical, label, ownedKeys }) {
+    const existing = void 0 === value ? {} : requireObject(value, label);
+    const frameworkOwnedKeys = new Set([
+        ...ownedKeys,
+        ...retiredPackageSourceKeys
+    ]);
+    for (const key of Object.keys(canonical))if (!frameworkOwnedKeys.has(key)) throw new Error(`${label} canonical key ${key} is not framework-owned.`);
+    const extensionEntries = Object.entries(existing).filter(([key])=>!frameworkOwnedKeys.has(key));
+    const next = Object.fromEntries(extensionEntries);
+    Object.assign(next, canonical);
+    const expectedKeys = [
+        ...extensionEntries.map(([key])=>key),
+        ...Object.keys(canonical)
+    ];
+    const actualKeys = Object.keys(next);
+    if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index)=>key !== expectedKeys[index])) throw new Error(`${label} could not establish exact package-source keys.`);
+    for (const [key, extensionValue] of extensionEntries)if (!Object.is(next[key], extensionValue)) throw new Error(`${label} could not preserve extension key ${key}.`);
+    for (const key of frameworkOwnedKeys){
+        const shouldExist = Object.hasOwn(canonical, key);
+        if (Object.hasOwn(next, key) !== shouldExist || shouldExist && !Object.is(next[key], canonical[key])) throw new Error(`${label} could not establish exact postcondition for ${key}.`);
+    }
+    return next;
+}
+function reconcileCompactPackageSourceMetadata(value, packageSource) {
+    return reconcilePackageSourceMetadata(value, {
+        canonical: {
+            strategy: packageSource.strategy,
+            modernPackageVersion: packageSource.modernPackageVersion,
+            ...packageSource.registry ? {
+                registry: packageSource.registry
+            } : {},
+            ...packageSource.aliasScope ? {
+                aliasScope: packageSource.aliasScope
+            } : {},
+            ...packageSource.aliasPackageNamePrefix ? {
+                aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
+            } : {}
+        },
+        label: 'packageSource',
+        ownedKeys: packageSourceOwnedKeys
+    });
+}
+function normalizeStrictEffectApiMetadata(value) {
+    let changed = false;
+    const backendFederation = value.backendFederation;
+    if (backendFederation && 'object' == typeof backendFederation && !Array.isArray(backendFederation) && Object.hasOwn(backendFederation, 'entry')) {
+        delete backendFederation.entry;
+        changed = true;
+    }
+    const api = value.api;
+    if (!api || 'object' != typeof api || Array.isArray(api)) return changed;
+    if (void 0 !== api.backendFederation) {
+        delete api.backendFederation;
+        changed = true;
+    }
+    const oldEffect = api.effect;
+    if (oldEffect && 'object' == typeof oldEffect && !Array.isArray(oldEffect)) {
+        if (void 0 === api.stem && 'string' == typeof oldEffect.stem) {
+            api.stem = oldEffect.stem;
+            changed = true;
+        }
+        if (void 0 === api.prefix && 'string' == typeof oldEffect.prefix) {
+            api.prefix = oldEffect.prefix;
+            changed = true;
+        }
+        if (void 0 === api.consumedBy && Array.isArray(oldEffect.consumedBy)) {
+            api.consumedBy = oldEffect.consumedBy;
+            changed = true;
+        }
+        delete api.effect;
+        changed = true;
+    }
+    if ('effect' !== api.runtime) {
+        api.runtime = 'effect';
+        changed = true;
+    }
+    if (api.bff && 'object' == typeof api.bff && !Array.isArray(api.bff)) {
+        if (true !== api.bff.strictEffectApproach) {
+            api.bff.strictEffectApproach = true;
+            changed = true;
+        }
+    }
+    if ('string' == typeof value.path) {
+        const directServerEntry = `${value.path}/api/index.ts`;
+        if ('string' == typeof api.serverEntry && /\/api\/effect\/index\.[cm]?[jt]sx?$/u.test(api.serverEntry)) {
+            api.serverEntry = directServerEntry;
+            changed = true;
+        }
+        if (api.contract && 'object' == typeof api.contract && !Array.isArray(api.contract)) {
+            if ('./shared/effect/api' === api.contract.export) {
+                api.contract.export = './api';
+                changed = true;
+            }
+            if ('string' == typeof api.contract.path && /\/shared\/effect\/api\.[cm]?[jt]sx?$/u.test(api.contract.path)) {
+                api.contract.path = `${value.path}/shared/api.ts`;
+                changed = true;
+            }
+        }
+        if (api.client && 'object' == typeof api.client && !Array.isArray(api.client)) {
+            if ('./effect/client' === api.client.export) {
+                api.client.export = './api/client';
+                changed = true;
+            }
+            if ('string' == typeof api.client.path && /\/src\/effect\/[^/]+-client\.[cm]?ts$/u.test(api.client.path)) {
+                const basename = external_node_path_default().basename(api.client.path);
+                api.client.path = `${value.path}/src/api/${basename}`;
+                changed = true;
+            }
+        }
+        if (void 0 === api.serverEntry && 'effect' === api.runtime) {
+            api.serverEntry = directServerEntry;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function updateUltramodernConfig(io, config, packageSource) {
+    const configPath = external_node_path_default().join(io.workspaceRoot, '.modernjs/ultramodern.json');
+    config.packageSource = reconcileCompactPackageSourceMetadata(config.packageSource, packageSource);
+    if (config.generator && 'object' == typeof config.generator && !Array.isArray(config.generator) && 'string' == typeof config.generator.version) config.generator.version = packageSource.modernPackageVersion;
+    (0, external_toolchain_pins_cjs_namespaceObject.updateUltramodernConfigToolchain)(config);
+    for (const app of config.topology?.apps ?? [])if (app && 'object' == typeof app && !Array.isArray(app)) normalizeStrictEffectApiMetadata(app);
+    (0, external_io_cjs_namespaceObject.writeJsonFile)(io, configPath, config);
+}
+function updateReferenceTopology(io) {
+    const topologyPath = external_node_path_default().join(io.workspaceRoot, 'topology/reference-topology.json');
+    if (!external_node_fs_default().existsSync(topologyPath)) return false;
+    const topology = (0, external_io_cjs_namespaceObject.readJsonFile)(topologyPath);
+    let changed = false;
+    for (const vertical of topology.verticals ?? [])if (vertical && 'object' == typeof vertical && !Array.isArray(vertical)) changed = normalizeStrictEffectApiMetadata(vertical) || changed;
+    if (changed) (0, external_io_cjs_namespaceObject.writeJsonFile)(io, topologyPath, topology);
+    return changed;
+}
+exports.reconcileCompactPackageSourceMetadata = __webpack_exports__.reconcileCompactPackageSourceMetadata;
+exports.reconcilePackageSourceMetadata = __webpack_exports__.reconcilePackageSourceMetadata;
+exports.updateReferenceTopology = __webpack_exports__.updateReferenceTopology;
+exports.updateUltramodernConfig = __webpack_exports__.updateUltramodernConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "reconcileCompactPackageSourceMetadata",
+    "reconcilePackageSourceMetadata",
+    "updateReferenceTopology",
+    "updateUltramodernConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/declaration-patches.cjs

@@ -0,0 +1,47 @@
+"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__, {
+    ensureGeneratedDeclarationPatches: ()=>ensureGeneratedDeclarationPatches
+});
+const external_generated_patches_cjs_namespaceObject = require("./generated-patches.cjs");
+const external_policy_constants_cjs_namespaceObject = require("./policy-constants.cjs");
+function ensureGeneratedDeclarationPatches(io, options) {
+    let changed = false;
+    for (const patch of external_policy_constants_cjs_namespaceObject.requiredGeneratedPatches)changed = (0, external_generated_patches_cjs_namespaceObject.ensureGeneratedPatchFile)(io, patch.path, patch.sourcePath) || changed;
+    changed = options.includeDrizzleOrmPatch ? (0, external_generated_patches_cjs_namespaceObject.ensureGeneratedPatchFile)(io, external_policy_constants_cjs_namespaceObject.drizzleOrmDeclarationPatchPath, external_policy_constants_cjs_namespaceObject.drizzleOrmDeclarationPatchSourcePath) || changed : (0, external_generated_patches_cjs_namespaceObject.removeGeneratedPatchFileIfUnchanged)(io, external_policy_constants_cjs_namespaceObject.drizzleOrmDeclarationPatchPath, external_policy_constants_cjs_namespaceObject.drizzleOrmDeclarationPatchSourcePath) || changed;
+    return changed;
+}
+exports.ensureGeneratedDeclarationPatches = __webpack_exports__.ensureGeneratedDeclarationPatches;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ensureGeneratedDeclarationPatches"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/dependency-usage.cjs

@@ -0,0 +1,112 @@
+"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__, {
+    workspaceUsesDependency: ()=>workspaceUsesDependency
+});
+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 utils_namespaceObject = require("@modern-js/utils");
+const external_pnpm_yaml_cjs_namespaceObject = require("./pnpm-yaml.cjs");
+function workspaceUsesDependency(workspaceRoot, packageName, exactVersion) {
+    const packageJsonPaths = [
+        external_node_path_default().join(workspaceRoot, 'package.json')
+    ];
+    let compatibleRangeDeclared = false;
+    for (const workspaceDir of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteWorkspaceDir = external_node_path_default().join(workspaceRoot, workspaceDir);
+        if (external_node_fs_default().existsSync(absoluteWorkspaceDir)) for (const entry of external_node_fs_default().readdirSync(absoluteWorkspaceDir, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageJsonPath = external_node_path_default().join(absoluteWorkspaceDir, entry.name, 'package.json');
+            if (external_node_fs_default().existsSync(packageJsonPath)) packageJsonPaths.push(packageJsonPath);
+        }
+    }
+    const aliasPrefix = `npm:${packageName}@`;
+    for (const packageJsonPath of packageJsonPaths){
+        const packageJson = JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, 'utf-8'));
+        for (const field of [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies'
+        ]){
+            const dependencies = packageJson[field];
+            if (dependencies && 'object' == typeof dependencies) {
+                if (Object.prototype.hasOwnProperty.call(dependencies, packageName)) {
+                    const specifier = dependencies[packageName];
+                    if (void 0 === exactVersion || specifier === exactVersion || specifier === `${aliasPrefix}${exactVersion}`) return true;
+                    if ('string' == typeof specifier && utils_namespaceObject.semver.satisfies(exactVersion, specifier, {
+                        includePrerelease: true
+                    })) compatibleRangeDeclared = true;
+                }
+                for (const specifier of Object.values(dependencies)){
+                    if ('string' != typeof specifier || !specifier.startsWith(aliasPrefix)) continue;
+                    const aliasedVersion = specifier.slice(aliasPrefix.length);
+                    if (void 0 === exactVersion || aliasedVersion === exactVersion) return true;
+                    if (utils_namespaceObject.semver.satisfies(exactVersion, aliasedVersion, {
+                        includePrerelease: true
+                    })) compatibleRangeDeclared = true;
+                }
+            }
+        }
+    }
+    if (!exactVersion || !compatibleRangeDeclared) return false;
+    const lockfilePath = external_node_path_default().join(workspaceRoot, 'pnpm-lock.yaml');
+    if (!external_node_fs_default().existsSync(lockfilePath)) return true;
+    try {
+        const closure = external_pnpm_yaml_cjs_namespaceObject.discoverReachablePnpmLockReleaseAgeClosure(external_pnpm_yaml_cjs_namespaceObject.parsePnpmWorkspaceYaml(external_node_fs_default().readFileSync(lockfilePath, 'utf-8'), lockfilePath).document);
+        return closure.unresolved.length > 0 || closure.candidates.some((candidate)=>candidate.packageName === packageName && candidate.version === exactVersion);
+    } catch  {
+        return true;
+    }
+}
+exports.workspaceUsesDependency = __webpack_exports__.workspaceUsesDependency;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "workspaceUsesDependency"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-backend-federation.cjs

@@ -0,0 +1,55 @@
+"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__, {
+    updateGeneratedBackendFederationContractFiles: ()=>updateGeneratedBackendFederationContractFiles
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const backend_federation_cjs_namespaceObject = require("../../../ultramodern-workspace/backend-federation.cjs");
+const external_config_cjs_namespaceObject = require("../../config.cjs");
+function updateGeneratedBackendFederationContractFiles(io, config) {
+    for (const app of (0, external_config_cjs_namespaceObject.allWorkspaceAppsFromToolingConfig)(config))if (app.api) io.writeGenerated(external_node_path_default().join(io.workspaceRoot, app.directory, 'api/backend-federation.ts'), (0, backend_federation_cjs_namespaceObject.createBackendFederationContractFile)(app));
+}
+exports.updateGeneratedBackendFederationContractFiles = __webpack_exports__.updateGeneratedBackendFederationContractFiles;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "updateGeneratedBackendFederationContractFiles"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-build-identity.cjs

@@ -0,0 +1,102 @@
+"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__, {
+    rewriteApiMarkerIdentitySchema: ()=>rewriteApiMarkerIdentitySchema,
+    rewriteLegacyApiMarkerBinding: ()=>rewriteLegacyApiMarkerBinding,
+    updateGeneratedBuildIdentityModules: ()=>updateGeneratedBuildIdentityModules
+});
+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 module_federation_cjs_namespaceObject = require("../../../ultramodern-workspace/module-federation.cjs");
+const external_config_cjs_namespaceObject = require("../../config.cjs");
+const legacyApiMarkerPattern = /export const ultramodernApiMarker\s*=\s*\{[\s\S]*?\}\s+as const;\n?/u;
+const markerSchemaPattern = /(export const [A-Za-z_$][\w$]*MarkerSchema(?:\s*:[^=]+)?\s*=\s*Schema\.Struct\(\{\n)([\s\S]*?)(\n\}\);)/u;
+function rewriteLegacyApiMarkerBinding(source) {
+    return source.replace(legacyApiMarkerPattern, "export { ultramodernApiMarker } from './ultramodern-build.ts';\n");
+}
+function rewriteApiMarkerIdentitySchema(source) {
+    const match = source.match(markerSchemaPattern);
+    if (!match) return source;
+    let body = match[2];
+    if (![
+        'appId',
+        'build',
+        'deployProfile',
+        'packageName',
+        'surface',
+        'version'
+    ].every((field)=>new RegExp(`^\\s+${field}: Schema\\.String,\\s*$`, 'mu').test(body))) return source;
+    for (const [anchor, field] of [
+        [
+            'build',
+            'buildMarker'
+        ],
+        [
+            'packageName',
+            'sourceRevision'
+        ],
+        [
+            'surface',
+            'unitId'
+        ]
+    ])if (!new RegExp(`^\\s+${field}: Schema\\.String,\\s*$`, 'mu').test(body)) body = body.replace(new RegExp(`^(\\s+)${anchor}: Schema\\.String,\\s*$`, 'mu'), `$&\n$1${field}: Schema.String,`);
+    return source.replace(markerSchemaPattern, (_full, prefix, _body, suffix)=>`${prefix}${body}${suffix}`);
+}
+function updateGeneratedBuildIdentityModules(io, config) {
+    for (const app of (0, external_config_cjs_namespaceObject.allWorkspaceAppsFromToolingConfig)(config)){
+        const sharedApiPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'shared/api.ts');
+        if (app.api && external_node_fs_default().existsSync(sharedApiPath)) io.write(sharedApiPath, rewriteApiMarkerIdentitySchema(rewriteLegacyApiMarkerBinding(external_node_fs_default().readFileSync(sharedApiPath, 'utf-8'))));
+        io.writeGenerated(external_node_path_default().join(io.workspaceRoot, app.directory, 'src/ultramodern-build.ts'), (0, module_federation_cjs_namespaceObject.createUltramodernBuildReexportModule)());
+        io.writeGenerated(external_node_path_default().join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.ts'), (0, module_federation_cjs_namespaceObject.createUltramodernBuildModule)(config.workspace.packageScope, app));
+        io.write(external_node_path_default().join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.json'), (0, module_federation_cjs_namespaceObject.createUltramodernBuildArtifactJson)(config.workspace.packageScope, app));
+    }
+}
+exports.rewriteApiMarkerIdentitySchema = __webpack_exports__.rewriteApiMarkerIdentitySchema;
+exports.rewriteLegacyApiMarkerBinding = __webpack_exports__.rewriteLegacyApiMarkerBinding;
+exports.updateGeneratedBuildIdentityModules = __webpack_exports__.updateGeneratedBuildIdentityModules;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "rewriteApiMarkerIdentitySchema",
+    "rewriteLegacyApiMarkerBinding",
+    "updateGeneratedBuildIdentityModules"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});