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

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

@@ -0,0 +1,329 @@
+import { semver, yaml } from "@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 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 = 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 = yaml.dump(document, {
+        noCompatMode: true,
+        noRefs: true,
+        lineWidth: -1,
+        quotingType: "'"
+    });
+    return '\n' === lineEnding ? rendered : rendered.replaceAll('\n', lineEnding);
+}
+export { discoverReachablePnpmLockReleaseAgeClosure, isYamlRecord, parsePnpmWorkspaceYaml, stringifyPnpmWorkspaceYaml };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/policy-constants.js

@@ -0,0 +1,19 @@
+import node_path from "node:path";
+import { ULTRAMODERN_WORKSPACE_POLICY } from "../../../ultramodern-workspace/policy.js";
+import { createPackageRoot } from "../context.js";
+const conditionalPatches = 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 node_path.join(createPackageRoot, 'template-workspace', patchPath);
+}
+const requiredGeneratedPatches = ULTRAMODERN_WORKSPACE_POLICY.pnpm.patchedDependencies.required.map((patch)=>({
+        path: patch.path,
+        sourcePath: patchSourcePath(patch.path)
+    }));
+const drizzleOrmDeclarationPatchPath = conditionalPatchPath('drizzle-orm');
+const drizzleOrmDeclarationPatchSourcePath = patchSourcePath(drizzleOrmDeclarationPatchPath);
+export { drizzleOrmDeclarationPatchPath, drizzleOrmDeclarationPatchSourcePath, requiredGeneratedPatches };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/react-router-retirement.js

@@ -0,0 +1,148 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { moduleFederationConfigFile } from "../../../ultramodern-workspace/mf-validation/constants.js";
+import { parseObjectLiteral } from "../../../ultramodern-workspace/mf-validation/object-literal.js";
+import { locateCreateModuleFederationConfigObject } from "../../../ultramodern-workspace/mf-validation/syntax.js";
+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 (!node_fs.existsSync(directory)) return false;
+    for (const entry of node_fs.readdirSync(directory, {
+        withFileTypes: true
+    })){
+        const entryPath = node_path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (!skippedSourceDirectories.has(entry.name) && directoryImportsReactRouter(entryPath)) return true;
+            continue;
+        }
+        if (entry.isFile() && authoredSourceExtensions.has(node_path.extname(entry.name))) {
+            if (reactRouterSpecifier.test(node_fs.readFileSync(entryPath, 'utf-8'))) return true;
+        }
+    }
+    return false;
+}
+function authoredSourceImportsReactRouter(packageDirectory) {
+    return authoredSourceDirectories.some((directory)=>directoryImportsReactRouter(node_path.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 = node_path.join(packageDirectory, 'package.json');
+    if (!node_fs.existsSync(packageFile)) return;
+    try {
+        return JSON.parse(node_fs.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}/${moduleFederationConfigFile}`;
+        const configPath = node_path.join(workspaceRoot, relativeConfigPath);
+        if (!node_fs.existsSync(configPath)) continue;
+        const source = node_fs.readFileSync(configPath, 'utf-8');
+        const packageDirectory = node_path.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 = locateCreateModuleFederationConfigObject(source);
+    } catch  {
+        return;
+    }
+    if (void 0 === configObject) return;
+    const properties = 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}/${moduleFederationConfigFile}`;
+        const configPath = node_path.join(io.workspaceRoot, relativeConfigPath);
+        if (!node_fs.existsSync(configPath)) continue;
+        const nextSource = insertBridgeRouterOptOut(node_fs.readFileSync(configPath, 'utf-8'), appDeclaresReactRouter(node_path.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;
+}
+export { appDeclaresReactRouter, authoredSourceImportsReactRouter, ensureGeneratedModuleFederationBridgeRouterOptOut, insertBridgeRouterOptOut, isGeneratedModuleFederationConfig, preflightModuleFederationBridgeRouter, removeRetiredReactRouterDependency };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/toolchain-pins.js

@@ -0,0 +1,80 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { ULTRAMODERN_PACKAGE_PINS, ULTRAMODERN_WORKSPACE_POLICY } from "../../../ultramodern-workspace/policy.js";
+const { toolchain: toolchain } = ULTRAMODERN_WORKSPACE_POLICY;
+const retiredRootToolingDependencies = [
+    "@typescript/typescript6"
+];
+function isRecord(value) {
+    return Boolean(value) && 'object' == typeof value && !Array.isArray(value);
+}
+function ensureRecord(parent, key, label) {
+    const value = parent[key];
+    if (void 0 === value) {
+        const created = {};
+        parent[key] = created;
+        return created;
+    }
+    if (!isRecord(value)) throw new Error(`${label} must be an object.`);
+    return value;
+}
+function updateUltramodernConfigToolchain(config) {
+    const workspace = ensureRecord(config, 'workspace', 'workspace');
+    const packageManager = ensureRecord(workspace, 'packageManager', 'workspace.packageManager');
+    packageManager.name = toolchain.packageManager.name;
+    packageManager.version = toolchain.packageManager.version;
+    const node = ensureRecord(workspace, 'node', 'workspace.node');
+    node.version = toolchain.node.version;
+    node.engineRange = toolchain.node.engineRange;
+}
+function updateRootPackageToolchain(packageJson) {
+    packageJson.packageManager = `${toolchain.packageManager.name}@${toolchain.packageManager.version}`;
+    const engines = ensureRecord(packageJson, 'engines', 'package.json engines');
+    engines.node = toolchain.node.engineRange;
+    engines.pnpm = toolchain.packageManager.engineRange;
+    const devDependencies = ensureRecord(packageJson, 'devDependencies', 'package.json devDependencies');
+    for (const packageName of retiredRootToolingDependencies)delete devDependencies[packageName];
+    devDependencies["@typescript/native"] = ULTRAMODERN_PACKAGE_PINS.rootDevDependencies["@typescript/native"];
+    devDependencies.miniflare = ULTRAMODERN_PACKAGE_PINS.rootDevDependencies.miniflare;
+}
+function updateMiseTools(content) {
+    const lines = content.replace(/\r\n/gu, '\n').split('\n');
+    if ('' === lines.at(-1)) lines.pop();
+    let toolsStart = lines.findIndex((line)=>/^\s*\[tools\]\s*(?:#.*)?$/u.test(line));
+    if (-1 === toolsStart) {
+        if (lines.length > 0) lines.push('');
+        toolsStart = lines.length;
+        lines.push('[tools]');
+    }
+    const nextSection = lines.findIndex((line, index)=>index > toolsStart && /^\s*\[[^\]]+\]\s*(?:#.*)?$/u.test(line));
+    let toolsEnd = -1 === nextSection ? lines.length : nextSection;
+    const upsertTool = (name, version)=>{
+        const pattern = new RegExp(`^\\s*${name}\\s*=`, 'u');
+        const line = `${name} = "${version}"`;
+        const indexes = lines.flatMap((candidate, candidateIndex)=>candidateIndex > toolsStart && candidateIndex < toolsEnd && pattern.test(candidate) ? [
+                candidateIndex
+            ] : []);
+        if (indexes.length > 1) throw new Error(`.mise.toml [tools] contains duplicate ${name} pins.`);
+        const index = indexes[0];
+        if (void 0 === index) {
+            lines.splice(toolsEnd, 0, line);
+            toolsEnd += 1;
+            return;
+        }
+        lines[index] = line;
+    };
+    upsertTool('node', toolchain.node.version);
+    upsertTool('pnpm', toolchain.packageManager.version);
+    return `${lines.join('\n')}\n`;
+}
+function updateGeneratedToolchainFiles(io) {
+    const misePath = node_path.join(io.workspaceRoot, '.mise.toml');
+    const miseContent = node_fs.existsSync(misePath) ? node_fs.readFileSync(misePath, 'utf-8') : '';
+    io.write(misePath, updateMiseTools(miseContent));
+    const workflowPath = node_path.join(io.workspaceRoot, '.github/workflows/ultramodern-workspace-gates.yml');
+    if (!node_fs.existsSync(workflowPath)) return;
+    const workflow = node_fs.readFileSync(workflowPath, 'utf-8');
+    const updatedWorkflow = workflow.replace(/^(\s*)node-version\s*:\s*.*$/mu, `$1node-version: '${toolchain.node.version}'`);
+    io.write(workflowPath, updatedWorkflow);
+}
+export { updateGeneratedToolchainFiles, updateRootPackageToolchain, updateUltramodernConfigToolchain };