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

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/pnpm-yaml.cjs

@@ -0,0 +1,376 @@
+"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__, {
+    discoverReachablePnpmLockReleaseAgeClosure: ()=>discoverReachablePnpmLockReleaseAgeClosure,
+    isYamlRecord: ()=>isYamlRecord,
+    parsePnpmWorkspaceYaml: ()=>parsePnpmWorkspaceYaml,
+    stringifyPnpmWorkspaceYaml: ()=>stringifyPnpmWorkspaceYaml
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const dependencyBlocks = [
+    'dependencies',
+    'devDependencies',
+    'optionalDependencies'
+];
+const exactPackageNamePattern = /^(?:@[a-z0-9][a-z0-9._~-]*\/[a-z0-9][a-z0-9._~-]*|[a-z0-9][a-z0-9._~-]*)$/u;
+const integrityPattern = /^sha512-[A-Za-z0-9+/]+={0,2}$/u;
+function isExactSemver(version) {
+    return utils_namespaceObject.semver.valid(version) === version;
+}
+function isYamlRecord(value) {
+    return Boolean(value) && 'object' == typeof value && !Array.isArray(value);
+}
+function requiredYamlRecord(value, label) {
+    if (!isYamlRecord(value)) throw new Error(`${label} must be a YAML mapping.`);
+    return value;
+}
+function sortedEntries(value) {
+    return Object.entries(requiredYamlRecord(value, 'pnpm lockfile mapping')).sort(([left], [right])=>left.localeCompare(right));
+}
+function packageVersionKey(identity) {
+    return `${identity.packageName}@${identity.version}`;
+}
+function splitPeerContext(locator) {
+    const peerStart = locator.indexOf('(');
+    if (-1 === peerStart) return {
+        base: locator,
+        peers: []
+    };
+    const context = locator.slice(peerStart);
+    const segments = [];
+    let start = -1;
+    let depth = 0;
+    for(let index = 0; index < context.length; index += 1){
+        const character = context[index];
+        if ('(' === character) {
+            if (0 === depth) start = index + 1;
+            depth += 1;
+            continue;
+        }
+        if (')' !== character || 0 === depth) {
+            if (0 === depth) return {
+                unresolved: locator
+            };
+            continue;
+        }
+        depth -= 1;
+        if (0 === depth) {
+            const segment = context.slice(start, index);
+            if ('' === segment) return {
+                unresolved: locator
+            };
+            segments.push(segment);
+            start = -1;
+        }
+    }
+    if (0 !== depth || -1 !== start) return {
+        unresolved: locator
+    };
+    const peers = [];
+    for (const segment of segments){
+        if (/^patch_hash=[a-f0-9]{32,128}$/u.test(segment) || /^[a-f0-9]{32,128}$/u.test(segment)) continue;
+        const peer = parsePackageKey(segment);
+        if (!peer) return {
+            unresolved: locator
+        };
+        peers.push(peer);
+    }
+    return {
+        base: locator.slice(0, peerStart),
+        peers
+    };
+}
+function parsePackageLocator(rawLocator) {
+    const locator = rawLocator.replace(/^\//u, '');
+    const separator = locator.lastIndexOf('@');
+    if (separator <= 0) return;
+    const packageName = locator.slice(0, separator);
+    const version = locator.slice(separator + 1);
+    if (!exactPackageNamePattern.test(packageName) || !isExactSemver(version)) return;
+    return {
+        packageName,
+        version,
+        peers: []
+    };
+}
+function parsePackageKey(rawKey) {
+    const peerContext = splitPeerContext(rawKey.replace(/^\//u, ''));
+    if ('unresolved' in peerContext) return;
+    const { base, peers } = peerContext;
+    const identity = parsePackageLocator(base);
+    return identity ? {
+        ...identity,
+        peers
+    } : void 0;
+}
+function isSkippableLocalDependencyVersion(value) {
+    if (/^(?:file|link):\S+$/u.test(value)) return true;
+    if (!value.startsWith('workspace:')) return false;
+    const version = value.slice(10);
+    return '*' === version || '^' === version || '~' === version || /^[~^]?/u.test(version) && isExactSemver(version.replace(/^[~^]/u, ''));
+}
+function aliasNameFromSpecifier(specifier) {
+    if ('string' != typeof specifier || !specifier.startsWith('npm:')) return;
+    const separator = specifier.slice(4).lastIndexOf('@');
+    return separator > 0 ? specifier.slice(4, 4 + separator) : void 0;
+}
+function dependencyIdentity(dependencyName, rawValue) {
+    const descriptor = isYamlRecord(rawValue) ? rawValue : void 0;
+    if (descriptor && !Object.hasOwn(descriptor, 'version')) return {
+        unresolved: "missing descriptor version"
+    };
+    const value = descriptor?.version ?? rawValue;
+    if ('string' != typeof value || '' === value) return {
+        unresolved: "missing or invalid descriptor version"
+    };
+    if (isSkippableLocalDependencyVersion(value)) return;
+    if (/^(?:file|link|workspace):/u.test(value)) return {
+        unresolved: value
+    };
+    const peerContext = splitPeerContext(value.startsWith('npm:') ? value.slice(4) : value);
+    if ('unresolved' in peerContext) return peerContext;
+    const { base, peers } = peerContext;
+    const full = parsePackageLocator(base);
+    if (full) return {
+        ...full,
+        peers
+    };
+    if (!isExactSemver(base)) return {
+        unresolved: descriptor ? `invalid descriptor version ${value}` : value
+    };
+    return {
+        packageName: aliasNameFromSpecifier(descriptor?.specifier) ?? dependencyName,
+        version: base,
+        peers
+    };
+}
+function dependencyEdges(record) {
+    const mapping = requiredYamlRecord(record, 'pnpm lockfile dependency record');
+    const edges = [];
+    for (const blockName of dependencyBlocks){
+        const dependencies = mapping[blockName];
+        if (void 0 !== dependencies) for (const [dependencyName, descriptor] of sortedEntries(dependencies))edges.push({
+            dependencyName,
+            descriptor
+        });
+    }
+    return edges;
+}
+function discoverReachablePnpmLockReleaseAgeClosure(lockfile) {
+    const lock = requiredYamlRecord(lockfile, 'pnpm lockfile');
+    if ('string' != typeof lock.lockfileVersion && 'number' != typeof lock.lockfileVersion) throw new Error('pnpm lockfileVersion is missing.');
+    const importers = requiredYamlRecord(lock.importers, 'pnpm lockfile importers');
+    const packages = requiredYamlRecord(lock.packages, 'pnpm lockfile packages');
+    const snapshots = requiredYamlRecord(lock.snapshots, 'pnpm lockfile snapshots');
+    const packageRecords = new Map(sortedEntries(packages));
+    const snapshotRecords = new Map(sortedEntries(snapshots));
+    const packageRecordsByIdentity = new Map();
+    for (const [packageKey, packageRecord] of packageRecords){
+        const identity = parsePackageKey(packageKey);
+        if (!identity) continue;
+        const key = packageVersionKey(identity);
+        packageRecordsByIdentity.set(key, [
+            ...packageRecordsByIdentity.get(key) ?? [],
+            [
+                packageKey,
+                packageRecord
+            ]
+        ]);
+    }
+    const nodes = new Map();
+    const nodeIdsByIdentity = new Map();
+    for (const nodeId of [
+        ...snapshotRecords.keys()
+    ].sort((left, right)=>left.localeCompare(right))){
+        const identity = parsePackageKey(nodeId);
+        if (!identity) continue;
+        const key = packageVersionKey(identity);
+        nodes.set(nodeId, {
+            identity,
+            packageRecords: (packageRecordsByIdentity.get(key) ?? []).map(([, record])=>record),
+            snapshotRecord: snapshotRecords.get(nodeId)
+        });
+        nodeIdsByIdentity.set(key, [
+            ...nodeIdsByIdentity.get(key) ?? [],
+            nodeId
+        ]);
+    }
+    const unresolved = [];
+    const shortestNodePaths = new Map();
+    const queue = [];
+    const recordUnresolved = (identity, path, reason)=>{
+        unresolved.push({
+            package: identity ? packageVersionKey(identity) : void 0,
+            path,
+            reason
+        });
+    };
+    const enqueueIdentity = (identity, path)=>{
+        const key = packageVersionKey(identity);
+        const targetNodeIds = nodeIdsByIdentity.get(key);
+        if (!targetNodeIds?.length) return void recordUnresolved(identity, [
+            ...path,
+            key
+        ], 'missing lock snapshot');
+        for (const nodeId of targetNodeIds){
+            const nextPath = [
+                ...path,
+                key
+            ];
+            const currentPath = shortestNodePaths.get(nodeId);
+            if (!currentPath || !(currentPath.length <= nextPath.length)) {
+                shortestNodePaths.set(nodeId, nextPath);
+                queue.push(nodeId);
+            }
+        }
+    };
+    for (const [importerName, importer] of sortedEntries(importers))for (const edge of dependencyEdges(importer)){
+        const identity = dependencyIdentity(edge.dependencyName, edge.descriptor);
+        if (!identity) continue;
+        const path = [
+            `importer:${importerName}`
+        ];
+        if ('unresolved' in identity) {
+            recordUnresolved(void 0, [
+                ...path,
+                edge.dependencyName
+            ], `non-exact dependency locator ${identity.unresolved}`);
+            continue;
+        }
+        enqueueIdentity(identity, path);
+    }
+    while(queue.length > 0){
+        const nodeId = queue.shift();
+        const node = nodes.get(nodeId);
+        const nodePath = shortestNodePaths.get(nodeId);
+        if (0 === node.packageRecords.length) {
+            recordUnresolved(node.identity, nodePath, 'missing lock package');
+            continue;
+        }
+        for (const peer of node.identity.peers)enqueueIdentity(peer, nodePath);
+        for (const record of [
+            ...node.packageRecords,
+            node.snapshotRecord
+        ])for (const edge of dependencyEdges(record)){
+            const identity = dependencyIdentity(edge.dependencyName, edge.descriptor);
+            if (identity) {
+                if ('unresolved' in identity) {
+                    recordUnresolved(void 0, [
+                        ...nodePath,
+                        edge.dependencyName
+                    ], `non-exact dependency locator ${identity.unresolved}`);
+                    continue;
+                }
+                enqueueIdentity(identity, nodePath);
+            }
+        }
+    }
+    const shortestIdentityPaths = new Map();
+    for (const [nodeId, nodePath] of shortestNodePaths){
+        const node = nodes.get(nodeId);
+        const key = packageVersionKey(node.identity);
+        const currentPath = shortestIdentityPaths.get(key);
+        if (!currentPath || nodePath.length < currentPath.length) shortestIdentityPaths.set(key, nodePath);
+    }
+    const candidates = [
+        ...shortestIdentityPaths.entries()
+    ].map(([key, path])=>{
+        const [packageName, version] = [
+            key.slice(0, key.lastIndexOf('@')),
+            key.slice(key.lastIndexOf('@') + 1)
+        ];
+        const packageRecordsForIdentity = packageRecordsByIdentity.get(key);
+        if (!packageRecordsForIdentity?.length) return void recordUnresolved({
+            packageName,
+            version,
+            peers: []
+        }, path, 'missing exact SHA-512 lock integrity');
+        let integrity;
+        for (const [packageKey, packageRecord] of packageRecordsForIdentity){
+            const resolution = requiredYamlRecord(requiredYamlRecord(packageRecord, `pnpm lockfile package ${packageKey}`).resolution, `pnpm lockfile package ${packageKey} resolution`);
+            if ('string' != typeof resolution.integrity || !integrityPattern.test(resolution.integrity)) throw new Error(`pnpm lockfile package ${packageKey} has uncertain registry integrity.`);
+            if (integrity && integrity !== resolution.integrity) throw new Error(`pnpm lockfile has conflicting registry integrity for ${key}.`);
+            integrity = resolution.integrity;
+        }
+        return {
+            packageName,
+            version,
+            registry: {
+                dist: {
+                    integrity: integrity
+                }
+            },
+            path
+        };
+    }).filter((candidate)=>Boolean(candidate)).sort((left, right)=>packageVersionKey(left).localeCompare(packageVersionKey(right)));
+    unresolved.sort((left, right)=>JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    return {
+        candidates,
+        unresolved
+    };
+}
+function parsePnpmWorkspaceYaml(source, filename = 'pnpm-workspace.yaml') {
+    let document;
+    try {
+        document = utils_namespaceObject.yaml.load(source, {
+            filename
+        });
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Cannot migrate malformed ${filename}: ${message}`);
+    }
+    if (!isYamlRecord(document)) throw new Error(`Cannot migrate ${filename}: root must be a YAML mapping.`);
+    return {
+        document,
+        lineEnding: source.includes('\r\n') ? '\r\n' : '\n'
+    };
+}
+function stringifyPnpmWorkspaceYaml(document, lineEnding = '\n') {
+    const rendered = utils_namespaceObject.yaml.dump(document, {
+        noCompatMode: true,
+        noRefs: true,
+        lineWidth: -1,
+        quotingType: "'"
+    });
+    return '\n' === lineEnding ? rendered : rendered.replaceAll('\n', lineEnding);
+}
+exports.discoverReachablePnpmLockReleaseAgeClosure = __webpack_exports__.discoverReachablePnpmLockReleaseAgeClosure;
+exports.isYamlRecord = __webpack_exports__.isYamlRecord;
+exports.parsePnpmWorkspaceYaml = __webpack_exports__.parsePnpmWorkspaceYaml;
+exports.stringifyPnpmWorkspaceYaml = __webpack_exports__.stringifyPnpmWorkspaceYaml;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "discoverReachablePnpmLockReleaseAgeClosure",
+    "isYamlRecord",
+    "parsePnpmWorkspaceYaml",
+    "stringifyPnpmWorkspaceYaml"
+].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/policy-constants.cjs

@@ -0,0 +1,73 @@
+"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__, {
+    drizzleOrmDeclarationPatchPath: ()=>drizzleOrmDeclarationPatchPath,
+    drizzleOrmDeclarationPatchSourcePath: ()=>drizzleOrmDeclarationPatchSourcePath,
+    requiredGeneratedPatches: ()=>requiredGeneratedPatches
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const policy_cjs_namespaceObject = require("../../../ultramodern-workspace/policy.cjs");
+const external_context_cjs_namespaceObject = require("../context.cjs");
+const conditionalPatches = policy_cjs_namespaceObject.ULTRAMODERN_WORKSPACE_POLICY.pnpm.patchedDependencies.conditional;
+function conditionalPatchPath(packageName) {
+    const patch = conditionalPatches.find((candidate)=>candidate.packageName === packageName);
+    if (!patch) throw new Error(`Missing canonical patch policy for ${packageName}.`);
+    return patch.path;
+}
+function patchSourcePath(patchPath) {
+    return external_node_path_default().join(external_context_cjs_namespaceObject.createPackageRoot, 'template-workspace', patchPath);
+}
+const requiredGeneratedPatches = policy_cjs_namespaceObject.ULTRAMODERN_WORKSPACE_POLICY.pnpm.patchedDependencies.required.map((patch)=>({
+        path: patch.path,
+        sourcePath: patchSourcePath(patch.path)
+    }));
+const drizzleOrmDeclarationPatchPath = conditionalPatchPath('drizzle-orm');
+const drizzleOrmDeclarationPatchSourcePath = patchSourcePath(drizzleOrmDeclarationPatchPath);
+exports.drizzleOrmDeclarationPatchPath = __webpack_exports__.drizzleOrmDeclarationPatchPath;
+exports.drizzleOrmDeclarationPatchSourcePath = __webpack_exports__.drizzleOrmDeclarationPatchSourcePath;
+exports.requiredGeneratedPatches = __webpack_exports__.requiredGeneratedPatches;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "drizzleOrmDeclarationPatchPath",
+    "drizzleOrmDeclarationPatchSourcePath",
+    "requiredGeneratedPatches"
+].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/react-router-retirement.cjs

@@ -0,0 +1,215 @@
+"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__, {
+    appDeclaresReactRouter: ()=>appDeclaresReactRouter,
+    authoredSourceImportsReactRouter: ()=>authoredSourceImportsReactRouter,
+    ensureGeneratedModuleFederationBridgeRouterOptOut: ()=>ensureGeneratedModuleFederationBridgeRouterOptOut,
+    insertBridgeRouterOptOut: ()=>insertBridgeRouterOptOut,
+    isGeneratedModuleFederationConfig: ()=>isGeneratedModuleFederationConfig,
+    preflightModuleFederationBridgeRouter: ()=>preflightModuleFederationBridgeRouter,
+    removeRetiredReactRouterDependency: ()=>removeRetiredReactRouterDependency
+});
+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 constants_cjs_namespaceObject = require("../../../ultramodern-workspace/mf-validation/constants.cjs");
+const object_literal_cjs_namespaceObject = require("../../../ultramodern-workspace/mf-validation/object-literal.cjs");
+const syntax_cjs_namespaceObject = require("../../../ultramodern-workspace/mf-validation/syntax.cjs");
+const retiredRouterDependency = 'react-router';
+const reactRouterDependencies = [
+    'react-router',
+    'react-router-dom'
+];
+const declaredDependencyFields = [
+    'dependencies',
+    'devDependencies'
+];
+const authoredSourceDirectories = [
+    'src',
+    'api',
+    'server'
+];
+const authoredSourceExtensions = new Set([
+    '.cjs',
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.mts',
+    '.ts',
+    '.tsx'
+]);
+const skippedSourceDirectories = new Set([
+    'dist',
+    'node_modules'
+]);
+const reactRouterSpecifier = /(['"`])react-router(?:-dom)?(?:\/[^'"`]*)?\1/u;
+function directoryImportsReactRouter(directory) {
+    if (!external_node_fs_default().existsSync(directory)) return false;
+    for (const entry of external_node_fs_default().readdirSync(directory, {
+        withFileTypes: true
+    })){
+        const entryPath = external_node_path_default().join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (!skippedSourceDirectories.has(entry.name) && directoryImportsReactRouter(entryPath)) return true;
+            continue;
+        }
+        if (entry.isFile() && authoredSourceExtensions.has(external_node_path_default().extname(entry.name))) {
+            if (reactRouterSpecifier.test(external_node_fs_default().readFileSync(entryPath, 'utf-8'))) return true;
+        }
+    }
+    return false;
+}
+function authoredSourceImportsReactRouter(packageDirectory) {
+    return authoredSourceDirectories.some((directory)=>directoryImportsReactRouter(external_node_path_default().join(packageDirectory, directory)));
+}
+function declaredDependencyFieldsWith(packageJson, dependency) {
+    return declaredDependencyFields.filter((field)=>{
+        const record = packageJson[field];
+        return 'object' == typeof record && null !== record && !Array.isArray(record) && Object.hasOwn(record, dependency);
+    });
+}
+function readPackageJson(packageDirectory) {
+    const packageFile = external_node_path_default().join(packageDirectory, 'package.json');
+    if (!external_node_fs_default().existsSync(packageFile)) return;
+    try {
+        return JSON.parse(external_node_fs_default().readFileSync(packageFile, 'utf-8'));
+    } catch  {
+        return;
+    }
+}
+function appDeclaresReactRouter(packageJsonOrDirectory) {
+    const packageJson = 'string' == typeof packageJsonOrDirectory ? readPackageJson(packageJsonOrDirectory) : packageJsonOrDirectory;
+    if (!packageJson) return false;
+    return reactRouterDependencies.some((dependency)=>declaredDependencyFieldsWith(packageJson, dependency).length > 0);
+}
+function removeRetiredReactRouterDependency(packageJson, packageDirectory) {
+    const fields = declaredDependencyFieldsWith(packageJson, retiredRouterDependency);
+    if (0 === fields.length) return 'absent';
+    if (authoredSourceImportsReactRouter(packageDirectory)) return 'preserved';
+    for (const field of fields)delete packageJson[field][retiredRouterDependency];
+    return 'removed';
+}
+function isGeneratedModuleFederationConfig(source) {
+    if (/^\s*\/\/ ultramodern-mf:/u.test(source)) return true;
+    return [
+        "import { createRequire } from 'node:module';",
+        'const pluginI18nVersion =',
+        'const pluginTanstackVersion =',
+        'const runtimeVersion =',
+        'const reactVersion =',
+        'const reactDomVersion =',
+        'const moduleFederationConfig: Parameters<',
+        'typeof createModuleFederationConfig',
+        'export default moduleFederationConfig;'
+    ].every((signature)=>source.includes(signature));
+}
+function preflightModuleFederationBridgeRouter(workspaceRoot, apps) {
+    for (const app of apps){
+        if ('api-only' === app.surfaceProfile) continue;
+        const relativeConfigPath = `${app.directory}/${constants_cjs_namespaceObject.moduleFederationConfigFile}`;
+        const configPath = external_node_path_default().join(workspaceRoot, relativeConfigPath);
+        if (!external_node_fs_default().existsSync(configPath)) continue;
+        const source = external_node_fs_default().readFileSync(configPath, 'utf-8');
+        const packageDirectory = external_node_path_default().join(workspaceRoot, app.directory);
+        const packageJson = readPackageJson(packageDirectory) ?? {};
+        removeRetiredReactRouterDependency(packageJson, packageDirectory);
+        const nextSource = insertBridgeRouterOptOut(source, appDeclaresReactRouter(packageJson));
+        if (void 0 === nextSource) throw new Error(`Cannot safely migrate ${relativeConfigPath}: its createModuleFederationConfig value is not a static object literal. Resolve bridge.enableBridgeRouter explicitly before retrying; no files were written.`);
+        if (isGeneratedModuleFederationConfig(source)) continue;
+    }
+}
+function createBridgeRouterEntry(enableBridgeRouter) {
+    return `
+  bridge: {
+    enableBridgeRouter: ${enableBridgeRouter},
+  },`;
+}
+function insertBridgeRouterOptOut(source, enableBridgeRouter = false) {
+    let configObject;
+    try {
+        configObject = (0, syntax_cjs_namespaceObject.locateCreateModuleFederationConfigObject)(source);
+    } catch  {
+        return;
+    }
+    if (void 0 === configObject) return;
+    const properties = (0, object_literal_cjs_namespaceObject.parseObjectLiteral)(configObject.source);
+    if (!properties || properties.hasSpread) return;
+    if (properties.properties.has('bridge')) return source;
+    const bridgeEntry = createBridgeRouterEntry(enableBridgeRouter);
+    const inner = configObject.source.slice(1, -1);
+    const nextObject = '' === inner.trim() ? `{${bridgeEntry}\n}` : `{${bridgeEntry}${inner}}`;
+    return source.slice(0, configObject.start) + nextObject + source.slice(configObject.end);
+}
+function ensureGeneratedModuleFederationBridgeRouterOptOut(io, apps) {
+    let changed = false;
+    for (const app of apps){
+        if ('api-only' === app.surfaceProfile) continue;
+        const relativeConfigPath = `${app.directory}/${constants_cjs_namespaceObject.moduleFederationConfigFile}`;
+        const configPath = external_node_path_default().join(io.workspaceRoot, relativeConfigPath);
+        if (!external_node_fs_default().existsSync(configPath)) continue;
+        const nextSource = insertBridgeRouterOptOut(external_node_fs_default().readFileSync(configPath, 'utf-8'), appDeclaresReactRouter(external_node_path_default().join(io.workspaceRoot, app.directory)));
+        if (void 0 === nextSource) {
+            io.log(`${relativeConfigPath} was left unchanged: its Module Federation config is not a static createModuleFederationConfig object literal, so bridge.enableBridgeRouter must be set by hand.`);
+            continue;
+        }
+        changed = io.write(configPath, nextSource) || changed;
+    }
+    return changed;
+}
+exports.appDeclaresReactRouter = __webpack_exports__.appDeclaresReactRouter;
+exports.authoredSourceImportsReactRouter = __webpack_exports__.authoredSourceImportsReactRouter;
+exports.ensureGeneratedModuleFederationBridgeRouterOptOut = __webpack_exports__.ensureGeneratedModuleFederationBridgeRouterOptOut;
+exports.insertBridgeRouterOptOut = __webpack_exports__.insertBridgeRouterOptOut;
+exports.isGeneratedModuleFederationConfig = __webpack_exports__.isGeneratedModuleFederationConfig;
+exports.preflightModuleFederationBridgeRouter = __webpack_exports__.preflightModuleFederationBridgeRouter;
+exports.removeRetiredReactRouterDependency = __webpack_exports__.removeRetiredReactRouterDependency;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "appDeclaresReactRouter",
+    "authoredSourceImportsReactRouter",
+    "ensureGeneratedModuleFederationBridgeRouterOptOut",
+    "insertBridgeRouterOptOut",
+    "isGeneratedModuleFederationConfig",
+    "preflightModuleFederationBridgeRouter",
+    "removeRetiredReactRouterDependency"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});