pnpm-settings-migrator 0.6.0 → 0.7.0

package/dist/cli.mjs

@@ -1,19 +1,19 @@
 import process from "node:process";
 import { cac } from "cac";
-import consola, { consola as consola$1 } from "consola";
-import { isPlainObject, isUndefined, pick } from "@ntnyq/utils";
-import { defu } from "defu";
-import detectIndent from "detect-indent";
+import consola$1, { consola } from "consola";
 import { resolve } from "pathe";
 import { Document, parse } from "yaml";
-import { access, readFile, writeFile } from "node:fs/promises";
+import { access, readFile, rm, writeFile } from "node:fs/promises";
 import { getColor } from "consola/utils";
+import { isPlainObject, isUndefined, pick } from "@ntnyq/utils";
+import { defu } from "defu";
 import camelcaseKeys from "camelcase-keys";
 import { readIniFile } from "read-ini-file";
 import { kebabCase } from "uncase";
+import detectIndent from "detect-indent";
 //#region package.json
 var name = "pnpm-settings-migrator";
-var version = "0.6.0";
+var version = "0.7.0";
 //#endregion
 //#region src/constants.ts
 const NPMRC = ".npmrc";
@@ -60,6 +60,7 @@ const PNPM_SETTINGS_FIELDS = [
 	"httpProxy",
 	"httpsProxy",
 	"ignoredBuiltDependencies",
+	"ignoreDepScripts",
 	"ignoreDeps",
 	"ignoredOptionalDependencies",
 	"ignorePatchFailures",
@@ -87,11 +88,14 @@ const PNPM_SETTINGS_FIELDS = [
 	"overrides",
 	"packageExtensions",
 	"packageImportMethod",
+	"packageManagerStrict",
+	"packageManagerStrictVersion",
 	"patchedDependencies",
 	"peerDependencyRules",
 	"peersSuffixMaxLength",
 	"pnpmfile",
 	"pnpmfileIgnorePkgManifest",
+	"pmOnFail",
 	"preferFrozenLockfile",
 	"preferWorkspacePackages",
 	"production",
@@ -130,11 +134,17 @@ const PNPM_SETTINGS_FIELDS = [
 ];
 const PNPM_V11_REMOVED_SETTINGS = [
 	"allowNonAppliedPatches",
+	"executionEnv",
+	"ignoreDepScripts",
 	"ignorePatchFailures",
 	"ignoredBuiltDependencies",
+	"managePackageManagerVersions",
 	"neverBuiltDependencies",
 	"onlyBuiltDependencies",
-	"onlyBuiltDependenciesFile"
+	"onlyBuiltDependenciesFile",
+	"packageManagerStrict",
+	"packageManagerStrictVersion",
+	"useNodeVersion"
 ];
 //#endregion
 //#region src/options.ts
@@ -160,8 +170,19 @@ const VALID_STRATEGIES = [
 const VALID_COMPATIBILITIES = [
 	"auto",
 	"v10",
-	"v11"
+	"v11",
+	"v12"
 ];
+function resolveCompatibility(compatibility) {
+	if (!compatibility) return DEFAULT_OPTIONS.compatibility;
+	if (VALID_COMPATIBILITIES.includes(compatibility)) return compatibility;
+	throw new Error(`Invalid compatibility: ${compatibility}. Expected one of: ${VALID_COMPATIBILITIES.join(", ")}`);
+}
+function resolveStrategy(strategy) {
+	if (!strategy) return DEFAULT_OPTIONS.strategy;
+	if (VALID_STRATEGIES.includes(strategy)) return strategy;
+	throw new Error(`Invalid strategy: ${strategy}. Expected one of: ${VALID_STRATEGIES.join(", ")}`);
+}
 /**
 * Resolve and normalize migration options with defaults.
 *
@@ -196,16 +217,6 @@ function resolveOptions(options = {}) {
 		replaceDeprecated: options.replaceDeprecated ?? DEFAULT_OPTIONS.replaceDeprecated
 	};
 }
-function resolveCompatibility(compatibility) {
-	if (!compatibility) return DEFAULT_OPTIONS.compatibility;
-	if (VALID_COMPATIBILITIES.includes(compatibility)) return compatibility;
-	throw new Error(`Invalid compatibility: ${compatibility}. Expected one of: ${VALID_COMPATIBILITIES.join(", ")}`);
-}
-function resolveStrategy(strategy) {
-	if (!strategy) return DEFAULT_OPTIONS.strategy;
-	if (VALID_STRATEGIES.includes(strategy)) return strategy;
-	throw new Error(`Invalid strategy: ${strategy}. Expected one of: ${VALID_STRATEGIES.join(", ")}`);
-}
 //#endregion
 //#region src/utils/fs.ts
 /**
@@ -225,6 +236,13 @@ async function fsReadFile(path) {
 	return await readFile(path, "utf-8");
 }
 /**
+* Remove a file if it exists.
+* @param path - file path
+*/
+async function fsRemoveFile(path) {
+	await rm(path, { force: true });
+}
+/**
 * Write file
 * @param path - file path
 * @param content - file content
@@ -240,39 +258,143 @@ const red = getColor("red");
 const bold = getColor("bold");
 const magenta = getColor("magenta");
 //#endregion
-//#region src/utils/merge.ts
+//#region src/utils/compatibility.ts
+const PNPM_REPLACEABLE_IN_V10_SETTINGS = [
+	"allowNonAppliedPatches",
+	"ignoredBuiltDependencies",
+	"neverBuiltDependencies",
+	"onlyBuiltDependencies",
+	"onlyBuiltDependenciesFile"
+];
 /**
-* Merge two objects based on the specified strategy.
-*
-* @param existing - Existing pnpm-workspace.yaml content
-* @param incoming - New settings from package.json and .npmrc
-* @param strategy - Merge strategy to use
-*
-* @returns Merged pnpm workspace configuration
-*
-* @example
-* ```ts
-* // Discard strategy - keep existing values
-* mergeByStrategy({ packages: ['a'] }, { packages: ['b'] }, 'discard')
-* // => { packages: ['a'] }
-*
-* // Merge strategy - combine arrays with deduplication
-* mergeByStrategy({ packages: ['a'] }, { packages: ['b'] }, 'merge')
-* // => { packages: ['a', 'b'] }
-*
-* // Overwrite strategy - use incoming values
-* mergeByStrategy({ packages: ['a'] }, { packages: ['b'] }, 'overwrite')
-* // => { packages: ['b'] }
-* ```
+* Read packages listed by the legacy `onlyBuiltDependenciesFile` setting.
 */
-function mergeByStrategy(existing, incoming, strategy) {
-	switch (strategy) {
-		case "discard": return discardMerge(existing, incoming);
-		case "merge": return mergeWithArrayDedupe(existing, incoming);
-		case "overwrite": return discardMerge(incoming, existing);
-		default: return defu(existing, incoming);
+async function readOnlyBuiltDependenciesFile(cwd, file) {
+	if (!file) return [];
+	const path = resolve(cwd, file);
+	const value = JSON.parse(await fsReadFile(path));
+	if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) throw new TypeError(`Invalid onlyBuiltDependenciesFile: ${file}. Expected a JSON array of package names.`);
+	return value;
+}
+/**
+* Build an `allowBuilds` map from legacy build-script settings.
+*/
+async function collectAllowBuildsFromLegacy(incomingSettings, cwd) {
+	const allowBuilds = {};
+	const allowedFromFile = await readOnlyBuiltDependenciesFile(cwd, incomingSettings.onlyBuiltDependenciesFile);
+	for (const name of [...incomingSettings.onlyBuiltDependencies || [], ...allowedFromFile]) allowBuilds[name] = true;
+	for (const name of incomingSettings.ignoredBuiltDependencies || []) allowBuilds[name] = false;
+	for (const name of incomingSettings.neverBuiltDependencies || []) allowBuilds[name] = false;
+	return Object.keys(allowBuilds).length ? allowBuilds : void 0;
+}
+/**
+* Resolve the pnpm v11 replacement for legacy package-manager settings.
+*/
+function resolvePmOnFail(settings) {
+	if (settings.pmOnFail) return settings.pmOnFail;
+	if (settings.packageManagerStrictVersion === true) return "error";
+	if (settings.packageManagerStrict === false) return "warn";
+	if (settings.managePackageManagerVersions === false) return "ignore";
+	if (settings.managePackageManagerVersions === true) return "download";
+}
+/**
+* Rename legacy audit settings while preserving values for manual ID updates.
+*/
+function normalizeAuditConfig(settings, warnings) {
+	const { auditConfig } = settings;
+	const ignoreCves = auditConfig?.ignoreCves;
+	if (!ignoreCves) return;
+	auditConfig.ignoreGhsas ??= ignoreCves;
+	Reflect.deleteProperty(auditConfig, "ignoreCves");
+	warnings.push("auditConfig.ignoreCves was renamed to auditConfig.ignoreGhsas; replace each CVE ID with its corresponding GHSA ID.");
+}
+/**
+* Resolve a removed Node.js runtime setting for migration to `package.json`.
+*/
+function resolveRuntimeVersion(settings, warnings) {
+	const { useNodeVersion } = settings;
+	const executionEnvNodeVersion = settings.executionEnv?.nodeVersion;
+	if (useNodeVersion && executionEnvNodeVersion && useNodeVersion !== executionEnvNodeVersion) warnings.push(`Both useNodeVersion (${useNodeVersion}) and executionEnv.nodeVersion (${executionEnvNodeVersion}) were found; useNodeVersion takes precedence.`);
+	return useNodeVersion || executionEnvNodeVersion;
+}
+/**
+* Normalize settings according to the selected compatibility target.
+*/
+async function normalizeIncomingSettings(incomingSettings, options) {
+	const { compatibility, cwd, replaceDeprecated } = options;
+	const before = JSON.stringify(incomingSettings);
+	const warnings = [];
+	if (compatibility === "v10" && !replaceDeprecated) return {
+		changed: false,
+		warnings
+	};
+	if (incomingSettings.allowNonAppliedPatches !== void 0) incomingSettings.allowUnusedPatches ??= incomingSettings.allowNonAppliedPatches;
+	const allowBuildsFromLegacy = await collectAllowBuildsFromLegacy(incomingSettings, cwd);
+	if (allowBuildsFromLegacy) incomingSettings.allowBuilds = {
+		...allowBuildsFromLegacy,
+		...incomingSettings.allowBuilds || {}
+	};
+	if (compatibility === "v10") {
+		for (const key of PNPM_REPLACEABLE_IN_V10_SETTINGS) Reflect.deleteProperty(incomingSettings, key);
+		return {
+			changed: before !== JSON.stringify(incomingSettings),
+			warnings
+		};
 	}
+	const pmOnFail = resolvePmOnFail(incomingSettings);
+	if (pmOnFail) incomingSettings.pmOnFail = pmOnFail;
+	normalizeAuditConfig(incomingSettings, warnings);
+	const runtimeVersion = resolveRuntimeVersion(incomingSettings, warnings);
+	if (incomingSettings.ignoreDepScripts !== void 0) warnings.push("ignoreDepScripts was removed in pnpm v11 and has no direct replacement.");
+	if (incomingSettings.ignorePatchFailures !== void 0) warnings.push("ignorePatchFailures was removed in pnpm v11; patch failures now always throw.");
+	for (const key of PNPM_V11_REMOVED_SETTINGS) Reflect.deleteProperty(incomingSettings, key);
+	return {
+		changed: before !== JSON.stringify(incomingSettings),
+		runtimeVersion,
+		warnings
+	};
+}
+/**
+* Move a removed Node.js runtime setting to `package.json#devEngines.runtime`.
+*/
+function migrateRuntimeToPackageJson(packageJson, runtimeVersion) {
+	if (!runtimeVersion) return { changed: false };
+	if (packageJson.devEngines?.runtime) return {
+		changed: false,
+		warning: "A devEngines.runtime declaration already exists; the removed pnpm Node.js runtime setting was not applied."
+	};
+	packageJson.devEngines = {
+		...packageJson.devEngines,
+		runtime: {
+			name: "node",
+			version: runtimeVersion
+		}
+	};
+	return { changed: true };
+}
+/**
+* Select the runtime setting that wins under the configured merge strategy.
+*/
+function resolveRuntimeVersionByStrategy(existingVersion, incomingVersion, strategy) {
+	if (strategy === "overwrite") return incomingVersion ?? existingVersion;
+	return existingVersion ?? incomingVersion;
+}
+//#endregion
+//#region src/utils/compatibility-target.ts
+const PNPM_V11_MAJOR = 11;
+const PNPM_V12_MAJOR = 12;
+/**
+* Resolve final compatibility target from user option and package manager hint.
+*/
+function resolveCompatibilityTarget(compatibility, packageManager, devPackageManager) {
+	if (compatibility !== "auto") return compatibility;
+	const match = (packageManager || (devPackageManager?.name === "pnpm" ? `pnpm@${devPackageManager.version}` : void 0))?.match(/^pnpm@[\s<=>^~]*(?<major>\d+)(?:\.|\s|$)/u);
+	const major = Number(match?.groups?.major);
+	if (major >= PNPM_V12_MAJOR) return "v12";
+	return major >= PNPM_V11_MAJOR ? "v11" : "v10";
 }
+//#endregion
+//#region src/utils/merge.ts
 /**
 * Merge objects with priority to the first argument.
 * Only adds keys from second argument that don't exist in first.
@@ -309,11 +431,43 @@ function mergeWithArrayDedupe(existing, incoming) {
 	for (const [key, incomingValue] of Object.entries(incoming)) {
 		const existingValue = result[key];
 		if (isUndefined(existingValue)) result[key] = incomingValue;
-		else if (Array.isArray(existingValue) && Array.isArray(incomingValue)) result[key] = Array.from(new Set([...existingValue, ...incomingValue]));
+		else if (Array.isArray(existingValue) && Array.isArray(incomingValue)) result[key] = Array.from(/* @__PURE__ */ new Set([...existingValue, ...incomingValue]));
 		else if (isPlainObject(existingValue) && isPlainObject(incomingValue)) result[key] = mergeWithArrayDedupe(existingValue, incomingValue);
 	}
 	return result;
 }
+/**
+* Merge two objects based on the specified strategy.
+*
+* @param existing - Existing pnpm-workspace.yaml content
+* @param incoming - New settings from package.json and .npmrc
+* @param strategy - Merge strategy to use
+*
+* @returns Merged pnpm workspace configuration
+*
+* @example
+* ```ts
+* // Discard strategy - keep existing values
+* mergeByStrategy({ packages: ['a'] }, { packages: ['b'] }, 'discard')
+* // => { packages: ['a'] }
+*
+* // Merge strategy - combine arrays with deduplication
+* mergeByStrategy({ packages: ['a'] }, { packages: ['b'] }, 'merge')
+* // => { packages: ['a', 'b'] }
+*
+* // Overwrite strategy - use incoming values
+* mergeByStrategy({ packages: ['a'] }, { packages: ['b'] }, 'overwrite')
+* // => { packages: ['b'] }
+* ```
+*/
+function mergeByStrategy(existing, incoming, strategy) {
+	switch (strategy) {
+		case "discard": return discardMerge(existing, incoming);
+		case "merge": return mergeWithArrayDedupe(existing, incoming);
+		case "overwrite": return discardMerge(incoming, existing);
+		default: return defu(existing, incoming);
+	}
+}
 //#endregion
 //#region src/utils/npmrc.ts
 const NPMRC_AUTH_OR_REGISTRY_KEYS = [
@@ -332,6 +486,33 @@ const NPMRC_AUTH_OR_REGISTRY_KEYS = [
 	"tokenhelper",
 	"username"
 ];
+const NODE_MIRROR_KEY_PATTERN = /^node-mirror:(?<channel>.+)$/iu;
+/**
+* Normalize `.npmrc` key for case-insensitive matching.
+*/
+function normalizeNpmrcKey(key) {
+	return key.trim().replace(/\[\]$/u, "").toLowerCase();
+}
+/**
+* Extract key name from a raw `.npmrc` line.
+*/
+function getNpmrcLineKey(line) {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith(";") || trimmed.startsWith("#")) return;
+	const index = trimmed.indexOf("=");
+	if (index <= 0) return;
+	return normalizeNpmrcKey(trimmed.slice(0, index));
+}
+/**
+* Check whether a `.npmrc` key is auth/registry-related and should stay in
+* pnpm v11 and newer.
+*/
+function isNpmrcAuthOrRegistryKey(key) {
+	const normalized = normalizeNpmrcKey(key);
+	if (normalized.startsWith("//")) return true;
+	if (normalized === "registry" || normalized.endsWith(":registry")) return true;
+	return NPMRC_AUTH_OR_REGISTRY_KEYS.some((authKey) => normalized === authKey || normalized.endsWith(`:${authKey}`));
+}
 /**
 * Remove pnpm-related settings from `.npmrc` file.
 *
@@ -351,14 +532,19 @@ const NPMRC_AUTH_OR_REGISTRY_KEYS = [
 * ```
 */
 async function pruneNpmrc(path, compatibility = "v10", migratedKeys = []) {
-	const pnpmSettingsFields = PNPM_SETTINGS_FIELDS.map((v) => kebabCase(v));
+	const pnpmSettingsFields = PNPM_SETTINGS_FIELDS.map((field) => kebabCase(field));
 	const migratedKeySet = new Set(migratedKeys.map(normalizeNpmrcKey));
-	await fsWriteFile(path, (await fsReadFile(path)).split(/\r?\n/).filter((line) => {
+	const updatedContent = (await fsReadFile(path)).split(/\r?\n/u).filter((line) => {
 		const key = getNpmrcLineKey(line);
 		if (!key) return true;
-		if (compatibility === "v11") return !migratedKeySet.has(normalizeNpmrcKey(key));
-		return !pnpmSettingsFields.some((v) => key.startsWith(v));
-	}).join("\n"));
+		if (compatibility !== "v10") return !migratedKeySet.has(normalizeNpmrcKey(key));
+		return !pnpmSettingsFields.some((field) => key.startsWith(field));
+	}).join("\n").trimEnd();
+	if (compatibility !== "v10" && !updatedContent.trim()) {
+		await fsRemoveFile(path);
+		return;
+	}
+	await fsWriteFile(path, updatedContent);
 }
 /**
 * Read and parse `.npmrc` file with camelCase key conversion.
@@ -382,56 +568,87 @@ async function pruneNpmrc(path, compatibility = "v10", migratedKeys = []) {
 /**
 * Read `.npmrc` and return settings that should be migrated into workspace config.
 *
-* - `v10`: returns all keys (legacy whitelist filtering happens in caller).
-* - `v11`: excludes auth/registry keys because pnpm still reads them from `.npmrc`.
+* - `v10`: returns settings from the legacy whitelist.
+* - `v11+`: excludes auth/registry keys because pnpm still reads them from
+*   `.npmrc`.
 */
 async function readMigratableNpmrc(path, compatibility) {
 	const raw = await readIniFile(path);
-	if (compatibility === "v10") return {
-		keys: Object.keys(raw),
-		settings: camelcaseKeys(raw)
-	};
+	if (compatibility === "v10") {
+		const settings = camelcaseKeys(raw);
+		return {
+			keys: PNPM_SETTINGS_FIELDS,
+			settings: pick(settings, PNPM_SETTINGS_FIELDS)
+		};
+	}
 	const migratable = {};
 	const keys = [];
+	const nodeDownloadMirrors = {};
 	for (const [key, value] of Object.entries(raw)) if (!isNpmrcAuthOrRegistryKey(key)) {
-		migratable[key] = value;
 		keys.push(key);
+		const nodeMirrorMatch = normalizeNpmrcKey(key).match(NODE_MIRROR_KEY_PATTERN);
+		if (nodeMirrorMatch?.groups?.channel) nodeDownloadMirrors[nodeMirrorMatch.groups.channel] = String(value);
+		else migratable[key] = value;
 	}
+	const settings = camelcaseKeys(migratable);
+	if (Object.keys(nodeDownloadMirrors).length) settings.nodeDownloadMirrors = nodeDownloadMirrors;
 	return {
 		keys,
-		settings: camelcaseKeys(migratable)
+		settings
 	};
 }
-async function readNpmrc(path) {
-	return camelcaseKeys(await readIniFile(path));
+//#endregion
+//#region src/utils/config.ts
+function resolveYamlIndent(content) {
+	const detectedIndent = detectIndent(content).amount;
+	return detectedIndent > 0 ? detectedIndent : 2;
 }
-/**
-* Extract key name from a raw `.npmrc` line.
-*/
-function getNpmrcLineKey(line) {
-	const trimmed = line.trim();
-	if (!trimmed || trimmed.startsWith(";") || trimmed.startsWith("#")) return;
-	const index = trimmed.indexOf("=");
-	if (index <= 0) return;
-	return normalizeNpmrcKey(trimmed.slice(0, index));
+async function readPackageJson(path, exists) {
+	if (!exists) return {
+		indent: 2,
+		value: {}
+	};
+	const content = await fsReadFile(path);
+	return {
+		indent: detectIndent(content).indent,
+		value: JSON.parse(content)
+	};
 }
-/**
-* Check whether a `.npmrc` key is auth/registry-related and should stay in v11.
-*/
-function isNpmrcAuthOrRegistryKey(key) {
-	const normalized = normalizeNpmrcKey(key);
-	if (normalized.startsWith("//")) return true;
-	if (normalized === "registry" || normalized.endsWith(":registry")) return true;
-	return NPMRC_AUTH_OR_REGISTRY_KEYS.some((v) => normalized === v || normalized.endsWith(`:${v}`));
+async function readPnpmWorkspace(path, exists) {
+	if (!exists) return {
+		indent: 2,
+		value: {}
+	};
+	const content = await fsReadFile(path);
+	return {
+		indent: resolveYamlIndent(content),
+		value: parse(content) ?? {}
+	};
 }
-/**
-* Normalize `.npmrc` key for case-insensitive matching.
-*/
-function normalizeNpmrcKey(key) {
-	return key.trim().replace(/\[\]$/, "").toLowerCase();
+function resolvePackageJsonSettings(packageJson, yarnResolutions) {
+	const pnpmSettings = yarnResolutions && packageJson.resolutions ? {
+		...packageJson.pnpm,
+		overrides: defu(packageJson.pnpm?.overrides, packageJson.resolutions)
+	} : { ...packageJson.pnpm };
+	if (pnpmSettings.overrides && !Object.keys(pnpmSettings.overrides).length) delete pnpmSettings.overrides;
+	return pnpmSettings;
 }
 //#endregion
 //#region src/core.ts
+function hasSettingsSources(npmrcExists, packageJsonExists, pnpmWorkspaceExists) {
+	if (!npmrcExists) consola$1.info(`${dim(NPMRC)} not found`);
+	if (!packageJsonExists) consola$1.info(`${dim(PACKAGE_JSON)} not found`);
+	if (npmrcExists || packageJsonExists || pnpmWorkspaceExists) return true;
+	consola$1.warn("No pnpm settings files to migrate");
+	return false;
+}
+function hasMigratableSettings(sources) {
+	const { existingSettingsChanged, packageJson, pnpmSettingsInNpmrc, yarnResolutions } = sources;
+	return Boolean(existingSettingsChanged || packageJson.pnpm || yarnResolutions && packageJson.resolutions || Object.keys(pnpmSettingsInNpmrc).length);
+}
+function assertCanMigrateRuntime(runtimeVersion, packageJsonExists) {
+	if (runtimeVersion && !packageJsonExists) throw new Error("Cannot migrate the removed Node.js runtime setting without a package.json file.");
+}
 /**
 * Migrate pnpm settings from legacy locations to `pnpm-workspace.yaml`.
 *
@@ -440,6 +657,7 @@ function normalizeNpmrcKey(key) {
 * - `package.json` pnpm field
 * - `.npmrc` pnpm-related settings
 * - `package.json` resolutions (optional, converts to pnpm overrides)
+* - deprecated settings already present in `pnpm-workspace.yaml`
 *
 * @param rawOptions - Migration options
 * @param rawOptions.cwd - Current working directory (default: process.cwd())
@@ -477,53 +695,43 @@ async function migratePnpmSettings(rawOptions = {}) {
 			fsExists(packageJsonPath),
 			fsExists(pnpmWorkspaceYamlPath)
 		]);
-		if (!npmrcExists) consola.info(`${dim(NPMRC)} not found`);
-		if (!packageJsonExists) consola.info(`${dim(PACKAGE_JSON)} not found`);
-		if (!npmrcExists && !packageJsonExists) {
-			consola.warn("No pnpm settings files to migrate");
-			return;
-		}
-		let packageJsonIndent = 2;
-		let packageJsonObject = {};
-		let pnpmWorkspaceYamlIndent = 2;
-		let pnpmWorkspaceYamlObject = {};
-		if (packageJsonExists) {
-			const content = await fsReadFile(packageJsonPath);
-			packageJsonIndent = detectIndent(content).indent;
-			packageJsonObject = JSON.parse(content);
-		}
-		if (pnpmWorkspaceExists) {
-			const content = await fsReadFile(pnpmWorkspaceYamlPath);
-			pnpmWorkspaceYamlIndent = detectIndent(content).amount;
-			pnpmWorkspaceYamlObject = parse(content);
-		}
-		const compatibility = resolveCompatibilityTarget(options.compatibility, packageJsonObject.packageManager);
-		const npmrcMigratable = npmrcExists ? compatibility === "v10" ? {
-			keys: PNPM_SETTINGS_FIELDS,
-			settings: pick(await readNpmrc(npmrcPath), PNPM_SETTINGS_FIELDS)
-		} : await readMigratableNpmrc(npmrcPath, compatibility) : {
+		if (!hasSettingsSources(npmrcExists, packageJsonExists, pnpmWorkspaceExists)) return;
+		const [packageJson, pnpmWorkspace] = await Promise.all([readPackageJson(packageJsonPath, packageJsonExists), readPnpmWorkspace(pnpmWorkspaceYamlPath, pnpmWorkspaceExists)]);
+		const compatibility = resolveCompatibilityTarget(options.compatibility, packageJson.value.packageManager, packageJson.value.devEngines?.packageManager);
+		const npmrcMigratable = npmrcExists ? await readMigratableNpmrc(npmrcPath, compatibility) : {
 			keys: [],
 			settings: {}
 		};
 		const pnpmSettingsInNpmrc = npmrcMigratable.settings;
-		const hasPnpmInPackageJson = !!packageJsonObject.pnpm;
-		const hasResolutions = options.yarnResolutions && !!packageJsonObject.resolutions;
-		const hasNpmrcSettings = Object.keys(pnpmSettingsInNpmrc).length > 0;
-		if (!hasPnpmInPackageJson && !hasResolutions && !hasNpmrcSettings) {
-			consola.warn("No pnpm settings fields to migrate");
-			return;
-		}
-		const pnpmSettingsInPackageJson = options.yarnResolutions && packageJsonObject.resolutions ? {
-			...packageJsonObject.pnpm,
-			overrides: defu(packageJsonObject.pnpm?.overrides, packageJsonObject.resolutions)
-		} : { ...packageJsonObject.pnpm };
-		if (pnpmSettingsInPackageJson.overrides && !Object.keys(pnpmSettingsInPackageJson.overrides).length) delete pnpmSettingsInPackageJson.overrides;
+		const pnpmSettingsInPackageJson = resolvePackageJsonSettings(packageJson.value, options.yarnResolutions);
 		const incomingSettings = {
 			...pnpmSettingsInNpmrc,
 			...pnpmSettingsInPackageJson
 		};
-		normalizeIncomingSettings(incomingSettings, compatibility, options.replaceDeprecated);
-		const pnpmWorkspaceResult = mergeByStrategy(pnpmWorkspaceYamlObject, incomingSettings, options.strategy);
+		const [existingNormalization, incomingNormalization] = await Promise.all([normalizeIncomingSettings(pnpmWorkspace.value, {
+			compatibility,
+			cwd: options.cwd,
+			replaceDeprecated: options.replaceDeprecated
+		}), normalizeIncomingSettings(incomingSettings, {
+			compatibility,
+			cwd: options.cwd,
+			replaceDeprecated: options.replaceDeprecated
+		})]);
+		for (const warning of [...existingNormalization.warnings, ...incomingNormalization.warnings]) consola$1.warn(warning);
+		const runtimeVersion = resolveRuntimeVersionByStrategy(existingNormalization.runtimeVersion, incomingNormalization.runtimeVersion, options.strategy);
+		assertCanMigrateRuntime(runtimeVersion, packageJsonExists);
+		const runtimeMigration = migrateRuntimeToPackageJson(packageJson.value, runtimeVersion);
+		if (runtimeMigration.warning) consola$1.warn(runtimeMigration.warning);
+		if (!hasMigratableSettings({
+			existingSettingsChanged: existingNormalization.changed,
+			packageJson: packageJson.value,
+			pnpmSettingsInNpmrc,
+			yarnResolutions: options.yarnResolutions
+		})) {
+			consola$1.warn("No pnpm settings fields to migrate");
+			return;
+		}
+		const pnpmWorkspaceResult = mergeByStrategy(pnpmWorkspace.value, incomingSettings, options.strategy);
 		const yamlDocument = new Document({}, { sortMapEntries: options.sortKeys });
 		Object.entries(pnpmWorkspaceResult).forEach(([key, value]) => {
 			yamlDocument.add({
@@ -531,63 +739,37 @@ async function migratePnpmSettings(rawOptions = {}) {
 				value
 			});
 		});
-		const yamlContent = yamlDocument.toString({ indent: pnpmWorkspaceYamlIndent });
-		await fsWriteFile(pnpmWorkspaceYamlPath, options.newlineBetween ? yamlContent.replace(/\n(?=[^\s#][^:\n]*:)/g, "\n\n") : yamlContent);
+		const yamlContent = yamlDocument.toString({ indent: pnpmWorkspace.indent });
+		await fsWriteFile(pnpmWorkspaceYamlPath, options.newlineBetween ? yamlContent.replace(/\n(?=[^\s#][^:\n]*:)/gu, "\n\n") : yamlContent);
 		if (npmrcExists && options.cleanNpmrc) await pruneNpmrc(npmrcPath, compatibility, npmrcMigratable.keys);
-		if (packageJsonExists && options.cleanPackageJson && (packageJsonObject.pnpm || packageJsonObject.resolutions)) {
-			delete packageJsonObject.pnpm;
-			if (options.yarnResolutions) delete packageJsonObject.resolutions;
-			await fsWriteFile(packageJsonPath, JSON.stringify(packageJsonObject, null, packageJsonIndent));
+		let packageJsonChanged = runtimeMigration.changed;
+		if (packageJsonExists && options.cleanPackageJson) {
+			if (packageJson.value.pnpm) packageJsonChanged = true;
+			delete packageJson.value.pnpm;
+			if (options.yarnResolutions && packageJson.value.resolutions) {
+				packageJsonChanged = true;
+				delete packageJson.value.resolutions;
+			}
 		}
+		if (packageJsonExists && packageJsonChanged) await fsWriteFile(packageJsonPath, JSON.stringify(packageJson.value, null, packageJson.indent));
 	} catch (err) {
-		consola.error("Failed to migrate pnpm settings:", err);
+		consola$1.error("Failed to migrate pnpm settings:", err);
 		throw err;
 	}
 }
-/**
-* Build v11 `allowBuilds` map from legacy build-script settings.
-*/
-function collectAllowBuildsFromLegacy(incomingSettings) {
-	const allowBuilds = {};
-	for (const name of incomingSettings.onlyBuiltDependencies || []) allowBuilds[name] = true;
-	for (const name of incomingSettings.ignoredBuiltDependencies || []) allowBuilds[name] = false;
-	for (const name of incomingSettings.neverBuiltDependencies || []) allowBuilds[name] = false;
-	return Object.keys(allowBuilds).length ? allowBuilds : void 0;
-}
-/**
-* Normalize incoming settings according to compatibility target.
-*/
-function normalizeIncomingSettings(incomingSettings, compatibility, replaceDeprecated) {
-	if (compatibility === "v10" && !replaceDeprecated) return;
-	if (incomingSettings.allowNonAppliedPatches !== void 0) incomingSettings.allowUnusedPatches = incomingSettings.allowUnusedPatches ?? incomingSettings.allowNonAppliedPatches;
-	const allowBuildsFromLegacy = collectAllowBuildsFromLegacy(incomingSettings);
-	if (allowBuildsFromLegacy) incomingSettings.allowBuilds = {
-		...allowBuildsFromLegacy,
-		...incomingSettings.allowBuilds || {}
-	};
-	for (const key of PNPM_V11_REMOVED_SETTINGS) delete incomingSettings[key];
-}
-/**
-* Resolve final compatibility target from user option and package manager hint.
-*/
-function resolveCompatibilityTarget(compatibility, packageManager) {
-	if (compatibility !== "auto") return compatibility;
-	const [, major] = (packageManager || "").match(/^pnpm@(\d+)(?:\.|$)/) || [];
-	return Number(major) >= 11 ? "v11" : "v10";
-}
 //#endregion
 //#region src/cli.ts
 const cli = cac(name);
-cli.version(version).option("--cwd [cwd]", "Current working directory").option("--sort-keys", "Sort keys when write pnpm-workspace.yaml").option("--compatibility <compatibility>", "Compatibility target (auto, v10, v11)").option("--replace-deprecated", "Replace deprecated pnpm settings with new ones and remove old keys").option("--strategy <strategy>", "Strategy to handle conflicts (discard, merge, overwrite)").option("--no-yarn-resolutions", "Disable migrating resolutions field in package.json").option("--no-newline-between", "Disable adding newlines between each root keys").option("--no-clean-npmrc", "Disable removing pnpm settings in .npmrc file").option("--no-clean-package-json", "Disable removing pnpm fields in package.json").help();
+cli.version(version).option("--cwd [cwd]", "Current working directory").option("--sort-keys", "Sort keys when write pnpm-workspace.yaml").option("--compatibility <compatibility>", "Compatibility target (auto, v10, v11, v12)").option("--replace-deprecated", "Replace deprecated pnpm settings with new ones and remove old keys").option("--strategy <strategy>", "Strategy to handle conflicts (discard, merge, overwrite)").option("--no-yarn-resolutions", "Disable migrating resolutions field in package.json").option("--no-newline-between", "Disable adding newlines between each root keys").option("--no-clean-npmrc", "Disable removing pnpm settings in .npmrc file").option("--no-clean-package-json", "Disable removing pnpm fields in package.json").help();
 cli.command("").action(async (options) => {
 	try {
-		consola$1.log(`\n${bold(magenta(name))} ${dim(`v${version}`)}`);
-		consola$1.log(dim("\n--------------\n"));
+		consola.log(`\n${bold(magenta(name))} ${dim(`v${version}`)}`);
+		consola.log(dim("\n--------------\n"));
 		await migratePnpmSettings(options);
-		consola$1.success(green("pnpm settings migrate has finished"));
+		consola.success(green("pnpm settings migrate has finished"));
 	} catch (err) {
-		consola$1.fail(red(String(err)));
-		if (err instanceof Error && err.stack) consola$1.fail(dim(err.stack?.split("\n").slice(1).join("\n")));
+		consola.fail(red(String(err)));
+		if (err instanceof Error && err.stack) consola.fail(dim(err.stack?.split("\n").slice(1).join("\n")));
 		process.exit(1);
 	}
 });