vite-plus 0.2.8 → 0.3.0

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

@@ -1,22 +1,24 @@
 import { r as __toESM } from "./rolldown-runtime-CMFfr-1z.js";
-import { a as VITEST_AGE_GATE_EXEMPT_PACKAGES, c as VITE_PLUS_OVERRIDE_PACKAGES, d as isForceOverrideMode, l as VITE_PLUS_VERSION, n as BASEURL_TSCONFIG_WARNING, o as VITEST_VERSION, s as VITE_PLUS_NAME } from "./constants-BppDcRc1.js";
-import { i as ensureVitePlusImportRuleDefaults, r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-BHOzlwMw.js";
-import { A as isCancel, C as log, E as select, M as runCommandSilently, N as require_cross_spawn, d as readYamlFile, f as scalarString, g as getSpinner, t as cancelAndExit, u as editYamlFile, v as PackageManager, w as multiselect, x as confirm, y as require_semver } from "./prompts-DYap08te.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-BU88uu6o.js";
-import { t as require_dist } from "./dist-CSQWHI6y.js";
-import { a as hasTypesToRewriteInTsconfig, c as rewriteTypesInTsconfig, i as hasBaseUrlInTsconfig, n as findTsconfigFiles, o as hasVitestTypesInTsconfig, s as removeDeprecatedTsconfigFalseOption } from "./tsconfig-CVUKLfL8.js";
-import { n as detectPackageMetadata, r as getScopeFromPackageName } from "./package-hV-77cBb.js";
-import { f as displayRelative, l as SUPPORTED_GIT_HOOK_NAMES, p as rulesDir, u as findUnsafeHookInstallPath } from "./agent-CI79DuSy.js";
-import { n as addMigrationWarning, t as addManualStep } from "./report-BS7ULx7A.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 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 { detectWorkspace, hasConfigKey, mergeJsonConfig, mergeTsdownConfig, rewriteEslint, rewriteImportsInDirectory, rewritePrettier, rewriteScripts, wrapLazyPlugins } from "../binding/index.js";
+import { fileURLToPath } from "node:url";
+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, readlinkSync, realpathSync as realpathSync$1 } from "fs";
-import { fileURLToPath } from "node:url";
 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";
@@ -81,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);
@@ -131,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",
@@ -153,14 +207,7 @@ const PRETTIER_CONFIG_FILES = [
 ];
 function detectConfigs(projectPath) {
 	const configs = {};
-	for (const config of [
-		"vite.config.ts",
-		"vite.config.mts",
-		"vite.config.cts",
-		"vite.config.js",
-		"vite.config.mjs",
-		"vite.config.cjs"
-	]) if (fs.existsSync(path.join(projectPath, config))) {
+	for (const config of VITE_CONFIG_FILES) if (fs.existsSync(path.join(projectPath, config))) {
 		configs.viteConfig = config;
 		break;
 	}
@@ -188,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;
@@ -229,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 {}
@@ -308,17 +360,7 @@ async function runOxlintMigrateStep(vpBin, cwd, migratePackage, args, spinner, f
 }
 async function migrateEslintToOxlint(projectPath, interactive, eslintConfigFile, packages, options) {
 	const vpBin = process.env.VP_CLI_BIN ?? "vp";
-	const spinner = options?.silent ? {
-		start: () => {},
-		stop: () => {},
-		pause: () => {},
-		resume: () => {},
-		cancel: () => {},
-		error: () => {},
-		clear: () => {},
-		message: () => {},
-		isCancelled: false
-	} : getSpinner(interactive);
+	const spinner = options?.silent ? getSilentSpinner() : getSpinner(interactive);
 	if (eslintConfigFile) {
 		const { versions } = await import("./versions.js");
 		const migratePackage = `@oxlint/migrate@${versions.oxlint}`;
@@ -778,17 +820,7 @@ async function runPrettierMigrateStep(vpBin, cwd, spinner, failMessage, manualHi
 }
 async function migratePrettierToOxfmt(projectPath, interactive, prettierConfigFile, packages, options) {
 	const vpBin = process.env.VP_CLI_BIN ?? "vp";
-	const spinner = options?.silent ? {
-		start: () => {},
-		stop: () => {},
-		pause: () => {},
-		resume: () => {},
-		cancel: () => {},
-		error: () => {},
-		clear: () => {},
-		message: () => {},
-		isCancelled: false
-	} : getSpinner(interactive);
+	const spinner = options?.silent ? getSilentSpinner() : getSpinner(interactive);
 	if (prettierConfigFile) {
 		let tempPrettierConfig;
 		if (prettierConfigFile === "package.json#prettier") {
@@ -907,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"];
@@ -1163,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;
@@ -1266,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;
 }
@@ -2711,9 +3138,10 @@ var Minimatch = class {
 				const next = pp[i + 1];
 				const prev = pp[i - 1];
 				if (p !== GLOBSTAR || prev === GLOBSTAR) return;
-				if (prev === void 0) if (next !== void 0 && next !== GLOBSTAR) pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
-				else pp[i] = twoStar;
-				else if (next === void 0) pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
+				if (prev === void 0) {
+					if (next !== void 0 && next !== GLOBSTAR) pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+					else pp[i] = twoStar;
+				} else if (next === void 0) pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
 				else if (next !== GLOBSTAR) {
 					pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
 					pp[i + 1] = GLOBSTAR;
@@ -2971,7 +3399,7 @@ var L = class c {
 		}
 	}
 	getRemainingTTL(t) {
-		return this.#s.has(t) ? Infinity : 0;
+		return this.#s.has(t) ? 1 / 0 : 0;
 	}
 	#j() {
 		let t = new z(this.#o), e = new z(this.#o);
@@ -3011,7 +3439,7 @@ var L = class c {
 			let r = this.#s.get(h);
 			if (r === void 0) return 0;
 			let a = t[r], w = e[r];
-			if (!a || !w) return Infinity;
+			if (!a || !w) return 1 / 0;
 			return a - ((n || o()) - w);
 		}, this.#p = (h) => {
 			let r = e[h], a = t[h];
@@ -4211,7 +4639,7 @@ const realpathSync$2 = realpathSync$1.native;
 const defaultFS = {
 	lstatSync: lstatSync$1,
 	readdir,
-	readdirSync,
+	readdirSync: readdirSync$1,
 	readlinkSync,
 	realpathSync: realpathSync$2,
 	promises: {
@@ -4251,7 +4679,7 @@ const ENOREALPATH = 512;
 const ENOCHILD = 704;
 const TYPEMASK = 1023;
 const entToType = (s) => s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
-const normalizeCache = new L({ max: 2 ** 12 });
+const normalizeCache = new L({ max: 4096 });
 const normalize$1 = (s) => {
 	const c = normalizeCache.get(s);
 	if (c) return c;
@@ -4259,7 +4687,7 @@ const normalize$1 = (s) => {
 	normalizeCache.set(s, n);
 	return n;
 };
-const normalizeNocaseCache = new L({ max: 2 ** 12 });
+const normalizeNocaseCache = new L({ max: 4096 });
 const normalizeNocase = (s) => {
 	const c = normalizeNocaseCache.get(s);
 	if (c) return c;
@@ -5979,8 +6407,10 @@ var Ignore = class {
 			const absolute = p.isAbsolute();
 			if (absolute) this.absolute.push(m);
 			else this.relative.push(m);
-			if (children) if (absolute) this.absoluteChildren.push(m);
-			else this.relativeChildren.push(m);
+			if (children) {
+				if (absolute) this.absoluteChildren.push(m);
+				else this.relativeChildren.push(m);
+			}
 		}
 	}
 	ignored(p) {
@@ -6956,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);
@@ -7058,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
@@ -7180,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 = [];
@@ -7335,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])],
@@ -7732,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);
@@ -7955,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;
 }
@@ -7998,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,
@@ -8084,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;
@@ -8118,20 +8592,21 @@ function ensureVitePlusBootstrap(workspaceInfo, report) {
 		});
 		result.packageJson = result.packageJson || childChanged;
 	}
-	if (workspaceInfo.packageManager === PackageManager.pnpm) if (usePnpmWorkspaceYaml) {
-		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 (fs.existsSync(pnpmWorkspaceYamlPath)) ensurePnpmWorkspacePackages(projectPath, workspaceInfo.workspacePatterns);
-		result.packageManagerConfig = before !== readTextFileIfExists(pnpmWorkspaceYamlPath);
-	} else {
-		const exoticChanged = ensurePnpmWorkspaceExoticSubdepsSetting(projectPath);
-		if (fs.existsSync(pnpmWorkspaceYamlPath)) ensurePnpmWorkspacePackages(projectPath, workspaceInfo.workspacePatterns);
-		const after = readTextFileIfExists(pnpmWorkspaceYamlPath);
-		result.packageManagerConfig = exoticChanged || pnpmWorkspaceCatalogBefore !== after;
-	}
-	else if (workspaceInfo.packageManager === PackageManager.yarn) {
+	if (workspaceInfo.packageManager === PackageManager.pnpm) {
+		if (usePnpmWorkspaceYaml) {
+			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, "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 {
+			const exoticChanged = ensurePnpmWorkspaceExoticSubdepsSetting(projectPath);
+			if (fs.existsSync(pnpmWorkspaceYamlPath)) ensurePnpmWorkspacePackages(projectPath, workspaceInfo.workspacePatterns);
+			const after = readTextFileIfExists(pnpmWorkspaceYamlPath);
+			result.packageManagerConfig = exoticChanged || pnpmWorkspaceCatalogBefore !== after;
+		}
+	} else if (workspaceInfo.packageManager === PackageManager.yarn) {
 		const yarnrcYmlPath = path.join(projectPath, ".yarnrc.yml");
 		const before = readTextFileIfExists(yarnrcYmlPath);
 		rewriteYarnrcYml(projectPath, usesVitest, vitestEcosystemPackages, providerCatalogAdditions, supportCatalog);
@@ -8625,16 +9100,48 @@ function rewriteAllImports(projectPath, silent = false, report, preserveNuxtVite
 		log.success(`Rewrote imports in ${modified === 1 ? "one file" : `${modified} files`}`);
 		log.info(result.modifiedFiles.map((file) => `  ${displayRelative(file)}`).join("\n"));
 	}
-	if (errors > 0) if (report) warnMigration(`${errors === 1 ? "one file had an error" : `${errors} files had errors`} while rewriting imports`, report);
-	else {
-		log.warn(`⚠ ${errors === 1 ? "one file had an error" : `${errors} files had errors`}:`);
-		for (const error of result.errors) log.error(`  ${displayRelative(error.path)}: ${error.message}`);
+	if (errors > 0) {
+		if (report) warnMigration(`${errors === 1 ? "one file had an error" : `${errors} files had errors`} while rewriting imports`, report);
+		else {
+			log.warn(`⚠ ${errors === 1 ? "one file had an error" : `${errors} files had errors`}:`);
+			for (const error of result.errors) log.error(`  ${displayRelative(error.path)}: ${error.message}`);
+		}
 	}
 	return modified > 0;
 }
 //#endregion
-//#region src/migration/migrator/git-hooks.ts
+//#region src/utils/git.ts
 var import_cross_spawn = /* @__PURE__ */ __toESM(require_cross_spawn(), 1);
+/**
+* Walk up from `startPath` looking for `.git` (directory or file — submodules
+* use a `.git` file).  Returns the directory that contains `.git`, or `null`.
+*/
+function findGitRoot(startPath) {
+	let dir = startPath;
+	while (true) {
+		if (fs.existsSync(path.join(dir, ".git"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+async function initGitRepository(cwd) {
+	const result = await runCommandSilently({
+		command: "git",
+		args: ["init"],
+		cwd,
+		envs: process.env
+	});
+	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
 const OTHER_HOOK_TOOLS = [
 	"simple-git-hooks",
 	"lefthook",
@@ -8669,19 +9176,6 @@ function findNonRegularViteHookPath(projectPath) {
 	}
 	return null;
 }
-/**
-* Walk up from `startPath` looking for `.git` (directory or file — submodules
-* use a `.git` file).  Returns the directory that contains `.git`, or `null`.
-*/
-function findGitRoot(startPath) {
-	let dir = startPath;
-	while (true) {
-		if (fs.existsSync(path.join(dir, ".git"))) return dir;
-		const parent = path.dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
 function findWorkspacePackageHookPolicy(workspaceRoot, packages) {
 	for (const pkg of packages) {
 		const packagePath = path.join(workspaceRoot, pkg.path);
@@ -8912,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.
 */
@@ -8996,10 +9490,26 @@ function readRulesYaml() {
 	cachedRulesYaml ??= fs.readFileSync(RULES_YAML_PATH, "utf8");
 	return cachedRulesYaml;
 }
+function splitRuleDocuments(yaml) {
+	const lines = yaml.split("\n");
+	const documents = [];
+	let start = 0;
+	for (const [index, line] of lines.entries()) {
+		if (line.trimEnd() !== "---") continue;
+		let documentStart = index;
+		while (documentStart > start && lines[documentStart - 1].trimStart().startsWith("#")) documentStart--;
+		if (documentStart > start) {
+			documents.push(lines.slice(start, documentStart).join("\n"));
+			start = documentStart;
+		}
+	}
+	documents.push(lines.slice(start).join("\n"));
+	return documents;
+}
 function getScriptRulesYaml(skipStagedMigration) {
 	const yaml = readRulesYaml();
 	if (!skipStagedMigration) return yaml;
-	cachedRulesYamlNoLintStaged ??= yaml.split("\n\n\n").filter((block) => !block.includes("id: replace-lint-staged")).join("\n\n\n");
+	cachedRulesYamlNoLintStaged ??= splitRuleDocuments(yaml).filter((document) => !document.includes("id: replace-lint-staged")).join("\n");
 	return cachedRulesYamlNoLintStaged;
 }
 function getCoreMigrationProjectPaths(workspaceInfo) {
@@ -9098,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])],
@@ -9236,7 +9742,8 @@ const VSCODE_SETTINGS = {
 	"[javascriptreact]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
 	"[typescript]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
 	"[typescriptreact]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
-	"oxc.fmt.configPath": "./vite.config.ts",
+	"oxc.disableNestedConfig": true,
+	"oxc.fmt.disableNestedConfig": true,
 	"editor.formatOnSave": true,
 	"editor.formatOnSaveMode": "file",
 	"editor.codeActionsOnSave": { "source.fixAll.oxc": "explicit" }
@@ -9280,19 +9787,68 @@ const ZED_SETTINGS = {
 		...language === "JavaScript" ? { code_action: "source.fixAll.oxc" } : {}
 	}]))
 };
-const EDITORS = [{
-	id: "vscode",
-	label: "VSCode",
-	targetDir: ".vscode",
-	files: {
-		"settings.json": VSCODE_SETTINGS,
-		"extensions.json": VSCODE_EXTENSIONS
+const JETBRAINS_EXTERNAL_DEPENDENCIES = `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalDependencies">
+    <plugin id="com.github.oxc.project.oxcintellijplugin" />
+  </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: jetbrainsNodeInterpreterPath(),
+		nodejs_package_manager_path: packageManager
+	} }, null, 2)}]]>
+  </component>
+</project>
+`;
+}
+const EDITORS = [
+	{
+		id: "vscode",
+		label: "VSCode",
+		targetDir: ".vscode",
+		files: {
+			"settings.json": VSCODE_SETTINGS,
+			"extensions.json": VSCODE_EXTENSIONS
+		}
+	},
+	{
+		id: "zed",
+		label: "Zed",
+		targetDir: ".zed",
+		files: { "settings.json": ZED_SETTINGS }
+	},
+	{
+		id: "jetbrains",
+		label: "JetBrains (IntelliJ, WebStorm, etc)",
+		targetDir: ".idea",
+		files: {
+			"externalDependencies.xml": JETBRAINS_EXTERNAL_DEPENDENCIES,
+			"workspace.xml": jetbrainsWorkspaceConfig(PackageManager.pnpm),
+			"OxfmtSettings.xml": `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="OxfmtSettings">
+    <option name="preferOxfmtCodeStyleSettings" value="true" />
+  </component>
+</project>
+`
+		}
 	}
+];
+const EDITOR_ALIASES = [{
+	id: "intellij",
+	alias: "jetbrains"
 }, {
-	id: "zed",
-	label: "Zed",
-	targetDir: ".zed",
-	files: { "settings.json": ZED_SETTINGS }
+	id: "webstorm",
+	alias: "jetbrains"
 }];
 async function selectEditor({ interactive, editor, onCancel }) {
 	if (editor === false) return;
@@ -9374,7 +9930,7 @@ function detectEditorConflicts({ projectRoot, editorId }) {
 	}
 	return conflicts;
 }
-async function writeEditorConfigs({ projectRoot, editorId, interactive, conflictDecisions, silent = false, extraVsCodeSettings }) {
+async function writeEditorConfigs({ projectRoot, editorId, interactive, conflictDecisions, silent = false, extraVsCodeSettings, packageManager = PackageManager.pnpm }) {
 	const editorIds = normalizeEditorSelection(editorId);
 	if (editorIds.length === 0) return;
 	for (const currentEditorId of editorIds) await writeEditorConfig({
@@ -9383,10 +9939,11 @@ async function writeEditorConfigs({ projectRoot, editorId, interactive, conflict
 		interactive,
 		conflictDecisions,
 		silent,
-		extraVsCodeSettings
+		extraVsCodeSettings,
+		packageManager
 	});
 }
-async function writeEditorConfig({ projectRoot, editorId, interactive, conflictDecisions, silent, extraVsCodeSettings }) {
+async function writeEditorConfig({ projectRoot, editorId, interactive, conflictDecisions, silent, extraVsCodeSettings, packageManager }) {
 	const editorConfig = EDITORS.find((e) => e.id === editorId);
 	if (!editorConfig) return;
 	const targetDir = path.join(projectRoot, editorConfig.targetDir);
@@ -9395,8 +9952,9 @@ async function writeEditorConfig({ projectRoot, editorId, interactive, conflictD
 		const incoming = editorId === "vscode" && fileName === "settings.json" && extraVsCodeSettings ? {
 			...extraVsCodeSettings,
 			...baseIncoming
-		} : baseIncoming;
+		} : editorId === "jetbrains" && fileName === "workspace.xml" ? jetbrainsWorkspaceConfig(packageManager) : baseIncoming;
 		const filePath = path.join(targetDir, fileName);
+		const jsonFormat = isJsonLikeFile(fileName);
 		if (fs.existsSync(filePath)) {
 			const displayPath = `${editorConfig.targetDir}/${fileName}`;
 			let conflictAction;
@@ -9404,11 +9962,11 @@ async function writeEditorConfig({ projectRoot, editorId, interactive, conflictD
 			if (preResolved) conflictAction = preResolved;
 			else if (interactive) {
 				const action = await select({
-					message: `${displayPath} already exists.\n  ` + styleText("gray", `Vite+ adds ${editorConfig.label} settings for the built-in linter and formatter. Merge adds new keys without overwriting existing ones.`),
+					message: `${displayPath} already exists.\n  ` + styleText("gray", jsonFormat ? `Vite+ adds ${editorConfig.label} settings for the built-in linter and formatter. Merge adds new keys without overwriting existing ones.` : `Vite+ adds ${editorConfig.label} settings for the built-in linter and formatter. Overwrite replaces the existing file with the generated config.`),
 					options: [{
-						label: "Merge",
+						label: jsonFormat ? "Merge" : "Overwrite",
 						value: "merge",
-						hint: "Merge new settings into existing file"
+						hint: jsonFormat ? "Merge new settings into existing file" : "Replace existing file with generated config"
 					}, {
 						label: "Skip",
 						value: "skip",
@@ -9417,15 +9975,34 @@ async function writeEditorConfig({ projectRoot, editorId, interactive, conflictD
 					initialValue: "skip"
 				});
 				conflictAction = isCancel(action) || action === "skip" ? "skip" : "merge";
-			} else conflictAction = "merge";
-			if (conflictAction === "merge") mergeAndWriteEditorConfig(filePath, incoming, fileName, displayPath, silent);
-			else if (!silent) log.info(`Skipped writing ${displayPath}`);
+			} else conflictAction = jsonFormat ? "merge" : "skip";
+			if (conflictAction === "merge") {
+				if (jsonFormat) {
+					if (!isPlainObject(incoming)) throw new Error(`Cannot merge editor config: ${displayPath} incoming value is not JSON`);
+					mergeAndWriteEditorConfig(filePath, incoming, fileName, displayPath, silent);
+				} else writeTextEditorConfig(filePath, incoming, displayPath, silent);
+			} else if (!silent) log.info(`Skipped writing ${displayPath}`);
 			continue;
 		}
-		writeJsonFile(filePath, incoming);
+		if (jsonFormat) {
+			if (!isPlainObject(incoming)) throw new Error(`Cannot write editor config: ${editorConfig.targetDir}/${fileName} must be JSON`);
+			writeJsonFile(filePath, incoming);
+		} else writeTextEditorConfig(filePath, incoming, `${editorConfig.targetDir}/${fileName}`, silent);
 		if (!silent) log.success(`Wrote editor config to ${editorConfig.targetDir}/${fileName}`);
 	}
 }
+function isJsonLikeFile(fileName) {
+	const ext = path.extname(fileName).toLowerCase();
+	return ext === ".json" || ext === ".jsonc";
+}
+function writeTextEditorConfig(filePath, incoming, displayPath, silent = false) {
+	if (typeof incoming !== "string") throw new Error(`Cannot write editor config: ${displayPath} must be text content`);
+	if ((fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : void 0) === incoming) {
+		if (!silent) log.info(`No changes needed for ${displayPath}`);
+		return;
+	}
+	fs.writeFileSync(filePath, incoming, "utf-8");
+}
 function normalizeEditorSelection(editorId) {
 	if (!editorId) return [];
 	return [...new Set(Array.isArray(editorId) ? editorId : [editorId])];
@@ -9497,7 +10074,13 @@ function mergeExtensionsText(text, existing, incoming, formattingOptions) {
 }
 function resolveEditorId(editor) {
 	const normalized = editor.trim().toLowerCase();
-	return EDITORS.find((option) => option.id === normalized || option.label.toLowerCase() === normalized)?.id;
+	const match = EDITORS.find((option) => option.id === normalized || option.label.toLowerCase() === normalized);
+	if (match) return match.id;
+	const aliasMatch = EDITOR_ALIASES.find((option) => option.id === normalized);
+	if (aliasMatch) {
+		log.warn(`--editor ${aliasMatch.id} was passed; use --editor ${aliasMatch.alias} instead, as it's the canonical ID for that editor.`);
+		return aliasMatch.alias;
+	}
 }
 function resolveEditorIds(editors) {
 	const editorIds = editors.flatMap((editor) => {
@@ -9508,4 +10091,4 @@ function resolveEditorIds(editors) {
 	return uniqueEditorIds.length === 0 ? void 0 : uniqueEditorIds;
 }
 //#endregion
-export { addFrameworkShim as A, detectIncompatibleEslintIntegration as B, ensureVitePlusBootstrap as C, isBingoTemplate as D, detectWorkspace$1 as E, migratePrettierToOxfmt as F, warnPackageLevelEslint as G, promptEslintMigration as H, promptPrettierMigration as I, checkViteVersion as K, warnPackageLevelPrettier as L, hasFrameworkShim as M, confirmPrettierMigration as N, updatePackageJsonWithDeps as O, detectPrettierProject as P, confirmEslintMigration as R, detectVitePlusBootstrapPending as S, detectYarnPnpMode as T, warnIncompatibleEslintIntegration as U, migrateEslintToOxlint as V, warnLegacyEslintConfig as W, shouldSkipStagedMigrationForHooks as _, writeEditorConfigs as a, mergeViteConfigFiles as b, rewriteStandaloneProject as c, detectNodeVersionManagerFile as d, migrateNodeVersionManagerFile as f, preflightGitHooksSetup as g, installGitHooks as h, selectEditors as i, detectFramework as j, updateWorkspaceConfig as k, detectPendingCoreMigration as l, detectLegacyGitHooksMigrationCandidate as m, detectExistingEditors as n, rewriteMonorepo as o, setPackageManager as p, checkVitestVersion as q, selectEditor as r, rewriteMonorepoProject as s, detectEditorConflicts as t, finalizeCoreMigrationForExistingVitePlus as u, injectCreateDefaultTemplate as v, configureYarnNodeModulesMode as w, collectToolchainVersionChanges as x, injectLintTypeCheckDefaults as y, detectEslintProject 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 };