vite-plus 0.2.9 → 0.3.0

package/dist/{editor-g4PosU99.js → editor-CC4DqODz.js}

@@ -1,23 +1,24 @@
 import { r as __toESM } from "./rolldown-runtime-CMFfr-1z.js";
-import { a as VITEST_AGE_GATE_EXEMPT_PACKAGES, c as VITE_PLUS_NAME, f as isForceOverrideMode, l as VITE_PLUS_OVERRIDE_PACKAGES, n as BASEURL_TSCONFIG_WARNING, o as VITEST_VERSION, s as VITE_CONFIG_FILES, u as VITE_PLUS_VERSION } from "./constants-CG513DRa.js";
-import { i as ensureVitePlusImportRuleDefaults, r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-BEZ9IUf7.js";
-import { A as isCancel, C as log, E as select, M as runCommandSilently, N as require_cross_spawn, _ as getSpinner, b as require_semver, d as readYamlFile, f as scalarString, g as getSilentSpinner, t as cancelAndExit, u as editYamlFile, w as multiselect, x as confirm, y as PackageManager } from "./prompts-CHz_98bJ.js";
-import { a as writeJsonFile, c as parse, i as readJsonFile, n as editJsonFile, o as applyEdits, r as isJsonFile, s as modify, t as detectFormattingOptions } from "./json-qlK6UH0r.js";
+import { a as TSDOWN_MIGRATE_VERSION, c as VITEST_VERSION, d as VITE_PLUS_OVERRIDE_PACKAGES, f as VITE_PLUS_VERSION, l as VITE_CONFIG_FILES, m as isForceOverrideMode, n as BASEURL_TSCONFIG_WARNING, o as TSDOWN_MIGRATION_SKILL_URL, s as VITEST_AGE_GATE_EXEMPT_PACKAGES, u as VITE_PLUS_NAME } from "./constants-Bn-U8o4v.js";
+import { i as ensureVitePlusImportRuleDefaults, r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-DX5ezKbB.js";
+import { A as isCancel, C as log, E as select, _ as getSpinner, b as require_semver, d as readYamlFile, f as scalarString, g as getSilentSpinner, t as cancelAndExit, u as editYamlFile, w as multiselect, x as confirm, y as PackageManager } from "./prompts-DF3yU-eU.js";
+import { a as writeJsonFile, c as parse, i as readJsonFile, n as editJsonFile, o as applyEdits, r as isJsonFile, s as modify, t as detectFormattingOptions } from "./json-cULBl7Pi.js";
+import { n as detectPackageMetadata, r as getScopeFromPackageName } from "./package-CBe9EWPY.js";
+import { l as displayRelative, u as rulesDir } from "./agent-Wqx0MPk0.js";
+import { n as addMigrationWarning, t as addManualStep } from "./report-ZNR1Mk6h.js";
+import { n as runCommandSilently, r as require_cross_spawn } from "./command-CguLh2KL.js";
 import { t as require_dist } from "./dist-BDYZP12R.js";
-import { a as hasTypesToRewriteInTsconfig, c as rewriteTypesInTsconfig, i as hasBaseUrlInTsconfig, n as findTsconfigFiles, o as hasVitestTypesInTsconfig, s as removeDeprecatedTsconfigFalseOption } from "./tsconfig-7v_BHagU.js";
-import { n as detectPackageMetadata, r as getScopeFromPackageName } from "./package-B4T8RGMG.js";
-import { l as displayRelative, u as rulesDir } from "./agent-DQU8uS6P.js";
-import { n as addMigrationWarning, t as addManualStep } from "./report-BS7ULx7A.js";
-import { a as findUnsafeHookInstallPath, n as SUPPORTED_GIT_HOOK_NAMES } from "./hooks-pNCBWtFT.js";
+import { a as hasBaseUrlInTsconfig, c as hasVitestTypesInTsconfig, l as removeDeprecatedTsconfigFalseOption, n as findTsconfigFiles, s as hasTypesToRewriteInTsconfig, u as rewriteTypesInTsconfig } from "./tsconfig-LD2QhQ0O.js";
+import { a as findUnsafeHookInstallPath, n as SUPPORTED_GIT_HOOK_NAMES } from "./hooks-DFqViZqZ.js";
 import path, { posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { detectWorkspace, hasConfigKey, mergeJsonConfig, mergeTsdownConfig, rewriteEslint, rewriteImportsInDirectory, rewritePrettier, rewriteScripts, wrapLazyPlugins } from "../binding/index.js";
+import { detectWorkspace, getVpDirs, hasConfigKey, mergeJsonConfig, mergeTsdownConfig, rewriteEslint, rewriteImportsInDirectory, rewritePrettier, rewriteScripts, wrapLazyPlugins } from "../binding/index.js";
 import { styleText } from "node:util";
 import * as actualFS from "node:fs";
 import fs from "node:fs";
 import os from "node:os";
-import { lstatSync as lstatSync$1, readdir, readdirSync as readdirSync$1, readlinkSync, realpathSync as realpathSync$1 } from "fs";
 import "oxlint";
+import { lstatSync as lstatSync$1, readdir, readdirSync as readdirSync$1, readlinkSync, realpathSync as realpathSync$1 } from "fs";
 import fsPromises, { lstat, readdir as readdir$1, readlink, realpath } from "node:fs/promises";
 import { EventEmitter } from "node:events";
 import Stream from "node:stream";
@@ -82,6 +83,48 @@ const VITEST_BROWSER_DEP_NAMES = [
 ];
 const VITEST_IS_MANAGED_OVERRIDE = "vitest" in VITE_PLUS_OVERRIDE_PACKAGES;
 const LEGACY_WRAPPER_FALLBACK_VERSIONS = { vitest: VITEST_VERSION };
+/**
+* Managed pnpm override keys use an explicit `@*` range, not a bare package
+* name: `vite@*`, not `vite`.
+*
+* pnpm applies overrides through a read-package hook. The hook replaces the
+* declared spec on every manifest, importer manifests included, before
+* resolution runs. A bare override key has no range, and pnpm treats a key with
+* no range as a match for every declared spec. That includes `catalog:`. An
+* importer that declares `vite: "catalog:"` therefore loses its link to the
+* catalog during resolution, and `pnpm update` then writes the resolved core
+* alias into that importer's package.json (issue #2309).
+*
+* The `@*` range keeps the override on the declared semver ranges that
+* transitive and peer `vite` declarations use. Those declarations are the
+* reason this override exists. The range leaves `catalog:` specs alone, because
+* `catalog:` is not a valid semver range, so pnpm's `isIntersectingRange`
+* rejects it before it compares anything. The installed result does not change:
+* an importer that references the catalog already resolves to the aliased core
+* through its catalog entry.
+*
+* Known gap on pnpm 9 to 11: a declaration that pins an EXACT prerelease, such
+* as `vite: "8.0.0-beta.18"`, escapes the override. pnpm compares with
+* `semver.intersects(declaredSpec, keyRange)`. That call is asymmetric for
+* prereleases: it returns false for an exact prerelease against a wildcard
+* range. The reversed argument order returns true. No range string avoids
+* this, because node-semver only admits a prerelease when a comparator carries
+* the same version tuple. A prerelease RANGE such as `^8.0.0-beta.1` still
+* matches. pnpm 12 matches the exact form too. A bare key would cover this
+* case, but a bare key is what clobbers `catalog:` specs. Below pnpm 12,
+* prerelease coverage and `catalog:` safety cannot both hold.
+*
+* This applies to pnpm only. npm and bun `overrides`, and yarn `resolutions`,
+* keep bare keys. Those package managers have no `catalog:` importer specs to
+* lose. Bun catalogs live in package.json, and bun resolves them before it
+* applies overrides.
+*/
+function pnpmOverrideKey(dependencyName) {
+	return `${dependencyName}@*`;
+}
+function managedOverrideKey(dependencyName, keyStyle) {
+	return keyStyle === "pnpm-ranged" ? pnpmOverrideKey(dependencyName) : dependencyName;
+}
 function warnMigration(message, report) {
 	addMigrationWarning(report, message);
 	if (!report) log.warn(message);
@@ -132,6 +175,16 @@ function pnpmMajor(version) {
 //#endregion
 //#region src/migration/detector.ts
 const PRETTIER_PACKAGE_JSON_CONFIG = "package.json#prettier";
+const TSUP_PACKAGE_JSON_CONFIG = "package.json#tsup";
+const TSUP_CONFIG_FILES = [
+	"tsup.config.ts",
+	"tsup.config.mts",
+	"tsup.config.cts",
+	"tsup.config.js",
+	"tsup.config.mjs",
+	"tsup.config.cjs",
+	"tsup.config.json"
+];
 const PRETTIER_CONFIG_FILES = [
 	".prettierrc",
 	".prettierrc.json",
@@ -182,6 +235,10 @@ function detectConfigs(projectPath) {
 		configs.tsdownConfig = config;
 		break;
 	}
+	for (const config of TSUP_CONFIG_FILES) if (fs.existsSync(path.join(projectPath, config))) {
+		configs.tsupConfig = config;
+		break;
+	}
 	for (const config of [".oxlintrc.json", ".oxlintrc.jsonc"]) if (fs.existsSync(path.join(projectPath, config))) {
 		configs.oxlintConfig = config;
 		break;
@@ -223,6 +280,7 @@ function detectConfigs(projectPath) {
 		const content = fs.readFileSync(packageJsonPath, "utf8");
 		const pkg = JSON.parse(content);
 		if (!configs.prettierConfig && pkg.prettier) configs.prettierConfig = PRETTIER_PACKAGE_JSON_CONFIG;
+		if (!configs.tsupConfig && pkg.tsup) configs.tsupConfig = TSUP_PACKAGE_JSON_CONFIG;
 		const voltaNode = pkg.volta?.node;
 		if (typeof voltaNode === "string") configs.voltaNode = voltaNode;
 	} catch {}
@@ -881,6 +939,397 @@ async function promptPrettierMigration(projectPath, interactive, packages) {
 	return true;
 }
 //#endregion
+//#region src/migration/migrator/tsup.ts
+function showTsdownMigrationOptions(targetLabel = "the project root", automaticMigrationFailed = false) {
+	const lines = [
+		"Choose one of these manual migration methods:",
+		`  1. Run \`vp dlx tsdown-migrate\` in ${targetLabel}.`,
+		"  2. Use the tsdown migration skill:",
+		`     ${TSDOWN_MIGRATION_SKILL_URL}`
+	];
+	if (automaticMigrationFailed) {
+		lines.unshift("Automatic tsup migration failed.", "");
+		lines.push("");
+	}
+	log.info(lines.join("\n"));
+}
+function showTsdownMigrationSkillGuidance(instructions) {
+	log.info([
+		...instructions,
+		"",
+		"Use the tsdown migration skill for guidance:",
+		`  ${TSDOWN_MIGRATION_SKILL_URL}`
+	].join("\n"));
+}
+function detectTsupProject(projectPath, packages) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	let hasDependency = false;
+	if (fs.existsSync(packageJsonPath)) {
+		const pkg = readJsonFile(packageJsonPath);
+		hasDependency = !!(pkg.devDependencies?.tsup || pkg.dependencies?.tsup);
+	}
+	const configFile = detectConfigs(projectPath).tsupConfig;
+	let hasConfig = !!configFile;
+	for (const wp of packages ?? []) {
+		const workspacePath = path.join(projectPath, wp.path);
+		hasConfig ||= !!detectConfigs(workspacePath).tsupConfig;
+		if (!hasDependency) {
+			const workspacePackageJsonPath = path.join(workspacePath, "package.json");
+			if (fs.existsSync(workspacePackageJsonPath)) {
+				const workspacePackageJson = readJsonFile(workspacePackageJsonPath);
+				hasDependency = !!(workspacePackageJson.devDependencies?.tsup || workspacePackageJson.dependencies?.tsup);
+			}
+		}
+	}
+	return {
+		hasDependency,
+		hasConfig,
+		configFile
+	};
+}
+const TSDOWN_MIGRATION_FILES = [
+	"package.json",
+	...TSUP_CONFIG_FILES,
+	...TSUP_CONFIG_FILES.map((file) => file.replace("tsup", "tsdown"))
+];
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const STANDARD_TSUP_CONFIG_FILE_PATTERN = TSUP_CONFIG_FILES.flatMap((file) => [file, file.replace("tsup", "tsdown")]).map(escapeRegExp).join("|");
+const TSDOWN_STANDARD_CONFIG_OPTION_RE = new RegExp(String.raw`(\btsdown(?:-node)?\b(?:(?!&&|\|\||[;|]).)*?)\s+(?:--config(?:=|\s+)|-c\s+)["']?(?:\.[\\/])?(?:${STANDARD_TSUP_CONFIG_FILE_PATTERN})["']?(?=\s|$|[;&|])`, "g");
+const TSUP_CONFIG_OPTION_RE = /\btsup(?:-node)?\b(?:(?!&&|\|\||[;|]).)*?\s+(?:--config(?:=|\s+)|-c\s+)(?:"([^"]+)"|'([^']+)'|([^\s;&|]+))(?=\s|$|[;&|])/g;
+function removeStandardTsdownConfigOption(script) {
+	return script.replace(TSDOWN_STANDARD_CONFIG_OPTION_RE, "$1");
+}
+function resolveScriptConfigPath(packagePath, configPath) {
+	return path.resolve(packagePath, configPath.replace(/[\\/]/g, path.sep));
+}
+function collectSharedTsupConfigs(projectPath, packages, tsupTargets) {
+	const migratedConfigPaths = new Set(tsupTargets.flatMap((target) => TSUP_CONFIG_FILES.map((file) => path.join(target, file)).filter((file) => fs.existsSync(file))));
+	const sharedConfigs = /* @__PURE__ */ new Map();
+	const consumers = [{
+		label: "the project root",
+		packagePath: path.resolve(projectPath)
+	}, ...(packages ?? []).map((workspacePackage) => ({
+		label: workspacePackage.path,
+		packagePath: path.resolve(projectPath, workspacePackage.path)
+	}))];
+	for (const { label, packagePath } of consumers) {
+		const packageJsonPath = path.join(packagePath, "package.json");
+		if (!fs.existsSync(packageJsonPath)) continue;
+		const packageJson = readJsonFile(packageJsonPath);
+		for (const [scriptName, script] of Object.entries(packageJson.scripts ?? {})) for (const match of script.matchAll(TSUP_CONFIG_OPTION_RE)) {
+			const configPath = resolveScriptConfigPath(packagePath, match[1] ?? match[2] ?? match[3]);
+			if (!migratedConfigPaths.has(configPath) || path.dirname(configPath) === packagePath) continue;
+			const sharedConfig = sharedConfigs.get(configPath) ?? { consumers: /* @__PURE__ */ new Map() };
+			const consumer = sharedConfig.consumers.get(packagePath) ?? {
+				label,
+				packagePath,
+				scriptNames: /* @__PURE__ */ new Set()
+			};
+			consumer.scriptNames.add(scriptName);
+			sharedConfig.consumers.set(packagePath, consumer);
+			sharedConfigs.set(configPath, sharedConfig);
+		}
+	}
+	return sharedConfigs;
+}
+function collectTsupConfigCollisions(tsupTargets) {
+	const collisions = [];
+	for (const target of tsupTargets) {
+		const tsdownConfig = detectConfigs(target).tsdownConfig;
+		if (tsdownConfig) collisions.push({ configPath: path.join(target, tsdownConfig) });
+		const packageJsonPath = path.join(target, "package.json");
+		if (fs.existsSync(packageJsonPath)) {
+			const packageJson = readJsonFile(packageJsonPath);
+			if (Object.hasOwn(packageJson, "tsdown")) collisions.push({ configPath: `${packageJsonPath}#tsdown` });
+		}
+	}
+	return collisions;
+}
+function collectInlineTsupConfigs(tsupTargets) {
+	return tsupTargets.flatMap((target) => {
+		const packageJsonPath = path.join(target, "package.json");
+		if (!fs.existsSync(packageJsonPath) || !Object.hasOwn(readJsonFile(packageJsonPath), "tsup")) return [];
+		return [{ configPath: `${packageJsonPath}#tsup` }];
+	});
+}
+function isRemovableDefaultConfigArgument(configArgument, defaultConfig) {
+	return !!defaultConfig && (configArgument === defaultConfig || configArgument === `./${defaultConfig}` || configArgument === `.\\${defaultConfig}`);
+}
+function collectUnsupportedTsupConfigConsumers(tsupTargets) {
+	const migratedConfigPaths = new Set(tsupTargets.flatMap((target) => TSUP_CONFIG_FILES.map((file) => path.join(target, file)).filter((file) => fs.existsSync(file))));
+	const unsupported = [];
+	for (const target of tsupTargets) {
+		const packageJsonPath = path.join(target, "package.json");
+		if (!fs.existsSync(packageJsonPath)) continue;
+		const detectedConfig = detectConfigs(target).tsupConfig;
+		const defaultConfigPath = detectedConfig && detectedConfig !== "package.json#tsup" ? path.join(target, detectedConfig) : void 0;
+		const packageJson = readJsonFile(packageJsonPath);
+		for (const [scriptName, script] of Object.entries(packageJson.scripts ?? {})) for (const match of script.matchAll(TSUP_CONFIG_OPTION_RE)) {
+			const configArgument = match[1] ?? match[2] ?? match[3];
+			const configPath = resolveScriptConfigPath(target, configArgument);
+			const isDefaultConfig = configPath === defaultConfigPath && isRemovableDefaultConfigArgument(configArgument, detectedConfig);
+			const isSharedMigratedConfig = migratedConfigPaths.has(configPath) && path.dirname(configPath) !== target;
+			if (!isDefaultConfig && !isSharedMigratedConfig) unsupported.push({
+				configArgument,
+				packagePath: target,
+				scriptName
+			});
+		}
+	}
+	return unsupported;
+}
+function restoreSharedTsupUsage(sharedConfigs, snapshots) {
+	const preservedDependencyTargets = /* @__PURE__ */ new Set();
+	const restoredScripts = /* @__PURE__ */ new Map();
+	for (const [configPath, sharedConfig] of sharedConfigs) {
+		const contents = snapshots.get(configPath);
+		if (contents !== void 0) fs.writeFileSync(configPath, contents);
+		preservedDependencyTargets.add(path.dirname(configPath));
+		for (const consumer of sharedConfig.consumers.values()) {
+			preservedDependencyTargets.add(consumer.packagePath);
+			const scriptNames = restoredScripts.get(consumer.packagePath) ?? /* @__PURE__ */ new Set();
+			for (const scriptName of consumer.scriptNames) scriptNames.add(scriptName);
+			restoredScripts.set(consumer.packagePath, scriptNames);
+		}
+	}
+	for (const target of preservedDependencyTargets) {
+		const packageJsonPath = path.join(target, "package.json");
+		const originalPackageJson = snapshots.get(packageJsonPath);
+		if (!originalPackageJson || !fs.existsSync(packageJsonPath)) continue;
+		const original = JSON.parse(originalPackageJson.toString());
+		editJsonFile(packageJsonPath, (pkg) => {
+			let changed = false;
+			for (const field of ["devDependencies", "dependencies"]) {
+				const spec = original[field]?.tsup;
+				if (spec && pkg[field]?.tsup !== spec) {
+					pkg[field] ??= {};
+					pkg[field].tsup = spec;
+					changed = true;
+				}
+			}
+			for (const scriptName of restoredScripts.get(target) ?? []) {
+				const script = original.scripts?.[scriptName];
+				if (script !== void 0 && pkg.scripts?.[scriptName] !== script) {
+					pkg.scripts ??= {};
+					pkg.scripts[scriptName] = script;
+					changed = true;
+				}
+			}
+			return changed ? pkg : void 0;
+		});
+	}
+	return preservedDependencyTargets;
+}
+function snapshotTsupMigrationTargets(targets) {
+	const snapshots = /* @__PURE__ */ new Map();
+	for (const target of targets) for (const file of TSDOWN_MIGRATION_FILES) {
+		const filePath = path.join(target, file);
+		snapshots.set(filePath, fs.existsSync(filePath) ? fs.readFileSync(filePath) : void 0);
+	}
+	return snapshots;
+}
+function restoreTsupMigrationTargets(snapshots) {
+	const failures = [];
+	for (const [filePath, contents] of snapshots) try {
+		if (contents === void 0) fs.rmSync(filePath, { force: true });
+		else fs.writeFileSync(filePath, contents);
+	} catch {
+		failures.push(displayRelative(filePath));
+	}
+	return failures;
+}
+function extractTsdownMigrationWarnings(output) {
+	return output.toString().replaceAll("\r\n", "\n").split(/\n\s*\n/).map((block) => block.trim().match(/^WARN\s+([\s\S]+)$/)?.[1]?.trim()).filter((warning) => !!warning);
+}
+/** Run `vp dlx tsdown-migrate` in `cwd` with graceful error handling. */
+async function runTsdownMigrateStep(vpBin, cwd, packageManager) {
+	try {
+		const result = await runCommandSilently({
+			command: vpBin,
+			args: [
+				"dlx",
+				`tsdown-migrate@${TSDOWN_MIGRATE_VERSION}`,
+				"--yes",
+				"--package-manager",
+				packageManager,
+				"--no-install"
+			],
+			cwd,
+			envs: process.env
+		});
+		if (result.exitCode !== 0) {
+			const stderr = result.stderr.toString().trim();
+			if (stderr) log.warn(`⚠ ${stderr}`);
+			return {
+				ok: false,
+				warnings: []
+			};
+		}
+		return {
+			ok: true,
+			warnings: [...extractTsdownMigrationWarnings(result.stdout), ...extractTsdownMigrationWarnings(result.stderr)]
+		};
+	} catch {
+		return {
+			ok: false,
+			warnings: []
+		};
+	}
+}
+async function migrateTsupToTsdown(projectPath, interactive, packageManager, tsupConfigFile, packages, options) {
+	const vpBin = process.env.VP_CLI_BIN ?? "vp";
+	const spinner = options?.silent ? getSilentSpinner() : getSpinner(interactive);
+	const rootPath = path.resolve(projectPath);
+	const tsupTargets = [rootPath, ...(packages ?? []).map((p) => path.resolve(rootPath, p.path))].filter((target) => target === rootPath ? !!tsupConfigFile : !!detectConfigs(target).tsupConfig);
+	const configCollisions = collectTsupConfigCollisions(tsupTargets);
+	if (configCollisions.length > 0) {
+		log.warn(`Automatic tsup migration was skipped because these tsdown configs already exist:\n${configCollisions.map(({ configPath }) => `  ${displayRelative(configPath, projectPath)}`).join("\n")}`);
+		showTsdownMigrationSkillGuidance([
+			"Resolve this configuration conflict manually:",
+			"  1. Merge the tsup and tsdown configurations into `pack` in `vite.config.*`.",
+			"  2. Do not run `tsdown-migrate`. It can overwrite the existing tsdown configuration."
+		]);
+		return false;
+	}
+	const inlineTsupConfigs = collectInlineTsupConfigs(tsupTargets);
+	if (inlineTsupConfigs.length > 0) {
+		log.warn(`Automatic tsup migration was skipped because these inline tsup configs cannot be migrated automatically:\n${inlineTsupConfigs.map(({ configPath }) => `  ${displayRelative(configPath, projectPath)}`).join("\n")}`);
+		showTsdownMigrationSkillGuidance([
+			"Resolve this inline configuration manually:",
+			"  1. Move each `package.json#tsup` configuration into `pack` in `vite.config.*`.",
+			"  2. Do not run `tsdown-migrate`. Vite+ Pack does not read `package.json#tsdown`."
+		]);
+		return false;
+	}
+	const unsupportedConfigConsumers = collectUnsupportedTsupConfigConsumers(tsupTargets);
+	if (unsupportedConfigConsumers.length > 0) {
+		log.warn(`Automatic tsup migration was skipped because these scripts use configs that cannot be migrated automatically:\n${unsupportedConfigConsumers.map(({ configArgument, packagePath, scriptName }) => `  ${displayRelative(path.join(packagePath, "package.json"), projectPath)}#${scriptName} -> ${configArgument}`).join("\n")}`);
+		showTsdownMigrationSkillGuidance([
+			"Resolve these config paths manually:",
+			"  1. Migrate each listed config into `pack` in `vite.config.*`.",
+			"  2. Update each listed script.",
+			"  3. Do not run `tsdown-migrate`. It cannot safely resolve these config paths."
+		]);
+		return false;
+	}
+	const sharedConfigs = collectSharedTsupConfigs(projectPath, packages, tsupTargets);
+	let preservedDependencyTargets = /* @__PURE__ */ new Set();
+	if (tsupTargets.length > 0) {
+		const snapshots = snapshotTsupMigrationTargets(tsupTargets);
+		const migrationWarnings = [];
+		spinner.start("Migrating tsup config to tsdown...");
+		for (const target of tsupTargets) {
+			const targetLabel = target === rootPath ? "the project root" : displayRelative(target, projectPath);
+			const migrateResult = await runTsdownMigrateStep(vpBin, target, packageManager);
+			if (!migrateResult.ok) {
+				spinner.stop();
+				const restoreFailures = restoreTsupMigrationTargets(snapshots);
+				if (restoreFailures.length > 0) log.warn(`Could not restore these files after the failed migration:\n${restoreFailures.map((file) => `  ${file}`).join("\n")}`);
+				showTsdownMigrationOptions(targetLabel, true);
+				return false;
+			}
+			for (const warning of migrateResult.warnings) migrationWarnings.push({
+				targetLabel,
+				warning
+			});
+		}
+		spinner.stop("tsup config migrated to tsdown.config");
+		preservedDependencyTargets = restoreSharedTsupUsage(sharedConfigs, snapshots);
+		for (const { targetLabel, warning } of migrationWarnings) {
+			const message = targetLabel === "the project root" ? `tsdown-migrate: ${warning}` : `tsdown-migrate (${targetLabel}): ${warning}`;
+			if (options?.report) addMigrationWarning(options.report, message);
+			else log.warn(message);
+		}
+		for (const [configPath, sharedConfig] of sharedConfigs) {
+			const message = `${displayRelative(configPath, projectPath)} is shared by ${[...sharedConfig.consumers.values()].map((consumer) => consumer.label).toSorted().join(", ")}. It was preserved and must be migrated manually.`;
+			if (options?.report) addMigrationWarning(options.report, message);
+			else log.warn(message);
+		}
+	}
+	if (options?.report) options.report.tsupMigrated = true;
+	for (const target of tsupTargets) {
+		if (!fs.existsSync(path.join(target, "package.json"))) continue;
+		deleteTsupConfigFiles(target, new Set([...sharedConfigs.keys()].filter((configPath) => path.dirname(configPath) === path.resolve(target))), options?.report, options?.silent);
+		rewriteTsupPackageJson(path.join(target, "package.json"), preservedDependencyTargets.has(path.resolve(target)));
+	}
+	return true;
+}
+function deleteTsupConfigFiles(basePath, preservedConfigs, report, silent = false) {
+	const configs = detectConfigs(basePath);
+	if (configs.tsupConfig && configs.tsupConfig !== "package.json#tsup") {
+		const configPath = path.join(basePath, configs.tsupConfig);
+		if (!preservedConfigs.has(configPath) && fs.existsSync(configPath)) {
+			fs.unlinkSync(configPath);
+			if (report) report.removedConfigCount++;
+			if (!silent) log.success(`✔ Removed ${displayRelative(configPath)}`);
+		}
+	}
+	for (const file of TSUP_CONFIG_FILES) {
+		if (file === configs.tsupConfig) continue;
+		const configPath = path.join(basePath, file);
+		if (!preservedConfigs.has(configPath) && fs.existsSync(configPath)) {
+			fs.unlinkSync(configPath);
+			if (report) report.removedConfigCount++;
+			if (!silent) log.success(`✔ Removed ${displayRelative(configPath)}`);
+		}
+	}
+	editJsonFile(path.join(basePath, "package.json"), (pkg) => {
+		if (pkg.tsup) {
+			delete pkg.tsup;
+			return pkg;
+		}
+	});
+}
+function rewriteTsupPackageJson(packageJsonPath, preserveTsupDependency = false) {
+	if (!fs.existsSync(packageJsonPath)) return;
+	editJsonFile(packageJsonPath, (pkg) => {
+		let changed = false;
+		for (const [name, script] of Object.entries(pkg.scripts ?? {})) {
+			const rewritten = removeStandardTsdownConfigOption(script);
+			if (rewritten !== script) {
+				pkg.scripts[name] = rewritten;
+				changed = true;
+			}
+		}
+		if (!preserveTsupDependency) {
+			for (const field of ["devDependencies", "dependencies"]) if (pkg[field]?.tsup) {
+				delete pkg[field].tsup;
+				changed = true;
+			}
+		}
+		return changed ? pkg : void 0;
+	});
+}
+function warnMissingTsupConfig() {
+	log.warn("tsup detected, but no tsup config was found. The tsup setup must be migrated manually.");
+}
+async function confirmTsupMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate tsup config to tsdown using tsdown-migrate?\n  " + styleText("gray", "tsdown is Vite+'s built-in bundler (exposed via `vp pack`) — a mostly drop-in tsup replacement powered by Rolldown. tsdown-migrate converts your existing config automatically."),
+			initialValue: true
+		});
+		if (isCancel(confirmed)) cancelAndExit();
+		if (!confirmed) showTsdownMigrationOptions();
+		return confirmed;
+	}
+	log.info("tsup configuration detected. Auto-migrating to tsdown...");
+	return true;
+}
+async function promptTsupMigration(projectPath, interactive, packageManager, packages) {
+	const tsupProject = detectTsupProject(projectPath, packages);
+	if (!tsupProject.hasDependency) return false;
+	if (!tsupProject.hasConfig) {
+		warnMissingTsupConfig();
+		return false;
+	}
+	if (!await confirmTsupMigration(interactive)) return false;
+	if (!await migrateTsupToTsdown(projectPath, interactive, packageManager, tsupProject.configFile, packages)) cancelAndExit("Complete the tsup migration manually, then re-run `vp migrate`.", 1);
+	return true;
+}
+//#endregion
 //#region src/migration/migrator/tsconfig.ts
 function cleanupDeprecatedTsconfigOptions(projectPath, silent = false, report) {
 	const deprecatedOptions = ["esModuleInterop", "allowSyntheticDefaultImports"];
@@ -1137,17 +1586,21 @@ function projectListsRequiredVitestPeer(projectPath, pkg) {
 function projectUsesVitestDirectly(projectPath, pkg, requiredVitestPeer, preserveNuxtVitestImports = true, precomputedScans) {
 	return projectListsVitestEcosystemDep(pkg) || (requiredVitestPeer ?? projectListsRequiredVitestPeer(projectPath, pkg)) || VITEST_BROWSER_DEP_NAMES.some((name) => pkg.peerDependencies?.[name] !== void 0) || (precomputedScans?.retainedModule ?? sourceTreeReferencesRetainedVitestModule(projectPath)) || preserveNuxtVitestImports && hasNuxtTestUtilsDependency(pkg) || (precomputedScans?.browserMode ?? usesVitestBrowserMode(projectPath));
 }
-function removeManagedVitestEntry(record) {
-	if (VITEST_IS_MANAGED_OVERRIDE && typeof record?.vitest === "string") {
-		delete record.vitest;
-		return true;
+function removeManagedVitestEntry(record, keyStyle = "bare") {
+	if (!VITEST_IS_MANAGED_OVERRIDE || !record) return false;
+	let removed = false;
+	for (const key of managedVitestOverrideKeys(keyStyle)) if (typeof record[key] === "string") {
+		delete record[key];
+		removed = true;
 	}
-	return false;
+	return removed;
 }
-function removeYamlMapVitestEntry(map) {
+function removeYamlMapVitestEntry(map, keyStyle = "bare") {
 	if (!VITEST_IS_MANAGED_OVERRIDE || !(map instanceof import_dist.YAMLMap)) return;
-	const target = map.items.find((item) => item.key instanceof import_dist.Scalar && item.key.value === "vitest")?.key;
-	if (target) map.delete(target);
+	for (const key of managedVitestOverrideKeys(keyStyle)) map.delete(key);
+}
+function managedVitestOverrideKeys(keyStyle) {
+	return keyStyle === "pnpm-ranged" ? ["vitest", pnpmOverrideKey("vitest")] : ["vitest"];
 }
 function removeVitestPeerDependencyRule(peerDependencyRules) {
 	if (!VITEST_IS_MANAGED_OVERRIDE) return;
@@ -1240,7 +1693,7 @@ function vitestEcosystemCatalogReferencesPending(pkg, catalogDependencyResolver)
 		pkg.optionalDependencies
 	]) {
 		if (!dependencies) continue;
-		for (const [name, spec] of Object.entries(dependencies)) if (isAlignableVitestEcosystemPackage(name) && spec.startsWith("catalog:") && catalogDependencyResolver(spec, name) !== "4.1.10") return true;
+		for (const [name, spec] of Object.entries(dependencies)) if (isAlignableVitestEcosystemPackage(name) && spec.startsWith("catalog:") && catalogDependencyResolver(spec, name) !== "4.1.11") return true;
 	}
 	return false;
 }
@@ -6933,10 +7386,12 @@ function rewritePnpmWorkspaceYaml(projectPath, pnpmMajorVersion, shouldAllowBrow
 			const keysSnapshot = overrides.items.map((item) => item.key);
 			for (const keyNode of keysSnapshot) if (shouldDropProviderOverrideKey(keyNode instanceof import_dist.Scalar ? String(keyNode.value ?? "") : String(keyNode ?? ""))) overrides.delete(keyNode);
 		}
-		if (!usesVitest) removeYamlMapVitestEntry(doc.getIn(["overrides"]));
+		if (!usesVitest) removeYamlMapVitestEntry(doc.getIn(["overrides"]), "pnpm-ranged");
 		for (const key of Object.keys(managed)) {
-			const version = getCatalogDependencySpec(getYamlMapScalarStringValue(overrides, key), managed[key], true, { preferredCatalogSpec });
-			doc.setIn(["overrides", scalarString(key)], scalarString(version));
+			const overrideKey = pnpmOverrideKey(key);
+			const version = getCatalogDependencySpec(getYamlMapScalarStringValue(overrides, overrideKey) ?? getYamlMapScalarStringValue(overrides, key), managed[key], true, { preferredCatalogSpec });
+			if (overrides instanceof import_dist.YAMLMap) overrides.delete(key);
+			doc.setIn(["overrides", scalarString(overrideKey)], scalarString(version));
 		}
 		const updatedOverrides = doc.getIn(["overrides"]);
 		const updatedOverrideKeys = updatedOverrides.items.map((item) => item.key);
@@ -7035,14 +7490,17 @@ function getCatalogDependencySpec(currentValue, version, supportCatalog, options
 }
 /**
 * #1932: under pnpm, an importer that depends on `vite-plus` (which bundles
-* `vitest`) needs a DIRECT `vite` devDep so the `vite` override binds vitest's
-* required `vite` peer to @voidzero-dev/vite-plus-core. Without a direct edge,
-* pnpm's `autoInstallPeers` fabricates a separate upstream `vite` to satisfy the
+* `vitest`) needs a DIRECT `vite` devDep pointing at @voidzero-dev/vite-plus-core
+* so vitest's required `vite` peer binds to it. Without a direct edge, pnpm's
+* `autoInstallPeers` fabricates a separate upstream `vite` to satisfy the
 * peer, splitting vite-plus / vite / vitest into duplicate instances (the extra
 * vite also lacks vite's `@voidzero-dev/vite-task-client` integration, breaking
-* the `vp test` cache). npm/yarn/bun redirect transitive/peer vite via root
-* overrides/resolutions (and drop the aliased vite), so this is pnpm-only,
-* mirroring the bun root-package branch in `rewriteRootWorkspacePackageJson`.
+* the `vp test` cache). Under a catalog the edge is a `catalog:` reference and
+* the catalog entry carries the alias; the `vite@*` workspace override covers
+* transitive and peer declarations instead of this one (see `pnpmOverrideKey`).
+* npm/yarn/bun redirect transitive/peer vite via root overrides/resolutions (and
+* drop the aliased vite), so this is pnpm-only, mirroring the bun root-package
+* branch in `rewriteRootWorkspacePackageJson`.
 *
 * A package that already declares `vite` in ANY dependency field, including
 * `peerDependencies` (e.g. a vite plugin pinning `vite ^6`), is left untouched
@@ -7157,6 +7615,39 @@ function getYamlMapScalarStringValue(map, key) {
 	if (!(map instanceof import_dist.YAMLMap)) return;
 	for (const item of map.items) if (item.key instanceof import_dist.Scalar && item.key.value === key && item.value instanceof import_dist.Scalar && typeof item.value.value === "string") return item.value.value;
 }
+/**
+* Merge the managed override entries into a pnpm `overrides` record, under the
+* range-qualified keys (see `pnpmOverrideKey`).
+*
+* Both writers of the package.json `pnpm.overrides` sink go through this
+* helper: the standalone writer and the monorepo-root writer. That sink serves
+* pnpm 9.5 to 10.6.1. The helper deletes a bare managed key that a pre-#2309
+* migration left. Two keys for one package would restore the match that
+* clobbers `catalog:` importer specs.
+*
+* A bare key's `catalog:` value moves to the ranged key, so a user's own
+* `catalog:<name>` choice survives the re-keying. This mirrors
+* `getCatalogDependencySpec`, which keeps a `catalog:` reference in the
+* pnpm-workspace.yaml sink. A `file:` managed spec (force-override mode) always
+* wins, because there is no catalog to resolve against in that mode.
+*
+* Force-override mode also appends the `vite-plus` pin, under a BARE key. The
+* pin only exists in `file:` tgz mode, where migration writes the tgz spec
+* straight into every manifest instead of a `catalog:` reference. In that mode
+* there is no catalog provenance for a bare key to strip. This matches the
+* workspace-yaml force-override path in `rewriteStandaloneProject`.
+*/
+function mergeManagedPnpmOverrides(overrides, managed) {
+	const next = { ...overrides };
+	for (const [dependencyName, managedSpec] of Object.entries(managed)) {
+		const overrideKey = pnpmOverrideKey(dependencyName);
+		const existing = next[overrideKey] ?? next[dependencyName];
+		delete next[dependencyName];
+		next[overrideKey] = existing?.startsWith("catalog:") && !managedSpec.startsWith("file:") ? existing : managedSpec;
+	}
+	if (isForceOverrideMode()) next[VITE_PLUS_NAME] = VITE_PLUS_VERSION;
+	return next;
+}
 function pruneYamlMapLegacyWrapperAliases(map) {
 	if (!(map instanceof import_dist.YAMLMap)) return;
 	const stale = [];
@@ -7312,15 +7803,11 @@ function rewriteRootWorkspacePackageJson(projectPath, packageManager, skipStaged
 			const overrideKeys = Object.keys(managed);
 			if (!pnpmSupportsWorkspaceSettings(pnpmVersion ?? "")) {
 				dropRemovePackageOverrideKeys(pkg.pnpm?.overrides);
-				if (!workspaceUsesVitest) removeManagedVitestEntry(pkg.pnpm?.overrides);
+				if (!workspaceUsesVitest) removeManagedVitestEntry(pkg.pnpm?.overrides, "pnpm-ranged");
 				if (!workspaceUsesVitest && pkg.pnpm?.peerDependencyRules) removeVitestPeerDependencyRule(pkg.pnpm.peerDependencyRules);
 				pkg.pnpm = {
 					...pkg.pnpm,
-					overrides: {
-						...pkg.pnpm?.overrides,
-						...managed,
-						...isForceOverrideMode() ? { [VITE_PLUS_NAME]: VITE_PLUS_VERSION } : {}
-					},
+					overrides: mergeManagedPnpmOverrides(pkg.pnpm?.overrides, managed),
 					peerDependencyRules: {
 						...pkg.pnpm?.peerDependencyRules,
 						allowAny: [.../* @__PURE__ */ new Set([...pkg.pnpm?.peerDependencyRules?.allowAny ?? [], ...overrideKeys])],
@@ -7709,9 +8196,11 @@ function overrideSpecSatisfiesVitePlus(dependencyName, spec, catalogDependencyRe
 	if (!spec.startsWith("catalog:")) return false;
 	return isSemanticVitePlusOverrideSpec(dependencyName, catalogDependencyResolver?.(spec, dependencyName));
 }
-function overridesSatisfyVitePlus(overrides, usesVitest, catalogDependencyResolver) {
-	if (!usesVitest && VITEST_IS_MANAGED_OVERRIDE && typeof overrides?.vitest === "string") return false;
-	return Object.keys(managedOverridePackages(usesVitest)).every((dependencyName) => overrideSpecSatisfiesVitePlus(dependencyName, overrides?.[dependencyName], catalogDependencyResolver));
+function overridesSatisfyVitePlus(overrides, usesVitest, catalogDependencyResolver, keyStyle = "bare") {
+	const managed = managedOverridePackages(usesVitest);
+	if (!usesVitest && VITEST_IS_MANAGED_OVERRIDE && (typeof overrides?.vitest === "string" || keyStyle === "pnpm-ranged" && typeof overrides?.[pnpmOverrideKey("vitest")] === "string")) return false;
+	if (keyStyle === "pnpm-ranged" && Object.keys(managed).some((dependencyName) => typeof overrides?.[dependencyName] === "string")) return false;
+	return Object.keys(managed).every((dependencyName) => overrideSpecSatisfiesVitePlus(dependencyName, overrides?.[managedOverrideKey(dependencyName, keyStyle)], catalogDependencyResolver));
 }
 function hasPackageManagerPin(pkg) {
 	return Boolean(pkg.packageManager || pkg.devEngines?.packageManager);
@@ -7932,11 +8421,11 @@ function detectVitePlusBootstrapPending(projectPath, packageManager, packages, p
 	if (packageManager === PackageManager.pnpm) {
 		if (!pnpmWorkspaceExoticSubdepsSettingSatisfied(projectPath)) return true;
 		if (!usePnpmWorkspaceYaml) {
-			if (supportCatalog) return catalogVitePlusDependencyPending(pkg, catalogDependencyResolver) || !overridesSatisfyVitePlus(pkg.pnpm?.overrides, usesVitest, catalogDependencyResolver) || !pnpmPeerDependencyRulesSatisfyVitePlus(pkg.pnpm?.peerDependencyRules, usesVitest);
-			return vitePlusDependencyNeedsConcreteVersion(pkg) || !overridesSatisfyVitePlus(pkg.pnpm?.overrides, usesVitest) || !pnpmPeerDependencyRulesSatisfyVitePlus(pkg.pnpm?.peerDependencyRules, usesVitest);
+			if (supportCatalog) return catalogVitePlusDependencyPending(pkg, catalogDependencyResolver) || !overridesSatisfyVitePlus(pkg.pnpm?.overrides, usesVitest, catalogDependencyResolver, "pnpm-ranged") || !pnpmPeerDependencyRulesSatisfyVitePlus(pkg.pnpm?.peerDependencyRules, usesVitest);
+			return vitePlusDependencyNeedsConcreteVersion(pkg) || !overridesSatisfyVitePlus(pkg.pnpm?.overrides, usesVitest, void 0, "pnpm-ranged") || !pnpmPeerDependencyRulesSatisfyVitePlus(pkg.pnpm?.peerDependencyRules, usesVitest);
 		}
 		const resolver = readPnpmWorkspaceCatalogDependencyResolver(projectPath);
-		return workspaceCatalogVitePlusDependencyPending(projectPath, packages, resolver) || !overridesSatisfyVitePlus(readPnpmWorkspaceOverrides(projectPath), usesVitest, resolver) || !pnpmPeerDependencyRulesSatisfyVitePlus(readPnpmWorkspacePeerDependencyRules(projectPath), usesVitest) || pnpmWorkspaceMinimumReleaseAgeExemptionsPending(projectPath);
+		return workspaceCatalogVitePlusDependencyPending(projectPath, packages, resolver) || !overridesSatisfyVitePlus(readPnpmWorkspaceOverrides(projectPath), usesVitest, resolver, "pnpm-ranged") || !pnpmPeerDependencyRulesSatisfyVitePlus(readPnpmWorkspacePeerDependencyRules(projectPath), usesVitest) || pnpmWorkspaceMinimumReleaseAgeExemptionsPending(projectPath);
 	}
 	return false;
 }
@@ -7975,13 +8464,21 @@ function ensureVitePlusDependencySpecs(pkg, version, ensurePresent = true) {
 function readTextFileIfExists(filePath) {
 	return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : void 0;
 }
-function ensureOverrideEntries(overrides, usesVitest, catalogDependencyResolver) {
+function ensureOverrideEntries(overrides, usesVitest, catalogDependencyResolver, keyStyle = "bare") {
 	const next = { ...overrides };
 	let changed = false;
-	if (!usesVitest && removeManagedVitestEntry(next)) changed = true;
-	for (const [dependencyName, overrideSpec] of Object.entries(managedOverridePackages(usesVitest))) if (!overrideSpecSatisfiesVitePlus(dependencyName, next[dependencyName], catalogDependencyResolver)) {
-		next[dependencyName] = overrideSpec;
-		changed = true;
+	if (!usesVitest && removeManagedVitestEntry(next, keyStyle)) changed = true;
+	for (const [dependencyName, overrideSpec] of Object.entries(managedOverridePackages(usesVitest))) {
+		const overrideKey = managedOverrideKey(dependencyName, keyStyle);
+		if (overrideKey !== dependencyName && next[dependencyName] !== void 0) {
+			next[overrideKey] ??= next[dependencyName];
+			delete next[dependencyName];
+			changed = true;
+		}
+		if (!overrideSpecSatisfiesVitePlus(dependencyName, next[overrideKey], catalogDependencyResolver)) {
+			next[overrideKey] = overrideSpec;
+			changed = true;
+		}
 	}
 	return {
 		overrides: next,
@@ -8061,7 +8558,7 @@ function ensureVitePlusBootstrap(workspaceInfo, report) {
 			}
 		} else if (workspaceInfo.packageManager === PackageManager.pnpm && !usePnpmWorkspaceYaml) {
 			pkg.pnpm ??= {};
-			const ensured = ensureOverrideEntries(pkg.pnpm.overrides, usesVitest, supportCatalog ? readPnpmWorkspaceCatalogDependencyResolver(projectPath) : void 0);
+			const ensured = ensureOverrideEntries(pkg.pnpm.overrides, usesVitest, supportCatalog ? readPnpmWorkspaceCatalogDependencyResolver(projectPath) : void 0, "pnpm-ranged");
 			if (ensured.changed) {
 				pkg.pnpm.overrides = ensured.overrides;
 				packageJsonChanged = true;
@@ -8100,7 +8597,7 @@ function ensureVitePlusBootstrap(workspaceInfo, report) {
 			const before = readTextFileIfExists(pnpmWorkspaceYamlPath);
 			migratePnpmSettingsToWorkspaceYaml(projectPath, movedPnpmSettings);
 			const catalogDependencyResolver = readPnpmWorkspaceCatalogDependencyResolver(projectPath);
-			if (movedPnpmSettings !== void 0 || result.packageJson || ecosystemCatalogReferencesPending || !pnpmWorkspaceExoticSubdepsSettingSatisfied(projectPath) || pnpmWorkspaceMinimumReleaseAgeExemptionsPending(projectPath) || workspaceCatalogVitePlusDependencyPending(projectPath, workspaceInfo.packages, catalogDependencyResolver) || !overridesSatisfyVitePlus(readPnpmWorkspaceOverrides(projectPath), usesVitest, catalogDependencyResolver) || !pnpmPeerDependencyRulesSatisfyVitePlus(readPnpmWorkspacePeerDependencyRules(projectPath), usesVitest)) rewritePnpmWorkspaceYaml(projectPath, pnpmMajorVersion, shouldAllowBrowserBuilds, usesVitest, vitestEcosystemPackages, true, providerCatalogAdditions);
+			if (movedPnpmSettings !== void 0 || result.packageJson || ecosystemCatalogReferencesPending || !pnpmWorkspaceExoticSubdepsSettingSatisfied(projectPath) || pnpmWorkspaceMinimumReleaseAgeExemptionsPending(projectPath) || workspaceCatalogVitePlusDependencyPending(projectPath, workspaceInfo.packages, catalogDependencyResolver) || !overridesSatisfyVitePlus(readPnpmWorkspaceOverrides(projectPath), usesVitest, catalogDependencyResolver, "pnpm-ranged") || !pnpmPeerDependencyRulesSatisfyVitePlus(readPnpmWorkspacePeerDependencyRules(projectPath), usesVitest)) rewritePnpmWorkspaceYaml(projectPath, pnpmMajorVersion, shouldAllowBrowserBuilds, usesVitest, vitestEcosystemPackages, true, providerCatalogAdditions);
 			if (fs.existsSync(pnpmWorkspaceYamlPath)) ensurePnpmWorkspacePackages(projectPath, workspaceInfo.workspacePatterns);
 			result.packageManagerConfig = before !== readTextFileIfExists(pnpmWorkspaceYamlPath);
 		} else {
@@ -8629,12 +9126,19 @@ function findGitRoot(startPath) {
 	}
 }
 async function initGitRepository(cwd) {
-	return (await runCommandSilently({
+	const result = await runCommandSilently({
 		command: "git",
 		args: ["init"],
 		cwd,
 		envs: process.env
-	})).exitCode === 0;
+	});
+	if (result.exitCode !== 0) {
+		log.warn("Failed to initialize git repository");
+		const stderr = result.stderr.toString().trim();
+		if (stderr) log.info(stderr);
+		return false;
+	}
+	return true;
 }
 //#endregion
 //#region src/migration/migrator/git-hooks.ts
@@ -8902,7 +9406,7 @@ const NODE_VERSION_FILE_NVMRC_RE = /(node-version-file:[ \t]*)(['"]?)(\.\/)?\.nv
 * Collect GitHub Actions YAML files that may carry a `node-version-file:`
 * reference: top-level workflows (`.github/workflows/*.{yml,yaml}`, which GitHub
 * runs only when flat in that directory) and composite action definitions
-* (`.github/actions/**​/action.{yml,yaml}`, which may nest at any depth). Returns
+* (`.github/actions/**\/action.{yml,yaml}`, which may nest at any depth). Returns
 * absolute paths; a missing `.github` tree just yields an empty list. `nocase`
 * keeps the match case-insensitive on case-sensitive filesystems.
 */
@@ -9104,16 +9608,12 @@ function rewriteStandaloneProject(projectPath, workspaceInfo, skipStagedMigratio
 			if (!usePnpmWorkspaceYaml) {
 				dropRemovePackageOverrideKeys(pkg.pnpm?.overrides);
 				if (!usesVitest) {
-					removeManagedVitestEntry(pkg.pnpm?.overrides);
+					removeManagedVitestEntry(pkg.pnpm?.overrides, "pnpm-ranged");
 					if (pkg.pnpm?.peerDependencyRules) removeVitestPeerDependencyRule(pkg.pnpm.peerDependencyRules);
 				}
 				pkg.pnpm = {
 					...pkg.pnpm,
-					overrides: {
-						...pkg.pnpm?.overrides,
-						...managed,
-						...isForceOverrideMode() ? { [VITE_PLUS_NAME]: VITE_PLUS_VERSION } : {}
-					},
+					overrides: mergeManagedPnpmOverrides(pkg.pnpm?.overrides, managed),
 					peerDependencyRules: {
 						...pkg.pnpm?.peerDependencyRules,
 						allowAny: [.../* @__PURE__ */ new Set([...pkg.pnpm?.peerDependencyRules?.allowAny ?? [], ...overrideKeys])],
@@ -9294,13 +9794,16 @@ const JETBRAINS_EXTERNAL_DEPENDENCIES = `<?xml version="1.0" encoding="UTF-8"?>
   </component>
 </project>
 `;
+function jetbrainsNodeInterpreterPath() {
+	return path.join(getVpDirs().bin, process.platform === "win32" ? "node.exe" : "node");
+}
 function jetbrainsWorkspaceConfig(packageManager) {
 	return `<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="PropertiesComponent">
     <![CDATA[${JSON.stringify({ keyToString: {
 		"javascript.preferred.runtime.type.id": "node",
-		nodejs_interpreter_path: "$USER_HOME$/.vite-plus/bin/node.exe",
+		nodejs_interpreter_path: jetbrainsNodeInterpreterPath(),
 		nodejs_package_manager_path: packageManager
 	} }, null, 2)}]]>
   </component>
@@ -9588,4 +10091,4 @@ function resolveEditorIds(editors) {
 	return uniqueEditorIds.length === 0 ? void 0 : uniqueEditorIds;
 }
 //#endregion
-export { isBingoTemplate as A, warnPackageLevelPrettier as B, mergeViteConfigFiles as C, configureYarnNodeModulesMode as D, ensureVitePlusBootstrap as E, hasFrameworkShim as F, promptEslintMigration as G, detectEslintProject as H, confirmPrettierMigration as I, warnPackageLevelEslint as J, warnIncompatibleEslintIntegration as K, detectPrettierProject as L, updateWorkspaceConfig as M, addFrameworkShim as N, detectYarnPnpMode as O, detectFramework as P, migratePrettierToOxfmt as R, injectLintTypeCheckDefaults as S, detectVitePlusBootstrapPending as T, detectIncompatibleEslintIntegration as U, confirmEslintMigration as V, migrateEslintToOxlint as W, checkVitestVersion as X, checkViteVersion as Y, preflightGitHooksSetup as _, selectEditors as a, initGitRepository as b, rewriteMonorepoProject as c, finalizeCoreMigrationForExistingVitePlus as d, detectNodeVersionManagerFile as f, installGitHooks as g, detectLegacyGitHooksMigrationCandidate as h, selectEditor as i, updatePackageJsonWithDeps as j, detectWorkspace$1 as k, rewriteStandaloneProject as l, setPackageManager as m, detectExistingEditors as n, writeEditorConfigs as o, migrateNodeVersionManagerFile as p, warnLegacyEslintConfig as q, isJsonLikeFile as r, rewriteMonorepo as s, detectEditorConflicts as t, detectPendingCoreMigration as u, shouldSkipStagedMigrationForHooks as v, collectToolchainVersionChanges as w, injectCreateDefaultTemplate as x, findGitRoot as y, promptPrettierMigration as z };
+export { warnLegacyEslintConfig as $, detectWorkspace$1 as A, promptTsupMigration as B, mergeTsdownConfigFile as C, ensureVitePlusBootstrap as D, detectVitePlusBootstrapPending as E, detectFramework as F, promptPrettierMigration as G, confirmPrettierMigration as H, hasFrameworkShim as I, detectEslintProject as J, warnPackageLevelPrettier as K, confirmTsupMigration as L, updatePackageJsonWithDeps as M, updateWorkspaceConfig as N, configureYarnNodeModulesMode as O, addFrameworkShim as P, warnIncompatibleEslintIntegration as Q, detectTsupProject as R, injectLintTypeCheckDefaults as S, collectToolchainVersionChanges as T, detectPrettierProject as U, warnMissingTsupConfig as V, migratePrettierToOxfmt as W, migrateEslintToOxlint as X, detectIncompatibleEslintIntegration as Y, promptEslintMigration as Z, preflightGitHooksSetup as _, selectEditors as a, initGitRepository as b, rewriteMonorepoProject as c, finalizeCoreMigrationForExistingVitePlus as d, warnPackageLevelEslint as et, detectNodeVersionManagerFile as f, installGitHooks as g, detectLegacyGitHooksMigrationCandidate as h, selectEditor as i, isBingoTemplate as j, detectYarnPnpMode as k, rewriteStandaloneProject as l, setPackageManager as m, detectExistingEditors as n, checkVitestVersion as nt, writeEditorConfigs as o, migrateNodeVersionManagerFile as p, confirmEslintMigration as q, isJsonLikeFile as r, rewriteMonorepo as s, detectEditorConflicts as t, checkViteVersion as tt, detectPendingCoreMigration as u, shouldSkipStagedMigrationForHooks as v, mergeViteConfigFiles as w, injectCreateDefaultTemplate as x, findGitRoot as y, migrateTsupToTsdown as z };