vite-plus 0.1.23 → 0.2.0

package/dist/{agent-aSGY0osq.js → agent-BD31CsvU.js}

@@ -1,14 +1,16 @@
-import { r as __toESM } from "./chunk-DnnnRqeS.js";
-import { a as VITE_PLUS_OVERRIDE_PACKAGES, c as isForceOverrideMode, i as VITE_PLUS_NAME, n as BASEURL_TSCONFIG_WARNING, o as VITE_PLUS_VERSION } from "./constants-DCBWlNrn.js";
-import { i as ensureVitePlusImportRuleDefaults, r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-B89iKTKN.js";
-import { A as q, C as log, E as select, M as runCommandSilently, N as require_cross_spawn, a as removeDeprecatedTsconfigFalseOption, i as hasBaseUrlInTsconfig, n as findTsconfigFiles, o as rewriteTypesInTsconfig, s as cancelAndExit, u as getSpinner, v as PackageManager, w as multiselect, x as confirm, y as require_semver } from "./tsconfig-DlUVXT3J.js";
-import { t as require_dist } from "./dist-BgQuvbtq.js";
-import { c as editJsonFile, l as isJsonFile, n as detectPackageMetadata, u as readJsonFile } from "./package-PmBUZ-ve.js";
-import { n as addMigrationWarning, t as addManualStep } from "./report-DgSBQUdz.js";
+import { 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-CJ_StdFc.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 } from "../binding/index.js";
+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);
@@ -173,14 +175,134 @@ const REMOVE_PACKAGES = [
 	"oxfmt",
 	"tsdown",
 	"@vitest/browser",
-	"@vitest/browser-preview",
-	"@vitest/browser-playwright",
-	"@vitest/browser-webdriverio"
+	"@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: "*"
@@ -202,6 +324,46 @@ const OXLINT_NATIVE_PLUGINS = new Set([
 	"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);
@@ -643,11 +805,17 @@ function cleanupDeprecatedTsconfigOptions(projectPath, silent = false, 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: [
@@ -716,51 +884,67 @@ function rewriteStandaloneProject(projectPath, workspaceInfo, skipStagedMigratio
 	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
-		};
-		else if (packageManager === PackageManager.pnpm) {
+		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) 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, "*"]))
+			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);
+				};
+			} else remainingPnpmOverrides = cleanupPnpmOverridesForWorkspaceYaml(pkg, overrideKeys);
 			for (const key in pkg.pnpm?.overrides) if (key.includes(">")) {
 				const splits = key.split(">");
 				if (splits[splits.length - 1].trim() === "vite") delete pkg.pnpm.overrides[key];
 			}
-			for (const key of [...overrideKeys, ...REMOVE_PACKAGES]) if (pkg.resolutions?.[key]) delete pkg.resolutions[key];
+			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);
+		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 = {
@@ -770,10 +954,11 @@ function rewriteStandaloneProject(projectPath, workspaceInfo, skipStagedMigratio
 		}
 		return pkg;
 	});
-	if (shouldRewritePnpmWorkspaceYaml) rewritePnpmWorkspaceYaml(projectPath);
+	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);
 	}
@@ -785,6 +970,7 @@ function rewriteStandaloneProject(projectPath, workspaceInfo, skipStagedMigratio
 	injectFmtDefaults(projectPath, silent, report);
 	mergeTsdownConfigFile(projectPath, silent, report);
 	rewriteAllImports(projectPath, silent, report);
+	wrapLazyPluginsInViteConfig(projectPath, silent, report);
 	setPackageManager(projectPath, workspaceInfo.downloadPackageManager);
 }
 /**
@@ -793,15 +979,17 @@ function rewriteStandaloneProject(projectPath, workspaceInfo, skipStagedMigratio
 */
 function rewriteMonorepo(workspaceInfo, skipStagedMigration, silent = false, report) {
 	const catalogDependencyResolver = createCatalogDependencyResolver(workspaceInfo.rootDir, workspaceInfo.packageManager);
-	if (workspaceInfo.packageManager === PackageManager.pnpm) rewritePnpmWorkspaceYaml(workspaceInfo.rootDir);
+	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);
+	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);
+	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);
@@ -810,6 +998,8 @@ function rewriteMonorepo(workspaceInfo, skipStagedMigration, silent = false, rep
 	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);
 }
 /**
@@ -821,32 +1011,41 @@ function rewriteMonorepo(workspaceInfo, skipStagedMigration, silent = false, rep
 *   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) {
+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);
+		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) {
+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));
@@ -874,7 +1073,8 @@ function rewritePnpmWorkspaceYaml(projectPath) {
 				"oxlint-tsgolint",
 				"@oxlint-tsgolint/*",
 				"oxfmt",
-				"@oxfmt/*"
+				"@oxfmt/*",
+				...VITEST_AGE_GATE_EXEMPT_PACKAGES
 			];
 			let minimumReleaseAgeExclude = doc.getIn(["minimumReleaseAgeExclude"]);
 			if (!minimumReleaseAgeExclude) minimumReleaseAgeExclude = new import_dist.YAMLSeq();
@@ -890,9 +1090,10 @@ function rewritePnpmWorkspaceYaml(projectPath) {
 * 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, ...REMOVE_PACKAGES]) {
+	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;
@@ -925,6 +1126,65 @@ function migratePnpmOverridesToWorkspaceYaml(projectPath, overrides) {
 		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.
 */
@@ -943,11 +1203,78 @@ function cleanupPeerDependencyRules(peerDependencyRules, overrideKeys) {
 * 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);
 	});
 }
@@ -989,17 +1316,15 @@ function createCatalogDependencyResolver(projectPath, packageManager) {
 		if (!fs.existsSync(packageJsonPath)) return;
 		const pkg = readJsonFile(packageJsonPath);
 		const workspacesObj = pkg.workspaces && !Array.isArray(pkg.workspaces) ? pkg.workspaces : void 0;
-		return (catalogSpec, dependencyName) => {
-			const catalogName = catalogSpec.slice(8);
-			if (catalogName) return workspacesObj?.catalogs?.[catalogName]?.[dependencyName] ?? pkg.catalogs?.[catalogName]?.[dependencyName];
-			return workspacesObj?.catalog?.[dependencyName] ?? pkg.catalog?.[dependencyName];
-		};
+		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) return catalogs?.[catalogName]?.[dependencyName];
+		if (catalogName && catalogName !== "default") return catalogs?.[catalogName]?.[dependencyName];
 		return catalog?.[dependencyName];
 	};
 }
@@ -1007,6 +1332,19 @@ 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;
@@ -1017,6 +1355,7 @@ function rewriteCatalog(doc) {
 		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) {
@@ -1044,6 +1383,7 @@ function rewriteCatalog(doc) {
 			];
 			if (doc.hasIn(catalogPath)) doc.deleteIn(catalogPath);
 		}
+		pruneYamlMapLegacyWrapperAliases(item.value);
 	}
 }
 function rewriteCatalogObject(catalog, addMissing) {
@@ -1058,6 +1398,34 @@ 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.
@@ -1071,30 +1439,54 @@ function rewriteBunCatalog(projectPath) {
 		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);
+			if (pkg.catalog) {
+				rewriteCatalogObject(pkg.catalog, false);
+				pruneLegacyWrapperAliases(pkg.catalog);
+			}
 		} else {
 			pkg.catalog = catalog;
-			if (workspacesObj?.catalog) rewriteCatalogObject(workspacesObj.catalog, false);
+			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);
 		}
-		if (workspacesObj?.catalogs) rewriteCatalogsObject(workspacesObj.catalogs);
-		if (pkg.catalogs) rewriteCatalogsObject(pkg.catalogs);
 		const overrides = { ...pkg.overrides };
-		for (const [key, value] of Object.entries(VITE_PLUS_OVERRIDE_PACKAGES)) overrides[key] = getCatalogDependencySpec(overrides[key], value, true);
+		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) {
+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
@@ -1103,24 +1495,31 @@ function rewriteRootWorkspacePackageJson(projectPath, packageManager, skipStaged
 			...pkg.overrides,
 			...VITE_PLUS_OVERRIDE_PACKAGES
 		};
-		else if (packageManager === PackageManager.bun) {} else if (packageManager === PackageManager.pnpm) {
+		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()) pkg.pnpm = {
-				...pkg.pnpm,
-				overrides: {
-					...pkg.pnpm?.overrides,
-					...VITE_PLUS_OVERRIDE_PACKAGES,
-					[VITE_PLUS_NAME]: VITE_PLUS_VERSION
-				}
-			};
-			else {
-				for (const key of [...overrideKeys, ...REMOVE_PACKAGES]) if (pkg.resolutions?.[key]) delete pkg.resolutions[key];
+			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,
@@ -1132,7 +1531,7 @@ function rewriteRootWorkspacePackageJson(projectPath, packageManager, skipStaged
 	rewriteMonorepoProject(projectPath, packageManager, skipStagedMigration, void 0, void 0, catalogDependencyResolver, packages ? {
 		rootDir: projectPath,
 		packages
-	} : void 0);
+	} : void 0, true);
 }
 const RULES_YAML_PATH = path.join(rulesDir, "vite-tools.yml");
 const PREPARE_RULES_YAML_PATH = path.join(rulesDir, "vite-prepare.yml");
@@ -1153,7 +1552,401 @@ function readPrepareRulesYaml() {
 	cachedPrepareRulesYaml ??= fs.readFileSync(PREPARE_RULES_YAML_PATH, "utf8");
 	return cachedPrepareRulesYaml;
 }
-function rewritePackageJson(pkg, packageManager, isMonorepo, skipStagedMigration, catalogDependencyResolver) {
+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);
@@ -1184,6 +1977,7 @@ function rewritePackageJson(pkg, packageManager, isMonorepo, skipStagedMigration
 			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,
@@ -1193,6 +1987,13 @@ function rewritePackageJson(pkg, packageManager, isMonorepo, skipStagedMigration
 		});
 		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]) {
@@ -1206,23 +2007,63 @@ function rewritePackageJson(pkg, packageManager, isMonorepo, skipStagedMigration
 			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 (needVitePlus) {
+	if (needDirectVitest) {
 		const installableDeps = {
 			...pkg.dependencies,
 			...pkg.devDependencies,
 			...pkg.optionalDependencies
 		};
-		if (!installableDeps.vitest && Object.keys(installableDeps).some((name) => name.includes("vitest"))) {
-			const ver = VITE_PLUS_OVERRIDE_PACKAGES.vitest;
+		if (!installableDeps.vitest && (effectiveBrowserMode || Object.keys(installableDeps).some((name) => name.includes("vitest")))) {
 			pkg.devDependencies ??= {};
-			pkg.devDependencies.vitest = getCatalogDependencySpec(void 0, ver, supportCatalog);
+			pkg.devDependencies.vitest = getCatalogDependencySpec(void 0, VITEST_VERSION, supportCatalog);
 		}
 	}
 	return extractedStagedConfig;
@@ -1590,6 +2431,20 @@ function hasStagedConfigInViteConfig(projectPath) {
 	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
@@ -1614,19 +2469,28 @@ function rewriteAllImports(projectPath, silent = false, report) {
 		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 not coercible (e.g. `"latest"`), falls back to
-* the installed version in node_modules via `detectPackageMetadata`.
+* 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) {
+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);
@@ -1650,6 +2514,12 @@ function removeReplacedHookPackages(packageJsonPath) {
 		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`.
@@ -1674,8 +2544,8 @@ function collapseHuskyInstall(script) {
 * 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) {
-	if (setupGitHooks(projectPath, getOldHooksDir(projectPath), silent, report)) {
+function installGitHooks(projectPath, silent = false, report, packageManager) {
+	if (setupGitHooks(projectPath, getOldHooksDir(projectPath), silent, report, packageManager)) {
 		rewritePrepareScript(projectPath);
 		return true;
 	}
@@ -1701,8 +2571,11 @@ function getOldHooksDir(rootDir) {
 *
 * 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) {
+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");
@@ -1711,7 +2584,7 @@ function preflightGitHooksSetup(projectPath) {
 	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);
+	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;
@@ -1721,8 +2594,8 @@ function preflightGitHooksSetup(projectPath) {
 * 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) {
-	const reason = preflightGitHooksSetup(projectPath);
+function setupGitHooks(projectPath, oldHooksDir, silent = false, report, packageManager) {
+	const reason = preflightGitHooksSetup(projectPath, packageManager);
 	if (reason) {
 		warnMigration(reason, report);
 		return false;
@@ -1792,10 +2665,10 @@ function setupGitHooks(projectPath, oldHooksDir, silent = false, report) {
 	const vpBin = process.env.VP_CLI_BIN ?? "vp";
 	const configArgs = isCustomDir ? [
 		"config",
-		"--hooks-only",
+		"--no-agent",
 		"--hooks-dir",
 		hooksDir
-	] : ["config", "--hooks-only"];
+	] : ["config", "--no-agent"];
 	const configResult = import_cross_spawn.default.sync(vpBin, configArgs, {
 		cwd: projectPath,
 		stdio: "pipe"
@@ -1913,7 +2786,14 @@ function rewritePrepareScript(rootDir) {
 }
 function setPackageManager(projectDir, downloadPackageManager) {
 	editJsonFile(path.join(projectDir, "package.json"), (pkg) => {
-		if (!pkg.packageManager) pkg.packageManager = `${downloadPackageManager.name}@${downloadPackageManager.version}`;
+		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;
 	});
 }
@@ -2023,7 +2903,7 @@ async function confirmEslintMigration(interactive) {
 			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 (q(confirmed)) cancelAndExit();
+		if (R(confirmed)) cancelAndExit();
 		return confirmed;
 	}
 	return true;
@@ -2057,7 +2937,7 @@ async function confirmPrettierMigration(interactive) {
 			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 (q(confirmed)) cancelAndExit();
+		if (R(confirmed)) cancelAndExit();
 		return confirmed;
 	}
 	log.info("Prettier configuration detected. Auto-migrating to Oxfmt...");
@@ -2189,7 +3069,7 @@ async function selectAgentTargets({ interactive, agent, onCancel }) {
 			initialValues: [AGENT_DEFAULT_ID],
 			required: false
 		});
-		if (q(selectedAgentIds)) {
+		if (R(selectedAgentIds)) {
 			onCancel();
 			return {
 				targetPaths: void 0,
@@ -2376,7 +3256,7 @@ async function writeAgentInstructions({ projectRoot, targetPath, targetPaths, in
 					}],
 					initialValue: "skip"
 				});
-				conflictAction = q(action) || action === "skip" ? "skip" : "append";
+				conflictAction = R(action) || action === "skip" ? "skip" : "append";
 			} else conflictAction = "skip";
 			if (conflictAction === "append") await appendAgentContent(destinationPath, targetPathToWrite, existingContent, incomingContent, silent);
 			else {
@@ -2458,4 +3338,4 @@ function getMarkedRange(content, startMarker, endMarker) {
 	};
 }
 //#endregion
-export { promptEslintMigration as A, editYamlFile as B, injectLintTypeCheckDefaults as C, migrateNodeVersionManagerFile as D, migrateEslintToOxlint as E, setPackageManager as F, displayRelative as H, warnIncompatibleEslintIntegration as I, warnLegacyEslintConfig as L, rewriteMonorepo as M, rewriteMonorepoProject as N, migratePrettierToOxfmt as O, rewriteStandaloneProject as P, warnPackageLevelEslint as R, injectCreateDefaultTemplate as S, mergeViteConfigFiles as T, templatesDir as U, readYamlFile as V, detectNodeVersionManagerFile as _, selectAgentTargets as a, hasFrameworkShim as b, writeCopilotSetupWorkflow as c, checkVitestVersion as d, confirmEslintMigration as f, detectIncompatibleEslintIntegration as g, detectFramework as h, selectAgentTargetPaths as i, promptPrettierMigration as j, preflightGitHooksSetup as k, addFrameworkShim as l, detectEslintProject as m, detectAgentConflicts as n, updateExistingAgentInstructions as o, confirmPrettierMigration as p, detectExistingAgentTargetPaths as r, writeAgentInstructions as s, COPILOT_AGENT_ID as t, checkViteVersion as u, detectPrettierProject as v, installGitHooks as w, hasStagedConfigInViteConfig as x, ensurePreCommitHook as y, warnPackageLevelPrettier as z };
+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 };