vite-plus 0.2.1 → 0.2.3

package/dist/agent--cKmgD_n.js

@@ -1,3341 +0,0 @@
-import { r as __toESM } from "./rolldown-runtime-DnnnRqeS.js";
-import { a as VITEST_VERSION, c as VITE_PLUS_VERSION, i as VITEST_AGE_GATE_EXEMPT_PACKAGES, n as BASEURL_TSCONFIG_WARNING, o as VITE_PLUS_NAME, s as VITE_PLUS_OVERRIDE_PACKAGES, u as isForceOverrideMode } from "./constants-CrfJQIUX.js";
-import { i as ensureVitePlusImportRuleDefaults, r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-q8a5PFch.js";
-import { A as select, C as require_semver, D as log, I as runCommandSilently, L as require_cross_spawn, O as multiselect, P as R, S as PackageManager, T as confirm, a as hasTypesToRewriteInTsconfig, b as getSpinner, c as cancelAndExit, i as hasBaseUrlInTsconfig, n as findTsconfigFiles, o as removeDeprecatedTsconfigFalseOption, s as rewriteTypesInTsconfig } from "./tsconfig-BWQPmGKz.js";
-import { n as isJsonFile, r as readJsonFile, t as editJsonFile } from "./json-Dn87fvjk.js";
-import { t as require_dist } from "./dist-Oxo16Y0q.js";
-import { n as detectPackageMetadata } from "./package-BHirM1_v.js";
-import { n as addMigrationWarning, t as addManualStep } from "./report-BHSkWqRR.js";
-import path from "node:path";
-import { hasConfigKey, mergeJsonConfig, mergeTsdownConfig, rewriteEslint, rewriteImportsInDirectory, rewritePrettier, rewriteScripts, wrapLazyPlugins } from "../binding/index.js";
-import fs from "node:fs";
-import { styleText } from "node:util";
-import os from "node:os";
-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"
-];
-const WEBDRIVERIO_PROVIDER = "@vitest/browser-webdriverio";
-const PLAYWRIGHT_PROVIDER = "@vitest/browser-playwright";
-const OPT_IN_BROWSER_PROVIDERS = [WEBDRIVERIO_PROVIDER, PLAYWRIGHT_PROVIDER];
-const PROVIDER_OVERRIDE_DROP_NAMES = [...REMOVE_PACKAGES, ...OPT_IN_BROWSER_PROVIDERS];
-function extractOverrideTargetName(key) {
-	let target = key.trim();
-	for (let delim = target.search(/[^ |@]>/); delim !== -1; delim = target.search(/[^ |@]>/)) target = target.slice(delim + 2).trim();
-	if (!target) return target;
-	if (target.includes("/")) {
-		const segments = target.split("/");
-		const last = segments[segments.length - 1];
-		const scope = segments[segments.length - 2];
-		target = scope?.startsWith("@") ? `${scope}/${last}` : last;
-	}
-	const nameStart = target.startsWith("@") ? target.indexOf("/") + 1 : 0;
-	const versionAt = target.indexOf("@", nameStart);
-	if (versionAt > 0) target = target.slice(0, versionAt);
-	return target;
-}
-function isRemovePackageOverrideKey(key) {
-	return PROVIDER_OVERRIDE_DROP_NAMES.includes(extractOverrideTargetName(key));
-}
-function stripSegmentVersion(segment) {
-	const nameStart = segment.startsWith("@") ? segment.indexOf("/") + 1 : 0;
-	const versionAt = segment.indexOf("@", nameStart);
-	return versionAt > 0 ? segment.slice(0, versionAt) : segment;
-}
-function parentGlobMatchesName(glob, name) {
-	const pattern = glob.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
-	return new RegExp(`^${pattern}$`).test(name);
-}
-function ancestorSegmentMatches(segment, name) {
-	return segment.includes("*") ? parentGlobMatchesName(segment, name) : segment === name;
-}
-const OWNED_PROVIDER_ANCESTOR_NAMES = REMOVE_PACKAGES.filter((name) => name.startsWith("@vitest/"));
-function parentChainReachesVitePlus(segments) {
-	const concrete = segments.filter((segment) => segment !== "**");
-	let index = 0;
-	if (concrete.length > 0 && ancestorSegmentMatches(concrete[0], "vite-plus")) index = 1;
-	for (; index < concrete.length; index += 1) {
-		const segment = concrete[index];
-		if (!OWNED_PROVIDER_ANCESTOR_NAMES.some((name) => ancestorSegmentMatches(segment, name))) return false;
-	}
-	return true;
-}
-function extractOverrideParentSegments(key) {
-	let rest = key.trim();
-	const pnpmParents = [];
-	for (let delim = rest.search(/[^ |@]>/); delim !== -1; delim = rest.search(/[^ |@]>/)) {
-		pnpmParents.push(stripSegmentVersion(rest.slice(0, delim + 1).trim()));
-		rest = rest.slice(delim + 2).trim();
-	}
-	if (pnpmParents.length > 0) return pnpmParents;
-	if (!rest.includes("/")) return null;
-	const segments = rest.split("/");
-	const descriptorSegmentCount = segments[segments.length - 2]?.startsWith("@") ?? false ? 2 : 1;
-	const rawParents = segments.slice(0, segments.length - descriptorSegmentCount);
-	if (rawParents.length === 0) return null;
-	const parents = [];
-	for (let i = 0; i < rawParents.length; i += 1) {
-		const segment = rawParents[i];
-		if (segment.startsWith("@") && i + 1 < rawParents.length) {
-			parents.push(stripSegmentVersion(`${segment}/${rawParents[i + 1]}`));
-			i += 1;
-		} else parents.push(stripSegmentVersion(segment));
-	}
-	return parents;
-}
-function providerKeyReachesVitePlus(key, ancestorChain) {
-	if (!isRemovePackageOverrideKey(key)) return false;
-	const keyParents = extractOverrideParentSegments(key) ?? [];
-	return parentChainReachesVitePlus([...ancestorChain, ...keyParents]);
-}
-function shouldDropProviderOverrideKey(key) {
-	return providerKeyReachesVitePlus(key, []);
-}
-function childChainContribution(key) {
-	return [...extractOverrideParentSegments(key) ?? [], extractOverrideTargetName(key)];
-}
-// @vitest/provider`. Covers bare, versioned, global-glob and `vite-plus`-parent
-function dropRemovePackageOverrideKeys(overrides, ancestorChain = []) {
-	if (!overrides) return false;
-	let removed = false;
-	for (const key of Object.keys(overrides)) {
-		const value = overrides[key];
-		const child = value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-		if (providerKeyReachesVitePlus(key, ancestorChain)) {
-			if (child) {
-				let changed = false;
-				if ("." in child) {
-					delete child["."];
-					changed = true;
-				}
-				if (dropRemovePackageOverrideKeys(child, [...ancestorChain, ...childChainContribution(key)])) changed = true;
-				if (Object.keys(child).length === 0) {
-					delete overrides[key];
-					changed = true;
-				}
-				if (changed) removed = true;
-			} else {
-				delete overrides[key];
-				removed = true;
-			}
-			continue;
-		}
-		if (child) {
-			if (dropRemovePackageOverrideKeys(child, [...ancestorChain, ...childChainContribution(key)])) {
-				removed = true;
-				if (Object.keys(child).length === 0) delete overrides[key];
-			}
-		}
-	}
-	return removed;
-}
-const BROWSER_PROVIDER_PEER_DEPS = {
-	"@vitest/browser-playwright": "playwright",
-	"@vitest/browser-webdriverio": "webdriverio"
-};
-const BROWSER_PROVIDER_POSTINSTALL_PACKAGES = ["edgedriver", "geckodriver"];
-const WEBDRIVERIO_ALLOW_SIGNAL_DEPS = ["webdriverio", WEBDRIVERIO_PROVIDER];
-const VITEST_BROWSER_DEP_NAMES = [
-	"@vitest/browser",
-	"@vitest/browser-preview",
-	"@vitest/browser-playwright",
-	"@vitest/browser-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"
-]);
-const LEGACY_WRAPPER_PACKAGE_NAMES = ["@voidzero-dev/vite-plus-test"];
-const LEGACY_WRAPPER_FALLBACK_VERSIONS = { vitest: VITEST_VERSION };
-function isLegacyWrapperSpec(value) {
-	if (typeof value !== "string" || !value) return false;
-	for (const name of LEGACY_WRAPPER_PACKAGE_NAMES) if (value === `npm:${name}` || value.startsWith(`npm:${name}@`)) return true;
-	return false;
-}
-/**
-* Rewrite or remove keys whose value points at a deleted vite-plus wrapper.
-* When a fallback exists for the key (e.g. `vitest`), the value is replaced
-* so existing `catalog:` references continue to resolve. Otherwise the key
-* is dropped entirely. Returns true iff any entry was changed.
-*
-* npm/bun `overrides` may nest an object of scoped overrides under a parent
-* key (e.g. `{ "some-parent": { "vitest": "npm:@voidzero-dev/vite-plus-test@latest" } }`),
-* so object values are recursed into; a parent emptied by pruning is dropped so
-* no `{}` is left behind. Flat maps (pnpm `overrides`, yarn `resolutions`,
-* catalogs) hold only string values, where the recursion is inert.
-*/
-function pruneLegacyWrapperAliases(record) {
-	if (!record) return false;
-	let mutated = false;
-	for (const key of Object.keys(record)) {
-		const value = record[key];
-		if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-			if (pruneLegacyWrapperAliases(value)) {
-				mutated = true;
-				if (Object.keys(value).length === 0) delete record[key];
-			}
-			continue;
-		}
-		if (isLegacyWrapperSpec(value)) {
-			const fallback = LEGACY_WRAPPER_FALLBACK_VERSIONS[key];
-			if (fallback !== void 0) record[key] = fallback;
-			else delete record[key];
-			mutated = true;
-		}
-	}
-	return mutated;
-}
-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) {
-	let changed = false;
-	const files = findTsconfigFiles(projectPath);
-	for (const filePath of files) if (rewriteTypesInTsconfig(filePath)) {
-		changed = true;
-		if (report) report.removedConfigCount++;
-		if (!silent) log.success(`✔ Rewrote types in ${displayRelative(filePath)}`);
-	}
-	return changed;
-}
-function hasTsconfigTypesToRewrite(projectPath) {
-	return findTsconfigFiles(projectPath).some((filePath) => hasTypesToRewriteInTsconfig(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);
-	const pnpmMajorVersion = pnpmMajor(workspaceInfo.downloadPackageManager.version);
-	let extractedStagedConfig = null;
-	let remainingPnpmOverrides;
-	let shouldRewritePnpmWorkspaceYaml = false;
-	let shouldAddPnpmWorkspaceVitePlusOverride = false;
-	let shouldAllowBrowserProviderBuilds = false;
-	let usePnpmWorkspaceYaml = false;
-	editJsonFile(packageJsonPath, (pkg) => {
-		shouldAllowBrowserProviderBuilds = hasOwnWebdriverioDependency(pkg) || usesWebdriverioProvider(projectPath);
-		pruneLegacyWrapperAliases(pkg.resolutions);
-		pruneLegacyWrapperAliases(pkg.overrides);
-		pruneLegacyWrapperAliases(pkg.pnpm?.overrides);
-		dropRemovePackageOverrideKeys(pkg.resolutions);
-		dropRemovePackageOverrideKeys(pkg.overrides);
-		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
-			};
-			if (packageManager === PackageManager.bun) pkg.devDependencies = {
-				...pkg.devDependencies,
-				vite: VITE_PLUS_OVERRIDE_PACKAGES.vite
-			};
-		} else if (packageManager === PackageManager.pnpm) {
-			usePnpmWorkspaceYaml = !pkg.pnpm;
-			if (usePnpmWorkspaceYaml) {
-				shouldRewritePnpmWorkspaceYaml = true;
-				shouldAddPnpmWorkspaceVitePlusOverride = isForceOverrideMode();
-			}
-			const overrideKeys = Object.keys(VITE_PLUS_OVERRIDE_PACKAGES);
-			if (!usePnpmWorkspaceYaml) {
-				dropRemovePackageOverrideKeys(pkg.pnpm?.overrides);
-				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, ...PROVIDER_OVERRIDE_DROP_NAMES]) if (pkg.resolutions?.[key]) delete pkg.resolutions[key];
-			if (!usePnpmWorkspaceYaml && pnpmMajorVersion !== void 0 && pkg.pnpm) applyBuildAllowanceToPackageJsonPnpm(pkg.pnpm, pnpmMajorVersion, shouldAllowBrowserProviderBuilds);
-		}
-		extractedStagedConfig = rewritePackageJson(pkg, packageManager, usePnpmWorkspaceYaml, skipStagedMigration, catalogDependencyResolver, usesVitestBrowserMode(projectPath), collectProviderSourceModes(projectPath));
-		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, pnpmMajorVersion, shouldAllowBrowserProviderBuilds);
-	if (remainingPnpmOverrides) migratePnpmOverridesToWorkspaceYaml(projectPath, remainingPnpmOverrides);
-	if (shouldAddPnpmWorkspaceVitePlusOverride) migratePnpmOverridesToWorkspaceYaml(projectPath, { [VITE_PLUS_NAME]: VITE_PLUS_VERSION });
-	if (packageManager === PackageManager.yarn) rewriteYarnrcYml(projectPath);
-	else if (packageManager === PackageManager.bun) ensureBunfigPeerSuppression(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);
-	wrapLazyPluginsInViteConfig(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);
-	const pnpmMajorVersion = pnpmMajor(workspaceInfo.downloadPackageManager.version);
-	const workspaceShouldAllowBrowserBuilds = workspaceUsesWebdriverio(workspaceInfo.rootDir, workspaceInfo.packages);
-	if (workspaceInfo.packageManager === PackageManager.pnpm) rewritePnpmWorkspaceYaml(workspaceInfo.rootDir, pnpmMajorVersion, workspaceShouldAllowBrowserBuilds);
-	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, pnpmMajorVersion, workspaceShouldAllowBrowserBuilds);
-	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, true);
-	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);
-	wrapLazyPluginsInViteConfig(workspaceInfo.rootDir, silent, report);
-	for (const pkg of workspaceInfo.packages) wrapLazyPluginsInViteConfig(path.join(workspaceInfo.rootDir, pkg.path), 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, deferLazyPluginWrapping = false) {
-	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;
-	const yarnHoisting = packageManager === PackageManager.yarn ? findYarnWorkspaceHoisting(workspaceContext?.rootDir ?? projectPath) : void 0;
-	let extractedStagedConfig = null;
-	editJsonFile(packageJsonPath, (pkg) => {
-		extractedStagedConfig = rewritePackageJson(pkg, packageManager, true, skipStagedMigration, catalogDependencyResolver, usesVitestBrowserMode(projectPath), collectProviderSourceModes(projectPath));
-		if (yarnHoisting && path.resolve(projectPath) !== yarnHoisting.rootDir && pkg.devDependencies?.["vite-plus"]) applyYarnWorkspaceHoistingFix(pkg, yarnHoisting.limit, yarnHoisting.nodeLinker, path.relative(yarnHoisting.rootDir, projectPath) || projectPath, report);
-		return pkg;
-	});
-	if (extractedStagedConfig) {
-		if (mergeStagedConfigToViteConfig(projectPath, extractedStagedConfig, silent, report)) removeLintStagedFromPackageJson(packageJsonPath);
-	}
-	if (!deferLazyPluginWrapping) wrapLazyPluginsInViteConfig(projectPath, silent, report);
-}
-/**
-* Rewrite pnpm-workspace.yaml to add vite-plus dependencies
-* @param projectPath - The path to the project
-*/
-function rewritePnpmWorkspaceYaml(projectPath, pnpmMajorVersion, shouldAllowBrowserBuilds) {
-	const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
-	if (!fs.existsSync(pnpmWorkspaceYamlPath)) fs.writeFileSync(pnpmWorkspaceYamlPath, "");
-	editYamlFile(pnpmWorkspaceYamlPath, (doc) => {
-		rewriteCatalog(doc);
-		if (pnpmMajorVersion !== void 0) applyBuildAllowanceToWorkspaceYaml(doc, pnpmMajorVersion, shouldAllowBrowserBuilds);
-		const overrides = doc.getIn(["overrides"]);
-		pruneYamlMapLegacyWrapperAliases(overrides);
-		if (overrides instanceof import_dist.YAMLMap) {
-			const keysSnapshot = overrides.items.map((item) => item.key);
-			for (const keyNode of keysSnapshot) if (shouldDropProviderOverrideKey(keyNode instanceof import_dist.Scalar ? String(keyNode.value ?? "") : String(keyNode ?? ""))) overrides.delete(keyNode);
-		}
-		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/*",
-				...VITEST_AGE_GATE_EXEMPT_PACKAGES
-			];
-			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) {
-	dropRemovePackageOverrideKeys(pkg.pnpm?.overrides);
-	const catalogOverrides = {};
-	const overrides = pkg.pnpm?.overrides;
-	for (const key of [...overrideKeys, ...PROVIDER_OVERRIDE_DROP_NAMES]) {
-		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));
-	});
-}
-function hasOwnWebdriverioDependency(pkg) {
-	for (const name of WEBDRIVERIO_ALLOW_SIGNAL_DEPS) if (pkg.dependencies?.[name] ?? pkg.devDependencies?.[name] ?? pkg.optionalDependencies?.[name] ?? pkg.peerDependencies?.[name]) return true;
-	return false;
-}
-function workspaceUsesWebdriverio(rootDir, packages) {
-	const rootPkg = readPackageJsonIfExists(path.join(rootDir, "package.json"));
-	if (rootPkg && hasOwnWebdriverioDependency(rootPkg)) return true;
-	if (usesWebdriverioProvider(rootDir)) return true;
-	if (!packages) return false;
-	for (const pkg of packages) {
-		const packageDir = path.join(rootDir, pkg.path);
-		const subPkg = readPackageJsonIfExists(path.join(packageDir, "package.json"));
-		if (subPkg && hasOwnWebdriverioDependency(subPkg)) return true;
-		if (usesWebdriverioProvider(packageDir)) return true;
-	}
-	return false;
-}
-function readPackageJsonIfExists(packageJsonPath) {
-	if (!fs.existsSync(packageJsonPath)) return;
-	try {
-		return readJsonFile(packageJsonPath);
-	} catch {
-		return;
-	}
-}
-function pnpmMajor(version) {
-	const coerced = version ? import_semver.default.coerce(version)?.version : void 0;
-	return coerced ? import_semver.default.major(coerced) : void 0;
-}
-function applyBuildAllowanceToPackageJsonPnpm(pnpm, major, shouldAllow) {
-	if (major >= 10) {
-		if (shouldAllow) for (const name of BROWSER_PROVIDER_POSTINSTALL_PACKAGES) (pnpm.allowBuilds ??= {})[name] = true;
-	} else if (shouldAllow) {
-		const list = pnpm.onlyBuiltDependencies ?? [];
-		const existing = new Set(list);
-		for (const name of BROWSER_PROVIDER_POSTINSTALL_PACKAGES) if (!existing.has(name)) {
-			list.push(name);
-			existing.add(name);
-		}
-		pnpm.onlyBuiltDependencies = list;
-	}
-}
-function applyBuildAllowanceToWorkspaceYaml(doc, major, shouldAllow) {
-	if (major >= 10) {
-		if (shouldAllow) {
-			const existing = doc.getIn(["allowBuilds"]);
-			const isNew = !(existing instanceof import_dist.YAMLMap);
-			const allowBuilds = isNew ? new import_dist.YAMLMap() : existing;
-			for (const name of BROWSER_PROVIDER_POSTINSTALL_PACKAGES) allowBuilds.set(scalarString(name), new import_dist.Scalar(true));
-			if (isNew) doc.setIn(["allowBuilds"], allowBuilds);
-		}
-	} else if (shouldAllow) {
-		let onlyBuiltDependencies = doc.getIn(["onlyBuiltDependencies"]);
-		if (!(onlyBuiltDependencies instanceof import_dist.YAMLSeq)) onlyBuiltDependencies = new import_dist.YAMLSeq();
-		const existing = new Set(onlyBuiltDependencies.items.map((n) => n.value));
-		for (const name of BROWSER_PROVIDER_POSTINSTALL_PACKAGES) if (!existing.has(name)) onlyBuiltDependencies.add(scalarString(name));
-		doc.setIn(["onlyBuiltDependencies"], onlyBuiltDependencies);
-	}
-}
-/**
-* 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 readYarnrcValue(dir, key) {
-	const yarnrcYmlPath = path.join(dir, ".yarnrc.yml");
-	if (!fs.existsSync(yarnrcYmlPath)) return;
-	try {
-		const value = readYamlFile(yarnrcYmlPath)?.[key];
-		return typeof value === "string" ? value : void 0;
-	} catch {
-		return;
-	}
-}
-function resolveEffectiveYarnConfigValue(workspaceRootDir, key, envVar) {
-	const fromEnv = process.env[envVar]?.trim();
-	if (fromEnv) return fromEnv;
-	let dir = path.resolve(workspaceRootDir);
-	for (;;) {
-		const value = readYarnrcValue(dir, key);
-		if (value !== void 0) return value;
-		const parent = path.dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-	const home = os.homedir();
-	return home ? readYarnrcValue(home, key) : void 0;
-}
-function dirIsWorkspaceRoot(dir) {
-	const pkgJsonPath = path.join(dir, "package.json");
-	if (!fs.existsSync(pkgJsonPath)) return false;
-	try {
-		return readJsonFile(pkgJsonPath).workspaces != null;
-	} catch {
-		return false;
-	}
-}
-function findYarnWorkspaceHoisting(startDir) {
-	let dir = path.resolve(startDir);
-	for (;;) {
-		if (dirIsWorkspaceRoot(dir)) return {
-			rootDir: dir,
-			limit: resolveEffectiveYarnConfigValue(dir, "nmHoistingLimits", "YARN_NM_HOISTING_LIMITS"),
-			nodeLinker: resolveEffectiveYarnConfigValue(dir, "nodeLinker", "YARN_NODE_LINKER")
-		};
-		const parent = path.dirname(dir);
-		if (parent === dir) return;
-		dir = parent;
-	}
-}
-function setYarnWorkspaceHoistingOptOut(pkg) {
-	if (pkg.installConfig?.hoistingLimits !== void 0) return;
-	pkg.installConfig = {
-		...pkg.installConfig,
-		hoistingLimits: "none"
-	};
-}
-function applyYarnWorkspaceHoistingFix(pkg, rootLimit, nodeLinker, workspaceLabel, report) {
-	if (nodeLinker !== "node-modules") return;
-	if (rootLimit === "workspaces" && pkg.installConfig?.hoistingLimits === void 0) {
-		setYarnWorkspaceHoistingOptOut(pkg);
-		return;
-	}
-	const explicit = pkg.installConfig?.hoistingLimits;
-	if (rootLimit === "dependencies" || explicit === "workspaces" || explicit === "dependencies") warnMigration(`Yarn workspace "${workspaceLabel}" isolates dependency hoisting (hoistingLimits: ${explicit ?? rootLimit}), so it keeps its own \`vitest\`/\`vite-plus\` copy and \`vp test\` may crash with a split \`@vitest/runner\`. Dedupe them to a single copy — relax this workspace's hoisting isolation or pin one \`vitest\` for the workspace.`, report);
-}
-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");
-		let npmPreapprovedPackages = doc.getIn(["npmPreapprovedPackages"]);
-		if (!npmPreapprovedPackages) npmPreapprovedPackages = new import_dist.YAMLSeq();
-		const existingPreapproved = new Set(npmPreapprovedPackages.items.map((n) => n.value));
-		for (const pkg of VITEST_AGE_GATE_EXEMPT_PACKAGES) if (!existingPreapproved.has(pkg)) npmPreapprovedPackages.add(scalarString(pkg));
-		doc.setIn(["npmPreapprovedPackages"], npmPreapprovedPackages);
-		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 pruneYamlMapLegacyWrapperAliases(map) {
-	if (!(map instanceof import_dist.YAMLMap)) return;
-	const stale = [];
-	for (const item of map.items) {
-		const value = item.value instanceof import_dist.Scalar ? item.value.value : void 0;
-		if (typeof value === "string" && isLegacyWrapperSpec(value) && item.key instanceof import_dist.Scalar) stale.push({
-			key: item.key,
-			fallback: LEGACY_WRAPPER_FALLBACK_VERSIONS[item.key.value]
-		});
-	}
-	for (const { key, fallback } of stale) if (fallback !== void 0) map.set(key, scalarString(fallback));
-	else map.delete(key);
-}
-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);
-	}
-	pruneYamlMapLegacyWrapperAliases(doc.getIn(["catalog"]));
-	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);
-		}
-		pruneYamlMapLegacyWrapperAliases(item.value);
-	}
-}
-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);
-}
-/**
-* Bun rejects vitest@4.1.9's `vite^6/^7/^8` peer-dep when the user's project
-* overrides `vite` to `@voidzero-dev/vite-plus-core` (whose package.json version
-* does not match those ranges). pnpm/yarn/npm all tolerate this redirect; bun
-* does not, and there is no `peerDependencyRules`-style escape hatch — only the
-* `[install] peer = false` setting in `bunfig.toml`.
-*
-* `vite-plus`/`@voidzero-dev/vite-plus-core` already provide the vite surface
-* the user needs, so disabling bun's auto-install of *missing* peers is safe in
-* this configuration: any vitest peer that's not already pulled in transitively
-* (jsdom, happy-dom, etc.) is marked optional upstream anyway.
-*
-* Writes/merges `bunfig.toml` at `projectPath` so the suppression applies on
-* the migration's reinstall AND every subsequent `bun install` the user runs.
-*/
-function ensureBunfigPeerSuppression(projectPath) {
-	const bunfigPath = path.join(projectPath, "bunfig.toml");
-	const block = "[install]\npeer = false\n";
-	if (!fs.existsSync(bunfigPath)) {
-		fs.writeFileSync(bunfigPath, block);
-		return;
-	}
-	const existing = fs.readFileSync(bunfigPath, "utf8");
-	if (/^\s*peer\s*=\s*(true|false)\s*$/m.test(existing)) return;
-	const installSectionRe = /^\[install\][^[]*/m;
-	const next = installSectionRe.test(existing) ? existing.replace(installSectionRe, (section) => `${section.trimEnd()}\npeer = false\n`) : `${existing.trimEnd()}\n\n${block}`;
-	fs.writeFileSync(bunfigPath, next);
-}
-/**
-* 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);
-		pruneLegacyWrapperAliases(catalog);
-		if (useWorkspacesCatalog) {
-			workspacesObj.catalog = catalog;
-			if (pkg.catalog) {
-				rewriteCatalogObject(pkg.catalog, false);
-				pruneLegacyWrapperAliases(pkg.catalog);
-			}
-		} else {
-			pkg.catalog = catalog;
-			if (workspacesObj?.catalog) {
-				rewriteCatalogObject(workspacesObj.catalog, false);
-				pruneLegacyWrapperAliases(workspacesObj.catalog);
-			}
-		}
-		if (workspacesObj?.catalogs) {
-			rewriteCatalogsObject(workspacesObj.catalogs);
-			for (const named of Object.values(workspacesObj.catalogs)) pruneLegacyWrapperAliases(named);
-		}
-		if (pkg.catalogs) {
-			rewriteCatalogsObject(pkg.catalogs);
-			for (const named of Object.values(pkg.catalogs)) pruneLegacyWrapperAliases(named);
-		}
-		const overrides = { ...pkg.overrides };
-		pruneLegacyWrapperAliases(overrides);
-		for (const [key, value] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) {
-			const current = overrides[key];
-			if (current !== void 0 && typeof current !== "string") continue;
-			overrides[key] = getCatalogDependencySpec(current, value, true);
-		}
-		pkg.overrides = overrides;
-		return pkg;
-	});
-	ensureBunfigPeerSuppression(projectPath);
-}
-/**
-* Rewrite root workspace package.json to add vite-plus dependencies
-* @param projectPath - The path to the project
-*/
-function rewriteRootWorkspacePackageJson(projectPath, packageManager, skipStagedMigration, catalogDependencyResolver, packages, pnpmMajorVersion, shouldAllowBrowserBuilds = false) {
-	const packageJsonPath = path.join(projectPath, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return;
-	let remainingPnpmOverrides;
-	editJsonFile(packageJsonPath, (pkg) => {
-		pruneLegacyWrapperAliases(pkg.resolutions);
-		pruneLegacyWrapperAliases(pkg.overrides);
-		pruneLegacyWrapperAliases(pkg.pnpm?.overrides);
-		dropRemovePackageOverrideKeys(pkg.resolutions);
-		dropRemovePackageOverrideKeys(pkg.overrides);
-		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) pkg.devDependencies = {
-			...pkg.devDependencies,
-			vite: getCatalogDependencySpec(pkg.devDependencies?.vite, VITE_PLUS_OVERRIDE_PACKAGES.vite, true)
-		};
-		else if (packageManager === PackageManager.pnpm) {
-			const overrideKeys = Object.keys(VITE_PLUS_OVERRIDE_PACKAGES);
-			if (isForceOverrideMode()) {
-				dropRemovePackageOverrideKeys(pkg.pnpm?.overrides);
-				pkg.pnpm = {
-					...pkg.pnpm,
-					overrides: {
-						...pkg.pnpm?.overrides,
-						...VITE_PLUS_OVERRIDE_PACKAGES,
-						[VITE_PLUS_NAME]: VITE_PLUS_VERSION
-					}
-				};
-			} else {
-				for (const key of [...overrideKeys, ...PROVIDER_OVERRIDE_DROP_NAMES]) 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 (pnpmMajorVersion !== void 0 && pkg.pnpm) applyBuildAllowanceToPackageJsonPnpm(pkg.pnpm, pnpmMajorVersion, shouldAllowBrowserBuilds);
-		}
-		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, true);
-}
-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 getCoreMigrationProjectPaths(workspaceInfo) {
-	return [workspaceInfo.rootDir, ...(workspaceInfo.packages ?? []).map((pkg) => path.join(workspaceInfo.rootDir, pkg.path))];
-}
-function hasCorePackageScriptRewrites(projectPath) {
-	const packageJsonPath = path.join(projectPath, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return false;
-	const pkg = readJsonFile(packageJsonPath);
-	if (!pkg.scripts) return false;
-	return !!rewriteScripts(JSON.stringify(pkg.scripts), getScriptRulesYaml(true));
-}
-function rewriteCorePackageScripts(projectPath) {
-	const packageJsonPath = path.join(projectPath, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return false;
-	let changed = false;
-	editJsonFile(packageJsonPath, (pkg) => {
-		if (!pkg.scripts) return;
-		const updated = rewriteScripts(JSON.stringify(pkg.scripts), getScriptRulesYaml(true));
-		if (!updated) return;
-		pkg.scripts = JSON.parse(updated);
-		changed = true;
-		return pkg;
-	});
-	return changed;
-}
-function detectPendingCoreMigration(workspaceInfo) {
-	const projectPaths = getCoreMigrationProjectPaths(workspaceInfo);
-	return {
-		scripts: projectPaths.some((projectPath) => hasCorePackageScriptRewrites(projectPath)),
-		tsconfigTypes: projectPaths.some((projectPath) => hasTsconfigTypesToRewrite(projectPath))
-	};
-}
-function finalizeCoreMigrationForExistingVitePlus(workspaceInfo, silent = false, report, pending = detectPendingCoreMigration(workspaceInfo)) {
-	const projectPaths = getCoreMigrationProjectPaths(workspaceInfo);
-	const result = {
-		scripts: false,
-		tsconfigTypes: false,
-		imports: false
-	};
-	if (pending.scripts) for (const projectPath of projectPaths) result.scripts = rewriteCorePackageScripts(projectPath) || result.scripts;
-	if (pending.tsconfigTypes) for (const projectPath of projectPaths) result.tsconfigTypes = rewriteTsconfigTypes(projectPath, silent, report) || result.tsconfigTypes;
-	result.imports = rewriteAllImports(workspaceInfo.rootDir, silent, report);
-	return result;
-}
-function getVitePlusOverridePackageName(dependencyName) {
-	if (dependencyName === "vite") return "@voidzero-dev/vite-plus-core";
-	if (dependencyName === "vitest") return "@voidzero-dev/vite-plus-test";
-}
-function isSemanticVitePlusOverrideSpec(dependencyName, spec) {
-	if (!spec) return false;
-	if (isLegacyWrapperSpec(spec)) return false;
-	if (spec === VITE_PLUS_OVERRIDE_PACKAGES[dependencyName]) return true;
-	const packageName = getVitePlusOverridePackageName(dependencyName);
-	return packageName !== void 0 && spec.includes(packageName);
-}
-function overrideSpecSatisfiesVitePlus(dependencyName, spec, catalogDependencyResolver) {
-	if (!spec) return false;
-	if (isSemanticVitePlusOverrideSpec(dependencyName, spec)) return true;
-	if (!spec.startsWith("catalog:")) return false;
-	return isSemanticVitePlusOverrideSpec(dependencyName, catalogDependencyResolver?.(spec, dependencyName));
-}
-function overridesSatisfyVitePlus(overrides, catalogDependencyResolver) {
-	return Object.keys(VITE_PLUS_OVERRIDE_PACKAGES).every((dependencyName) => overrideSpecSatisfiesVitePlus(dependencyName, overrides?.[dependencyName], catalogDependencyResolver));
-}
-function hasPackageManagerPin(pkg) {
-	return Boolean(pkg.packageManager || pkg.devEngines?.packageManager);
-}
-function vitePlusDependencyNeedsConcreteVersion(pkg) {
-	return [
-		pkg.devDependencies,
-		pkg.dependencies,
-		pkg.optionalDependencies
-	].some((dependencies) => dependencies?.["vite-plus"]?.startsWith("catalog:") ?? false);
-}
-function defaultCatalogVitePlusDependencyPending(pkg, catalogDependencyResolver) {
-	return [
-		pkg.devDependencies,
-		pkg.dependencies,
-		pkg.optionalDependencies
-	].some((dependencies) => {
-		const spec = dependencies?.[VITE_PLUS_NAME];
-		if (spec !== "catalog:" && spec !== "catalog:default") return false;
-		return catalogDependencyResolver?.(spec, VITE_PLUS_NAME) !== VITE_PLUS_VERSION;
-	});
-}
-function pnpmPeerDependencyRulesSatisfyVitePlus(peerDependencyRules) {
-	const overrideKeys = Object.keys(VITE_PLUS_OVERRIDE_PACKAGES);
-	const allowAny = new Set(peerDependencyRules?.allowAny ?? []);
-	const allowedVersions = peerDependencyRules?.allowedVersions ?? {};
-	return overrideKeys.every((key) => allowAny.has(key) && allowedVersions[key] === "*");
-}
-function npmVitePlusManagedDependenciesPending(pkg) {
-	const dependencyGroups = [
-		pkg.devDependencies,
-		pkg.dependencies,
-		pkg.optionalDependencies
-	];
-	return Object.keys(VITE_PLUS_OVERRIDE_PACKAGES).some((dependencyName) => dependencyGroups.some((dependencies) => dependencies?.[dependencyName] !== void 0 && !overrideSpecSatisfiesVitePlus(dependencyName, dependencies[dependencyName])));
-}
-function readPnpmWorkspaceCatalogDependencyResolver(projectPath) {
-	const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
-	if (!fs.existsSync(pnpmWorkspaceYamlPath)) return;
-	const doc = readYamlFile(pnpmWorkspaceYamlPath);
-	return createCatalogDependencyResolverFromCatalogs(doc?.catalog, doc?.catalogs);
-}
-function readPnpmWorkspaceOverrides(projectPath) {
-	const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
-	if (!fs.existsSync(pnpmWorkspaceYamlPath)) return;
-	return readYamlFile(pnpmWorkspaceYamlPath)?.overrides;
-}
-function readPnpmWorkspacePeerDependencyRules(projectPath) {
-	const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
-	if (!fs.existsSync(pnpmWorkspaceYamlPath)) return;
-	return readYamlFile(pnpmWorkspaceYamlPath)?.peerDependencyRules;
-}
-function yarnrcSatisfiesVitePlus(projectPath) {
-	const yarnrcYmlPath = path.join(projectPath, ".yarnrc.yml");
-	if (!fs.existsSync(yarnrcYmlPath)) return false;
-	const doc = readYamlFile(yarnrcYmlPath);
-	return !!doc && Object.hasOwn(doc, "nodeLinker") && overridesSatisfyVitePlus(doc.catalog) && (VITE_PLUS_VERSION.startsWith("file:") || doc.catalog?.["vite-plus"] === VITE_PLUS_VERSION);
-}
-function ensurePnpmWorkspacePackages(projectPath, workspacePatterns) {
-	if (workspacePatterns.length === 0) return false;
-	const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
-	let changed = false;
-	editYamlFile(pnpmWorkspaceYamlPath, (doc) => {
-		if (doc.has("packages")) return;
-		const packages = new import_dist.YAMLSeq();
-		for (const pattern of workspacePatterns) packages.add(scalarString(pattern));
-		doc.set("packages", packages);
-		changed = true;
-	});
-	return changed;
-}
-function readBunCatalogDependencyResolver(pkg) {
-	const workspacesObj = pkg.workspaces && !Array.isArray(pkg.workspaces) ? pkg.workspaces : {};
-	const fromWorkspaces = createCatalogDependencyResolverFromCatalogs(workspacesObj.catalog, workspacesObj.catalogs);
-	const fromPkg = createCatalogDependencyResolverFromCatalogs(pkg.catalog, pkg.catalogs);
-	return (catalogSpec, dependencyName) => fromWorkspaces(catalogSpec, dependencyName) ?? fromPkg(catalogSpec, dependencyName);
-}
-function detectVitePlusBootstrapPending(projectPath, packageManager) {
-	const packageJsonPath = path.join(projectPath, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return false;
-	const pkg = readJsonFile(packageJsonPath);
-	if (!pkg.devDependencies?.["vite-plus"] || !hasPackageManagerPin(pkg)) return true;
-	if (packageManager === void 0) return true;
-	if (packageManager === PackageManager.yarn) return !overridesSatisfyVitePlus(pkg.resolutions) || !yarnrcSatisfiesVitePlus(projectPath);
-	if (packageManager === PackageManager.npm) return vitePlusDependencyNeedsConcreteVersion(pkg) || !overridesSatisfyVitePlus(pkg.overrides) || npmVitePlusManagedDependenciesPending(pkg);
-	if (packageManager === PackageManager.bun) return !overridesSatisfyVitePlus(pkg.overrides, readBunCatalogDependencyResolver(pkg));
-	if (packageManager === PackageManager.pnpm) {
-		if (pkg.pnpm) return vitePlusDependencyNeedsConcreteVersion(pkg) || !overridesSatisfyVitePlus(pkg.pnpm.overrides) || !pnpmPeerDependencyRulesSatisfyVitePlus(pkg.pnpm.peerDependencyRules);
-		const resolver = readPnpmWorkspaceCatalogDependencyResolver(projectPath);
-		return defaultCatalogVitePlusDependencyPending(pkg, resolver) || !overridesSatisfyVitePlus(readPnpmWorkspaceOverrides(projectPath), resolver) || !pnpmPeerDependencyRulesSatisfyVitePlus(readPnpmWorkspacePeerDependencyRules(projectPath));
-	}
-	return false;
-}
-function ensureVitePlusDependencySpecs(pkg, version) {
-	let changed = false;
-	if (version !== "catalog:") {
-		const dependencyGroups = [
-			pkg.devDependencies,
-			pkg.dependencies,
-			pkg.optionalDependencies
-		];
-		for (const dependencies of dependencyGroups) if (dependencies?.["vite-plus"]?.startsWith("catalog:")) {
-			dependencies[VITE_PLUS_NAME] = version;
-			changed = true;
-		}
-	}
-	if (pkg.devDependencies?.["vite-plus"]) return changed;
-	pkg.devDependencies = {
-		...pkg.devDependencies,
-		[VITE_PLUS_NAME]: version
-	};
-	return true;
-}
-function ensureOverrideEntries(overrides, catalogDependencyResolver) {
-	const next = { ...overrides };
-	let changed = false;
-	for (const [dependencyName, overrideSpec] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) if (!overrideSpecSatisfiesVitePlus(dependencyName, next[dependencyName], catalogDependencyResolver)) {
-		next[dependencyName] = overrideSpec;
-		changed = true;
-	}
-	return {
-		overrides: next,
-		changed
-	};
-}
-function ensureNpmVitePlusManagedDependencies(pkg) {
-	let changed = false;
-	const dependencyGroups = [
-		pkg.devDependencies,
-		pkg.dependencies,
-		pkg.optionalDependencies
-	];
-	for (const [dependencyName, version] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) for (const dependencies of dependencyGroups) if (dependencies?.[dependencyName] !== void 0 && !overrideSpecSatisfiesVitePlus(dependencyName, dependencies[dependencyName])) {
-		dependencies[dependencyName] = version;
-		changed = true;
-	}
-	return changed;
-}
-function ensurePnpmPeerDependencyRules(pkg) {
-	const overrideKeys = Object.keys(VITE_PLUS_OVERRIDE_PACKAGES);
-	pkg.pnpm ??= {};
-	const peerDependencyRules = {
-		...pkg.pnpm.peerDependencyRules,
-		allowAny: [...new Set([...pkg.pnpm.peerDependencyRules?.allowAny ?? [], ...overrideKeys])],
-		allowedVersions: {
-			...pkg.pnpm.peerDependencyRules?.allowedVersions,
-			...Object.fromEntries(overrideKeys.map((key) => [key, "*"]))
-		}
-	};
-	const changed = JSON.stringify(pkg.pnpm.peerDependencyRules ?? {}) !== JSON.stringify(peerDependencyRules);
-	pkg.pnpm.peerDependencyRules = peerDependencyRules;
-	return changed;
-}
-function ensureVitePlusBootstrap(workspaceInfo, report) {
-	const projectPath = workspaceInfo.rootDir;
-	const packageJsonPath = path.join(projectPath, "package.json");
-	const result = {
-		changed: false,
-		packageJson: false,
-		packageManagerConfig: false,
-		packageManagerField: false
-	};
-	if (!fs.existsSync(packageJsonPath)) return result;
-	editJsonFile(packageJsonPath, (pkg) => {
-		const usePnpmWorkspaceYaml = workspaceInfo.packageManager === PackageManager.pnpm && !pkg.pnpm;
-		let packageJsonChanged = ensureVitePlusDependencySpecs(pkg, !VITE_PLUS_VERSION.startsWith("file:") && (usePnpmWorkspaceYaml || workspaceInfo.packageManager === PackageManager.bun) ? "catalog:" : VITE_PLUS_VERSION);
-		if (workspaceInfo.packageManager === PackageManager.npm) packageJsonChanged = ensureNpmVitePlusManagedDependencies(pkg) || packageJsonChanged;
-		if (workspaceInfo.packageManager === PackageManager.yarn) {
-			const ensured = ensureOverrideEntries(pkg.resolutions);
-			if (ensured.changed) {
-				pkg.resolutions = ensured.overrides;
-				packageJsonChanged = true;
-			}
-		} else if (workspaceInfo.packageManager === PackageManager.npm) {
-			const ensured = ensureOverrideEntries(pkg.overrides);
-			if (ensured.changed) {
-				pkg.overrides = ensured.overrides;
-				packageJsonChanged = true;
-			}
-		} else if (workspaceInfo.packageManager === PackageManager.bun) {
-			const ensured = ensureOverrideEntries(pkg.overrides, readBunCatalogDependencyResolver(pkg));
-			if (ensured.changed) {
-				pkg.overrides = ensured.overrides;
-				packageJsonChanged = true;
-			}
-		} else if (workspaceInfo.packageManager === PackageManager.pnpm && pkg.pnpm) {
-			const ensured = ensureOverrideEntries(pkg.pnpm.overrides);
-			if (ensured.changed) {
-				pkg.pnpm.overrides = ensured.overrides;
-				packageJsonChanged = true;
-			}
-			packageJsonChanged = ensurePnpmPeerDependencyRules(pkg) || packageJsonChanged;
-		}
-		result.packageJson = packageJsonChanged;
-		return pkg;
-	});
-	if (workspaceInfo.packageManager === PackageManager.pnpm) {
-		const pkg = readJsonFile(packageJsonPath);
-		if (!pkg.pnpm) {
-			const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
-			const before = fs.existsSync(pnpmWorkspaceYamlPath) ? fs.readFileSync(pnpmWorkspaceYamlPath, "utf-8") : void 0;
-			const catalogDependencyResolver = readPnpmWorkspaceCatalogDependencyResolver(projectPath);
-			if (defaultCatalogVitePlusDependencyPending(pkg, catalogDependencyResolver) || !overridesSatisfyVitePlus(readPnpmWorkspaceOverrides(projectPath), catalogDependencyResolver) || !pnpmPeerDependencyRulesSatisfyVitePlus(readPnpmWorkspacePeerDependencyRules(projectPath))) rewritePnpmWorkspaceYaml(projectPath, void 0, false);
-			if (fs.existsSync(pnpmWorkspaceYamlPath)) ensurePnpmWorkspacePackages(projectPath, workspaceInfo.workspacePatterns);
-			result.packageManagerConfig = before !== (fs.existsSync(pnpmWorkspaceYamlPath) ? fs.readFileSync(pnpmWorkspaceYamlPath, "utf-8") : void 0);
-		}
-	} else if (workspaceInfo.packageManager === PackageManager.yarn) {
-		const yarnrcYmlPath = path.join(projectPath, ".yarnrc.yml");
-		const before = fs.existsSync(yarnrcYmlPath) ? fs.readFileSync(yarnrcYmlPath, "utf-8") : void 0;
-		rewriteYarnrcYml(projectPath);
-		result.packageManagerConfig = before !== fs.readFileSync(yarnrcYmlPath, "utf-8");
-	} else if (workspaceInfo.packageManager === PackageManager.bun) {
-		const before = fs.readFileSync(packageJsonPath, "utf-8");
-		rewriteBunCatalog(projectPath);
-		const after = fs.readFileSync(packageJsonPath, "utf-8");
-		result.packageJson = result.packageJson || before !== after;
-	}
-	const beforePackageManager = fs.readFileSync(packageJsonPath, "utf-8");
-	setPackageManager(projectPath, workspaceInfo.downloadPackageManager);
-	result.packageManagerField = beforePackageManager !== fs.readFileSync(packageJsonPath, "utf-8");
-	result.changed = result.packageJson || result.packageManagerConfig || result.packageManagerField;
-	if (result.changed && report) report.packageManagerBootstrapConfigured = true;
-	return result;
-}
-const VITEST_BROWSER_SPECIFIER_HINTS = [
-	"@vitest/browser",
-	"vite-plus/test/browser",
-	"vite-plus/test/plugins/browser",
-	"vite-plus/test/internal/browser",
-	"vite-plus/test/client",
-	"vite-plus/test/context",
-	"vite-plus/test/locators",
-	"vite-plus/test/matchers",
-	"vite-plus/test/utils"
-];
-const WEBDRIVERIO_PROVIDER_SPECIFIER_HINTS = [
-	"@vitest/browser-webdriverio",
-	"vite-plus/test/browser-webdriverio",
-	"vite-plus/test/browser/providers/webdriverio",
-	"vite-plus/test/plugins/browser-webdriverio"
-];
-const PLAYWRIGHT_PROVIDER_SPECIFIER_HINTS = [
-	"@vitest/browser-playwright",
-	"vite-plus/test/browser-playwright",
-	"vite-plus/test/browser/providers/playwright",
-	"vite-plus/test/plugins/browser-playwright"
-];
-const BROWSER_PROVIDER_SPECIFIER_HINTS = {
-	[WEBDRIVERIO_PROVIDER]: WEBDRIVERIO_PROVIDER_SPECIFIER_HINTS,
-	[PLAYWRIGHT_PROVIDER]: PLAYWRIGHT_PROVIDER_SPECIFIER_HINTS
-};
-const VITEST_SCAN_EXTENSIONS = new Set([
-	".ts",
-	".mts",
-	".cts",
-	".tsx",
-	".js",
-	".mjs",
-	".cjs",
-	".jsx"
-]);
-const VITEST_SCAN_SKIP_DIRS = new Set([
-	"node_modules",
-	"dist",
-	"build",
-	"out",
-	"coverage",
-	".git",
-	".next",
-	".nuxt",
-	".svelte-kit",
-	".vite",
-	".cache"
-]);
-/**
-* Detect whether a package uses vitest's browser mode.
-*
-* Upstream `@vitest/browser` injects `optimizeDeps.include` entries of the form
-* `vitest > expect-type` (and `vitest > @vitest/snapshot > magic-string`,
-* `vitest > @vitest/expect > chai`). Vite resolves the leading `vitest` segment
-* from the Vite config root, so `vitest` MUST be resolvable as a package from
-* the consuming package's directory. In a pnpm strict (non-hoisted) layout,
-* `vitest` pulled in only transitively via `vite-plus` is NOT reachable from the
-* package root — the optimizer then fails with `Failed to resolve dependency`
-* and the browser test page hangs forever.
-*
-* When this returns true the migration adds `vitest` as a direct
-* devDependency so it is hoisted next to the package and the optimizer chain
-* resolves. The signal is any of the package's TS/JS files (config, workspace
-* config under any name, or test file) referencing `@vitest/browser*` or
-* `vite-plus/test/browser*`. The scan recurses through the package directory
-* (skipping `node_modules`, build output, VCS metadata) so browser config in a
-* non-standard filename or browser imports in test files are all caught.
-*
-* Recursion stops at nested `package.json` boundaries: a workspace sub-package
-* is a separate package that the migration scans on its own pass, so the root
-* package must not inherit a browser-mode signal from a sub-package.
-*/
-function sourceTreeReferencesAny(projectPath, hints) {
-	const matchesHint = (content) => hints.some((hint) => content.includes(hint));
-	const scanDir = (dir, isRoot) => {
-		let entries;
-		try {
-			entries = fs.readdirSync(dir, { withFileTypes: true });
-		} catch {
-			return false;
-		}
-		if (!isRoot && entries.some((e) => e.isFile() && e.name === "package.json")) return false;
-		for (const entry of entries) {
-			const entryPath = path.join(dir, entry.name);
-			if (entry.isDirectory()) {
-				if (VITEST_SCAN_SKIP_DIRS.has(entry.name)) continue;
-				if (scanDir(entryPath, false)) return true;
-			} else if (entry.isFile() && VITEST_SCAN_EXTENSIONS.has(path.extname(entry.name))) try {
-				if (matchesHint(fs.readFileSync(entryPath, "utf8"))) return true;
-			} catch {}
-		}
-		return false;
-	};
-	return scanDir(projectPath, true);
-}
-function usesVitestBrowserMode(projectPath) {
-	return sourceTreeReferencesAny(projectPath, VITEST_BROWSER_SPECIFIER_HINTS);
-}
-function usesWebdriverioProvider(projectPath) {
-	return sourceTreeReferencesAny(projectPath, WEBDRIVERIO_PROVIDER_SPECIFIER_HINTS);
-}
-function collectProviderSourceModes(projectPath) {
-	const modes = {};
-	for (const provider of OPT_IN_BROWSER_PROVIDERS) modes[provider] = sourceTreeReferencesAny(projectPath, BROWSER_PROVIDER_SPECIFIER_HINTS[provider]);
-	return modes;
-}
-function rewritePackageJson(pkg, packageManager, isMonorepo, skipStagedMigration, catalogDependencyResolver, vitestBrowserMode, providerSourceModes) {
-	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 { dependencies } of dependencyGroups) if (pruneLegacyWrapperAliases(dependencies)) needVitePlus = true;
-	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;
-	}
-	if (isForceOverrideMode()) {
-		for (const { dependencies } of dependencyGroups) if (dependencies?.["vite-plus"]) {
-			dependencies[VITE_PLUS_NAME] = VITE_PLUS_VERSION;
-			needVitePlus = true;
-		}
-	}
-	const hasBrowserDepSignal = VITEST_BROWSER_DEP_NAMES.some((name) => dependencyGroups.some(({ dependencies }) => dependencies?.[name] !== void 0));
-	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] = "*";
-		}
-	}
-	let usesAnyOptInProvider = false;
-	for (const provider of OPT_IN_BROWSER_PROVIDERS) {
-		if (!(providerSourceModes?.[provider] || dependencyGroups.some(({ dependencies }) => dependencies?.[provider] !== void 0))) continue;
-		usesAnyOptInProvider = true;
-		const installGroup = [
-			pkg.dependencies,
-			pkg.devDependencies,
-			pkg.optionalDependencies
-		].find((deps) => deps?.[provider] !== void 0);
-		if (installGroup) installGroup[provider] = VITEST_VERSION;
-		else {
-			pkg.devDependencies ??= {};
-			pkg.devDependencies[provider] = VITEST_VERSION;
-		}
-		const peer = BROWSER_PROVIDER_PEER_DEPS[provider];
-		const peerPresent = pkg.dependencies?.[peer] ?? pkg.devDependencies?.[peer] ?? pkg.peerDependencies?.[peer] ?? pkg.optionalDependencies?.[peer];
-		if (peer && !peerPresent) {
-			pkg.devDependencies ??= {};
-			pkg.devDependencies[peer] = "*";
-		}
-		needVitePlus = true;
-	}
-	if (usesAnyOptInProvider && packageManager === PackageManager.npm) {
-		const viteOverride = VITE_PLUS_OVERRIDE_PACKAGES.vite;
-		const viteAlreadyDirect = pkg.dependencies?.vite ?? pkg.devDependencies?.vite ?? pkg.optionalDependencies?.vite;
-		if (viteOverride && !viteAlreadyDirect) {
-			pkg.devDependencies ??= {};
-			pkg.devDependencies.vite = viteOverride;
-			needVitePlus = true;
-		}
-	}
-	const effectiveBrowserMode = vitestBrowserMode || hasBrowserDepSignal;
-	const installableNames = [
-		...Object.keys(pkg.dependencies ?? {}),
-		...Object.keys(pkg.devDependencies ?? {}),
-		...Object.keys(pkg.optionalDependencies ?? {})
-	];
-	const adjacentSignals = [...installableNames, ...Object.keys(pkg.peerDependencies ?? {})];
-	const isVitestAdjacent = !installableNames.includes("vitest") && adjacentSignals.some((name) => name !== "vitest" && name.includes("vitest"));
-	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 (!existingVitePlus && (isVitestAdjacent || effectiveBrowserMode)) needVitePlus = true;
-	const needDirectVitest = needVitePlus || effectiveBrowserMode || isVitestAdjacent;
-	if (needVitePlus || shouldNormalizeExistingVitePlus) pkg.devDependencies = {
-		...pkg.devDependencies,
-		[VITE_PLUS_NAME]: canonicalVitePlusSpec
-	};
-	if (needDirectVitest) {
-		const installableDeps = {
-			...pkg.dependencies,
-			...pkg.devDependencies,
-			...pkg.optionalDependencies
-		};
-		if (!installableDeps.vitest && (effectiveBrowserMode || Object.keys(installableDeps).some((name) => name.includes("vitest")))) {
-			pkg.devDependencies ??= {};
-			pkg.devDependencies.vitest = getCatalogDependencySpec(void 0, VITEST_VERSION, 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);
-}
-/**
-* Wrap safe inline Vite plugin arrays with lazyPlugins so check/lint/fmt do not
-* eagerly execute plugin factories while loading vite.config.ts.
-*/
-function wrapLazyPluginsInViteConfig(projectPath, silent = false, report) {
-	const configs = detectConfigs(projectPath);
-	if (!configs.viteConfig) return;
-	const viteConfigPath = path.join(projectPath, configs.viteConfig);
-	const result = wrapLazyPlugins(viteConfigPath);
-	if (!result.updated) return;
-	fs.writeFileSync(viteConfigPath, result.content);
-	if (report) report.wrappedPluginConfigCount++;
-	if (!silent) log.success(`✔ Wrapped inline Vite plugins with lazyPlugins in ${displayRelative(viteConfigPath)}`);
-}
-/**
-* 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}`);
-	}
-	return modified > 0;
-}
-/**
-* 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;
-	});
-}
-function detectLegacyGitHooksMigrationCandidate(projectPath) {
-	const packageJsonPath = path.join(projectPath, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return false;
-	const pkg = readJsonFile(packageJsonPath);
-	return getOldHooksDir(projectPath) !== void 0 || pkg["lint-staged"] !== void 0;
-}
-/**
-* 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",
-		"--no-agent",
-		"--hooks-dir",
-		hooksDir
-	] : ["config", "--no-agent"];
-	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.devEngines?.packageManager) pkg.devEngines = {
-			...typeof pkg.devEngines === "object" && pkg.devEngines !== null && !Array.isArray(pkg.devEngines) ? pkg.devEngines : void 0,
-			packageManager: {
-				name: downloadPackageManager.name,
-				version: downloadPackageManager.version,
-				onFail: "download"
-			}
-		};
-		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 { mergeViteConfigFiles as A, setPackageManager as B, ensureVitePlusBootstrap as C, injectCreateDefaultTemplate as D, hasStagedConfigInViteConfig as E, promptEslintMigration as F, editYamlFile as G, warnLegacyEslintConfig as H, promptPrettierMigration as I, templatesDir as J, readYamlFile as K, rewriteMonorepo as L, migrateNodeVersionManagerFile as M, migratePrettierToOxfmt as N, injectLintTypeCheckDefaults as O, preflightGitHooksSetup as P, rewriteMonorepoProject as R, ensurePreCommitHook as S, hasFrameworkShim as T, warnPackageLevelEslint as U, warnIncompatibleEslintIntegration as V, warnPackageLevelPrettier as W, detectLegacyGitHooksMigrationCandidate as _, selectAgentTargets as a, detectPrettierProject as b, writeCopilotSetupWorkflow as c, checkVitestVersion as d, confirmEslintMigration as f, detectIncompatibleEslintIntegration as g, detectFramework as h, selectAgentTargetPaths as i, migrateEslintToOxlint as j, installGitHooks as k, addFrameworkShim as l, detectEslintProject as m, detectAgentConflicts as n, updateExistingAgentInstructions as o, confirmPrettierMigration as p, displayRelative as q, detectExistingAgentTargetPaths as r, writeAgentInstructions as s, COPILOT_AGENT_ID as t, checkViteVersion as u, detectNodeVersionManagerFile as v, finalizeCoreMigrationForExistingVitePlus as w, detectVitePlusBootstrapPending as x, detectPendingCoreMigration as y, rewriteStandaloneProject as z };