vite-plus 0.1.22 → 0.1.24

package/dist/agent-Nuk-9l77.js

@@ -0,0 +1,2470 @@
+import { r as __toESM } from "./chunk-DnnnRqeS.js";
+import { a as VITE_PLUS_OVERRIDE_PACKAGES, c as isForceOverrideMode, i as VITE_PLUS_NAME, n as BASEURL_TSCONFIG_WARNING, o as VITE_PLUS_VERSION } from "./constants-DCBWlNrn.js";
+import { i as ensureVitePlusImportRuleDefaults, r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-B89iKTKN.js";
+import { A as R, C as log, E as select, M as runCommandSilently, N as require_cross_spawn, a as removeDeprecatedTsconfigFalseOption, i as hasBaseUrlInTsconfig, n as findTsconfigFiles, o as rewriteTypesInTsconfig, s as cancelAndExit, u as getSpinner, v as PackageManager, w as multiselect, x as confirm, y as require_semver } from "./tsconfig-DFb5BKyT.js";
+import { t as require_dist } from "./dist-BgQuvbtq.js";
+import { c as editJsonFile, l as isJsonFile, n as detectPackageMetadata, u as readJsonFile } from "./package-PmBUZ-ve.js";
+import { n as addMigrationWarning, t as addManualStep } from "./report-DgSBQUdz.js";
+import path from "node:path";
+import { hasConfigKey, mergeJsonConfig, mergeTsdownConfig, rewriteEslint, rewriteImportsInDirectory, rewritePrettier, rewriteScripts } from "../binding/index.js";
+import fs from "node:fs";
+import { styleText } from "node:util";
+import fsPromises from "node:fs/promises";
+//#region src/utils/path.ts
+var import_cross_spawn = /* @__PURE__ */ __toESM(require_cross_spawn(), 1);
+var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
+var import_dist = require_dist();
+function findPkgRoot() {
+	let dir = import.meta.dirname;
+	while (dir !== path.dirname(dir)) {
+		if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+		dir = path.dirname(dir);
+	}
+	return dir;
+}
+const pkgRoot = findPkgRoot();
+const templatesDir = path.join(pkgRoot, "templates");
+const rulesDir = path.join(pkgRoot, "rules");
+function displayRelative(to, from = process.cwd()) {
+	return path.relative(from, to).replaceAll("\\", "/");
+}
+//#endregion
+//#region src/utils/yaml.ts
+function readYamlFile(file) {
+	return (0, import_dist.parse)(fs.readFileSync(file, "utf-8"));
+}
+function editYamlFile(file, callback) {
+	const doc = (0, import_dist.parseDocument)(fs.readFileSync(file, "utf-8"));
+	callback(doc);
+	fs.writeFileSync(file, doc.toString({ singleQuote: true }), "utf-8");
+}
+function scalarString(value) {
+	return new import_dist.Scalar(value);
+}
+//#endregion
+//#region src/migration/detector.ts
+const PRETTIER_PACKAGE_JSON_CONFIG = "package.json#prettier";
+const PRETTIER_CONFIG_FILES = [
+	".prettierrc",
+	".prettierrc.json",
+	".prettierrc.jsonc",
+	".prettierrc.yaml",
+	".prettierrc.yml",
+	".prettierrc.toml",
+	".prettierrc.js",
+	".prettierrc.cjs",
+	".prettierrc.mjs",
+	".prettierrc.ts",
+	".prettierrc.cts",
+	".prettierrc.mts",
+	"prettier.config.js",
+	"prettier.config.cjs",
+	"prettier.config.mjs",
+	"prettier.config.ts",
+	"prettier.config.cts",
+	"prettier.config.mts"
+];
+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))) {
+		configs.viteConfig = config;
+		break;
+	}
+	for (const config of [
+		"vitest.config.ts",
+		"vitest.config.mts",
+		"vitest.config.cts",
+		"vitest.config.js",
+		"vitest.config.mjs",
+		"vitest.config.cjs"
+	]) if (fs.existsSync(path.join(projectPath, config))) {
+		configs.vitestConfig = config;
+		break;
+	}
+	for (const config of [
+		"tsdown.config.ts",
+		"tsdown.config.mts",
+		"tsdown.config.cts",
+		"tsdown.config.js",
+		"tsdown.config.mjs",
+		"tsdown.config.cjs",
+		"tsdown.config.json",
+		"tsdown.config"
+	]) if (fs.existsSync(path.join(projectPath, config))) {
+		configs.tsdownConfig = config;
+		break;
+	}
+	for (const config of [".oxlintrc.json", ".oxlintrc.jsonc"]) if (fs.existsSync(path.join(projectPath, config))) {
+		configs.oxlintConfig = config;
+		break;
+	}
+	for (const config of [".oxfmtrc.json", ".oxfmtrc.jsonc"]) if (fs.existsSync(path.join(projectPath, config))) {
+		configs.oxfmtConfig = config;
+		break;
+	}
+	for (const config of [
+		"eslint.config.js",
+		"eslint.config.mjs",
+		"eslint.config.cjs",
+		"eslint.config.ts",
+		"eslint.config.mts",
+		"eslint.config.cts"
+	]) if (fs.existsSync(path.join(projectPath, config))) {
+		configs.eslintConfig = config;
+		break;
+	}
+	for (const config of [
+		".eslintrc",
+		".eslintrc.json",
+		".eslintrc.js",
+		".eslintrc.cjs",
+		".eslintrc.yaml",
+		".eslintrc.yml"
+	]) if (fs.existsSync(path.join(projectPath, config))) {
+		configs.eslintLegacyConfig = config;
+		break;
+	}
+	for (const config of PRETTIER_CONFIG_FILES) if (fs.existsSync(path.join(projectPath, config))) {
+		configs.prettierConfig = config;
+		break;
+	}
+	if (fs.existsSync(path.join(projectPath, ".prettierignore"))) configs.prettierIgnore = true;
+	if (fs.existsSync(path.join(projectPath, ".nvmrc"))) configs.nvmrcFile = true;
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (fs.existsSync(packageJsonPath)) try {
+		const content = fs.readFileSync(packageJsonPath, "utf8");
+		const pkg = JSON.parse(content);
+		if (!configs.prettierConfig && pkg.prettier) configs.prettierConfig = PRETTIER_PACKAGE_JSON_CONFIG;
+		const voltaNode = pkg.volta?.node;
+		if (typeof voltaNode === "string") configs.voltaNode = voltaNode;
+	} catch {}
+	return configs;
+}
+//#endregion
+//#region src/migration/migrator.ts
+const LINT_STAGED_JSON_CONFIG_FILES = [".lintstagedrc.json", ".lintstagedrc"];
+const LINT_STAGED_OTHER_CONFIG_FILES = [
+	".lintstagedrc.yaml",
+	".lintstagedrc.yml",
+	".lintstagedrc.mjs",
+	"lint-staged.config.mjs",
+	".lintstagedrc.cjs",
+	"lint-staged.config.cjs",
+	".lintstagedrc.js",
+	"lint-staged.config.js",
+	".lintstagedrc.ts",
+	"lint-staged.config.ts",
+	".lintstagedrc.mts",
+	"lint-staged.config.mts",
+	".lintstagedrc.cts",
+	"lint-staged.config.cts"
+];
+const LINT_STAGED_ALL_CONFIG_FILES = [...LINT_STAGED_JSON_CONFIG_FILES, ...LINT_STAGED_OTHER_CONFIG_FILES];
+const REMOVE_PACKAGES = [
+	"oxlint",
+	"oxlint-tsgolint",
+	"oxfmt",
+	"tsdown",
+	"@vitest/browser",
+	"@vitest/browser-preview",
+	"@vitest/browser-playwright",
+	"@vitest/browser-webdriverio"
+];
+const BROWSER_PROVIDER_PEER_DEPS = {
+	"@vitest/browser-playwright": "playwright",
+	"@vitest/browser-webdriverio": "webdriverio"
+};
+const PUBLIC_PEER_DEPENDENCY_FALLBACKS = {
+	vite: "*",
+	vitest: "*"
+};
+const OXLINT_NATIVE_PLUGINS = new Set([
+	"eslint",
+	"react",
+	"unicorn",
+	"typescript",
+	"oxc",
+	"import",
+	"jsdoc",
+	"jest",
+	"vitest",
+	"jsx-a11y",
+	"nextjs",
+	"react-perf",
+	"promise",
+	"node",
+	"vue"
+]);
+function warnMigration(message, report) {
+	addMigrationWarning(report, message);
+	if (!report) log.warn(message);
+}
+function infoMigration(message, report) {
+	addManualStep(report, message);
+	if (!report) log.info(message);
+}
+function checkViteVersion(projectPath) {
+	return checkPackageVersion(projectPath, "vite", "7.0.0");
+}
+function checkVitestVersion(projectPath) {
+	return checkPackageVersion(projectPath, "vitest", "4.0.0");
+}
+/**
+* Check the package version is supported by auto migration
+* @param projectPath - The path to the project
+* @param name - The name of the package
+* @param minVersion - The minimum version of the package
+* @returns true if the package version is supported by auto migration
+*/
+function checkPackageVersion(projectPath, name, minVersion) {
+	const metadata = detectPackageMetadata(projectPath, name);
+	if (!metadata || metadata.name !== name) return true;
+	if (import_semver.default.satisfies(metadata.version, `<${minVersion}`)) {
+		const packageJsonFilePath = path.join(projectPath, "package.json");
+		log.error(`✘ ${name}@${metadata.version} in ${displayRelative(packageJsonFilePath)} is not supported by auto migration`);
+		log.info(`Please upgrade ${name} to version >=${minVersion} first`);
+		return false;
+	}
+	return true;
+}
+function detectEslintProject(projectPath, packages) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return { hasDependency: false };
+	const pkg = readJsonFile(packageJsonPath);
+	let hasDependency = !!(pkg.devDependencies?.eslint || pkg.dependencies?.eslint);
+	const configs = detectConfigs(projectPath);
+	let configFile = configs.eslintConfig;
+	const legacyConfigFile = configs.eslintLegacyConfig;
+	if (!hasDependency && packages) for (const wp of packages) {
+		const pkgJsonPath = path.join(projectPath, wp.path, "package.json");
+		if (!fs.existsSync(pkgJsonPath)) continue;
+		const wpPkg = readJsonFile(pkgJsonPath);
+		if (wpPkg.devDependencies?.eslint || wpPkg.dependencies?.eslint) {
+			hasDependency = true;
+			break;
+		}
+	}
+	return {
+		hasDependency,
+		configFile,
+		legacyConfigFile
+	};
+}
+/**
+* Run a `vp dlx @oxlint/migrate` step with graceful error handling.
+* Returns true on success, false on failure (spawn error or non-zero exit).
+*/
+async function runOxlintMigrateStep(vpBin, cwd, migratePackage, args, spinner, failMessage, manualHint) {
+	try {
+		const result = await runCommandSilently({
+			command: vpBin,
+			args: [
+				"dlx",
+				migratePackage,
+				...args
+			],
+			cwd,
+			envs: process.env
+		});
+		if (result.exitCode !== 0) {
+			spinner.stop(failMessage);
+			const stderr = result.stderr.toString().trim();
+			if (stderr) log.warn(`⚠ ${stderr}`);
+			log.info(manualHint);
+			return false;
+		}
+		return true;
+	} catch {
+		spinner.stop(failMessage);
+		log.info(manualHint);
+		return false;
+	}
+}
+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);
+	if (eslintConfigFile) {
+		const { versions } = await import("./versions.js");
+		const migratePackage = `@oxlint/migrate@${versions.oxlint}`;
+		const migrateArgs = [
+			"--merge",
+			...!hasBaseUrlInTsconfig(projectPath) ? ["--type-aware"] : [],
+			"--with-nursery",
+			"--details"
+		];
+		spinner.start("Migrating ESLint config to Oxlint...");
+		if (!await runOxlintMigrateStep(vpBin, projectPath, migratePackage, migrateArgs, spinner, "ESLint migration failed", `You can run \`vp dlx ${migratePackage} ${migrateArgs.join(" ")}\` manually later`)) return false;
+		spinner.stop("ESLint config migrated to .oxlintrc.json");
+		spinner.start("Replacing ESLint comments with Oxlint equivalents...");
+		if (await runOxlintMigrateStep(vpBin, projectPath, migratePackage, ["--replace-eslint-comments"], spinner, "ESLint comment replacement failed", `You can run \`vp dlx ${migratePackage} --replace-eslint-comments\` manually later`)) spinner.stop("ESLint comments replaced");
+	}
+	if (options?.report) options.report.eslintMigrated = true;
+	const preserveJsPlugins = collectJsPluginPackageNames(projectPath);
+	const cleanupTargets = [projectPath, ...(packages ?? []).map((p) => path.join(projectPath, p.path))];
+	for (const target of cleanupTargets) {
+		if (!fs.existsSync(path.join(target, "package.json"))) continue;
+		deleteEslintConfigFiles(target, options?.report, options?.silent);
+		rewriteEslintPackageJson(path.join(target, "package.json"), preserveJsPlugins);
+		rewriteEslintLintStagedConfigFiles(target, options?.report);
+	}
+	return true;
+}
+/**
+* Read `<projectPath>/.oxlintrc.json` (if any) and collect the package
+* names referenced via `lint.jsPlugins[]` string entries. Object-form
+* entries (`{ name, specifier }`) and local-path specifiers (`./X`,
+* `../X`, `/X`) are excluded — neither maps to a `package.json` entry
+* we'd accidentally strip.
+*/
+function collectJsPluginPackageNames(projectPath) {
+	const out = /* @__PURE__ */ new Set();
+	const oxlintConfigPath = path.join(projectPath, ".oxlintrc.json");
+	if (!fs.existsSync(oxlintConfigPath)) return out;
+	let config;
+	try {
+		config = readJsonFile(oxlintConfigPath, true);
+	} catch {
+		return out;
+	}
+	const collectFrom = (jsPlugins) => {
+		for (const entry of jsPlugins ?? []) {
+			if (typeof entry !== "string") continue;
+			if (entry.startsWith("./") || entry.startsWith("../") || entry.startsWith("/")) continue;
+			out.add(entry);
+		}
+	};
+	collectFrom(config.jsPlugins);
+	if (Array.isArray(config.overrides)) for (const override of config.overrides) collectFrom(override.jsPlugins);
+	return out;
+}
+function deleteEslintConfigFiles(basePath, report, silent = false) {
+	const configs = detectConfigs(basePath);
+	for (const file of [configs.eslintConfig, configs.eslintLegacyConfig]) if (file) {
+		const configPath = path.join(basePath, file);
+		if (fs.existsSync(configPath)) {
+			fs.unlinkSync(configPath);
+			if (report) report.removedConfigCount++;
+			if (!silent) log.success(`✔ Removed ${displayRelative(configPath)}`);
+		}
+	}
+}
+const ESLINT_ECOSYSTEM_NAMES = new Set([
+	"eslint",
+	"typescript-eslint",
+	"eslintrc",
+	"eslint-utils",
+	"eslint-visitor-keys",
+	"eslint-scope",
+	"eslint-define-config",
+	"eslint-doc-generator",
+	"@typescript-eslint/eslint-plugin",
+	"@typescript-eslint/parser",
+	"@typescript-eslint/rule-tester"
+]);
+const ESLINT_ECOSYSTEM_PREFIXES = [
+	"eslint-plugin-",
+	"eslint-config-",
+	"eslint-formatter-"
+];
+const ESLINT_ECOSYSTEM_SCOPES = [
+	"@eslint/",
+	"@eslint-community/",
+	"@angular-eslint/"
+];
+/**
+* Decide whether a dependency entry should be removed alongside `eslint`
+* itself. The set is intentionally broad: anything whose only purpose is
+* to extend, configure, format, or wire ESLint becomes dead weight after
+* migration. `@types/<X>` packages are checked symmetrically with `<X>`
+* so type-only counterparts of removed runtime packages also go.
+*/
+function isEslintEcosystemDep(name) {
+	const stripped = name.startsWith("@types/") ? name.slice(7) : name;
+	if (ESLINT_ECOSYSTEM_NAMES.has(stripped)) return true;
+	if (ESLINT_ECOSYSTEM_PREFIXES.some((p) => stripped.startsWith(p))) return true;
+	if (ESLINT_ECOSYSTEM_SCOPES.some((s) => stripped.startsWith(s))) return true;
+	//   @vitest/eslint-plugin
+	if (/^@[^/]+\/eslint-(plugin|config|formatter)(-.+)?$/.test(stripped)) return true;
+	return false;
+}
+/**
+* Rewrite a project's `package.json` after ESLint has been migrated to
+* Oxlint: drop every ESLint-ecosystem dependency (see
+* `isEslintEcosystemDep`), strip empty containers, and rewrite eslint
+* tokens in scripts / lint-staged. Applied uniformly to the root and to
+* every workspace package — the migration treats the whole workspace as
+* in scope for adoption, so a half-cleanup at the workspace level would
+* be inconsistent with the rest of the flow (which already replaces
+* vite-related overrides and adds vite-plus across all packages).
+*
+* `preserveJsPlugins` names packages that `@oxlint/migrate` referenced
+* via `lint.jsPlugins` and that Oxlint will need to `import()` at lint
+* time. They override `isEslintEcosystemDep` so the generated config
+* isn't immediately invalidated by the cleanup step.
+*/
+function rewriteEslintPackageJson(packageJsonPath, preserveJsPlugins = /* @__PURE__ */ new Set()) {
+	editJsonFile(packageJsonPath, (pkg) => {
+		let changed = false;
+		for (const field of [
+			"devDependencies",
+			"dependencies",
+			"peerDependencies",
+			"optionalDependencies"
+		]) {
+			const deps = pkg[field];
+			if (!deps) continue;
+			let removedAny = false;
+			for (const name of Object.keys(deps)) {
+				if (preserveJsPlugins.has(name)) continue;
+				if (isEslintEcosystemDep(name)) {
+					delete deps[name];
+					changed = true;
+					removedAny = true;
+				}
+			}
+			if (removedAny && Object.keys(deps).length === 0) delete pkg[field];
+		}
+		if (pkg.scripts) {
+			const updated = rewriteEslint(JSON.stringify(pkg.scripts));
+			if (updated) {
+				pkg.scripts = JSON.parse(updated);
+				changed = true;
+			}
+		}
+		if (pkg["lint-staged"]) {
+			const updated = rewriteEslint(JSON.stringify(pkg["lint-staged"]));
+			if (updated) {
+				pkg["lint-staged"] = JSON.parse(updated);
+				changed = true;
+			}
+		}
+		return changed ? pkg : void 0;
+	});
+}
+/**
+* Rewrite tool references in lint-staged config files (JSON ones are rewritten,
+* non-JSON ones get a warning).
+*/
+function rewriteToolLintStagedConfigFiles(projectPath, rewriteFn, toolName, report) {
+	for (const filename of LINT_STAGED_JSON_CONFIG_FILES) {
+		const configPath = path.join(projectPath, filename);
+		if (!fs.existsSync(configPath)) continue;
+		if (filename === ".lintstagedrc" && !isJsonFile(configPath)) {
+			warnMigration(`${displayRelative(configPath)} is not JSON — please update ${toolName} references manually`, report);
+			continue;
+		}
+		editJsonFile(configPath, (config) => {
+			const updated = rewriteFn(JSON.stringify(config));
+			if (updated) return JSON.parse(updated);
+		});
+	}
+	for (const filename of LINT_STAGED_OTHER_CONFIG_FILES) {
+		const configPath = path.join(projectPath, filename);
+		if (!fs.existsSync(configPath)) continue;
+		warnMigration(`${displayRelative(configPath)} — please update ${toolName} references manually`, report);
+	}
+}
+function rewriteEslintLintStagedConfigFiles(projectPath, report) {
+	rewriteToolLintStagedConfigFiles(projectPath, rewriteEslint, "eslint", report);
+}
+function detectPrettierProject(projectPath, packages) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return { hasDependency: false };
+	const pkg = readJsonFile(packageJsonPath);
+	let hasDependency = !!(pkg.devDependencies?.prettier || pkg.dependencies?.prettier);
+	const configFile = detectConfigs(projectPath).prettierConfig;
+	if (!hasDependency && packages) for (const wp of packages) {
+		const pkgJsonPath = path.join(projectPath, wp.path, "package.json");
+		if (!fs.existsSync(pkgJsonPath)) continue;
+		const wpPkg = readJsonFile(pkgJsonPath);
+		if (wpPkg.devDependencies?.prettier || wpPkg.dependencies?.prettier) {
+			hasDependency = true;
+			break;
+		}
+	}
+	return {
+		hasDependency,
+		configFile
+	};
+}
+/**
+* Run `vp fmt --migrate=prettier` step with graceful error handling.
+* Returns true on success, false on failure.
+*/
+async function runPrettierMigrateStep(vpBin, cwd, spinner, failMessage, manualHint) {
+	try {
+		const result = await runCommandSilently({
+			command: vpBin,
+			args: ["fmt", "--migrate=prettier"],
+			cwd,
+			envs: process.env
+		});
+		if (result.exitCode !== 0) {
+			spinner.stop(failMessage);
+			const stderr = result.stderr.toString().trim();
+			if (stderr) log.warn(`⚠ ${stderr}`);
+			log.info(manualHint);
+			return false;
+		}
+		return true;
+	} catch {
+		spinner.stop(failMessage);
+		log.info(manualHint);
+		return false;
+	}
+}
+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);
+	if (prettierConfigFile) {
+		let tempPrettierConfig;
+		if (prettierConfigFile === "package.json#prettier") {
+			const pkg = readJsonFile(path.join(projectPath, "package.json"));
+			if (pkg.prettier) {
+				tempPrettierConfig = path.join(projectPath, ".prettierrc.json");
+				fs.writeFileSync(tempPrettierConfig, JSON.stringify(pkg.prettier, null, 2));
+			} else return true;
+		}
+		try {
+			spinner.start("Migrating Prettier config to Oxfmt...");
+			if (!await runPrettierMigrateStep(vpBin, projectPath, spinner, "Prettier migration failed", "You can run `vp fmt --migrate=prettier` manually later")) return false;
+			spinner.stop("Prettier config migrated to .oxfmtrc.json");
+		} finally {
+			if (tempPrettierConfig) try {
+				fs.unlinkSync(tempPrettierConfig);
+			} catch {}
+		}
+	}
+	if (options?.report) options.report.prettierMigrated = true;
+	deletePrettierConfigFiles(projectPath, options?.report, options?.silent);
+	rewritePrettierPackageJson(path.join(projectPath, "package.json"));
+	if (packages) for (const pkg of packages) rewritePrettierPackageJson(path.join(projectPath, pkg.path, "package.json"));
+	rewritePrettierLintStagedConfigFiles(projectPath, options?.report);
+	const prettierIgnorePath = path.join(projectPath, ".prettierignore");
+	if (fs.existsSync(prettierIgnorePath)) warnMigration(`${displayRelative(prettierIgnorePath)} found — Oxfmt supports .prettierignore, but using the \`ignorePatterns\` option is recommended.`, options?.report);
+	return true;
+}
+function deletePrettierConfigFiles(basePath, report, silent = false) {
+	const configs = detectConfigs(basePath);
+	if (configs.prettierConfig && configs.prettierConfig !== "package.json#prettier") {
+		const configPath = path.join(basePath, configs.prettierConfig);
+		if (fs.existsSync(configPath)) {
+			fs.unlinkSync(configPath);
+			if (report) report.removedConfigCount++;
+			if (!silent) log.success(`✔ Removed ${displayRelative(configPath)}`);
+		}
+	}
+	for (const file of PRETTIER_CONFIG_FILES) {
+		if (file === configs.prettierConfig) continue;
+		const configPath = path.join(basePath, file);
+		if (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.prettier) {
+			delete pkg.prettier;
+			return pkg;
+		}
+	});
+}
+function rewritePrettierPackageJson(packageJsonPath) {
+	if (!fs.existsSync(packageJsonPath)) return;
+	editJsonFile(packageJsonPath, (pkg) => {
+		let changed = false;
+		if (pkg.devDependencies) {
+			for (const dep of Object.keys(pkg.devDependencies)) if (dep === "prettier" || dep.startsWith("prettier-plugin-")) {
+				delete pkg.devDependencies[dep];
+				changed = true;
+			}
+		}
+		if (pkg.dependencies) {
+			for (const dep of Object.keys(pkg.dependencies)) if (dep === "prettier" || dep.startsWith("prettier-plugin-")) {
+				delete pkg.dependencies[dep];
+				changed = true;
+			}
+		}
+		if (pkg.scripts) {
+			const updated = rewritePrettier(JSON.stringify(pkg.scripts));
+			if (updated) {
+				pkg.scripts = JSON.parse(updated);
+				changed = true;
+			}
+		}
+		if (pkg["lint-staged"]) {
+			const updated = rewritePrettier(JSON.stringify(pkg["lint-staged"]));
+			if (updated) {
+				pkg["lint-staged"] = JSON.parse(updated);
+				changed = true;
+			}
+		}
+		return changed ? pkg : void 0;
+	});
+}
+function rewritePrettierLintStagedConfigFiles(projectPath, report) {
+	rewriteToolLintStagedConfigFiles(projectPath, rewritePrettier, "prettier", report);
+}
+function cleanupDeprecatedTsconfigOptions(projectPath, silent = false, report) {
+	const deprecatedOptions = ["esModuleInterop", "allowSyntheticDefaultImports"];
+	const files = findTsconfigFiles(projectPath);
+	for (const filePath of files) for (const name of deprecatedOptions) if (removeDeprecatedTsconfigFalseOption(filePath, name)) {
+		if (report) report.removedConfigCount++;
+		if (!silent) log.success(`✔ Removed ${name}: false from ${displayRelative(filePath)}`);
+		warnMigration(`Removed \`"${name}": false\` from ${displayRelative(filePath)} — this option has been deprecated. See https://github.com/oxc-project/tsgolint/issues/351, https://github.com/microsoft/TypeScript/issues/62529`, report);
+	}
+}
+function rewriteTsconfigTypes(projectPath, silent = false, report) {
+	const files = findTsconfigFiles(projectPath);
+	for (const filePath of files) if (rewriteTypesInTsconfig(filePath)) {
+		if (report) report.removedConfigCount++;
+		if (!silent) log.success(`✔ Rewrote types in ${displayRelative(filePath)}`);
+	}
+}
+const FRAMEWORK_SHIMS = {
+	vue: [
+		"declare module '*.vue' {",
+		"  import type { DefineComponent } from 'vue';",
+		"  const component: DefineComponent<{}, {}, unknown>;",
+		"  export default component;",
+		"}"
+	].join("\n"),
+	astro: "/// <reference types=\"astro/client\" />"
+};
+function detectFramework(projectPath) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return [];
+	const pkg = readJsonFile(packageJsonPath);
+	const allDeps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	return ["vue", "astro"].filter((framework) => !!allDeps[framework]);
+}
+function getEnvDtsPath(projectPath) {
+	const srcEnvDts = path.join(projectPath, "src", "env.d.ts");
+	const rootEnvDts = path.join(projectPath, "env.d.ts");
+	for (const candidate of [srcEnvDts, rootEnvDts]) if (fs.existsSync(candidate)) return candidate;
+	return fs.existsSync(path.join(projectPath, "src")) ? srcEnvDts : rootEnvDts;
+}
+function hasFrameworkShim(projectPath, framework) {
+	const dirsToScan = [projectPath, path.join(projectPath, "src")];
+	for (const dir of dirsToScan) {
+		if (!fs.existsSync(dir)) continue;
+		let entries;
+		try {
+			entries = fs.readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.endsWith(".d.ts")) continue;
+			const content = fs.readFileSync(path.join(dir, entry), "utf-8");
+			if (framework === "astro") {
+				if (content.includes("astro/client")) return true;
+			} else if (content.includes(`'*.${framework}'`) || content.includes(`"*.${framework}"`)) return true;
+		}
+	}
+	return false;
+}
+function addFrameworkShim(projectPath, framework, report) {
+	const envDtsPath = getEnvDtsPath(projectPath);
+	const shim = FRAMEWORK_SHIMS[framework];
+	if (fs.existsSync(envDtsPath)) {
+		const existing = fs.readFileSync(envDtsPath, "utf-8");
+		fs.writeFileSync(envDtsPath, `${existing.trimEnd()}\n\n${shim}\n`, "utf-8");
+	} else {
+		fs.mkdirSync(path.dirname(envDtsPath), { recursive: true });
+		fs.writeFileSync(envDtsPath, `${shim}\n`, "utf-8");
+	}
+	if (report) report.frameworkShimAdded = true;
+}
+/**
+* Rewrite standalone project to add vite-plus dependencies
+* @param projectPath - The path to the project
+*/
+function rewriteStandaloneProject(projectPath, workspaceInfo, skipStagedMigration, silent = false, report) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return;
+	const packageManager = workspaceInfo.packageManager;
+	const catalogDependencyResolver = createCatalogDependencyResolver(projectPath, packageManager);
+	let extractedStagedConfig = null;
+	let remainingPnpmOverrides;
+	let shouldRewritePnpmWorkspaceYaml = false;
+	let shouldAddPnpmWorkspaceVitePlusOverride = false;
+	let usePnpmWorkspaceYaml = false;
+	editJsonFile(packageJsonPath, (pkg) => {
+		if (packageManager === PackageManager.yarn) pkg.resolutions = {
+			...pkg.resolutions,
+			...VITE_PLUS_OVERRIDE_PACKAGES
+		};
+		else if (packageManager === PackageManager.npm || packageManager === PackageManager.bun) pkg.overrides = {
+			...pkg.overrides,
+			...VITE_PLUS_OVERRIDE_PACKAGES
+		};
+		else if (packageManager === PackageManager.pnpm) {
+			usePnpmWorkspaceYaml = !pkg.pnpm;
+			if (usePnpmWorkspaceYaml) {
+				shouldRewritePnpmWorkspaceYaml = true;
+				shouldAddPnpmWorkspaceVitePlusOverride = isForceOverrideMode();
+			}
+			const overrideKeys = Object.keys(VITE_PLUS_OVERRIDE_PACKAGES);
+			if (!usePnpmWorkspaceYaml) pkg.pnpm = {
+				...pkg.pnpm,
+				overrides: {
+					...pkg.pnpm?.overrides,
+					...VITE_PLUS_OVERRIDE_PACKAGES,
+					...isForceOverrideMode() ? { [VITE_PLUS_NAME]: VITE_PLUS_VERSION } : {}
+				},
+				peerDependencyRules: {
+					...pkg.pnpm?.peerDependencyRules,
+					allowAny: [...new Set([...pkg.pnpm?.peerDependencyRules?.allowAny ?? [], ...overrideKeys])],
+					allowedVersions: {
+						...pkg.pnpm?.peerDependencyRules?.allowedVersions,
+						...Object.fromEntries(overrideKeys.map((key) => [key, "*"]))
+					}
+				}
+			};
+			else remainingPnpmOverrides = cleanupPnpmOverridesForWorkspaceYaml(pkg, overrideKeys);
+			for (const key in pkg.pnpm?.overrides) if (key.includes(">")) {
+				const splits = key.split(">");
+				if (splits[splits.length - 1].trim() === "vite") delete pkg.pnpm.overrides[key];
+			}
+			for (const key of [...overrideKeys, ...REMOVE_PACKAGES]) if (pkg.resolutions?.[key]) delete pkg.resolutions[key];
+		}
+		extractedStagedConfig = rewritePackageJson(pkg, packageManager, usePnpmWorkspaceYaml, skipStagedMigration, catalogDependencyResolver);
+		if (!pkg.devDependencies?.["vite-plus"] || isForceOverrideMode()) {
+			const version = usePnpmWorkspaceYaml && !VITE_PLUS_VERSION.startsWith("file:") ? "catalog:" : VITE_PLUS_VERSION;
+			pkg.devDependencies = {
+				...pkg.devDependencies,
+				[VITE_PLUS_NAME]: version
+			};
+		}
+		return pkg;
+	});
+	if (shouldRewritePnpmWorkspaceYaml) rewritePnpmWorkspaceYaml(projectPath);
+	if (remainingPnpmOverrides) migratePnpmOverridesToWorkspaceYaml(projectPath, remainingPnpmOverrides);
+	if (shouldAddPnpmWorkspaceVitePlusOverride) migratePnpmOverridesToWorkspaceYaml(projectPath, { [VITE_PLUS_NAME]: VITE_PLUS_VERSION });
+	if (packageManager === PackageManager.yarn) rewriteYarnrcYml(projectPath);
+	if (extractedStagedConfig) {
+		if (mergeStagedConfigToViteConfig(projectPath, extractedStagedConfig, silent, report)) removeLintStagedFromPackageJson(packageJsonPath);
+	}
+	if (!skipStagedMigration) rewriteLintStagedConfigFile(projectPath, report);
+	cleanupDeprecatedTsconfigOptions(projectPath, silent, report);
+	rewriteTsconfigTypes(projectPath, silent, report);
+	mergeViteConfigFiles(projectPath, silent, report, workspaceInfo.packages);
+	injectLintTypeCheckDefaults(projectPath, silent, report);
+	injectFmtDefaults(projectPath, silent, report);
+	mergeTsdownConfigFile(projectPath, silent, report);
+	rewriteAllImports(projectPath, silent, report);
+	setPackageManager(projectPath, workspaceInfo.downloadPackageManager);
+}
+/**
+* Rewrite monorepo to add vite-plus dependencies
+* @param workspaceInfo - The workspace info
+*/
+function rewriteMonorepo(workspaceInfo, skipStagedMigration, silent = false, report) {
+	const catalogDependencyResolver = createCatalogDependencyResolver(workspaceInfo.rootDir, workspaceInfo.packageManager);
+	if (workspaceInfo.packageManager === PackageManager.pnpm) rewritePnpmWorkspaceYaml(workspaceInfo.rootDir);
+	else if (workspaceInfo.packageManager === PackageManager.yarn) rewriteYarnrcYml(workspaceInfo.rootDir);
+	else if (workspaceInfo.packageManager === PackageManager.bun) rewriteBunCatalog(workspaceInfo.rootDir);
+	rewriteRootWorkspacePackageJson(workspaceInfo.rootDir, workspaceInfo.packageManager, skipStagedMigration, catalogDependencyResolver, workspaceInfo.packages);
+	const workspaceContext = {
+		rootDir: workspaceInfo.rootDir,
+		packages: workspaceInfo.packages
+	};
+	for (const pkg of workspaceInfo.packages) rewriteMonorepoProject(path.join(workspaceInfo.rootDir, pkg.path), workspaceInfo.packageManager, skipStagedMigration, silent, report, catalogDependencyResolver, workspaceContext);
+	if (!skipStagedMigration) rewriteLintStagedConfigFile(workspaceInfo.rootDir, report);
+	cleanupDeprecatedTsconfigOptions(workspaceInfo.rootDir, silent, report);
+	rewriteTsconfigTypes(workspaceInfo.rootDir, silent, report);
+	mergeViteConfigFiles(workspaceInfo.rootDir, silent, report, workspaceInfo.packages);
+	injectLintTypeCheckDefaults(workspaceInfo.rootDir, silent, report);
+	injectFmtDefaults(workspaceInfo.rootDir, silent, report);
+	mergeTsdownConfigFile(workspaceInfo.rootDir, silent, report);
+	rewriteAllImports(workspaceInfo.rootDir, silent, report);
+	setPackageManager(workspaceInfo.rootDir, workspaceInfo.downloadPackageManager);
+}
+/**
+* Rewrite monorepo project to add vite-plus dependencies
+* @param projectPath - The path to the project
+* @param workspaceContext - Full workspace info, used so the lint-config
+*   sanitizer can see hoisted deps living elsewhere in the workspace,
+*   not just this sub-package's own `package.json`. `rootDir` is the
+*   workspace root (paths in `packages` are relative to it); `packages`
+*   is the workspace package list.
+*/
+function rewriteMonorepoProject(projectPath, packageManager, skipStagedMigration, silent = false, report, catalogDependencyResolver, workspaceContext) {
+	cleanupDeprecatedTsconfigOptions(projectPath, silent, report);
+	rewriteTsconfigTypes(projectPath, silent, report);
+	mergeViteConfigFiles(projectPath, silent, report, workspaceContext?.packages, workspaceContext?.rootDir);
+	mergeTsdownConfigFile(projectPath, silent, report);
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return;
+	let extractedStagedConfig = null;
+	editJsonFile(packageJsonPath, (pkg) => {
+		extractedStagedConfig = rewritePackageJson(pkg, packageManager, true, skipStagedMigration, catalogDependencyResolver);
+		return pkg;
+	});
+	if (extractedStagedConfig) {
+		if (mergeStagedConfigToViteConfig(projectPath, extractedStagedConfig, silent, report)) removeLintStagedFromPackageJson(packageJsonPath);
+	}
+}
+/**
+* Rewrite pnpm-workspace.yaml to add vite-plus dependencies
+* @param projectPath - The path to the project
+*/
+function rewritePnpmWorkspaceYaml(projectPath) {
+	const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
+	if (!fs.existsSync(pnpmWorkspaceYamlPath)) fs.writeFileSync(pnpmWorkspaceYamlPath, "");
+	editYamlFile(pnpmWorkspaceYamlPath, (doc) => {
+		rewriteCatalog(doc);
+		const overrides = doc.getIn(["overrides"]);
+		for (const key of Object.keys(VITE_PLUS_OVERRIDE_PACKAGES)) {
+			const version = getCatalogDependencySpec(getYamlMapScalarStringValue(overrides, key), VITE_PLUS_OVERRIDE_PACKAGES[key], true);
+			doc.setIn(["overrides", scalarString(key)], scalarString(version));
+		}
+		const updatedOverrides = doc.getIn(["overrides"]);
+		for (const item of updatedOverrides.items) if (item.key.value.includes(">")) {
+			const splits = item.key.value.split(">");
+			if (splits[splits.length - 1].trim() === "vite") updatedOverrides.delete(item.key);
+		}
+		let allowAny = doc.getIn(["peerDependencyRules", "allowAny"]);
+		if (!allowAny) allowAny = new import_dist.YAMLSeq();
+		const existing = new Set(allowAny.items.map((n) => n.value));
+		for (const key of Object.keys(VITE_PLUS_OVERRIDE_PACKAGES)) if (!existing.has(key)) allowAny.add(scalarString(key));
+		doc.setIn(["peerDependencyRules", "allowAny"], allowAny);
+		let allowedVersions = doc.getIn(["peerDependencyRules", "allowedVersions"]);
+		if (!allowedVersions) allowedVersions = new import_dist.YAMLMap();
+		for (const key of Object.keys(VITE_PLUS_OVERRIDE_PACKAGES)) allowedVersions.set(scalarString(key), scalarString("*"));
+		doc.setIn(["peerDependencyRules", "allowedVersions"], allowedVersions);
+		if (doc.has("minimumReleaseAge")) {
+			const excludes = [
+				"vite-plus",
+				"@voidzero-dev/*",
+				"oxlint",
+				"@oxlint/*",
+				"oxlint-tsgolint",
+				"@oxlint-tsgolint/*",
+				"oxfmt",
+				"@oxfmt/*"
+			];
+			let minimumReleaseAgeExclude = doc.getIn(["minimumReleaseAgeExclude"]);
+			if (!minimumReleaseAgeExclude) minimumReleaseAgeExclude = new import_dist.YAMLSeq();
+			const existing = new Set(minimumReleaseAgeExclude.items.map((n) => n.value));
+			for (const exclude of excludes) if (!existing.has(exclude)) minimumReleaseAgeExclude.add(scalarString(exclude));
+			doc.setIn(["minimumReleaseAgeExclude"], minimumReleaseAgeExclude);
+		}
+	});
+}
+/**
+* Clean up pnpm.overrides and peerDependencyRules from package.json when migrating
+* to pnpm-workspace.yaml. Returns any remaining non-Vite overrides that need to be
+* moved to pnpm-workspace.yaml.
+*/
+function cleanupPnpmOverridesForWorkspaceYaml(pkg, overrideKeys) {
+	const catalogOverrides = {};
+	const overrides = pkg.pnpm?.overrides;
+	for (const key of [...overrideKeys, ...REMOVE_PACKAGES]) {
+		const value = overrides?.[key];
+		if (value) {
+			if (overrideKeys.includes(key) && value.startsWith("catalog:")) catalogOverrides[key] = value;
+			delete overrides[key];
+		}
+	}
+	for (const key in pkg.pnpm?.overrides) if (key.includes(">")) {
+		const splits = key.split(">");
+		if (splits[splits.length - 1].trim() === "vite") delete pkg.pnpm.overrides[key];
+	}
+	let remaining;
+	if (Object.keys(catalogOverrides).length > 0) remaining = { ...catalogOverrides };
+	if (pkg.pnpm?.overrides && Object.keys(pkg.pnpm.overrides).length > 0) remaining = {
+		...remaining,
+		...pkg.pnpm.overrides
+	};
+	delete pkg.pnpm?.overrides;
+	cleanupPeerDependencyRules(pkg.pnpm?.peerDependencyRules, overrideKeys);
+	if (pkg.pnpm?.peerDependencyRules && Object.keys(pkg.pnpm.peerDependencyRules).length === 0) delete pkg.pnpm.peerDependencyRules;
+	if (pkg.pnpm && Object.keys(pkg.pnpm).length === 0) delete pkg.pnpm;
+	return remaining;
+}
+/**
+* Move remaining non-Vite pnpm.overrides from package.json to pnpm-workspace.yaml.
+* pnpm ignores workspace-level overrides when pnpm.overrides exists in package.json,
+* so all overrides must live in pnpm-workspace.yaml.
+*/
+function migratePnpmOverridesToWorkspaceYaml(projectPath, overrides) {
+	editYamlFile(path.join(projectPath, "pnpm-workspace.yaml"), (doc) => {
+		for (const [key, value] of Object.entries(overrides)) doc.setIn(["overrides", scalarString(key)], scalarString(value));
+	});
+}
+/**
+* Remove only Vite-managed entries from peerDependencyRules, preserving custom ones.
+*/
+function cleanupPeerDependencyRules(peerDependencyRules, overrideKeys) {
+	if (!peerDependencyRules) return;
+	if (Array.isArray(peerDependencyRules.allowAny)) {
+		peerDependencyRules.allowAny = peerDependencyRules.allowAny.filter((key) => !overrideKeys.includes(key));
+		if (peerDependencyRules.allowAny.length === 0) delete peerDependencyRules.allowAny;
+	}
+	if (peerDependencyRules.allowedVersions) {
+		for (const key of overrideKeys) delete peerDependencyRules.allowedVersions[key];
+		if (Object.keys(peerDependencyRules.allowedVersions).length === 0) delete peerDependencyRules.allowedVersions;
+	}
+}
+/**
+* Rewrite .yarnrc.yml to add vite-plus dependencies
+* @param projectPath - The path to the project
+*/
+function rewriteYarnrcYml(projectPath) {
+	const yarnrcYmlPath = path.join(projectPath, ".yarnrc.yml");
+	if (!fs.existsSync(yarnrcYmlPath)) fs.writeFileSync(yarnrcYmlPath, "");
+	editYamlFile(yarnrcYmlPath, (doc) => {
+		if (!doc.has("nodeLinker")) doc.set("nodeLinker", "node-modules");
+		rewriteCatalog(doc);
+	});
+}
+/**
+* Rewrite catalog in pnpm-workspace.yaml or .yarnrc.yml
+* @param doc - The document to rewrite
+*/
+function getCatalogDependencySpec(currentValue, version, supportCatalog, options) {
+	if (options?.dependencyField === "peerDependencies") {
+		if (currentValue?.startsWith("catalog:") && options.dependencyName) {
+			const resolved = options.catalogDependencyResolver?.(currentValue, options.dependencyName);
+			if (resolved && !isVitePlusOverrideSpec(resolved)) return resolved;
+			return PUBLIC_PEER_DEPENDENCY_FALLBACKS[options.dependencyName] ?? currentValue;
+		}
+		return currentValue ?? version;
+	}
+	if (options?.dependencyField === "optionalDependencies" && options?.packageManager === PackageManager.yarn) return version;
+	if (!supportCatalog || version.startsWith("file:")) return version;
+	return currentValue?.startsWith("catalog:") ? currentValue : "catalog:";
+}
+function isVitePlusOverrideSpec(value) {
+	return Object.values(VITE_PLUS_OVERRIDE_PACKAGES).includes(value) || value.startsWith("npm:@voidzero-dev/vite-plus-");
+}
+function createCatalogDependencyResolver(projectPath, packageManager) {
+	if (packageManager === PackageManager.pnpm) {
+		const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
+		if (!fs.existsSync(pnpmWorkspaceYamlPath)) return;
+		const doc = readYamlFile(pnpmWorkspaceYamlPath);
+		return createCatalogDependencyResolverFromCatalogs(doc?.catalog, doc?.catalogs);
+	}
+	if (packageManager === PackageManager.yarn) {
+		const yarnrcYmlPath = path.join(projectPath, ".yarnrc.yml");
+		if (!fs.existsSync(yarnrcYmlPath)) return;
+		const doc = readYamlFile(yarnrcYmlPath);
+		return createCatalogDependencyResolverFromCatalogs(doc?.catalog, doc?.catalogs);
+	}
+	if (packageManager === PackageManager.bun) {
+		const packageJsonPath = path.join(projectPath, "package.json");
+		if (!fs.existsSync(packageJsonPath)) return;
+		const pkg = readJsonFile(packageJsonPath);
+		const workspacesObj = pkg.workspaces && !Array.isArray(pkg.workspaces) ? pkg.workspaces : void 0;
+		const fromWorkspaces = createCatalogDependencyResolverFromCatalogs(workspacesObj?.catalog, workspacesObj?.catalogs);
+		const fromPkg = createCatalogDependencyResolverFromCatalogs(pkg.catalog, pkg.catalogs);
+		return (catalogSpec, dependencyName) => fromWorkspaces(catalogSpec, dependencyName) ?? fromPkg(catalogSpec, dependencyName);
+	}
+}
+function createCatalogDependencyResolverFromCatalogs(catalog, catalogs) {
+	return (catalogSpec, dependencyName) => {
+		const catalogName = catalogSpec.slice(8);
+		if (catalogName && catalogName !== "default") return catalogs?.[catalogName]?.[dependencyName];
+		return catalog?.[dependencyName];
+	};
+}
+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;
+}
+function rewriteCatalog(doc) {
+	for (const [key, value] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) {
+		if (value.startsWith("file:")) continue;
+		doc.setIn(["catalog", key], scalarString(value));
+	}
+	if (!VITE_PLUS_VERSION.startsWith("file:")) doc.setIn(["catalog", VITE_PLUS_NAME], scalarString(VITE_PLUS_VERSION));
+	for (const name of REMOVE_PACKAGES) {
+		const path = ["catalog", name];
+		if (doc.hasIn(path)) doc.deleteIn(path);
+	}
+	const catalogs = doc.getIn(["catalogs"]);
+	if (!(catalogs instanceof import_dist.YAMLMap)) return;
+	for (const item of catalogs.items) {
+		const catalogName = item.key instanceof import_dist.Scalar ? item.key.value : void 0;
+		if (typeof catalogName !== "string" || !(item.value instanceof import_dist.YAMLMap)) continue;
+		for (const [key, value] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) {
+			const catalogPath = [
+				"catalogs",
+				catalogName,
+				key
+			];
+			if (!value.startsWith("file:") && doc.hasIn(catalogPath)) doc.setIn(catalogPath, scalarString(value));
+		}
+		const vitePlusPath = [
+			"catalogs",
+			catalogName,
+			VITE_PLUS_NAME
+		];
+		if (!VITE_PLUS_VERSION.startsWith("file:") && doc.hasIn(vitePlusPath)) doc.setIn(vitePlusPath, scalarString(VITE_PLUS_VERSION));
+		for (const name of REMOVE_PACKAGES) {
+			const catalogPath = [
+				"catalogs",
+				catalogName,
+				name
+			];
+			if (doc.hasIn(catalogPath)) doc.deleteIn(catalogPath);
+		}
+	}
+}
+function rewriteCatalogObject(catalog, addMissing) {
+	for (const [key, value] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) {
+		if (value.startsWith("file:") || !addMissing && !(key in catalog)) continue;
+		catalog[key] = value;
+	}
+	if (!VITE_PLUS_VERSION.startsWith("file:") && (addMissing || "vite-plus" in catalog)) catalog[VITE_PLUS_NAME] = VITE_PLUS_VERSION;
+	for (const name of REMOVE_PACKAGES) delete catalog[name];
+}
+function rewriteCatalogsObject(catalogs) {
+	for (const catalog of Object.values(catalogs)) rewriteCatalogObject(catalog, false);
+}
+/**
+* Write catalog entries to root package.json for bun.
+* Bun stores catalogs in package.json under the `catalog` key,
+* unlike pnpm which uses pnpm-workspace.yaml.
+* @see https://bun.sh/docs/pm/catalogs
+*/
+function rewriteBunCatalog(projectPath) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return;
+	editJsonFile(packageJsonPath, (pkg) => {
+		const workspacesObj = pkg.workspaces && !Array.isArray(pkg.workspaces) ? pkg.workspaces : void 0;
+		const useWorkspacesCatalog = workspacesObj?.catalog != null || pkg.catalog == null && workspacesObj?.catalogs != null;
+		const catalog = { ...useWorkspacesCatalog ? workspacesObj?.catalog : pkg.catalog };
+		rewriteCatalogObject(catalog, true);
+		if (useWorkspacesCatalog) {
+			workspacesObj.catalog = catalog;
+			if (pkg.catalog) rewriteCatalogObject(pkg.catalog, false);
+		} else {
+			pkg.catalog = catalog;
+			if (workspacesObj?.catalog) rewriteCatalogObject(workspacesObj.catalog, false);
+		}
+		if (workspacesObj?.catalogs) rewriteCatalogsObject(workspacesObj.catalogs);
+		if (pkg.catalogs) rewriteCatalogsObject(pkg.catalogs);
+		const overrides = { ...pkg.overrides };
+		for (const [key, value] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) overrides[key] = getCatalogDependencySpec(overrides[key], value, true);
+		pkg.overrides = overrides;
+		return pkg;
+	});
+}
+/**
+* Rewrite root workspace package.json to add vite-plus dependencies
+* @param projectPath - The path to the project
+*/
+function rewriteRootWorkspacePackageJson(projectPath, packageManager, skipStagedMigration, catalogDependencyResolver, packages) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return;
+	let remainingPnpmOverrides;
+	editJsonFile(packageJsonPath, (pkg) => {
+		if (packageManager === PackageManager.yarn) pkg.resolutions = {
+			...pkg.resolutions,
+			...VITE_PLUS_OVERRIDE_PACKAGES
+		};
+		else if (packageManager === PackageManager.npm) pkg.overrides = {
+			...pkg.overrides,
+			...VITE_PLUS_OVERRIDE_PACKAGES
+		};
+		else if (packageManager === PackageManager.bun) {} else if (packageManager === PackageManager.pnpm) {
+			const overrideKeys = Object.keys(VITE_PLUS_OVERRIDE_PACKAGES);
+			if (isForceOverrideMode()) pkg.pnpm = {
+				...pkg.pnpm,
+				overrides: {
+					...pkg.pnpm?.overrides,
+					...VITE_PLUS_OVERRIDE_PACKAGES,
+					[VITE_PLUS_NAME]: VITE_PLUS_VERSION
+				}
+			};
+			else {
+				for (const key of [...overrideKeys, ...REMOVE_PACKAGES]) if (pkg.resolutions?.[key]) delete pkg.resolutions[key];
+				remainingPnpmOverrides = cleanupPnpmOverridesForWorkspaceYaml(pkg, overrideKeys);
+			}
+			for (const key in pkg.pnpm?.overrides) if (key.includes(">")) {
+				const splits = key.split(">");
+				if (splits[splits.length - 1].trim() === "vite") delete pkg.pnpm.overrides[key];
+			}
+		}
+		if (!pkg.devDependencies?.["vite-plus"]) pkg.devDependencies = {
+			...pkg.devDependencies,
+			[VITE_PLUS_NAME]: packageManager === PackageManager.npm || VITE_PLUS_VERSION.startsWith("file:") ? VITE_PLUS_VERSION : "catalog:"
+		};
+		return pkg;
+	});
+	if (remainingPnpmOverrides) migratePnpmOverridesToWorkspaceYaml(projectPath, remainingPnpmOverrides);
+	rewriteMonorepoProject(projectPath, packageManager, skipStagedMigration, void 0, void 0, catalogDependencyResolver, packages ? {
+		rootDir: projectPath,
+		packages
+	} : void 0);
+}
+const RULES_YAML_PATH = path.join(rulesDir, "vite-tools.yml");
+const PREPARE_RULES_YAML_PATH = path.join(rulesDir, "vite-prepare.yml");
+let cachedRulesYaml;
+let cachedRulesYamlNoLintStaged;
+let cachedPrepareRulesYaml;
+function readRulesYaml() {
+	cachedRulesYaml ??= fs.readFileSync(RULES_YAML_PATH, "utf8");
+	return cachedRulesYaml;
+}
+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");
+	return cachedRulesYamlNoLintStaged;
+}
+function readPrepareRulesYaml() {
+	cachedPrepareRulesYaml ??= fs.readFileSync(PREPARE_RULES_YAML_PATH, "utf8");
+	return cachedPrepareRulesYaml;
+}
+function rewritePackageJson(pkg, packageManager, isMonorepo, skipStagedMigration, catalogDependencyResolver) {
+	if (pkg.scripts) {
+		const updated = rewriteScripts(JSON.stringify(pkg.scripts), getScriptRulesYaml(skipStagedMigration));
+		if (updated) pkg.scripts = JSON.parse(updated);
+	}
+	let extractedStagedConfig = null;
+	if (!skipStagedMigration && pkg["lint-staged"]) {
+		const config = pkg["lint-staged"];
+		const updated = rewriteScripts(JSON.stringify(config), readRulesYaml());
+		extractedStagedConfig = updated ? JSON.parse(updated) : config;
+	}
+	const supportCatalog = !!isMonorepo && packageManager !== PackageManager.npm;
+	let needVitePlus = false;
+	const dependencyGroups = [
+		{
+			dependencyField: "devDependencies",
+			dependencies: pkg.devDependencies
+		},
+		{
+			dependencyField: "dependencies",
+			dependencies: pkg.dependencies
+		},
+		{
+			dependencyField: "peerDependencies",
+			dependencies: pkg.peerDependencies
+		},
+		{
+			dependencyField: "optionalDependencies",
+			dependencies: pkg.optionalDependencies
+		}
+	];
+	for (const [key, version] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) for (const { dependencyField, dependencies } of dependencyGroups) if (dependencies?.[key]) {
+		dependencies[key] = getCatalogDependencySpec(dependencies[key], version, supportCatalog, {
+			dependencyField,
+			dependencyName: key,
+			packageManager,
+			catalogDependencyResolver
+		});
+		needVitePlus = true;
+	}
+	for (const name of REMOVE_PACKAGES) {
+		let wasRemoved = false;
+		for (const { dependencies } of dependencyGroups) if (dependencies?.[name]) {
+			delete dependencies[name];
+			wasRemoved = true;
+		}
+		if (wasRemoved) needVitePlus = true;
+		const peerDep = BROWSER_PROVIDER_PEER_DEPS[name];
+		if (wasRemoved && peerDep && !pkg.devDependencies?.[peerDep] && !pkg.dependencies?.[peerDep] && !pkg.peerDependencies?.[peerDep] && !pkg.optionalDependencies?.[peerDep]) {
+			pkg.devDependencies ??= {};
+			pkg.devDependencies[peerDep] = "*";
+		}
+	}
+	const canonicalVitePlusSpec = supportCatalog && !VITE_PLUS_VERSION.startsWith("file:") ? "catalog:" : VITE_PLUS_VERSION;
+	const existingVitePlus = pkg.devDependencies?.[VITE_PLUS_NAME];
+	const shouldNormalizeExistingVitePlus = !!existingVitePlus && supportCatalog && existingVitePlus !== canonicalVitePlusSpec && !isProtocolPinnedSpec(existingVitePlus);
+	if (needVitePlus || shouldNormalizeExistingVitePlus) pkg.devDependencies = {
+		...pkg.devDependencies,
+		[VITE_PLUS_NAME]: canonicalVitePlusSpec
+	};
+	if (needVitePlus) {
+		const installableDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies,
+			...pkg.optionalDependencies
+		};
+		if (!installableDeps.vitest && Object.keys(installableDeps).some((name) => name.includes("vitest"))) {
+			const ver = VITE_PLUS_OVERRIDE_PACKAGES.vitest;
+			pkg.devDependencies ??= {};
+			pkg.devDependencies.vitest = getCatalogDependencySpec(void 0, ver, supportCatalog);
+		}
+	}
+	return extractedStagedConfig;
+}
+function isProtocolPinnedSpec(spec) {
+	return /^(catalog:|workspace:|link:|file:|npm:|github:|git[+:]|https?:\/\/)/.test(spec);
+}
+function removeLintStagedFromPackageJson(packageJsonPath) {
+	editJsonFile(packageJsonPath, (pkg) => {
+		if (pkg["lint-staged"]) {
+			delete pkg["lint-staged"];
+			return pkg;
+		}
+	});
+}
+function rewriteLintStagedConfigFile(projectPath, report) {
+	let hasUnsupported = false;
+	for (const filename of LINT_STAGED_JSON_CONFIG_FILES) {
+		const configPath = path.join(projectPath, filename);
+		if (!fs.existsSync(configPath)) continue;
+		if (filename === ".lintstagedrc" && !isJsonFile(configPath)) {
+			warnMigration(`${displayRelative(configPath)} is not JSON format — please migrate to "staged" in vite.config.ts manually`, report);
+			hasUnsupported = true;
+			continue;
+		}
+		if (!hasStagedConfigInViteConfig(projectPath)) {
+			const config = readJsonFile(configPath);
+			const updated = rewriteScripts(JSON.stringify(config), readRulesYaml());
+			if (!mergeStagedConfigToViteConfig(projectPath, updated ? JSON.parse(updated) : config, true, report)) continue;
+			fs.unlinkSync(configPath);
+			if (report) report.inlinedLintStagedConfigCount++;
+		} else warnMigration(`${displayRelative(configPath)} found but "staged" already exists in vite.config.ts — please merge manually`, report);
+	}
+	for (const filename of LINT_STAGED_OTHER_CONFIG_FILES) {
+		const configPath = path.join(projectPath, filename);
+		if (!fs.existsSync(configPath)) continue;
+		warnMigration(`${displayRelative(configPath)} — please migrate to "staged" in vite.config.ts manually`, report);
+		hasUnsupported = true;
+	}
+	if (hasUnsupported) infoMigration("Only \"staged\" in vite.config.ts is supported. See https://viteplus.dev/guide/migrate#lint-staged", report);
+}
+/**
+* Ensure vite.config.ts exists, create it if not
+* @returns The vite config filename
+*/
+function ensureViteConfig(projectPath, configs, silent = false, report) {
+	if (!configs.viteConfig) {
+		configs.viteConfig = "vite.config.ts";
+		const viteConfigPath = path.join(projectPath, "vite.config.ts");
+		fs.writeFileSync(viteConfigPath, `import { defineConfig } from '${VITE_PLUS_NAME}';
+
+export default defineConfig({});
+`);
+		if (report) report.createdViteConfigCount++;
+		if (!silent) log.success(`✔ Created vite.config.ts in ${displayRelative(viteConfigPath)}`);
+	}
+	return configs.viteConfig;
+}
+/**
+* Merge tsdown.config.* into vite.config.ts
+* - For JSON files: merge content directly into `pack` field and delete the JSON file
+* - For TS/JS files: import the config file
+*/
+function mergeTsdownConfigFile(projectPath, silent = false, report) {
+	const configs = detectConfigs(projectPath);
+	if (!configs.tsdownConfig) return;
+	const viteConfig = ensureViteConfig(projectPath, configs, silent, report);
+	const fullViteConfigPath = path.join(projectPath, viteConfig);
+	const fullTsdownConfigPath = path.join(projectPath, configs.tsdownConfig);
+	if (configs.tsdownConfig.endsWith(".json")) {
+		mergeAndRemoveJsonConfig(projectPath, viteConfig, configs.tsdownConfig, "pack", silent, report);
+		return;
+	}
+	const result = mergeTsdownConfig(fullViteConfigPath, `./${configs.tsdownConfig}`);
+	if (result.updated) {
+		fs.writeFileSync(fullViteConfigPath, result.content);
+		if (report) report.tsdownImportCount++;
+		if (!silent) log.success(`✔ Added import for ${displayRelative(fullTsdownConfigPath)} in ${displayRelative(fullViteConfigPath)}`);
+	}
+	infoMigration(`Please manually merge ${displayRelative(fullTsdownConfigPath)} into ${displayRelative(fullViteConfigPath)}, see https://viteplus.dev/guide/migrate#tsdown`, report);
+}
+/**
+* Best-effort: derive the Oxlint rule-namespace a JS plugin package
+* contributes. Mirrors the conventions @oxlint/migrate uses when
+* translating ESLint configs, and the conventions Oxlint-native plugin
+* authors use (`oxlint-plugin-<name>` — see posva/pinia-colada in the
+* wild):
+*   `eslint-plugin-unocss`         → `unocss`        (rules: `unocss/order`)
+*   `oxlint-plugin-posva`          → `posva`         (rules: `posva/foo`)
+*   `@stylistic/eslint-plugin`     → `@stylistic`    (rules: `@stylistic/indent`)
+*   `@stylistic/eslint-plugin-ts`  → `@stylistic/ts` (rules: `@stylistic/ts/indent`)
+*   `@scope/oxlint-plugin-x`       → `@scope/x`
+*   anything else                  → the package name verbatim
+*/
+function deriveJsPluginNamespace(packageName) {
+	for (const prefix of ["eslint-plugin-", "oxlint-plugin-"]) if (packageName.startsWith(prefix)) return packageName.slice(prefix.length) || packageName;
+	const scoped = packageName.match(/^(@[^/]+)\/(?:eslint|oxlint)-plugin(?:-(.+))?$/);
+	if (scoped) return scoped[2] ? `${scoped[1]}/${scoped[2]}` : scoped[1];
+	return packageName;
+}
+/**
+* Collect every dependency name declared across the root + workspace
+* `package.json` files after the ESLint cleanup has run. Used to verify
+* that JS plugins referenced by the generated `.oxlintrc.json` are
+* actually installable.
+*/
+function collectInstalledPackageNames(projectPath, packages) {
+	const names = /* @__PURE__ */ new Set();
+	const paths = [projectPath, ...(packages ?? []).map((p) => path.join(projectPath, p.path))];
+	for (const dir of paths) {
+		const pkgJsonPath = path.join(dir, "package.json");
+		if (!fs.existsSync(pkgJsonPath)) continue;
+		let pkg;
+		try {
+			pkg = readJsonFile(pkgJsonPath);
+		} catch {
+			continue;
+		}
+		for (const field of [
+			"devDependencies",
+			"dependencies",
+			"peerDependencies",
+			"optionalDependencies"
+		]) {
+			const deps = pkg[field];
+			if (deps) for (const name of Object.keys(deps)) names.add(name);
+		}
+	}
+	return names;
+}
+/**
+* Test whether a rule key (e.g. `@stylistic/ts/indent`) belongs to any
+* namespace in `namespaces`. We can't just split on the first `/` —
+* `@stylistic/eslint-plugin-ts` contributes the multi-segment namespace
+* `@stylistic/ts`, so the lookup has to try progressively longer
+* prefixes until one matches or we run out of slashes.
+*/
+function ruleKeyMatchesNamespace(key, namespaces) {
+	if (!key.includes("/")) return true;
+	let idx = key.indexOf("/");
+	while (idx !== -1) {
+		if (namespaces.has(key.slice(0, idx))) return true;
+		idx = key.indexOf("/", idx + 1);
+	}
+	return false;
+}
+/** Filter a rules object to only entries whose namespace is recognized. */
+function filterRulesAgainstNamespaces(rules, namespaces) {
+	const out = {};
+	for (const [key, value] of Object.entries(rules)) if (ruleKeyMatchesNamespace(key, namespaces)) out[key] = value;
+	return out;
+}
+/**
+* Sort a jsPlugins array into installed entries (kept) and string
+* entries for packages that aren't present in the workspace. Object-form
+* entries (`{ name, specifier }`) and string entries that look like
+* local paths (`./X`, `/X`, `../X`) are passed through — Oxlint resolves
+* them itself.
+*/
+function partitionJsPlugins(entries, availablePackages) {
+	const kept = [];
+	const dropped = [];
+	for (const entry of entries) {
+		if (typeof entry !== "string") {
+			kept.push(entry);
+			continue;
+		}
+		if (entry.startsWith("./") || entry.startsWith("../") || entry.startsWith("/")) {
+			kept.push(entry);
+			continue;
+		}
+		if (availablePackages.has(entry)) kept.push(entry);
+		else dropped.push(entry);
+	}
+	return {
+		kept,
+		dropped
+	};
+}
+/** Build the set of rule-key namespaces backed by a given jsPlugins set. */
+function jsPluginsToNamespaces(entries) {
+	const ns = /* @__PURE__ */ new Set();
+	for (const entry of entries) if (typeof entry === "string") ns.add(deriveJsPluginNamespace(entry));
+	else if (entry && typeof entry === "object" && "name" in entry && entry.name) ns.add(entry.name);
+	ns.delete("");
+	return ns;
+}
+/**
+* Sanitize the `.oxlintrc.json` produced by `@oxlint/migrate` (in-place)
+* before it gets merged into `vite.config.ts`. Drop references that
+* won't resolve at lint time and warn the user.
+*
+* Why: `@oxlint/migrate` can emit `jsPlugins[]` / `plugins[]` / `rules`
+* entries referring to packages the user never installed (e.g.
+* translating `@unocss/eslint-config` into `eslint-plugin-unocss`),
+* to plugins outside Oxlint's native set, or under namespaces no
+* surviving plugin contributes. Without sanitization, `vp lint` aborts
+* with "Failed to load JS plugin" / "Plugin not found" before running
+* any rule. This produces a degraded-but-functional config instead.
+*
+* Per-override entries (`overrides[].jsPlugins`, `.plugins`, `.rules`)
+* are sanitized independently — an override can introduce its own
+* jsPlugin, so namespace availability is computed per-override (base
+* namespaces ∪ the override's own surviving jsPlugins' namespaces).
+*/
+function sanitizeMigratedOxlintConfig(config, availablePackages, report) {
+	const allDroppedJsPlugins = /* @__PURE__ */ new Set();
+	const allDroppedPlugins = /* @__PURE__ */ new Set();
+	const baseSplit = partitionJsPlugins(config.jsPlugins ?? [], availablePackages);
+	for (const n of baseSplit.dropped) allDroppedJsPlugins.add(n);
+	if (config.jsPlugins && baseSplit.dropped.length > 0) config.jsPlugins = baseSplit.kept;
+	const baseNamespaces = new Set(OXLINT_NATIVE_PLUGINS);
+	for (const ns of jsPluginsToNamespaces(baseSplit.kept)) baseNamespaces.add(ns);
+	if (config.plugins) {
+		const keptPlugins = [];
+		for (const p of config.plugins) if (baseNamespaces.has(p)) keptPlugins.push(p);
+		else allDroppedPlugins.add(p);
+		if (keptPlugins.length !== config.plugins.length) config.plugins = keptPlugins;
+	}
+	if (config.rules) {
+		const filtered = filterRulesAgainstNamespaces(config.rules, baseNamespaces);
+		if (Object.keys(filtered).length !== Object.keys(config.rules).length) config.rules = filtered;
+	}
+	if (Array.isArray(config.overrides)) for (const override of config.overrides) {
+		let overrideSurvivors = [];
+		if (override.jsPlugins) {
+			const split = partitionJsPlugins(override.jsPlugins, availablePackages);
+			for (const n of split.dropped) allDroppedJsPlugins.add(n);
+			if (split.dropped.length > 0) override.jsPlugins = split.kept;
+			overrideSurvivors = split.kept;
+		}
+		const overrideNamespaces = new Set(baseNamespaces);
+		for (const ns of jsPluginsToNamespaces(overrideSurvivors)) overrideNamespaces.add(ns);
+		if (override.plugins) {
+			const keptOverridePlugins = [];
+			for (const p of override.plugins) if (overrideNamespaces.has(p)) keptOverridePlugins.push(p);
+			else allDroppedPlugins.add(p);
+			if (keptOverridePlugins.length !== override.plugins.length) override.plugins = keptOverridePlugins;
+		}
+		if (override.rules) {
+			const filtered = filterRulesAgainstNamespaces(override.rules, overrideNamespaces);
+			if (Object.keys(filtered).length !== Object.keys(override.rules).length) override.rules = filtered;
+		}
+	}
+	if (allDroppedJsPlugins.size > 0) warnMigration(`Stripped JS plugin reference(s) from the generated lint config: ${[...allDroppedJsPlugins].join(", ")}. No matching package is present in this workspace, so loading them at lint time would fail. If you want their Oxlint coverage back, install each package (e.g. \`vp install <name>\`) and add its name back to \`lint.jsPlugins\` in vite.config.ts.`, report);
+	if (allDroppedPlugins.size > 0) warnMigration(`Stripped unknown plugin reference(s) from the generated lint config: ${[...allDroppedPlugins].join(", ")}. These aren't native Oxlint plugins and no surviving JS plugin contributes them.`, report);
+}
+/**
+* Merge oxlint and oxfmt config into vite.config.ts
+*/
+function mergeViteConfigFiles(projectPath, silent = false, report, packages, workspaceRoot) {
+	const configs = detectConfigs(projectPath);
+	if (!configs.oxfmtConfig && !configs.oxlintConfig) return;
+	const viteConfig = ensureViteConfig(projectPath, configs, silent, report);
+	if (configs.oxlintConfig) {
+		const fullOxlintPath = path.join(projectPath, configs.oxlintConfig);
+		const oxlintJson = readJsonFile(fullOxlintPath, true);
+		if (!oxlintJson.options) oxlintJson.options = {};
+		if (!hasBaseUrlInTsconfig(projectPath)) {
+			if (oxlintJson.options.typeAware === void 0) oxlintJson.options.typeAware = true;
+			if (oxlintJson.options.typeCheck === void 0) oxlintJson.options.typeCheck = true;
+		} else warnMigration(BASEURL_TSCONFIG_WARNING, report);
+		sanitizeMigratedOxlintConfig(oxlintJson, collectInstalledPackageNames(workspaceRoot ?? projectPath, packages), report);
+		const normalizedOxlintConfig = ensureVitePlusImportRuleDefaults(oxlintJson);
+		fs.writeFileSync(fullOxlintPath, JSON.stringify(normalizedOxlintConfig, null, 2));
+		mergeAndRemoveJsonConfig(projectPath, viteConfig, configs.oxlintConfig, "lint", silent, report);
+	}
+	if (configs.oxfmtConfig) mergeAndRemoveJsonConfig(projectPath, viteConfig, configs.oxfmtConfig, "fmt", silent, report);
+}
+/**
+* Inject typeAware and typeCheck defaults into vite.config.ts lint config.
+* Called after mergeViteConfigFiles() to handle the case where no .oxlintrc.json exists
+* (e.g., newly created projects from create-vite templates).
+*/
+function injectLintTypeCheckDefaults(projectPath, silent = false, report) {
+	if (hasBaseUrlInTsconfig(projectPath)) {
+		warnMigration(BASEURL_TSCONFIG_WARNING, report);
+		return;
+	}
+	injectConfigDefaults(projectPath, "lint", ".vite-plus-lint-init.oxlintrc.json", JSON.stringify(createDefaultVitePlusLintConfig({ includeTypeAwareDefaults: true })), silent, report);
+}
+function injectFmtDefaults(projectPath, silent = false, report) {
+	injectConfigDefaults(projectPath, "fmt", ".vite-plus-fmt-init.oxfmtrc.json", JSON.stringify({}), silent, report);
+}
+/**
+* Wire `create.defaultTemplate: '<scope>'` into the new monorepo's
+* `vite.config.ts`. The caller is `bin.ts`, only when scaffolding a
+* monorepo from a bundled `@org` manifest entry — that's the case where
+* the user just picked a template from a specific org and naturally
+* wants subsequent `vp create` invocations from the workspace to default
+* to that same org's picker.
+*/
+function injectCreateDefaultTemplate(projectPath, scope, silent = false, report) {
+	if (!scope) return;
+	injectConfigDefaults(projectPath, "create", ".vite-plus-create-init.json", JSON.stringify({ defaultTemplate: scope }), silent, report);
+}
+function injectConfigDefaults(projectPath, configKey, tempFileName, tempFileContent, silent, report) {
+	const configs = detectConfigs(projectPath);
+	if (configs.viteConfig && hasConfigKey(path.join(projectPath, configs.viteConfig), configKey)) return;
+	const viteConfig = ensureViteConfig(projectPath, configs, silent, report);
+	const tempConfigPath = path.join(projectPath, tempFileName);
+	fs.writeFileSync(tempConfigPath, tempFileContent);
+	const fullViteConfigPath = path.join(projectPath, viteConfig);
+	let result;
+	try {
+		result = mergeJsonConfig(fullViteConfigPath, tempConfigPath, configKey);
+	} finally {
+		fs.rmSync(tempConfigPath, { force: true });
+	}
+	if (result.updated) fs.writeFileSync(fullViteConfigPath, result.content);
+}
+function mergeAndRemoveJsonConfig(projectPath, viteConfigPath, jsonConfigPath, configKey, silent = false, report) {
+	const fullViteConfigPath = path.join(projectPath, viteConfigPath);
+	const fullJsonConfigPath = path.join(projectPath, jsonConfigPath);
+	if (hasConfigKey(fullViteConfigPath, configKey)) {
+		fs.unlinkSync(fullJsonConfigPath);
+		if (!silent) log.info(`${configKey} config already present in ${displayRelative(fullViteConfigPath)} — removed redundant ${displayRelative(fullJsonConfigPath)}`);
+		return;
+	}
+	const result = mergeJsonConfig(fullViteConfigPath, fullJsonConfigPath, configKey);
+	if (result.updated) {
+		fs.writeFileSync(fullViteConfigPath, result.content);
+		fs.unlinkSync(fullJsonConfigPath);
+		if (report) report.mergedConfigCount++;
+		if (!silent) log.success(`✔ Merged ${displayRelative(fullJsonConfigPath)} into ${displayRelative(fullViteConfigPath)}`);
+	} else {
+		warnMigration(`Failed to merge ${displayRelative(fullJsonConfigPath)} into ${displayRelative(fullViteConfigPath)}`, report);
+		infoMigration("Please complete the merge manually and follow the instructions in the documentation: https://viteplus.dev/config/", report);
+	}
+}
+/**
+* Merge a staged config object into vite.config.ts as `staged: { ... }`.
+* Writes the config to a temp JSON file, calls mergeJsonConfig NAPI, then cleans up.
+*/
+function mergeStagedConfigToViteConfig(projectPath, stagedConfig, silent = false, report) {
+	const viteConfig = ensureViteConfig(projectPath, detectConfigs(projectPath), silent, report);
+	const fullViteConfigPath = path.join(projectPath, viteConfig);
+	const tempJsonPath = path.join(projectPath, ".staged-config-temp.json");
+	fs.writeFileSync(tempJsonPath, JSON.stringify(stagedConfig, null, 2));
+	let result;
+	try {
+		result = mergeJsonConfig(fullViteConfigPath, tempJsonPath, "staged");
+	} finally {
+		fs.unlinkSync(tempJsonPath);
+	}
+	if (result.updated) {
+		fs.writeFileSync(fullViteConfigPath, result.content);
+		if (report) report.mergedStagedConfigCount++;
+		if (!silent) log.success(`✔ Merged staged config into ${displayRelative(fullViteConfigPath)}`);
+		return true;
+	} else {
+		warnMigration(`Failed to merge staged config into ${displayRelative(fullViteConfigPath)}`, report);
+		infoMigration(`Please add staged config to ${displayRelative(fullViteConfigPath)} manually, see https://viteplus.dev/guide/migrate#lint-staged`, report);
+		return false;
+	}
+}
+/**
+* Check if vite.config.ts already has a `staged` config key.
+*/
+function hasStagedConfigInViteConfig(projectPath) {
+	const configs = detectConfigs(projectPath);
+	if (!configs.viteConfig) return false;
+	const viteConfigPath = path.join(projectPath, configs.viteConfig);
+	const content = fs.readFileSync(viteConfigPath, "utf8");
+	return /\bstaged\s*:/.test(content);
+}
+/**
+* Rewrite imports in all TypeScript/JavaScript files under a directory
+* This rewrites vite/vitest imports to @voidzero-dev/vite-plus
+* @param projectPath - The root directory to search for files
+*/
+function rewriteAllImports(projectPath, silent = false, report) {
+	const result = rewriteImportsInDirectory(projectPath);
+	const modified = result.modifiedFiles.length;
+	const errors = result.errors.length;
+	if (report) {
+		report.rewrittenImportFileCount += modified;
+		report.rewrittenImportErrors.push(...result.errors.map((error) => ({
+			path: displayRelative(error.path),
+			message: error.message
+		})));
+	}
+	if (!silent && modified > 0) {
+		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}`);
+	}
+}
+/**
+* Check if the project has an unsupported husky version (<9.0.0).
+* Uses `semver.coerce` to handle ranges like `^8.0.0` → `8.0.0`.
+* When the specifier is a catalog reference (e.g. `"catalog:"`), resolves
+* it from the active package manager's catalog first — a `catalog:` spec is
+* only meaningful to the manager that owns the workspace, so we never read a
+* leftover/foreign catalog file. When it is still not coercible (e.g.
+* `"latest"`), falls back to the installed version in node_modules via
+* `detectPackageMetadata`.
+* Returns a reason string if hooks migration should be skipped, or null
+* if husky is absent or compatible.
+*/
+function checkUnsupportedHuskyVersion(projectPath, deps, prodDeps, packageManager) {
+	const huskyVersion = deps?.husky ?? prodDeps?.husky;
+	if (!huskyVersion) return null;
+	let coerced = import_semver.default.coerce(huskyVersion);
+	if (coerced == null && packageManager != null && huskyVersion.startsWith("catalog:")) {
+		const resolved = createCatalogDependencyResolver(projectPath, packageManager)?.(huskyVersion, "husky");
+		if (resolved) coerced = import_semver.default.coerce(resolved);
+	}
+	if (coerced == null) {
+		const installed = detectPackageMetadata(projectPath, "husky");
+		if (installed) coerced = import_semver.default.coerce(installed.version);
+		if (coerced == null) return `Could not determine husky version from "${huskyVersion}" — please specify a semver-compatible version (e.g., "^9.0.0") and re-run migration.`;
+	}
+	if (import_semver.default.satisfies(coerced, "<9.0.0")) return "Detected husky <9.0.0 — please upgrade to husky v9+ first, then re-run migration.";
+	return null;
+}
+const OTHER_HOOK_TOOLS = [
+	"simple-git-hooks",
+	"lefthook",
+	"yorkie"
+];
+const REPLACED_HOOK_PACKAGES = ["husky", "lint-staged"];
+function removeReplacedHookPackages(packageJsonPath) {
+	editJsonFile(packageJsonPath, (pkg) => {
+		for (const name of REPLACED_HOOK_PACKAGES) {
+			if (pkg.devDependencies?.[name]) delete pkg.devDependencies[name];
+			if (pkg.dependencies?.[name]) delete pkg.dependencies[name];
+		}
+		return pkg;
+	});
+}
+/**
+* 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;
+	}
+}
+/**
+* Normalize "husky install [dir]" → "husky [dir]" so downstream regex
+* and ast-grep rules can match a single pattern.
+*/
+function collapseHuskyInstall(script) {
+	return script.replace("husky install ", "husky ").replace("husky install", "husky");
+}
+/**
+* High-level helper: detect old hooks dir, set up git hooks, and rewrite
+* the prepare script.  Returns true if hooks were successfully installed.
+*/
+function installGitHooks(projectPath, silent = false, report, packageManager) {
+	if (setupGitHooks(projectPath, getOldHooksDir(projectPath), silent, report, packageManager)) {
+		rewritePrepareScript(projectPath);
+		return true;
+	}
+	return false;
+}
+/**
+* Read-only probe: extract the old husky hooks directory from `scripts.prepare`
+* without modifying package.json. Returns undefined when no husky reference is found.
+*/
+function getOldHooksDir(rootDir) {
+	const packageJsonPath = path.join(rootDir, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return;
+	const pkg = readJsonFile(packageJsonPath);
+	if (!pkg.scripts?.prepare) return;
+	const match = collapseHuskyInstall(pkg.scripts.prepare).match(/\bhusky(?:\s+([\w./-]+))?/);
+	if (!match) return;
+	return match[1] ?? ".husky";
+}
+/**
+* Pre-flight check: verify that git hooks can be set up for this project.
+* Returns `null` if hooks setup can proceed, or a warning reason string
+* explaining why hooks setup should be skipped.
+*
+* These checks are deterministic and read-only — they do not modify
+* the project in any way, making them safe to call before migration.
+*
+* `packageManager` is the project's detected manager; it scopes `catalog:`
+* resolution to that manager's catalog so a foreign catalog file is ignored.
+*/
+function preflightGitHooksSetup(projectPath, packageManager) {
+	const gitRoot = findGitRoot(projectPath);
+	if (gitRoot && path.resolve(projectPath) !== path.resolve(gitRoot)) return "Subdirectory project detected — skipping git hooks setup. Configure hooks at the repository root.";
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return null;
+	const pkgContent = readJsonFile(packageJsonPath);
+	const deps = pkgContent.devDependencies;
+	const prodDeps = pkgContent.dependencies;
+	for (const tool of OTHER_HOOK_TOOLS) if (deps?.[tool] || prodDeps?.[tool] || pkgContent[tool]) return `Detected ${tool} — skipping git hooks setup. Please configure git hooks manually.`;
+	const huskyReason = checkUnsupportedHuskyVersion(projectPath, deps, prodDeps, packageManager);
+	if (huskyReason) return huskyReason;
+	if (hasUnsupportedLintStagedConfig(projectPath)) return "Unsupported lint-staged config format — skipping git hooks setup. Please configure git hooks manually.";
+	return null;
+}
+/**
+* Set up git hooks with husky + lint-staged via vp commands.
+* Skips if another hook tool is detected (warns user).
+* Returns true if hooks were successfully set up, false if skipped.
+*/
+function setupGitHooks(projectPath, oldHooksDir, silent = false, report, packageManager) {
+	const reason = preflightGitHooksSetup(projectPath, packageManager);
+	if (reason) {
+		warnMigration(reason, report);
+		return false;
+	}
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return false;
+	const gitRoot = findGitRoot(projectPath);
+	const isCustomDir = oldHooksDir != null && oldHooksDir !== ".husky";
+	const hooksDir = isCustomDir ? oldHooksDir : ".vite-hooks";
+	editJsonFile(packageJsonPath, (pkg) => {
+		if (!pkg.scripts) pkg.scripts = {};
+		if (!pkg.scripts.prepare) pkg.scripts.prepare = "vp config";
+		else if (!pkg.scripts.prepare.includes("vp config") && !/\bhusky\b/.test(pkg.scripts.prepare)) pkg.scripts.prepare = `vp config && ${pkg.scripts.prepare}`;
+		return pkg;
+	});
+	let stagedMerged = hasStagedConfigInViteConfig(projectPath);
+	const hasStandaloneConfig = hasStandaloneLintStagedConfig(projectPath);
+	if (!stagedMerged && !hasStandaloneConfig) {
+		const stagedConfig = readJsonFile(packageJsonPath)?.["lint-staged"] ?? DEFAULT_STAGED_CONFIG;
+		const updated = rewriteScripts(JSON.stringify(stagedConfig), readRulesYaml());
+		stagedMerged = mergeStagedConfigToViteConfig(projectPath, updated ? JSON.parse(updated) : stagedConfig, silent, report);
+	}
+	if (stagedMerged) removeLintStagedFromPackageJson(packageJsonPath);
+	if (oldHooksDir && !isCustomDir) {
+		const oldDir = path.join(projectPath, oldHooksDir);
+		if (fs.existsSync(oldDir)) {
+			const targetDir = path.join(projectPath, hooksDir);
+			fs.mkdirSync(targetDir, { recursive: true });
+			for (const entry of fs.readdirSync(oldDir, { withFileTypes: true })) {
+				if (entry.isDirectory() || entry.name.startsWith(".")) continue;
+				const src = path.join(oldDir, entry.name);
+				const dest = path.join(targetDir, entry.name);
+				fs.copyFileSync(src, dest);
+				fs.chmodSync(dest, 493);
+			}
+			fs.rmSync(oldDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	if (stagedMerged) createPreCommitHook(projectPath, hooksDir);
+	if (!gitRoot) {
+		removeReplacedHookPackages(packageJsonPath);
+		return true;
+	}
+	if (oldHooksDir) {
+		const checkResult = import_cross_spawn.default.sync("git", [
+			"config",
+			"--local",
+			"core.hooksPath"
+		], {
+			cwd: projectPath,
+			stdio: "pipe"
+		});
+		const existingPath = checkResult.status === 0 ? checkResult.stdout?.toString().trim() : "";
+		if (existingPath === `${oldHooksDir}/_` || existingPath === oldHooksDir) import_cross_spawn.default.sync("git", [
+			"config",
+			"--local",
+			"--unset",
+			"core.hooksPath"
+		], {
+			cwd: projectPath,
+			stdio: "pipe"
+		});
+	}
+	const vpBin = process.env.VP_CLI_BIN ?? "vp";
+	const configArgs = isCustomDir ? [
+		"config",
+		"--hooks-only",
+		"--hooks-dir",
+		hooksDir
+	] : ["config", "--hooks-only"];
+	const configResult = import_cross_spawn.default.sync(vpBin, configArgs, {
+		cwd: projectPath,
+		stdio: "pipe"
+	});
+	if (configResult.status === 0) {
+		const stdout = configResult.stdout?.toString().trim() ?? "";
+		if (stdout) {
+			warnMigration(`Git hooks not configured — ${stdout}`, report);
+			return false;
+		}
+		removeReplacedHookPackages(packageJsonPath);
+		if (report) report.gitHooksConfigured = true;
+		if (!silent) log.success("✔ Git hooks configured");
+		return true;
+	}
+	warnMigration("Failed to install git hooks", report);
+	return false;
+}
+/**
+* Check if a standalone lint-staged config file exists
+*/
+function hasStandaloneLintStagedConfig(projectPath) {
+	return LINT_STAGED_ALL_CONFIG_FILES.some((file) => fs.existsSync(path.join(projectPath, file)));
+}
+/**
+* Check if a standalone lint-staged config exists in a format that can't be
+* auto-migrated to "staged" in vite.config.ts (non-JSON files like .yaml,
+* .mjs, .cjs, .js, or a non-JSON .lintstagedrc).
+*/
+function hasUnsupportedLintStagedConfig(projectPath) {
+	for (const filename of LINT_STAGED_OTHER_CONFIG_FILES) if (fs.existsSync(path.join(projectPath, filename))) return true;
+	const lintstagedrcPath = path.join(projectPath, ".lintstagedrc");
+	if (fs.existsSync(lintstagedrcPath) && !isJsonFile(lintstagedrcPath)) return true;
+	return false;
+}
+/**
+* Create pre-commit hook file in the hooks directory.
+*/
+const STALE_LINT_STAGED_PATTERNS = [/^((?:[A-Z_][A-Z0-9_]*(?:=\S*)?\s+)*)(pnpm|pnpm exec|npx|yarn|yarn run|npm exec|npm run|bunx|bun run|bun x)\s+lint-staged\b/, /^((?:[A-Z_][A-Z0-9_]*(?:=\S*)?\s+)*)lint-staged\b/];
+const DEFAULT_STAGED_CONFIG = { "*": "vp check --fix" };
+/**
+* Ensure the pre-commit hook exists with `vp staged`, and that
+* vite.config.ts contains a `staged` block (using the default config
+* if none is present). Called by `vp config` after hook installation.
+*/
+function ensurePreCommitHook(projectPath, dir = ".vite-hooks") {
+	if (!hasStagedConfigInViteConfig(projectPath)) mergeStagedConfigToViteConfig(projectPath, DEFAULT_STAGED_CONFIG, true);
+	createPreCommitHook(projectPath, dir);
+}
+function createPreCommitHook(projectPath, dir = ".vite-hooks") {
+	const huskyDir = path.join(projectPath, dir);
+	fs.mkdirSync(huskyDir, { recursive: true });
+	const hookPath = path.join(huskyDir, "pre-commit");
+	if (fs.existsSync(hookPath)) {
+		const existing = fs.readFileSync(hookPath, "utf8");
+		if (existing.includes("vp staged")) return;
+		const lines = existing.split("\n");
+		let replaced = false;
+		const result = [];
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!replaced) {
+				let matched = false;
+				for (const pattern of STALE_LINT_STAGED_PATTERNS) {
+					const match = pattern.exec(trimmed);
+					if (match) {
+						const parts = [
+							match[1]?.trim() ?? "",
+							"vp staged",
+							trimmed.slice(match[0].length).trim()
+						].filter(Boolean);
+						result.push(parts.join(" "));
+						replaced = true;
+						matched = true;
+						break;
+					}
+				}
+				if (matched) continue;
+			}
+			result.push(line);
+		}
+		if (!replaced) fs.writeFileSync(hookPath, `${result.join("\n").trimEnd()}\nvp staged\n`);
+		else fs.writeFileSync(hookPath, result.join("\n"));
+	} else {
+		fs.writeFileSync(hookPath, "vp staged\n");
+		fs.chmodSync(hookPath, 493);
+	}
+}
+/**
+* Rewrite only `scripts.prepare` in the root package.json using vite-prepare.yml rules.
+* Collapses "husky install" → "husky" before applying ast-grep so that the
+* replace-husky rule produces "vp config" with any directory argument preserved.
+* Returns the old husky hooks dir (if any) for migration to .vite-hooks.
+* Called only when hooks are being set up (not with --no-hooks).
+*/
+function rewritePrepareScript(rootDir) {
+	const packageJsonPath = path.join(rootDir, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return;
+	let oldDir;
+	editJsonFile(packageJsonPath, (pkg) => {
+		if (!pkg.scripts?.prepare) return pkg;
+		const prepare = collapseHuskyInstall(pkg.scripts.prepare);
+		const updated = rewriteScripts(JSON.stringify({ prepare }), readPrepareRulesYaml());
+		if (updated) {
+			let newPrepare = JSON.parse(updated).prepare;
+			newPrepare = newPrepare.replace(/\bvp config(?:\s+(?!-)([\w./-]+))?/, (_match, dir) => {
+				oldDir = dir ?? ".husky";
+				return dir ? `vp config --hooks-dir ${dir}` : "vp config";
+			});
+			pkg.scripts.prepare = newPrepare;
+		} else if (prepare !== pkg.scripts.prepare) pkg.scripts.prepare = prepare;
+		return pkg;
+	});
+	return oldDir;
+}
+function setPackageManager(projectDir, downloadPackageManager) {
+	editJsonFile(path.join(projectDir, "package.json"), (pkg) => {
+		if (!pkg.packageManager) pkg.packageManager = `${downloadPackageManager.name}@${downloadPackageManager.version}`;
+		return pkg;
+	});
+}
+/**
+* Detect a .nvmrc file in the project directory.
+* If not found, check for a Volta node version in package.json.
+* If either is found, return the relevant info for migration.
+* Returns undefined if not found or .node-version already exists.
+*/
+function detectNodeVersionManagerFile(projectPath) {
+	if (fs.existsSync(path.join(projectPath, ".node-version"))) return;
+	const configs = detectConfigs(projectPath);
+	if (configs.nvmrcFile) return configs.voltaNode ? {
+		file: ".nvmrc",
+		voltaPresent: true
+	} : { file: ".nvmrc" };
+	if (configs.voltaNode) return {
+		file: "package.json",
+		voltaNodeVersion: configs.voltaNode
+	};
+}
+/**
+* Parse a version alias from a .nvmrc file into a .node-version compatible string.
+* Accepts the first line of .nvmrc (pre-trimmed).
+* Returns null for unsupported aliases like "system", "default", "iojs".
+*/
+function parseNvmrcVersion(alias) {
+	const version = alias.trim();
+	if (!version) return null;
+	if (version === "node" || version === "stable") return "lts/*";
+	if (version === "iojs" || version === "system" || version === "default") return null;
+	if (version.startsWith("lts/")) return version;
+	const normalized = version.startsWith("v") ? version.slice(1) : version;
+	if (!normalized || !import_semver.default.validRange(normalized)) return null;
+	return normalized;
+}
+/**
+* Migrate .nvmrc or Volta node version from package.json to .node-version.
+* - For .nvmrc: the source file is removed after migration.
+* - For package.json (Volta): the volta field is left as-is; removal is left to the user's discretion.
+* Returns true on success, false if migration was skipped or failed.
+*/
+function migrateNodeVersionManagerFile(projectPath, detection, report) {
+	const nodeVersionPath = path.join(projectPath, ".node-version");
+	if (detection.file === "package.json") {
+		const { voltaNodeVersion } = detection;
+		const resolvedVersion = voltaNodeVersion === "lts" ? "lts/*" : voltaNodeVersion;
+		if (!import_semver.default.valid(resolvedVersion) && resolvedVersion !== "lts/*") {
+			warnMigration(`package.json volta.node "${voltaNodeVersion}" is not an exact version. Pin an exact version (e.g. ${voltaNodeVersion}.0 or run \`volta pin node@${voltaNodeVersion}\`) then re-run migration.`, report);
+			return false;
+		}
+		fs.writeFileSync(nodeVersionPath, `${resolvedVersion}\n`);
+		if (report) {
+			report.manualSteps.push("Remove the \"volta\" field from package.json");
+			report.nodeVersionFileMigrated = true;
+		} else log.info("You can now remove the \"volta\" field from package.json manually.");
+		return true;
+	}
+	const sourcePath = path.join(projectPath, ".nvmrc");
+	const originalAlias = fs.readFileSync(sourcePath, "utf8").split("\n")[0]?.trim() ?? "";
+	const version = parseNvmrcVersion(originalAlias);
+	if (!version) {
+		warnMigration(".nvmrc contains an unsupported version alias. Create .node-version manually with your desired Node.js version.", report);
+		return false;
+	}
+	if (version === "lts/*" && (originalAlias === "node" || originalAlias === "stable")) log.info(`"${originalAlias}" in .nvmrc is not a specific version; automatically mapping to "lts/*"`);
+	fs.writeFileSync(nodeVersionPath, `${version}\n`);
+	fs.unlinkSync(sourcePath);
+	if (report) {
+		report.nodeVersionFileMigrated = true;
+		if (detection.voltaPresent) report.manualSteps.push("Remove the \"volta\" field from package.json");
+	} else if (detection.voltaPresent) log.info("You can now remove the \"volta\" field from package.json manually.");
+	return true;
+}
+function warnPackageLevelEslint() {
+	log.warn("ESLint detected in workspace packages but no root config found. Package-level ESLint must be migrated manually.");
+}
+const INCOMPATIBLE_ESLINT_INTEGRATIONS = ["@nuxt/eslint"];
+/**
+* Detect framework-ESLint integration packages whose ESLint migration is
+* known to be incompatible. Returns the offending package name, or
+* `undefined` if none is present.
+*/
+function detectIncompatibleEslintIntegration(projectPath, packages) {
+	const candidates = [projectPath, ...(packages ?? []).map((p) => path.join(projectPath, p.path))];
+	for (const candidate of candidates) {
+		const pkgJsonPath = path.join(candidate, "package.json");
+		if (!fs.existsSync(pkgJsonPath)) continue;
+		let pkg;
+		try {
+			pkg = readJsonFile(pkgJsonPath);
+		} catch {
+			continue;
+		}
+		for (const name of INCOMPATIBLE_ESLINT_INTEGRATIONS) if (pkg.devDependencies?.[name] || pkg.dependencies?.[name]) return name;
+	}
+}
+function warnIncompatibleEslintIntegration(name) {
+	log.warn(`${name} detected — automatic ESLint migration is skipped. ${name} wires ESLint into a framework-specific flow that Vite+ cannot migrate cleanly yet. Your ESLint setup is preserved. To migrate manually, remove ${name} from package.json and re-run \`vp migrate\`.`);
+}
+function warnLegacyEslintConfig(legacyConfigFile) {
+	log.warn(`Legacy ESLint configuration detected (${legacyConfigFile}). Automatic migration to Oxlint requires ESLint v9+ with flat config format (eslint.config.*). Please upgrade to ESLint v9 first: https://eslint.org/docs/latest/use/migrate-to-9.0.0`);
+}
+async function confirmEslintMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate ESLint rules to Oxlint using @oxlint/migrate?\n  " + styleText("gray", "Oxlint is Vite+'s built-in linter — significantly faster than ESLint with compatible rule support. @oxlint/migrate converts your existing rules automatically."),
+			initialValue: true
+		});
+		if (R(confirmed)) cancelAndExit();
+		return confirmed;
+	}
+	return true;
+}
+async function promptEslintMigration(projectPath, interactive, packages) {
+	const incompatible = detectIncompatibleEslintIntegration(projectPath, packages);
+	if (incompatible) {
+		warnIncompatibleEslintIntegration(incompatible);
+		return false;
+	}
+	const eslintProject = detectEslintProject(projectPath, packages);
+	if (eslintProject.hasDependency && !eslintProject.configFile && eslintProject.legacyConfigFile) {
+		warnLegacyEslintConfig(eslintProject.legacyConfigFile);
+		return false;
+	}
+	if (!eslintProject.hasDependency) return false;
+	if (!eslintProject.configFile) {
+		warnPackageLevelEslint();
+		return false;
+	}
+	if (!await confirmEslintMigration(interactive)) return false;
+	if (!await migrateEslintToOxlint(projectPath, interactive, eslintProject.configFile, packages)) cancelAndExit("ESLint migration failed.", 1);
+	return true;
+}
+function warnPackageLevelPrettier() {
+	log.warn("Prettier detected in workspace packages but no root config found. Package-level Prettier must be migrated manually.");
+}
+async function confirmPrettierMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate Prettier to Oxfmt?\n  " + styleText("gray", "Oxfmt is Vite+'s built-in formatter that replaces Prettier with faster performance. Your configuration will be converted automatically."),
+			initialValue: true
+		});
+		if (R(confirmed)) cancelAndExit();
+		return confirmed;
+	}
+	log.info("Prettier configuration detected. Auto-migrating to Oxfmt...");
+	return true;
+}
+async function promptPrettierMigration(projectPath, interactive, packages) {
+	const prettierProject = detectPrettierProject(projectPath, packages);
+	if (!prettierProject.hasDependency) return false;
+	if (!prettierProject.configFile) {
+		warnPackageLevelPrettier();
+		return false;
+	}
+	if (!await confirmPrettierMigration(interactive)) return false;
+	if (!await migratePrettierToOxfmt(projectPath, interactive, prettierProject.configFile, packages)) cancelAndExit("Prettier migration failed.", 1);
+	return true;
+}
+//#endregion
+//#region src/utils/agent.ts
+const AGENTS = [
+	{
+		id: "agents",
+		label: "AGENTS.md",
+		targetPath: "AGENTS.md",
+		hint: "Codex, Amp, OpenCode, and similar agents",
+		aliases: [
+			"agents.md",
+			"chatgpt",
+			"chatgpt-codex",
+			"codex",
+			"amp",
+			"kilo",
+			"kilo-code",
+			"kiro",
+			"kiro-cli",
+			"opencode",
+			"other"
+		]
+	},
+	{
+		id: "claude",
+		label: "CLAUDE.md",
+		targetPath: "CLAUDE.md",
+		hint: "Claude Code",
+		aliases: ["claude.md", "claude-code"]
+	},
+	{
+		id: "gemini",
+		label: "GEMINI.md",
+		targetPath: "GEMINI.md",
+		hint: "Gemini CLI",
+		aliases: ["gemini.md", "gemini-cli"]
+	},
+	{
+		id: "copilot",
+		label: ".github/copilot-instructions.md",
+		targetPath: ".github/copilot-instructions.md",
+		hint: "GitHub Copilot",
+		aliases: ["github-copilot", "copilot-instructions.md"]
+	},
+	{
+		id: "cursor",
+		label: ".cursor/rules/viteplus.mdc",
+		targetPath: ".cursor/rules/viteplus.mdc",
+		hint: "Cursor",
+		aliases: ["viteplus.mdc"]
+	},
+	{
+		id: "jetbrains",
+		label: ".aiassistant/rules/viteplus.md",
+		targetPath: ".aiassistant/rules/viteplus.md",
+		hint: "JetBrains AI Assistant",
+		aliases: [
+			"jetbrains",
+			"jetbrains-ai-assistant",
+			"aiassistant",
+			"viteplus.md"
+		]
+	}
+];
+const AGENT_DEFAULT_ID = "agents";
+const AGENT_STANDARD_PATH = "AGENTS.md";
+const COPILOT_AGENT_ID = "copilot";
+const COPILOT_SETUP_WORKFLOW_PATH = ".github/workflows/copilot-setup-steps.yml";
+const AGENT_INSTRUCTIONS_START_MARKER = "<!--VITE PLUS START-->";
+const AGENT_INSTRUCTIONS_END_MARKER = "<!--VITE PLUS END-->";
+const AGENT_ALIASES = Object.fromEntries(AGENTS.flatMap((option) => (option.aliases ?? []).map((alias) => [normalizeAgentName(alias), option.id])));
+const COPILOT_SETUP_WORKFLOW_CONTENT = `name: "Copilot Setup Steps"
+
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+  pull_request:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+
+jobs:
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Set up Vite+
+        uses: voidzero-dev/setup-vp@v1
+        with:
+          cache: true
+          run-install: true
+      - name: Verify Vite+
+        run: vp --version
+`;
+async function selectAgentTargets({ interactive, agent, onCancel }) {
+	if (agent === false) return {
+		targetPaths: void 0,
+		selectedAgents: []
+	};
+	if (interactive && !agent) {
+		const selectedAgentIds = await multiselect({
+			message: "Which coding agent instruction files should Vite+ create?",
+			options: AGENTS.map((option) => ({
+				label: option.label,
+				value: option.id,
+				hint: option.hint
+			})),
+			initialValues: [AGENT_DEFAULT_ID],
+			required: false
+		});
+		if (R(selectedAgentIds)) {
+			onCancel();
+			return {
+				targetPaths: void 0,
+				selectedAgents: []
+			};
+		}
+		if (selectedAgentIds.length === 0) return {
+			targetPaths: void 0,
+			selectedAgents: []
+		};
+		const selectedAgents = resolveAgentOptions(selectedAgentIds);
+		return {
+			targetPaths: getAgentTargetPaths(selectedAgents),
+			selectedAgents
+		};
+	}
+	const selectedAgents = resolveAgentOptions(agent ?? AGENT_DEFAULT_ID);
+	return {
+		targetPaths: getAgentTargetPaths(selectedAgents),
+		selectedAgents
+	};
+}
+async function selectAgentTargetPaths({ interactive, agent, onCancel }) {
+	return (await selectAgentTargets({
+		interactive,
+		agent,
+		onCancel
+	})).targetPaths;
+}
+function detectExistingAgentTargetPaths(projectRoot) {
+	const detectedPaths = [];
+	const seenTargetPaths = /* @__PURE__ */ new Set();
+	for (const option of AGENTS) {
+		if (seenTargetPaths.has(option.targetPath)) continue;
+		seenTargetPaths.add(option.targetPath);
+		const targetPath = path.join(projectRoot, option.targetPath);
+		if (fs.existsSync(targetPath) && !fs.lstatSync(targetPath).isSymbolicLink()) detectedPaths.push(option.targetPath);
+	}
+	return detectedPaths.length > 0 ? detectedPaths : void 0;
+}
+/**
+* Silently update agent instruction files that contain Vite+ markers.
+* - No agent files → no writes
+* - No Vite+ markers → no writes
+* - Markers present, content up to date → no writes
+* - Markers present, content outdated → update marked section
+*/
+function updateExistingAgentInstructions(projectRoot) {
+	const targetPaths = detectExistingAgentTargetPaths(projectRoot);
+	if (!targetPaths) return;
+	const templatePath = path.join(pkgRoot, "AGENTS.md");
+	if (!fs.existsSync(templatePath)) return;
+	const templateContent = fs.readFileSync(templatePath, "utf-8");
+	for (const targetPath of targetPaths) try {
+		const fullPath = path.join(projectRoot, targetPath);
+		const existing = fs.readFileSync(fullPath, "utf-8");
+		const updated = replaceMarkedAgentInstructionsSection(existing, templateContent);
+		if (updated !== void 0 && updated !== existing) fs.writeFileSync(fullPath, updated);
+	} catch {}
+}
+function resolveAgentOptions(agent) {
+	const agentNames = parseAgentNames(agent);
+	const resolvedAgentNames = agentNames.length > 0 ? agentNames : [AGENT_DEFAULT_ID];
+	const dedupedAgents = [];
+	const seenAgentIds = /* @__PURE__ */ new Set();
+	for (const name of resolvedAgentNames) {
+		const option = resolveSingleAgentOption(name);
+		if (seenAgentIds.has(option.id)) continue;
+		seenAgentIds.add(option.id);
+		dedupedAgents.push(option);
+	}
+	return dedupedAgents;
+}
+function getAgentTargetPaths(agents) {
+	const dedupedTargetPaths = [];
+	const seenTargetPaths = /* @__PURE__ */ new Set();
+	for (const agent of agents) {
+		if (seenTargetPaths.has(agent.targetPath)) continue;
+		seenTargetPaths.add(agent.targetPath);
+		dedupedTargetPaths.push(agent.targetPath);
+	}
+	return dedupedTargetPaths;
+}
+function parseAgentNames(agent) {
+	if (!agent) return [];
+	return (Array.isArray(agent) ? agent : [agent]).filter((value) => typeof value === "string").flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function resolveSingleAgentOption(agent) {
+	const normalized = normalizeAgentName(agent);
+	const alias = AGENT_ALIASES[normalized];
+	const resolved = alias ? normalizeAgentName(alias) : normalized;
+	return AGENTS.find((option) => normalizeAgentName(option.id) === resolved || normalizeAgentName(option.label) === resolved || normalizeAgentName(option.targetPath) === resolved || option.aliases?.some((candidate) => normalizeAgentName(candidate) === resolved)) ?? AGENTS.find((option) => option.id === AGENT_DEFAULT_ID);
+}
+/**
+* Detect agent instruction files that would conflict (exist without markers).
+* Returns only files that need a user decision (append or skip).
+* Read-only — does not write or modify any files.
+*/
+async function detectAgentConflicts({ projectRoot, targetPaths }) {
+	if (!targetPaths || targetPaths.length === 0) return [];
+	const sourcePath = path.join(pkgRoot, "AGENTS.md");
+	if (!fs.existsSync(sourcePath)) return [];
+	const incomingContent = await fsPromises.readFile(sourcePath, "utf-8");
+	const shouldLinkToAgents = targetPaths.includes(AGENT_STANDARD_PATH);
+	const orderedPaths = shouldLinkToAgents ? [AGENT_STANDARD_PATH, ...targetPaths.filter((p) => p !== AGENT_STANDARD_PATH)] : targetPaths;
+	const conflicts = [];
+	const seenDestinationPaths = /* @__PURE__ */ new Set();
+	const seenRealPaths = /* @__PURE__ */ new Set();
+	for (const targetPathToCheck of orderedPaths) {
+		const destinationPath = path.join(projectRoot, targetPathToCheck);
+		const destinationKey = path.resolve(destinationPath);
+		if (seenDestinationPaths.has(destinationKey)) continue;
+		seenDestinationPaths.add(destinationKey);
+		if (shouldLinkToAgents && targetPathToCheck !== AGENT_STANDARD_PATH) {
+			if (await getExistingPathKind(destinationPath) !== "file") continue;
+		}
+		if (fs.existsSync(destinationPath)) {
+			if (fs.lstatSync(destinationPath).isSymbolicLink()) continue;
+			const destinationRealPath = await fsPromises.realpath(destinationPath);
+			if (seenRealPaths.has(destinationRealPath)) continue;
+			if (replaceMarkedAgentInstructionsSection(await fsPromises.readFile(destinationPath, "utf-8"), incomingContent) !== void 0) {
+				seenRealPaths.add(destinationRealPath);
+				continue;
+			}
+			conflicts.push({ targetPath: targetPathToCheck });
+			seenRealPaths.add(destinationRealPath);
+		}
+	}
+	return conflicts;
+}
+async function writeAgentInstructions({ projectRoot, targetPath, targetPaths, interactive, conflictDecisions, silent = false }) {
+	const paths = [...targetPaths ?? [], ...targetPath ? [targetPath] : []];
+	if (paths.length === 0) return;
+	const sourcePath = path.join(pkgRoot, "AGENTS.md");
+	if (!fs.existsSync(sourcePath)) {
+		if (!silent) log.warn("Agent instructions template not found; skipping.");
+		return;
+	}
+	const seenDestinationPaths = /* @__PURE__ */ new Set();
+	const seenRealPaths = /* @__PURE__ */ new Set();
+	const incomingContent = await fsPromises.readFile(sourcePath, "utf-8");
+	const shouldLinkToAgents = paths.includes(AGENT_STANDARD_PATH);
+	const orderedPaths = shouldLinkToAgents ? [AGENT_STANDARD_PATH, ...paths.filter((p) => p !== AGENT_STANDARD_PATH)] : paths;
+	for (const targetPathToWrite of orderedPaths) {
+		const destinationPath = path.join(projectRoot, targetPathToWrite);
+		const destinationKey = path.resolve(destinationPath);
+		if (seenDestinationPaths.has(destinationKey)) continue;
+		seenDestinationPaths.add(destinationKey);
+		await fsPromises.mkdir(path.dirname(destinationPath), { recursive: true });
+		if (shouldLinkToAgents && targetPathToWrite !== AGENT_STANDARD_PATH) {
+			if (await tryLinkTargetToAgents(projectRoot, targetPathToWrite, silent)) continue;
+		}
+		if (fs.existsSync(destinationPath)) {
+			if (fs.lstatSync(destinationPath).isSymbolicLink()) {
+				if (!silent) log.info(`Skipped writing ${targetPathToWrite} (symlink)`);
+				continue;
+			}
+			const destinationRealPath = await fsPromises.realpath(destinationPath);
+			if (seenRealPaths.has(destinationRealPath)) {
+				if (!silent) log.info(`Skipped writing ${targetPathToWrite} (duplicate target)`);
+				continue;
+			}
+			const existingContent = await fsPromises.readFile(destinationPath, "utf-8");
+			const updatedContent = replaceMarkedAgentInstructionsSection(existingContent, incomingContent);
+			if (updatedContent !== void 0) {
+				if (updatedContent !== existingContent) await fsPromises.writeFile(destinationPath, updatedContent);
+				seenRealPaths.add(destinationRealPath);
+				continue;
+			}
+			let conflictAction;
+			const preResolved = conflictDecisions?.get(targetPathToWrite);
+			if (preResolved) conflictAction = preResolved;
+			else if (interactive) {
+				const action = await select({
+					message: `Agent instructions already exist at ${targetPathToWrite}.\n  ` + styleText("gray", "The Vite+ template includes guidance on `vp` commands, the build pipeline, and project conventions."),
+					options: [{
+						label: "Append",
+						value: "append",
+						hint: "Add template content to the end"
+					}, {
+						label: "Skip",
+						value: "skip",
+						hint: "Leave existing file unchanged"
+					}],
+					initialValue: "skip"
+				});
+				conflictAction = R(action) || action === "skip" ? "skip" : "append";
+			} else conflictAction = "skip";
+			if (conflictAction === "append") await appendAgentContent(destinationPath, targetPathToWrite, existingContent, incomingContent, silent);
+			else {
+				const suffix = !preResolved && !interactive ? " (already exists)" : "";
+				if (!silent) log.info(`Skipped writing ${targetPathToWrite}${suffix}`);
+			}
+			seenRealPaths.add(destinationRealPath);
+			continue;
+		}
+		await fsPromises.writeFile(destinationPath, incomingContent);
+		if (!silent) log.success(`Wrote agent instructions to ${targetPathToWrite}`);
+		seenRealPaths.add(await fsPromises.realpath(destinationPath));
+	}
+}
+async function writeCopilotSetupWorkflow({ projectRoot, silent = false }) {
+	const destinationPath = path.join(projectRoot, COPILOT_SETUP_WORKFLOW_PATH);
+	await fsPromises.mkdir(path.dirname(destinationPath), { recursive: true });
+	if (fs.existsSync(destinationPath)) {
+		if (!silent) log.info(`Skipped writing ${COPILOT_SETUP_WORKFLOW_PATH} (already exists)`);
+		return;
+	}
+	await fsPromises.writeFile(destinationPath, COPILOT_SETUP_WORKFLOW_CONTENT);
+	if (!silent) log.success(`Wrote Copilot setup workflow to ${COPILOT_SETUP_WORKFLOW_PATH}`);
+}
+async function appendAgentContent(destinationPath, targetPath, existingContent, incomingContent, silent = false) {
+	const separator = existingContent.endsWith("\n") ? "" : "\n";
+	await fsPromises.appendFile(destinationPath, `${separator}\n${incomingContent}`);
+	if (!silent) log.success(`Appended agent instructions to ${targetPath}`);
+}
+function normalizeAgentName(value) {
+	return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function replaceMarkedAgentInstructionsSection(existing, incoming) {
+	const existingRange = getMarkedRange(existing, AGENT_INSTRUCTIONS_START_MARKER, AGENT_INSTRUCTIONS_END_MARKER);
+	if (!existingRange) return;
+	const incomingRange = getMarkedRange(incoming, AGENT_INSTRUCTIONS_START_MARKER, AGENT_INSTRUCTIONS_END_MARKER);
+	if (!incomingRange) return;
+	return `${existing.slice(0, existingRange.start)}${incoming.slice(incomingRange.start, incomingRange.end)}${existing.slice(existingRange.end)}`;
+}
+async function tryLinkTargetToAgents(projectRoot, targetPath, silent = false) {
+	const destinationPath = path.join(projectRoot, targetPath);
+	const agentsPath = path.join(projectRoot, AGENT_STANDARD_PATH);
+	const symlinkTarget = path.relative(path.dirname(destinationPath), agentsPath);
+	const existing = await getExistingPathKind(destinationPath);
+	if (existing === "file") return false;
+	if (existing === "symlink") {
+		const currentLink = await fsPromises.readlink(destinationPath);
+		if (path.resolve(path.dirname(destinationPath), currentLink) === agentsPath) {
+			if (!silent) log.info(`Skipped linking ${targetPath} (already linked to ${AGENT_STANDARD_PATH})`);
+			return true;
+		}
+		await fsPromises.unlink(destinationPath);
+	}
+	try {
+		await fsPromises.symlink(symlinkTarget, destinationPath);
+	} catch (err) {
+		if (err.code === "EPERM") {
+			await fsPromises.copyFile(agentsPath, destinationPath);
+			if (!silent) log.success(`Copied ${AGENT_STANDARD_PATH} to ${targetPath}`);
+			return true;
+		}
+		throw err;
+	}
+	if (!silent) log.success(`Linked ${targetPath} to ${AGENT_STANDARD_PATH}`);
+	return true;
+}
+async function getExistingPathKind(filePath) {
+	if (!fs.existsSync(filePath)) return "missing";
+	return (await fsPromises.lstat(filePath)).isSymbolicLink() ? "symlink" : "file";
+}
+function getMarkedRange(content, startMarker, endMarker) {
+	const start = content.indexOf(startMarker);
+	if (start === -1) return;
+	const endMarkerIndex = content.indexOf(endMarker, start + startMarker.length);
+	if (endMarkerIndex === -1) return;
+	return {
+		start,
+		end: endMarkerIndex + endMarker.length
+	};
+}
+//#endregion
+export { promptEslintMigration as A, editYamlFile as B, injectLintTypeCheckDefaults as C, migrateNodeVersionManagerFile as D, migrateEslintToOxlint as E, setPackageManager as F, displayRelative as H, warnIncompatibleEslintIntegration as I, warnLegacyEslintConfig as L, rewriteMonorepo as M, rewriteMonorepoProject as N, migratePrettierToOxfmt as O, rewriteStandaloneProject as P, warnPackageLevelEslint as R, injectCreateDefaultTemplate as S, mergeViteConfigFiles as T, templatesDir as U, readYamlFile as V, detectNodeVersionManagerFile as _, selectAgentTargets as a, hasFrameworkShim as b, writeCopilotSetupWorkflow as c, checkVitestVersion as d, confirmEslintMigration as f, detectIncompatibleEslintIntegration as g, detectFramework as h, selectAgentTargetPaths as i, promptPrettierMigration as j, preflightGitHooksSetup as k, addFrameworkShim as l, detectEslintProject as m, detectAgentConflicts as n, updateExistingAgentInstructions as o, confirmPrettierMigration as p, detectExistingAgentTargetPaths as r, writeAgentInstructions as s, COPILOT_AGENT_ID as t, checkViteVersion as u, detectPrettierProject as v, installGitHooks as w, hasStagedConfigInViteConfig as x, ensurePreCommitHook as y, warnPackageLevelPrettier as z };