vite-plus 0.3.2 → 1.0.0-rc.0

package/dist/migration/bin.js

@@ -1,24 +1,3088 @@
 import { r as __toESM } from "../rolldown-runtime-CMFfr-1z.js";
+import { t as documentationUrl$1 } from "../documentation-DqcZSthV.js";
 import { a as muted, c as warnMsg, i as log, o as printHeader, r as formatDuration, t as accent } from "../terminal-MKGAuy-p.js";
-import { a as SETUP_VP_VERSION, f as VITE_PLUS_VERSION, m as isForceOverrideMode } from "../constants-IhOditRA.js";
-import { a as writeJsonFile, i as readJsonFile } from "../json-cULBl7Pi.js";
-import { a as readNearestPackageJson, i as hasVitePlusDependency } from "../package-BB-Jh_z3.js";
-import { E as spinner, S as log$1, T as select, b as confirm, c as selectPackageManager, i as promptGitHooks, k as isCancel, l as upgradeYarn, n as defaultInteractive, o as runViteFmt, r as downloadPackageManager$1, s as runViteInstall, t as cancelAndExit, w as outro, y as PackageManager } from "../prompts-CujFOJXu.js";
+import { _ as engines, a as SETUP_VP_VERSION, d as VITE_PLUS_OVERRIDE_PACKAGES, f as VITE_PLUS_VERSION, m as isForceOverrideMode } from "../constants-CiKwrA0v.js";
+import { a as writeJsonFile, c as modify, i as readJsonFile, l as parse, o as applyEdits, s as findNodeAtLocation, u as parseTree } from "../json-JP24qHUF.js";
+import { a as readNearestPackageJson, i as hasVitePlusDependency, n as detectPackageMetadata } from "../package-B85H2Nw0.js";
+import { t as vitest_v5_entry_points_default } from "../vitest-v5-entry-points-DthU1e_O.js";
+import { E as spinner, S as log$1, T as select, b as confirm, c as selectPackageManager, i as promptGitHooks, k as isCancel, l as upgradeYarn, n as defaultInteractive, o as runViteFmt, r as downloadPackageManager$1, s as runViteInstall, t as cancelAndExit, w as outro, y as PackageManager } from "../prompts-CQobX7uP.js";
 import { t as require_semver } from "../semver-CaDAb8vV.js";
-import { i as selectAgentTargetPaths, l as displayRelative, n as detectAgentConflicts, r as detectExistingAgentTargetPaths, s as writeAgentInstructions } from "../agent-C59HKB4Y.js";
+import { i as selectAgentTargetPaths, l as displayRelative, n as detectAgentConflicts, r as detectExistingAgentTargetPaths, s as writeAgentInstructions } from "../agent-Dinpyd-k.js";
 import { n as addMigrationWarning, r as createMigrationReport } from "../report-CK5TnTsr.js";
-import { $ as warnIncompatibleEslintIntegration, A as detectYarnPnpMode, B as migrateTsupToTsdown, C as injectLintTypeCheckDefaults, D as detectVitePlusBootstrapPending, E as collectToolchainVersionChanges, F as addFrameworkShim, G as migratePrettierToOxfmt, H as warnMissingTsupConfig, I as detectFramework, J as confirmEslintMigration, L as hasFrameworkShim, O as ensureVitePlusBootstrap, R as confirmTsupMigration, T as mergeViteConfigFiles, U as confirmPrettierMigration, W as detectPrettierProject, X as detectIncompatibleEslintIntegration, Y as detectEslintProject, Z as migrateEslintToOxlint, _ as installGitHooks, d as finalizeCoreMigrationForExistingVitePlus, et as warnLegacyEslintConfig, f as detectNodeVersionManagerFile, g as detectLegacyGitHooksMigrationCandidate, i as selectEditor, j as detectWorkspace$1, k as configureYarnNodeModulesMode, l as rewriteStandaloneProject, m as migrateSetupVpVersion, nt as checkViteVersion, o as writeEditorConfigs, p as migrateNodeVersionManagerFile, q as warnPackageLevelPrettier, r as isJsonLikeFile, rt as checkVitestVersion, s as rewriteMonorepo, t as detectEditorConflicts, tt as warnPackageLevelEslint, u as detectPendingCoreMigration, v as preflightGitHooksSetup, w as mergeTsdownConfigFile, y as shouldSkipStagedMigrationForHooks, z as detectTsupProject } from "../editor-QOIGtmH4.js";
+import { $ as confirmEslintMigration, A as createCatalogDependencyResolver, B as addFrameworkShim, C as mergeViteConfigFiles, D as usesWebdriverioProvider, E as ensureVitePlusBootstrap, G as migrateTsupToTsdown, H as hasFrameworkShim, I as minimatch, J as confirmPrettierMigration, L as findGitRoot, M as detectWorkspace$1, O as configureYarnNodeModulesMode, Q as warnPackageLevelPrettier, S as mergeTsdownConfigFile, T as detectVitePlusBootstrapPending, U as confirmTsupMigration, V as detectFramework, W as detectTsupProject, X as migratePrettierToOxfmt, Y as detectPrettierProject, _ as installGitHooks, at as warnLegacyEslintConfig, ct as checkViteVersion, d as finalizeCoreMigrationForExistingVitePlus, et as detectEslintProject, f as detectNodeVersionManagerFile, g as detectLegacyGitHooksMigrationCandidate, i as selectEditor, it as warnIncompatibleEslintIntegration, k as detectYarnPnpMode, l as rewriteStandaloneProject, lt as checkVitestVersion, m as migrateSetupVpVersion, nt as migrateEslintToOxlint, o as writeEditorConfigs, ot as warnPackageLevelEslint, p as migrateNodeVersionManagerFile, q as warnMissingTsupConfig, r as isJsonLikeFile, s as rewriteMonorepo, st as WEBDRIVERIO_PROVIDER, t as detectEditorConflicts, tt as detectIncompatibleEslintIntegration, u as detectPendingCoreMigration, v as preflightGitHooksSetup, w as collectToolchainVersionChanges, x as injectLintTypeCheckDefaults, y as shouldSkipStagedMigrationForHooks, z as extractOverrideParentSegments } from "../editor-DMBczTdj.js";
 import { n as runCommandSilently } from "../command-CguLh2KL.js";
-import { a as hasBaseUrlInTsconfig, i as fixBaseUrlInTsconfig, t as confirmBaseUrlFix } from "../tsconfig-DCtWfQPA.js";
+import { t as require_dist } from "../dist-BDYZP12R.js";
+import { a as hasBaseUrlInTsconfig, i as fixBaseUrlInTsconfig, t as confirmBaseUrlFix } from "../tsconfig-Buo0RSzz.js";
+import { t as extractOverrideTargetName } from "../package-overrides-Dpn4scvN.js";
 import { t as unwrapCliParseOutcome } from "../cli-parse-DHE8NrBU.js";
 import { t as ROLLDOWN_COMPAT_RESULT_PREFIX } from "../protocol-D99W10Qi.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseMigrateArgs } from "../../binding/index.js";
+import { analyzeMigrationSource, isDirectoryGitignored, parseMigrateArgs } from "../../binding/index.js";
 import { styleText } from "node:util";
 import fs, { existsSync } from "node:fs";
-//#region src/migration/compat/runner.ts
+//#region src/migration/vitest-v5/commands.ts
+/** Parse only a single literal argv command. Shell expansion, pipelines, and
+* compound commands need review; treating them as argv could change behavior. */
+function literalArgv(command) {
+	const tokens = [];
+	let value = "";
+	let start = 0;
+	let quote = "";
+	let active = false;
+	for (let i = 0; i < command.length; i++) {
+		const character = command[i];
+		if (quote) {
+			if (character === quote) quote = "";
+			else if (character === "\\" || quote === "\"" && (character === "$" || character === "`")) return;
+			else value += character;
+		} else if (character === "'" || character === "\"") {
+			if (!active) start = i;
+			quote = character;
+			active = true;
+		} else if (character === "\n" || character === "\r") return;
+		else if (/\s/.test(character)) {
+			if (active) tokens.push({
+				value,
+				start,
+				end: i
+			});
+			active = false;
+			value = "";
+		} else if (/[|&;<>($`\\)]/.test(character)) return;
+		else {
+			if (!active) start = i;
+			value += character;
+			active = true;
+		}
+	}
+	if (quote) return;
+	if (active) tokens.push({
+		value,
+		start,
+		end: command.length
+	});
+	return tokens;
+}
+/** Read command lists without executing a shell. Directory-changing builtins,
+* expansions, pipelines, and shell programs remain unresolved. */
+function literalTestCommands(command) {
+	const commands = [];
+	let quote = "";
+	let start = 0;
+	const append = (end) => {
+		const tokens = literalArgv(command.slice(start, end));
+		if (!tokens?.length) return false;
+		const values = tokens.map(({ value }) => value);
+		while (/^[A-Za-z_]\w*=/.test(values[0] ?? "")) values.shift();
+		if (!values.length || [
+			"cd",
+			"pushd",
+			"popd",
+			".",
+			"source",
+			"eval",
+			"export",
+			"set",
+			"unset"
+		].includes(values[0])) return false;
+		commands.push(values);
+		return true;
+	};
+	for (let index = 0; index < command.length; index++) {
+		const char = command[index];
+		if (char === "\\") return;
+		if (quote) {
+			if (char === quote) quote = "";
+		} else if (char === "\"" || char === "'") quote = char;
+		else if (char === "#") return;
+		else if (char === ";" || command.slice(index, index + 2) === "&&" || command.slice(index, index + 2) === "||") {
+			if (!append(index)) return;
+			if (char !== ";") index++;
+			start = index + 1;
+		}
+	}
+	return !quote && append(command.length) ? commands : void 0;
+}
+/** Locate the runner's arguments after a supported package-manager wrapper. */
+function vitestCommandArgsStart(values) {
+	let start = 0;
+	if ([
+		"pnpm",
+		"npm",
+		"yarn",
+		"bun",
+		"npx",
+		"bunx"
+	].includes(values[0])) {
+		start = 1;
+		if (values[start] === "exec" || values[start] === "x") start++;
+		if (values[start] === "--") start++;
+	}
+	if (values[start] === "vitest") return start + 1;
+	if (values[start] === "vp" && values[start + 1] === "test") return start + 2;
+	return -1;
+}
+function migrateBenchmarkOutput(command) {
+	const argv = literalArgv(command);
+	if (!argv) return command;
+	const values = argv.map(({ value }) => value);
+	const start = vitestCommandArgsStart(values);
+	if (start < 0) return command;
+	const end = values.indexOf("--", start);
+	const args = argv.slice(start, end < 0 ? void 0 : end);
+	for (let index = 0; index < args.length; index++) {
+		const { value } = args[index];
+		if (/^--(?:outputJson|outputFile|reporters?)$/.test(value)) {
+			const next = args[++index]?.value;
+			if (!next || next.startsWith("-")) return command;
+		} else if (value.startsWith("-") && !/^--(?:run|watch)$/.test(value) && !/^--(?:outputJson|outputFile|reporters?)=/.test(value)) return command;
+	}
+	const legacy = args.filter(({ value }) => /^--outputJson(?:=|$)/.test(value));
+	if (legacy.length !== 1) return command;
+	const flag = legacy[0];
+	const value = flag.value.startsWith("--outputJson=") ? flag.value.slice(13) : args[args.indexOf(flag) + 1]?.value;
+	if (!value || value.startsWith("-")) return command;
+	const last = flag.value.includes("=") ? flag : args[args.indexOf(flag) + 1];
+	const raw = flag === last ? command.slice(flag.start + 13, flag.end) : command.slice(last.start, last.end);
+	if (!/^[\w./:@+-]+$/.test(raw) && !/^(['"]).*\1$/.test(raw)) return command;
+	const output = args.filter(({ value }) => /^--outputFile(?:[.=]|$)/.test(value));
+	if (output.length > 1) return command;
+	if (output.length) {
+		const token = output[0];
+		if (!/^--outputFile(?:=|$)/.test(token.value)) return command;
+		if ((token.value.includes("=") ? token.value.slice(13) : args[args.indexOf(token) + 1]?.value) !== value) return command;
+	}
+	const reporters = [];
+	for (const [index, { value }] of args.entries()) if (/^--reporters?=/.test(value)) reporters.push(value.slice(value.indexOf("=") + 1));
+	else if (/^--reporters?$/.test(value)) reporters.push(args[index + 1]?.value ?? "");
+	if (reporters.some((name) => ![
+		"default",
+		"verbose",
+		"json"
+	].includes(name))) return command;
+	const replacement = [
+		...!reporters.length ? ["--reporter=default"] : [],
+		...!reporters.includes("json") ? ["--reporter=json"] : [],
+		...!output.length ? [`--outputFile=${raw}`] : []
+	].join(" ");
+	return command.slice(0, flag.start) + replacement + command.slice(last.end);
+}
+function migrateVitestV5Command(file, command, preserveV4, line = 1, reviewV4 = preserveV4) {
+	const findings = [];
+	const report = (code, message, severity = "review") => findings.push({
+		file,
+		line,
+		column: 1,
+		code,
+		message,
+		severity
+	});
+	if (!/\bvitest\b|\bvp\s+test\b/.test(command)) return {
+		content: command,
+		findings
+	};
+	command = migrateBenchmarkOutput(command);
+	const argv = literalArgv(command);
+	const values = argv?.map(({ value }) => value);
+	const runner = values ? vitestCommandArgsStart(values) : -1;
+	let removedFlag = /(?:^|\s)(?:--compare|--outputJson)(?:\s|=|$)/.test(command);
+	let reviewNamePattern = /(?:^|\s)(?:-t|--testNamePattern|--test-name-pattern)(?:\s|=)/.test(command);
+	if (values && runner >= 0) {
+		const terminator = values.indexOf("--", runner);
+		const args = values.slice(runner, terminator === -1 ? void 0 : terminator);
+		removedFlag = args.some((value) => /^(?:--compare|--outputJson)(?:=|$)/.test(value));
+		reviewNamePattern = args.some((value, index) => {
+			if (!/^(?:-t|--testNamePattern|--test-name-pattern)(?:=|$)/.test(value)) return false;
+			const pattern = value.includes("=") ? value.slice(value.indexOf("=") + 1) : args[index + 1];
+			return !pattern || !/^[\w-]+$/.test(pattern);
+		});
+	}
+	if (reviewV4 && reviewNamePattern) report("test-name-pattern", "Review test-name patterns across suite boundaries; full names now use > separators.");
+	if (removedFlag) report("benchmark-api", "Replace removed --compare/--outputJson flags with bench context comparisons or regular JSON reporter output. The bench subcommand is still supported.", "block");
+	if (!reviewV4 || !/\blist\b/.test(command)) return {
+		content: command,
+		findings
+	};
+	if (!argv || !values) {
+		report("static-list", "Review this wrapped or compound list command and explicitly choose --no-static-parse to retain runtime collection.");
+		return {
+			content: command,
+			findings
+		};
+	}
+	const list = runner;
+	if (list < 0 || values[list] !== "list") {
+		report("static-list", "Resolve this list command wrapper and explicitly choose a static-parse setting.");
+		return {
+			content: command,
+			findings
+		};
+	}
+	const optionsEnd = values.indexOf("--", list + 1);
+	const args = values.slice(list + 1, optionsEnd < 0 ? void 0 : optionsEnd);
+	if (!preserveV4 || args.some((arg) => /^--(?:no-)?static-parse(?:=|$)/.test(arg))) return {
+		content: command,
+		findings
+	};
+	const offset = argv[list].end;
+	return {
+		content: `${command.slice(0, offset)} --no-static-parse${command.slice(offset)}`,
+		findings
+	};
+}
+//#endregion
+//#region src/migration/vitest-v5/ast.ts
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && "start" in value;
+}
+function isString(node) {
+	return node?.type === "Literal" && typeof node.value === "string";
+}
+function isBoolean(node) {
+	return node?.type === "Literal" && typeof node.value === "boolean";
+}
+function isRegExp(node) {
+	return node?.type === "Literal" && "regex" in node;
+}
+function propertyName(node) {
+	if (node?.type === "Identifier") return node.name;
+	if (isString(node)) return node.value;
+}
+function memberName(node) {
+	if (node?.type !== "MemberExpression") return;
+	if (node.computed && !isString(node.property)) return;
+	return propertyName(node.property);
+}
+function isModuleExports(editor, node) {
+	return node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "module" && propertyName(node.property) === "exports" && !editor.binding(node.object);
+}
+function objectProperty(object, key) {
+	return object.properties.find((prop) => prop.type === "Property" && prop.kind === "init" && !prop.computed && propertyName(prop.key) === key);
+}
+function staticObject(node, allowMethods = false) {
+	if (node?.type !== "ObjectExpression") return false;
+	const names = /* @__PURE__ */ new Set();
+	return node.properties.every((prop) => {
+		if (prop.type !== "Property" || prop.method && !allowMethods || prop.kind !== "init" || prop.computed) return false;
+		const name = propertyName(prop.key);
+		if (name === void 0 || names.has(name)) return false;
+		names.add(name);
+		return true;
+	});
+}
+/** Consider both possible project lists without evaluating environment-dependent
+* config code. Unknown spreads stay in the list for a localized review. */
+function projectElements(node) {
+	const expand = (value) => {
+		if (value.type === "ArrayExpression") return projectElements(value);
+		if (value.type === "ConditionalExpression") {
+			const consequent = expand(value.consequent);
+			const alternate = expand(value.alternate);
+			if (consequent && alternate && ![...consequent, ...alternate].some((entry) => isString(entry) && entry.value.startsWith("!"))) return [...consequent, ...alternate];
+		}
+	};
+	return node.elements.flatMap((entry) => entry?.type === "SpreadElement" ? expand(entry.argument) ?? [entry] : [entry]);
+}
+/** Compare data literals without evaluating config code or invoking getters.
+* Property order and spelling do not change the value of a plain config object. */
+function sameStaticValue(left, right) {
+	if (left.type === "Literal" && right.type === "Literal") return !("regex" in left || "regex" in right || "bigint" in left || "bigint" in right) && Object.is(left.value, right.value);
+	if (left.type === "UnaryExpression" && right.type === "UnaryExpression") return ["+", "-"].includes(left.operator) && left.operator === right.operator && left.argument.type === "Literal" && typeof left.argument.value === "number" && sameStaticValue(left.argument, right.argument);
+	if (left.type === "ArrayExpression" && right.type === "ArrayExpression") return left.elements.length === right.elements.length && left.elements.every((element, index) => {
+		const other = right.elements[index];
+		return !!element && !!other && sameStaticValue(element, other);
+	});
+	if (staticObject(left) && staticObject(right)) return left.properties.length === right.properties.length && left.properties.every((property) => {
+		const prop = property;
+		const other = objectProperty(right, propertyName(prop.key));
+		return !!other && sameStaticValue(prop.value, other.value);
+	});
+	return false;
+}
+function importedName(editor, node, sources) {
+	if (node?.type === "MemberExpression" && !node.optional && !node.computed && node.object.type === "Identifier") {
+		const declaration = editor.binding(node.object)?.declaration;
+		const parent = declaration && editor.parent(declaration);
+		if (declaration?.type === "ImportNamespaceSpecifier" && parent?.type === "ImportDeclaration" && parent.importKind !== "type" && sources.has(parent.source.value)) return propertyName(node.property);
+	}
+	if (node?.type !== "Identifier") return;
+	const declaration = editor.binding(node)?.declaration;
+	const parent = declaration && editor.parent(declaration);
+	if (declaration?.type !== "ImportSpecifier" || parent?.type !== "ImportDeclaration") return;
+	if (declaration.importKind === "type" || parent.importKind === "type") return;
+	if (sources.has(parent.source.value)) return propertyName(declaration.imported);
+}
+const ROOT_TEST_SOURCES = /* @__PURE__ */ new Set([
+	"vitest",
+	"vite-plus/test",
+	"@vitest/runner"
+]);
+const CONFIG_SOURCES = /* @__PURE__ */ new Set([
+	"vitest/config",
+	"vite-plus",
+	"vite-plus/test/config",
+	"vite"
+]);
+const NODE_SOURCES = /* @__PURE__ */ new Set(["vitest/node", "vite-plus/test/node"]);
+function parseSource(file, source) {
+	const { ast, bindings, comments } = JSON.parse(analyzeMigrationSource(file, source));
+	return {
+		program: ast.node,
+		bindings,
+		comments
+	};
+}
+function testApiName(editor, node, globals = false) {
+	const imported = importedName(editor, node, ROOT_TEST_SOURCES);
+	if (imported) return imported;
+	if (node?.type === "MemberExpression" && !node.optional && isImportMetaVitest(node.object)) return memberName(node);
+	const binding = node && editor.binding(node);
+	const property = binding?.declaration;
+	const pattern = property && editor.parent(property);
+	const declaration = pattern && editor.parent(pattern);
+	if (binding?.constant && property?.type === "Property" && !property.computed && property.value.type === "Identifier" && pattern?.type === "ObjectPattern" && declaration?.type === "VariableDeclarator" && isImportMetaVitest(declaration.init)) return propertyName(property.key);
+	if (globals && node?.type === "Identifier" && !editor.binding(node)) return node.name;
+}
+function isImportMetaVitest(node) {
+	return node?.type === "MemberExpression" && !node.optional && memberName(node) === "vitest" && node.object.type === "MetaProperty" && node.object.meta.name === "import" && node.object.property.name === "meta";
+}
+function printAddedProperty(property, indent, newline) {
+	const comment = property.comment ? `${property.comment.replaceAll("\n", `${newline}${indent}`)}${newline}${indent}` : "";
+	const value = typeof property.value === "string" ? property.value : printAddedObject(property.value, indent, newline);
+	return `${comment}${property.key}: ${value}`;
+}
+/** Format generated objects without reindenting copied expressions or string literals. */
+function printAddedObject(properties, indent = "", newline = "\n") {
+	const childIndent = `${indent}  `;
+	return `{${newline}${properties.map((property) => `${childIndent}${printAddedProperty(property, childIndent, newline)}`).join(`,${newline}`)}${newline}${indent}}`;
+}
+/** Offset edits retain comments and formatting outside the precise changed span. */
+var SourceEditor = class {
+	file;
+	source;
+	ast;
+	comments;
+	findings = [];
+	nodes = [];
+	parents = /* @__PURE__ */ new Map();
+	bindings = /* @__PURE__ */ new Map();
+	names = /* @__PURE__ */ new Set();
+	edits = [];
+	additions = /* @__PURE__ */ new Map();
+	constructor(file, source) {
+		this.file = file;
+		this.source = source;
+		const parsed = parseSource(file, source);
+		this.ast = parsed.program;
+		this.comments = parsed.comments;
+		const identifiers = /* @__PURE__ */ new Map();
+		const index = (node, parent) => {
+			this.nodes.push(node);
+			if (parent) this.parents.set(node, parent);
+			if (node.type === "Identifier") {
+				identifiers.set(node.start, node);
+				this.names.add(node.name);
+			}
+			for (const value of Object.values(node)) for (const child of Array.isArray(value) ? value : [value]) if (isNode(child)) index(child, node);
+		};
+		index(this.ast);
+		for (const binding of parsed.bindings) {
+			const identifier = identifiers.get(binding.start);
+			const declaration = identifier && this.parent(identifier);
+			if (!declaration) continue;
+			const resolved = {
+				declaration,
+				references: binding.references.map((start) => identifiers.get(start)).filter(isNode),
+				constant: binding.constant
+			};
+			for (const start of [binding.start, ...binding.references]) this.bindings.set(start, resolved);
+		}
+	}
+	visit(visitors) {
+		for (const node of this.nodes) {
+			const visitor = visitors[node.type];
+			visitor?.(node);
+		}
+	}
+	parent(node) {
+		return this.parents.get(node);
+	}
+	functionParent(node) {
+		let parent = this.parent(node);
+		while (parent) {
+			if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") return parent;
+			parent = this.parent(parent);
+		}
+	}
+	binding(node) {
+		return node.type === "Identifier" ? this.bindings.get(node.start) : void 0;
+	}
+	uniqueName(base, preferBase = false) {
+		let name = preferBase && !this.names.has(base) ? base : `_${base}`;
+		let suffix = 2;
+		while (this.names.has(name)) name = `_${base}${suffix++}`;
+		this.names.add(name);
+		return name;
+	}
+	text(node) {
+		return this.source.slice(node.start, node.end);
+	}
+	replace(node, text) {
+		this.edit(node.start, node.end, text);
+	}
+	edit(start, end, text) {
+		const same = this.edits.find((edit) => edit.start === start && edit.end === end);
+		if (same?.text === text) return;
+		if (same && start === end) {
+			same.text += text;
+			return;
+		}
+		this.edits.push({
+			start,
+			end,
+			text
+		});
+	}
+	add(object, key, value, comment) {
+		if (objectProperty(object, key)) return;
+		let additions = this.additions.get(object);
+		if (!additions) {
+			additions = /* @__PURE__ */ new Map();
+			this.additions.set(object, additions);
+		}
+		additions.set(key, {
+			key,
+			value,
+			comment
+		});
+	}
+	remove(object, prop) {
+		const index = object.properties.indexOf(prop);
+		const nextStart = object.properties[index + 1]?.start ?? object.end - 1;
+		const previousEnd = object.properties[index - 1]?.end ?? object.start + 1;
+		const commaBetween = (start, end) => {
+			for (let index = start; index < end; index++) {
+				const comment = this.comments.find((span) => span.start <= index && index < span.end);
+				if (comment) index = comment.end - 1;
+				else if (this.source[index] === ",") return index;
+			}
+		};
+		const followingComma = commaBetween(prop.end, nextStart);
+		const precedingComma = commaBetween(previousEnd, prop.start);
+		this.replace(prop, "");
+		const comma = followingComma ?? precedingComma;
+		if (comma !== void 0) this.edit(comma, comma + 1, "");
+	}
+	report(node, code, message, severity = "review") {
+		const lines = this.source.slice(0, node?.start ?? 0).split(/\r\n|[\r\n\u2028\u2029]/);
+		const line = lines.length;
+		const column = lines.at(-1).length + 1;
+		if (!this.findings.some((item) => item.line === line && item.column === column && item.code === code && item.message === message)) this.findings.push({
+			file: this.file,
+			line,
+			column,
+			code,
+			severity,
+			message
+		});
+	}
+	finish() {
+		for (const [object, additions] of this.additions) {
+			const start = object.start + 1;
+			const first = object.properties[0]?.start ?? object.end - 1;
+			const prefix = this.source.slice(start, first);
+			const newline = this.source.includes("\r\n") ? "\r\n" : "\n";
+			const multilinePrefix = prefix.includes("\n");
+			const multiline = multilinePrefix || [...additions.values()].some(({ comment, value }) => comment || Array.isArray(value));
+			const indent = this.source.slice(this.source.lastIndexOf("\n", first) + 1, first).match(/^[\t ]*/)?.[0] ?? "";
+			let objectIndent = indent;
+			if (!multilinePrefix) {
+				const lineStart = this.source.lastIndexOf("\n", object.start) + 1;
+				let parent = this.parent(object);
+				while (parent && parent.start >= lineStart) {
+					if (parent.type === "ObjectExpression") objectIndent += "  ";
+					parent = this.parent(parent);
+				}
+			}
+			const propertyIndent = multilinePrefix && object.properties.length ? indent : `${objectIndent}  `;
+			const entries = [...additions.values()].map((property) => printAddedProperty(property, propertyIndent, newline));
+			const suffix = multiline && !multilinePrefix ? `${newline}${object.properties.length ? propertyIndent : objectIndent}` : "";
+			this.edit(start, multiline && !multilinePrefix && /^\s*$/.test(prefix) ? first : start, multiline ? `${newline}${propertyIndent}${entries.join(`,${newline}${propertyIndent}`)}${object.properties.length ? "," : ""}${suffix}` : ` ${entries.join(", ")}${object.properties.length ? "," : ""} `);
+		}
+		const edits = this.edits.toSorted((a, b) => b.start - a.start || b.end - a.end);
+		let result = this.source;
+		let previousStart = this.source.length + 1;
+		for (const edit of edits) {
+			if (edit.end > previousStart) {
+				this.report(void 0, "overlapping-edits", "Review the overlapping Vitest transformations; this file was not changed.");
+				return {
+					content: this.source,
+					findings: this.findings
+				};
+			}
+			result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+			previousStart = edit.start;
+		}
+		if (result !== this.source) try {
+			parseSource(this.file, result);
+		} catch {
+			this.report(void 0, "unsafe-syntax", "The proposed transform did not parse. Review this file manually; it was not changed.");
+			return {
+				content: this.source,
+				findings: this.findings
+			};
+		}
+		return {
+			content: result,
+			findings: this.findings
+		};
+	}
+};
+//#endregion
+//#region src/migration/vitest-v5/benchmark-config.ts
+const REPORTERS = /* @__PURE__ */ new Set([
+	"default",
+	"verbose",
+	"dot",
+	"json",
+	"junit",
+	"tap",
+	"tap-flat",
+	"hanging-process",
+	"github-actions"
+]);
+function reporterNames(node) {
+	const entries = node.type === "ArrayExpression" ? node.elements : [node];
+	return entries.every(isString) ? entries.map((entry) => entry.value) : void 0;
+}
+/** Move only resolved built-in output settings. The normal config pass reports
+* any retained legacy options as blockers; no partial output plan is applied. */
+function migrateBenchmarkConfig(editor, test) {
+	const benchmark = objectProperty(test, "benchmark")?.value;
+	if (!staticObject(benchmark)) return;
+	const oldReporters = objectProperty(benchmark, "reporters");
+	const oldOutput = objectProperty(benchmark, "outputFile");
+	const oldJson = objectProperty(benchmark, "outputJson");
+	if (!oldReporters && !oldOutput && !oldJson) return;
+	const benchmarkNames = oldReporters ? reporterNames(oldReporters.value) : ["default"];
+	if (!benchmarkNames?.length || benchmarkNames.some((name) => !["default", "verbose"].includes(name))) return;
+	let destination;
+	for (const prop of [oldOutput, oldJson]) {
+		if (!prop) continue;
+		if (!isString(prop.value) || !prop.value.value || destination !== void 0 && destination !== prop.value.value) return;
+		destination = prop.value.value;
+	}
+	const reporters = objectProperty(test, "reporters");
+	const names = reporters ? reporterNames(reporters.value) : benchmarkNames;
+	if (!names || names.some((name) => !REPORTERS.has(name))) return;
+	const terminal = names.filter((name) => [
+		"default",
+		"verbose",
+		"dot"
+	].includes(name));
+	if (reporters && oldReporters && terminal.some((name) => !benchmarkNames.includes(name))) return;
+	const output = objectProperty(test, "outputFile");
+	const jsonOutput = output && (staticObject(output.value) ? objectProperty(output.value, "json")?.value : output.value);
+	if (destination) {
+		if (jsonOutput && (!isString(jsonOutput) || jsonOutput.value !== destination) || output && !isString(output.value) && !staticObject(output.value)) return;
+	}
+	const combined = [.../* @__PURE__ */ new Set([
+		...names,
+		...terminal.length && !oldReporters ? [] : benchmarkNames,
+		...destination ? ["json"] : []
+	])];
+	if (reporters) {
+		if (combined.join("\0") !== names.join("\0")) {
+			if (editor.comments.some(({ start, end }) => start >= reporters.value.start && end <= reporters.value.end)) return;
+			editor.replace(reporters.value, JSON.stringify(combined));
+		}
+	} else editor.add(test, "reporters", JSON.stringify(combined));
+	if (destination && !jsonOutput) {
+		if (output && staticObject(output.value)) editor.add(output.value, "json", JSON.stringify(destination));
+		else editor.add(test, "outputFile", `{ json: ${JSON.stringify(destination)} }`);
+	}
+	for (const prop of [
+		oldReporters,
+		oldOutput,
+		oldJson
+	]) if (prop) editor.remove(benchmark, prop);
+}
+//#endregion
+//#region src/migration/vitest-v5/compatibility.ts
+const settings = {
+	clearMocks: {
+		value: "false",
+		reason: "preserve mock call history.",
+		adoption: "Remove after tests no longer rely on calls from setup or earlier tests.",
+		section: "clearmocks-is-enabled-by-default"
+	},
+	sharedViteServer: {
+		value: "false",
+		reason: "keep separate Vite servers for inline projects.",
+		adoption: "Remove when plugins and config hooks can run once for shared projects.",
+		section: "inline-projects-share-the-vite-server-by-default"
+	},
+	extends: {
+		value: "false",
+		reason: "keep this inline project independent of the root config.",
+		adoption: "Remove to inherit root options, including plugins and setup files.",
+		section: "inline-projects-inherit-the-root-config-by-default"
+	},
+	exact: {
+		value: "false",
+		reason: "keep partial, case-insensitive locator matching.",
+		adoption: "Remove after updating locators for full, case-sensitive matches.",
+		section: "locators-are-strict-by-default"
+	},
+	perFile: {
+		value: "true",
+		reason: "enforce this coverage threshold per file.",
+		adoption: "Keep for per-file enforcement; remove to check matching files as a group.",
+		section: "glob-coverage-thresholds-no-longer-inherit-perfile"
+	},
+	toNotFake: {
+		value: "['Temporal']",
+		reason: "exclude the global Temporal polyfill from fake timers.",
+		adoption: "Remove only the Temporal entry when it should follow mocked time.",
+		section: "fake-timers-and-setsystemtime-now-mock-temporal"
+	}
+};
+/** Only attach this guidance to newly inserted v4 compatibility properties. */
+function compatibilityProperty(key) {
+	const { value, reason, adoption, section } = settings[key];
+	return {
+		key,
+		value,
+		comment: `// Vitest v4 compatibility: ${reason}\n// ${adoption}\n// ${documentationUrl$1("/guide/vitest-v5#remove-unneeded-compatibility-settings")}\n// https://vitest.dev/guide/migration/#${section}`
+	};
+}
+//#endregion
+//#region src/migration/vitest-v5/config-object.ts
+const CONFIG_KEYS = /* @__PURE__ */ new Set([
+	"root",
+	"test",
+	"extends"
+]);
+function unrelatedSpread(node) {
+	if (node.type === "ConditionalExpression") return unrelatedSpread(node.consequent) && unrelatedSpread(node.alternate);
+	return node.type === "ObjectExpression" && node.properties.every((property) => property.type === "SpreadElement" ? unrelatedSpread(property.argument) : !property.computed && !CONFIG_KEYS.has(propertyName(property.key) ?? "test"));
+}
+/** Read a config without evaluating user code. Only a single unconditional
+* return is supported; nested callback returns and conditional exits are not
+* alternative configs. Return the original object so edits keep its spans. */
+function resolveConfigObject(editor, node) {
+	if (node?.type === "Identifier") {
+		const binding = editor.binding(node);
+		if (binding?.references.some((reference) => {
+			const parent = editor.parent(reference);
+			return !(parent?.type === "ExportDefaultDeclaration" || parent?.type === "AssignmentExpression" && parent.right === reference && isModuleExports(editor, parent.left) || parent?.type === "CallExpression" && parent.arguments[0] === reference && ["defineConfig", "defineProject"].includes(importedName(editor, parent.callee, CONFIG_SOURCES) ?? ""));
+		})) return;
+		node = binding?.constant && binding.declaration.type === "VariableDeclarator" ? binding.declaration.init : void 0;
+	}
+	if (node?.type === "CallExpression") node = ["defineConfig", "defineProject"].includes(importedName(editor, node.callee, CONFIG_SOURCES) ?? "") ? node.arguments[0] : void 0;
+	if (node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "FunctionDeclaration") {
+		if (node.generator) return;
+		const body = node.body;
+		if (!body) return;
+		if (body.type === "BlockStatement") {
+			const last = body.body.at(-1);
+			if (last?.type !== "ReturnStatement" || !body.body.slice(0, -1).every((statement) => statement.type === "VariableDeclaration")) return;
+			node = last.argument;
+		} else node = body;
+	}
+	if (node?.type !== "ObjectExpression") return;
+	const names = /* @__PURE__ */ new Set();
+	for (const property of node.properties) {
+		if (property.type === "SpreadElement") {
+			if (!unrelatedSpread(property.argument)) return;
+			continue;
+		}
+		const name = propertyName(property.key);
+		if (property.computed || property.kind !== "init" || name === void 0 || names.has(name)) return;
+		names.add(name);
+	}
+	return node;
+}
+//#endregion
+//#region src/migration/vitest-v5/config.ts
+function isTrue(node) {
+	return isBoolean(node) && node.value;
+}
+const CONFIG_FILENAME = /(?:^|[/\\])(?:vite|vitest)(?:\.[\w-]+)?\.config\.[cm]?[jt]s$/;
+const CONFIG_HELPER_IMPORT = /['"](?:vite|vitest\/config|vite-plus(?:\/test\/config)?)['"]/;
+function hasTestConfigHelper(file, source) {
+	if (!CONFIG_HELPER_IMPORT.test(source)) return false;
+	try {
+		const editor = new SourceEditor(file, source);
+		if (editor.ast.body.some((node) => node.type === "ImportDeclaration" && node.importKind !== "type" && ["vitest/config", "vite-plus/test/config"].includes(node.source.value) && node.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier" || specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && [
+			"defineConfig",
+			"defineProject",
+			"mergeConfig"
+		].includes(propertyName(specifier.imported) ?? "")))) return true;
+		let hasTestOptions = false;
+		editor.visit({ CallExpression(node) {
+			if ([
+				"defineConfig",
+				"defineProject",
+				"mergeConfig"
+			].includes(importedName(editor, node.callee, CONFIG_SOURCES) ?? "") && node.arguments.some((argument) => argument.type === "ObjectExpression" && !!objectProperty(argument, "test"))) hasTestOptions = true;
+		} });
+		return hasTestOptions;
+	} catch {
+		return true;
+	}
+}
+/** Include literal referenced configs even when they use a custom filename and
+* export a raw object. Candidate files come from the owning package's scan. */
+function findVitestV5ConfigFiles(sources, entries = []) {
+	const files = new Set([...sources].filter(([file, source]) => /\.[cm]?[jt]sx?$/.test(file) && (CONFIG_FILENAME.test(file) || hasTestConfigHelper(file, source))).map(([file]) => file));
+	for (const file of entries) if (sources.has(file)) files.add(file);
+	for (const file of files) try {
+		const editor = new SourceEditor(file, sources.get(file));
+		function addReference(reference) {
+			if (reference.startsWith("!")) return;
+			const directory = path.dirname(file);
+			const target = path.resolve(directory, reference);
+			if (sources.has(target) && /\.[cm]?[jt]sx?$/.test(target)) {
+				files.add(target);
+				return;
+			}
+			const pattern = reference.replaceAll("\\", "/").replace(/^\.\//, "");
+			for (const candidate of sources.keys()) {
+				const relative = path.relative(directory, candidate).replaceAll("\\", "/");
+				if (/\.[cm]?[jt]sx?$/.test(candidate) && (minimatch(relative, pattern, { dot: true }) || CONFIG_FILENAME.test(candidate) && minimatch(path.posix.dirname(relative), pattern, { dot: true }))) files.add(candidate);
+			}
+		}
+		const collectReferences = (config) => {
+			const object = resolveConfigObject(editor, config);
+			if (!object) return;
+			config = object;
+			const base = objectProperty(config, "extends")?.value;
+			if (isString(base)) addReference(base.value);
+			const test = objectProperty(config, "test")?.value;
+			const projects = test?.type === "ObjectExpression" ? objectProperty(test, "projects")?.value : void 0;
+			if (projects?.type !== "ArrayExpression") return;
+			for (const project of projectElements(projects)) if (isString(project)) addReference(project.value);
+			else collectReferences(project ?? void 0);
+		};
+		editor.visit({
+			ExportDefaultDeclaration(node) {
+				const declaration = node.declaration;
+				if (declaration.type === "Identifier") {
+					const binding = editor.binding(declaration);
+					if (binding?.constant && binding.declaration.type === "VariableDeclarator") collectReferences(binding.declaration.init ?? void 0);
+				} else collectReferences(declaration);
+			},
+			CallExpression(node) {
+				if ([
+					"defineConfig",
+					"defineProject",
+					"mergeConfig"
+				].includes(importedName(editor, node.callee, CONFIG_SOURCES) ?? "")) for (const argument of node.arguments) collectReferences(argument);
+			},
+			AssignmentExpression(node) {
+				if (isModuleExports(editor, node.left)) collectReferences(node.right);
+			}
+		});
+	} catch {}
+	return files;
+}
+function hasConfigMerge(editor) {
+	let found = false;
+	editor.visit({ CallExpression(node) {
+		if (importedName(editor, node.callee, CONFIG_SOURCES) === "mergeConfig") found = true;
+	} });
+	return found;
+}
+/** Defaults on one merge fragment can override explicit settings in another.
+* Include local imported configs so the preflight and finalization agree. */
+function findVitestV5MergedConfigFiles(sources, configFiles) {
+	const merged = /* @__PURE__ */ new Set();
+	const imports = /* @__PURE__ */ new Map();
+	const extensions = [
+		".ts",
+		".mts",
+		".cts",
+		".js",
+		".mjs",
+		".cjs",
+		".tsx",
+		".jsx"
+	];
+	for (const file of configFiles) try {
+		const editor = new SourceEditor(file, sources.get(file));
+		if (hasConfigMerge(editor)) merged.add(file);
+		const dependencies = [];
+		for (const node of editor.ast.body) {
+			if (node.type !== "ImportDeclaration" && node.type !== "ExportNamedDeclaration" && node.type !== "ExportAllDeclaration") continue;
+			const reference = node.source?.value;
+			if (!reference?.startsWith(".")) continue;
+			const target = path.resolve(path.dirname(file), reference);
+			const dependency = [
+				target,
+				target.replace(/\.([cm]?)js$/, ".$1ts"),
+				...extensions.map((extension) => `${target}${extension}`),
+				...extensions.map((extension) => path.join(target, `index${extension}`))
+			].find((candidate) => configFiles.has(candidate));
+			if (dependency) dependencies.push(dependency);
+		}
+		imports.set(file, dependencies);
+	} catch {}
+	for (const file of merged) for (const dependency of imports.get(file) ?? []) merged.add(dependency);
+	return merged;
+}
+function migrateVitestV5Config(file, source, options, mergedConfig = false) {
+	const output = migrateConfig(file, source, options, mergedConfig, true);
+	const result = migrateConfig(file, output.content, options, mergedConfig);
+	return {
+		content: result.content,
+		findings: [...output.findings.filter(({ code }) => ["overlapping-edits", "unsafe-syntax"].includes(code)), ...result.findings]
+	};
+}
+function migrateConfig(file, source, options, mergedConfig, benchmarkOnly = false) {
+	const editor = new SourceEditor(file, source);
+	const visited = /* @__PURE__ */ new Set();
+	const merged = mergedConfig || hasConfigMerge(editor);
+	const preserveDefaults = options.preserveV4 && !merged && !benchmarkOnly;
+	const reviewV4 = options.preserveV4 || options.reviewV4;
+	if (merged && reviewV4) editor.report(void 0, "merged-config-defaults", "Review the effective merged config before adding v4 defaults for clearMocks, browser locators, fake timers, and projects. Defaults were not added to config fragments because they can override explicit settings in another fragment.");
+	function nested(object, key, additions, apply) {
+		const prop = objectProperty(object, key);
+		if (!prop) editor.add(object, key, typeof additions === "string" ? `{ ${additions} }` : additions);
+		else if (staticObject(prop.value)) apply(prop.value);
+		else editor.report(prop, "dynamic-config", `Resolve ${key} before applying Vitest v5 compatibility options.`);
+	}
+	function addCompatibility(object, key) {
+		const property = compatibilityProperty(key);
+		editor.add(object, key, property.value, property.comment);
+	}
+	function testOptions(test, inherits, parentTest) {
+		if (benchmarkOnly) {
+			if (!parentTest && !merged) migrateBenchmarkConfig(editor, test);
+			return;
+		}
+		if (preserveDefaults && !inherits) addCompatibility(test, "clearMocks");
+		const namePattern = objectProperty(test, "testNamePattern");
+		if (reviewV4 && namePattern && !(isString(namePattern.value) && /^[\w-]+$/.test(namePattern.value.value))) editor.report(namePattern, "test-name-pattern", "Review test-name patterns across suite boundaries; full names now use > separators.");
+		const browser = objectProperty(test, "browser");
+		if (browser && staticObject(browser.value)) {
+			const value = browser.value;
+			const inheritsBrowser = inherits && parentTest && objectProperty(parentTest, "browser");
+			if (preserveDefaults && !inheritsBrowser) nested(value, "locators", [compatibilityProperty("exact")], (locators) => addCompatibility(locators, "exact"));
+			const api = objectProperty(value, "api");
+			if (api) {
+				const target = objectProperty(test, "api");
+				if (target && !sameStaticValue(target.value, api.value)) editor.report(api, "api-conflict", "Resolve conflicting test.api and test.browser.api values before upgrading.", "block");
+				else {
+					editor.add(test, "api", editor.text(api.value));
+					editor.remove(value, api);
+				}
+			}
+			const screenshot = objectProperty(value, "screenshotDirectory");
+			if (options.preserveV4 && screenshot) {
+				const setting = `screenshotDirectory: ${editor.text(screenshot.value)}`;
+				nested(value, "expect", `toMatchScreenshot: { ${setting} }`, (expect) => {
+					nested(expect, "toMatchScreenshot", setting, (match) => editor.add(match, "screenshotDirectory", editor.text(screenshot.value)));
+				});
+			}
+			if (objectProperty(value, "commands")) editor.report(browser, "locator-commands", "Review browser command parameters: locators are SerializedLocator objects, not selector strings.");
+		} else if (browser && reviewV4) editor.report(browser, "dynamic-project", "Review dynamic browser options and preserve locators.exact: false when migrating v4.");
+		if (preserveDefaults && options.temporalPolyfill) nested(test, "fakeTimers", [compatibilityProperty("toNotFake")], (timers) => addCompatibility(timers, "toNotFake"));
+		const coverage = objectProperty(test, "coverage");
+		if (coverage && staticObject(coverage.value)) {
+			for (const key of ["include", "exclude"]) {
+				const pattern = objectProperty(coverage.value, key);
+				if (pattern && reviewV4) editor.report(pattern, "coverage-patterns", `Compare v4/v5 resolved coverage.${key} file sets; v5 matches relative paths more precisely.`);
+			}
+			const thresholds = objectProperty(coverage.value, "thresholds");
+			if (preserveDefaults && thresholds && staticObject(thresholds.value) && isTrue(objectProperty(thresholds.value, "perFile")?.value)) for (const threshold of thresholds.value.properties) {
+				if (threshold.type !== "Property" || [
+					"perFile",
+					"lines",
+					"branches",
+					"functions",
+					"statements",
+					"autoUpdate",
+					"100"
+				].includes(propertyName(threshold.key) ?? "")) continue;
+				if (staticObject(threshold.value)) addCompatibility(threshold.value, "perFile");
+				else editor.report(threshold, "coverage-thresholds", "Set perFile: true on this dynamic glob threshold to retain v4 enforcement.");
+			}
+		}
+		const benchmark = objectProperty(test, "benchmark");
+		if (benchmark) {
+			if (staticObject(benchmark.value)) for (const key of [
+				"reporters",
+				"outputFile",
+				"compare",
+				"outputJson"
+			]) {
+				const removed = objectProperty(benchmark.value, key);
+				if (removed) editor.report(removed, "benchmark-api", `Replace removed benchmark.${key} with regular test reporters and the bench test-context fixture.`, "block");
+			}
+			else editor.report(benchmark, "benchmark-api", "Review dynamic benchmark options for removed reporters, outputFile, compare, and outputJson settings.");
+		}
+		const projects = objectProperty(test, "projects");
+		if (!projects) return;
+		if (projects.value.type !== "ArrayExpression") {
+			if (reviewV4) editor.report(projects, "dynamic-project", "Resolve dynamic projects and review inheritance and sharedViteServer before upgrading.");
+			return;
+		}
+		if (projects.value.elements.some((item) => item && !isString(item)) && preserveDefaults) addCompatibility(test, "sharedViteServer");
+		for (const project of projectElements(projects.value)) {
+			if (!project || isString(project)) continue;
+			if (!staticObject(project)) {
+				if (reviewV4) editor.report(project, "dynamic-project", "Review this function, promise, or dynamic inline project. Set explicit inheritance and v4 compatibility options.");
+				continue;
+			}
+			const extendsValue = objectProperty(project, "extends");
+			if (preserveDefaults) addCompatibility(project, "extends");
+			config(project, isTrue(extendsValue?.value), test);
+		}
+	}
+	function config(object, inherits = false, parentTest) {
+		if (visited.has(object)) return;
+		visited.add(object);
+		const extendsValue = objectProperty(object, "extends");
+		if (extendsValue && !isBoolean(extendsValue.value) && reviewV4) {
+			editor.report(extendsValue, "project-inheritance", "Review this external or dynamic project base before adding v4 compatibility defaults. Inherited project settings were left unchanged.");
+			return;
+		}
+		const test = objectProperty(object, "test");
+		if (!test) {
+			if (preserveDefaults && !inherits) {
+				const properties = [compatibilityProperty("clearMocks")];
+				if (options.temporalPolyfill) properties.push({
+					key: "fakeTimers",
+					value: [compatibilityProperty("toNotFake")]
+				});
+				editor.add(object, "test", properties);
+			}
+		} else if (staticObject(test.value, true)) testOptions(test.value, inherits, parentTest);
+		else if (reviewV4) editor.report(test, "dynamic-config", "Review dynamic test options; v4 defaults cannot be preserved automatically.");
+	}
+	editor.visit({
+		AssignmentExpression(node) {
+			if (isModuleExports(editor, node.left)) {
+				const object = resolveConfigObject(editor, node.right);
+				if (object && node.right.type !== "CallExpression") config(object);
+				else if (node.right.type !== "CallExpression" && reviewV4) editor.report(node, "dynamic-config", "Review the effective CommonJS test config and its v4 defaults.");
+			}
+		},
+		ExportDefaultDeclaration(node) {
+			const object = resolveConfigObject(editor, node.declaration);
+			if (object && node.declaration.type !== "CallExpression") config(object);
+			else if (node.declaration.type !== "CallExpression" && reviewV4) editor.report(node, "dynamic-config", "Review the effective function or promise config and its v4 defaults.");
+		},
+		CallExpression(node) {
+			const name = importedName(editor, node.callee, CONFIG_SOURCES);
+			if (name === "defineConfig" || name === "defineProject") {
+				if (benchmarkOnly && name === "defineProject") return;
+				const parent = editor.parent(node);
+				const binding = parent?.type === "VariableDeclarator" && parent.id.type === "Identifier" ? editor.binding(parent.id) : void 0;
+				if (!(parent?.type === "ExportDefaultDeclaration" || parent?.type === "AssignmentExpression" && parent.right === node && isModuleExports(editor, parent.left) || binding?.constant && binding.references.length > 0 && binding.references.every((reference) => editor.parent(reference)?.type === "ExportDefaultDeclaration")) && !merged) {
+					if (reviewV4) editor.report(node, "dynamic-config", "Review this config fragment in its wrapper or inline project before adding v4 compatibility settings.");
+					return;
+				}
+				const object = resolveConfigObject(editor, node.arguments[0]);
+				if (object) config(object);
+				else if (reviewV4) editor.report(node.arguments[0], "dynamic-config", "Review this dynamic config; explicit v4 compatibility settings need manual insertion.");
+			}
+			if (name === "mergeConfig" && reviewV4) editor.report(node, "nested-project-merge", "Check merged root configs for test.projects; v5 permits nested projects and can recurse or duplicate them.");
+		},
+		Property(node) {
+			if (reviewV4 && [
+				"config",
+				"configResolved",
+				"configureServer",
+				"configureVitest"
+			].includes(propertyName(node.key) ?? "")) editor.report(node, "project-server-lifecycle", "Review this plugin hook for per-project config execution or Vite server state.");
+		}
+	});
+	return editor.finish();
+}
+//#endregion
+//#region src/migration/vitest-v5/documentation.ts
+const guide = documentationUrl$1("/guide/vitest-v5");
+const upstream = "https://vitest.dev/guide/migration/";
+const sections = {
+	"api-conflict": "browser-api-is-replaced-by-the-top-level-api",
+	"assertion-types": "assertion-types-expose-return-and-received-types",
+	"async-render": "render-is-async-in-vitest-browser-vue-and-vitest-browser-svelte",
+	"benchmark-api": "benchmarking-api-rewrite",
+	"browser-automock": "automocked-modules-stay-automocked-in-the-browser",
+	"browser-session": "browser-orchestrator-url-requires-a-session",
+	"class-mock": "class-mocks-keep-prototype-methods",
+	"coverage-patterns": "coverage-include-and-exclude-match-more-precisely",
+	"coverage-thresholds": "glob-coverage-thresholds-no-longer-inherit-perfile",
+	"dom-global": "dom-environment-global-assignments-now-update-the-underlying-window",
+	"global-descriptors": "populateglobal-returns-descriptors-in-originals",
+	"locator-commands": "locators-in-commands-are-serialized-as-objects",
+	"nested-hoisted-mock": "hoisted-mocking-calls-must-be-at-the-top-level",
+	"nested-project-merge": "referenced-config-files-can-define-their-own-projects",
+	"poll-timeout": "expect-poll-fails-when-it-times-out",
+	"project-inheritance": "inline-projects-inherit-the-root-config-by-default",
+	"project-server-lifecycle": "inline-projects-share-the-vite-server-by-default",
+	"removed-api": "removed-deprecated-entrypoints",
+	"resolve-config": "resolveconfig-returns-the-resolved-vite-config",
+	"sequential-api": "removed-test-sequential-describe-sequential-and-sequential-options",
+	"temporal-system-time": "fake-timers-and-setsystemtime-now-mock-temporal",
+	"test-name-pattern": "testnamepattern-matches-the-joined-full-name",
+	"text-content": "tohavetextcontent-now-performs-strict-equality",
+	"text-content-project": "tohavetextcontent-now-performs-strict-equality",
+	"ui-token": "vitest-ui-requires-an-authenticated-url",
+	"unawaited-assertion": "unawaited-asynchronous-assertions-fail-the-test",
+	"worker-id": "worker-and-concurrency-ids-are-1-based"
+};
+const localSections = {
+	"browser-provider": "community-webdriverio-provider",
+	"dynamic-config": "resolve-migration-findings",
+	"dynamic-project": "resolve-migration-findings",
+	"global-api-ownership": "resolve-migration-findings",
+	"jest-dom-types": "review-checklist",
+	"merged-config-defaults": "preserve-existing-behavior",
+	"node-runtime": "node-runtime",
+	"overlapping-edits": "resolve-migration-findings",
+	"source-parse": "resolve-migration-findings",
+	"source-version": "before-you-migrate",
+	"static-collect": "source-changes",
+	"static-list": "source-changes",
+	"unsafe-syntax": "resolve-migration-findings"
+};
+/** Give future/unknown findings a useful fallback rather than omitting help. */
+function vitestV5Documentation(code) {
+	if (sections[code]) return `${upstream}#${sections[code]}`;
+	return `${guide}#${localSections[code] ?? "resolve-migration-findings"}`;
+}
+//#endregion
+//#region src/migration/vitest-v5/lockfile.ts
 var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
+var import_dist = require_dist();
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function declaredVitest(pkg) {
+	const manifest = record$1(pkg);
+	for (const field of [
+		"dependencies",
+		"devDependencies",
+		"optionalDependencies",
+		"peerDependencies"
+	]) {
+		const spec = record$1(manifest?.[field])?.vitest;
+		if (typeof spec === "string") return spec;
+	}
+}
+/** Read a direct upstream Vitest edge without installing or changing a lockfile.
+* Unsupported protocols, ambiguous layouts and stale entries remain unknown.
+* In particular, never infer a runner from an unrelated transitive package. */
+function lockedVitestVersion(root, directory, manager, spec) {
+	const range = spec.replace(/^npm:vitest@/, "");
+	const validRange = import_semver.default.validRange(range);
+	if (!validRange && !/^[\w.-]+$/.test(range)) return;
+	function valid(version) {
+		if (typeof version !== "string" || !import_semver.default.valid(version)) return;
+		return !validRange || import_semver.default.satisfies(version, range, { includePrerelease: true }) ? version : void 0;
+	}
+	const relative = path.relative(root, directory).replaceAll("\\", "/");
+	const read = (name) => fs.readFileSync(path.join(root, name), "utf8").replace(/^\uFEFF/, "");
+	try {
+		if (manager === PackageManager.npm) {
+			const packages = record$1(JSON.parse(read(fs.existsSync(path.join(root, "npm-shrinkwrap.json")) ? "npm-shrinkwrap.json" : "package-lock.json")).packages);
+			if (!packages) return;
+			if (declaredVitest(packages[relative]) !== spec) return;
+			let owner = relative;
+			while (true) {
+				const entry = record$1(packages[path.posix.join(owner, "node_modules/vitest")]);
+				if (entry) return !entry.link && (!entry.name || entry.name === "vitest") ? valid(entry.version) : void 0;
+				if (!owner) return;
+				const parent = path.posix.dirname(owner);
+				owner = parent === "." ? "" : parent;
+			}
+		}
+		if (manager === PackageManager.yarn) {
+			const text = read("yarn.lock");
+			if (/^__metadata:/m.test(text)) {
+				const document = (0, import_dist.parseDocument)(text);
+				if (document.errors.length) return;
+				const descriptors = /* @__PURE__ */ new Set([`vitest@${spec}`, `vitest@npm:${range}`]);
+				const entries = Object.entries(record$1(document.toJS()) ?? {}).filter(([keys]) => keys.split(/,\s+/).some((key) => descriptors.has(key)));
+				if (entries.length !== 1) return;
+				const entry = record$1(entries[0][1]);
+				return typeof entry?.resolution === "string" && entry.resolution.startsWith("vitest@npm:") ? valid(entry.resolution.slice(11)) : void 0;
+			}
+			const matches = [];
+			for (const block of text.split(/\r?\n(?=[^\s#])/)) {
+				const [header] = block.split(/\r?\n/);
+				if (!header.endsWith(":")) continue;
+				const document = (0, import_dist.parseDocument)(`[${header.slice(0, -1)}]`);
+				const keys = document.errors.length ? void 0 : document.toJS();
+				if (Array.isArray(keys) && keys.includes(`vitest@${spec}`)) {
+					const version = /^  version "([^"]+)"\r?$/m.exec(block)?.[1];
+					if (!version) return;
+					matches.push(version);
+				}
+			}
+			return matches.length === 1 ? valid(matches[0]) : void 0;
+		}
+		if (manager === PackageManager.bun) {
+			const errors = [];
+			const lock = record$1(parse(read("bun.lock"), errors, { allowTrailingComma: true }));
+			if (errors.length || declaredVitest(record$1(lock?.workspaces)?.[relative]) !== spec) return;
+			const packages = record$1(lock?.packages);
+			const direct = packages?.vitest;
+			if (!Array.isArray(direct) || typeof direct[0] !== "string" || !direct[0].startsWith("vitest@")) return;
+			const directVersion = valid(direct[0].slice(7));
+			if (!directVersion) return;
+			const versions = /* @__PURE__ */ new Set();
+			for (const entry of Object.values(packages ?? {})) {
+				if (!Array.isArray(entry) || typeof entry[0] !== "string" || !entry[0].startsWith("vitest@")) continue;
+				const version = valid(entry[0].slice(7));
+				if (version) versions.add(version);
+			}
+			return versions.size === 1 ? directVersion : void 0;
+		}
+	} catch {}
+}
+//#endregion
+//#region src/migration/vitest-v5/storybook.ts
+const STORYBOOK_PLUGIN = /* @__PURE__ */ new Set(["@storybook/addon-vitest/vitest-plugin"]);
+const NODE_PATH = /* @__PURE__ */ new Set(["node:path", "path"]);
+const NODE_URL = /* @__PURE__ */ new Set(["node:url", "url"]);
+function importMeta(node) {
+	return node.type === "MetaProperty" && node.meta.name === "import" && node.property.name === "meta";
+}
+function pathFunction(editor, node) {
+	const name = importedName(editor, node, NODE_PATH);
+	if (name) return name;
+	if (node.type !== "MemberExpression" || node.object.type !== "Identifier") return;
+	const declaration = editor.binding(node.object)?.declaration;
+	const parent = declaration && editor.parent(declaration);
+	if (declaration?.type === "ImportDefaultSpecifier" && parent?.type === "ImportDeclaration" && NODE_PATH.has(parent.source.value)) return memberName(node);
+}
+/** Recognize common configDir expressions, without evaluating config code. */
+function configPath(editor, node, file, cwd, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(node)) return;
+	seen.add(node);
+	if (isString(node)) return node.value;
+	if (node.type === "Identifier") {
+		const binding = editor.binding(node);
+		if (!binding && node.name === "__dirname") return path.dirname(file);
+		if (!binding && node.name === "__filename") return file;
+		if (binding?.constant && binding.declaration.type === "VariableDeclarator" && binding.declaration.init) return configPath(editor, binding.declaration.init, file, cwd, seen);
+	}
+	if (node.type === "MemberExpression" && importMeta(node.object)) {
+		if (memberName(node) === "dirname") return path.dirname(file);
+		if (memberName(node) === "filename") return file;
+	}
+	if (node.type !== "CallExpression" || node.optional) return;
+	const first = node.arguments[0];
+	if (importedName(editor, node.callee, NODE_URL) === "fileURLToPath" && node.arguments.length === 1 && first?.type === "MemberExpression" && importMeta(first.object) && memberName(first) === "url") return file;
+	const method = pathFunction(editor, node.callee);
+	if (![
+		"join",
+		"resolve",
+		"dirname"
+	].includes(method ?? "")) return;
+	const args = node.arguments.map((arg) => configPath(editor, arg, file, cwd, new Set(seen)));
+	if (args.some((arg) => arg === void 0)) return;
+	const values = args;
+	if (method === "dirname") return values.length === 1 ? path.dirname(values[0]) : void 0;
+	return method === "resolve" ? path.resolve(cwd, ...values) : path.join(...values);
+}
+/** The addon replaces test.include with Storybook stories, not Vitest's default
+* test/spec glob. Keep this adapter static; never load addons or run presets.
+* https://storybook.js.org/docs/writing-tests/integrations/vitest-addon */
+function resolveStorybookScope(editor, object, sources, file, cwd) {
+	const plugins = objectProperty(object, "plugins")?.value;
+	if (!plugins) return;
+	const calls = [];
+	editor.visit({ CallExpression(node) {
+		if (node.start >= plugins.start && node.end <= plugins.end && importedName(editor, node.callee, STORYBOOK_PLUGIN) === "storybookTest") calls.push(node);
+	} });
+	if (!calls.length) return;
+	const unknown = (detail) => ({ reason: `Storybook test ownership is unresolved (${path.basename(file)}): ${detail}.` });
+	if (calls.length !== 1) return unknown("multiple storybookTest calls");
+	const call = calls[0];
+	let container = call;
+	while (container !== plugins) {
+		const parent = editor.parent(container);
+		if (parent?.type !== "ArrayExpression" && parent?.type !== "AwaitExpression") return unknown("conditional or wrapped storybookTest call");
+		container = parent;
+	}
+	const options = call.arguments[0];
+	if (call.optional || call.arguments.length > 1 || options && !staticObject(options)) return unknown("dynamic storybookTest options");
+	const configDir = options && objectProperty(options, "configDir")?.value;
+	const directory = configDir ? configPath(editor, configDir, file, cwd) : ".storybook";
+	if (directory === void 0) return unknown("dynamic configDir");
+	const resolvedDir = path.resolve(cwd, directory);
+	const mains = [
+		"js",
+		"jsx",
+		"ts",
+		"tsx",
+		"mjs",
+		"mts",
+		"cjs",
+		"cts"
+	].map((extension) => path.join(resolvedDir, `main.${extension}`)).filter((candidate) => sources.has(candidate));
+	const label = path.relative(cwd, resolvedDir).replaceAll("\\", "/");
+	if (mains.length !== 1) return unknown(`expected one readable main config in ${label}`);
+	if ([
+		"js",
+		"ts",
+		"mjs",
+		"cjs"
+	].some((extension) => sources.has(path.join(resolvedDir, `presets.${extension}`)))) return unknown(`custom presets in ${label}`);
+	const mainFile = mains[0];
+	try {
+		const mainEditor = new SourceEditor(mainFile, sources.get(mainFile));
+		const main = resolveConfigObject(mainEditor, mainEditor.ast.body.find((node) => node.type === "ExportDefaultDeclaration")?.declaration);
+		if (!main || main.properties.some((property) => property.type === "SpreadElement")) return unknown(`dynamic main config in ${label}`);
+		if ([
+			"presets",
+			"viteFinal",
+			"experimental_indexers"
+		].some((key) => objectProperty(main, key))) return unknown(`custom discovery hooks in ${label}/main`);
+		const stories = objectProperty(main, "stories")?.value;
+		if (stories?.type !== "ArrayExpression") return unknown(`dynamic stories in ${label}/main`);
+		const include = [];
+		for (const story of stories.elements) {
+			let pattern;
+			if (isString(story)) pattern = story.value;
+			else if (staticObject(story)) {
+				const directory = objectProperty(story, "directory")?.value;
+				const files = objectProperty(story, "files")?.value;
+				if (!isString(directory) || !isString(files)) return unknown(`dynamic story directory/files in ${label}/main`);
+				pattern = path.join(directory.value, files.value);
+			} else return unknown(`dynamic stories in ${label}/main`);
+			if (pattern.startsWith("!")) return unknown(`negated story pattern in ${label}/main`);
+			const target = path.resolve(resolvedDir, pattern);
+			if (!/[?*{[(]/.test(pattern) && !sources.has(target)) return unknown(`unresolved story file or directory in ${label}/main`);
+			include.push(target.replaceAll("\\", "/"));
+		}
+		return {
+			root: path.resolve(resolvedDir, ".."),
+			include
+		};
+	} catch {
+		return unknown(`cannot parse ${label}/main`);
+	}
+}
+//#endregion
+//#region src/migration/vitest-v5/scopes.ts
+const DEFAULT_TEST_INCLUDE = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
+const DEFAULT_TEST_EXCLUDE = ["**/node_modules/**", "**/.git/**"];
+const DEFAULT_BENCHMARK_INCLUDE = ["**/*.{bench,benchmark}.?(c|m)[jt]s?(x)"];
+const DEFAULT_BENCHMARK_EXCLUDE = ["**/node_modules/**", "**/.git/**"];
+const TEST_CONFIG_SOURCES = /* @__PURE__ */ new Set([
+	"vitest/config",
+	"vite-plus/test/config",
+	"vite-plus"
+]);
+const SCOPE_KEYS = [
+	"root",
+	"dir",
+	"include",
+	"exclude",
+	"includeSource",
+	"setupFiles",
+	"globals",
+	"browser",
+	"benchmark",
+	"projects",
+	"name"
+];
+const CONFIG_NAMES = ["vitest.config", "vite.config"].flatMap((name) => [
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs"
+].map((extension) => name + extension));
+function defaultConfig(sources, root) {
+	return CONFIG_NAMES.map((name) => path.join(root, name)).find((file) => sources.has(file));
+}
+/** Candidate config files are not all active projects. Select each package's
+* default config or literal script selections before following project edges. */
+function findVitestV5ConfigEntries(sources, directories) {
+	const entries = [];
+	for (const root of directories) {
+		const manifest = JSON.parse((sources.get(path.join(root, "package.json")) ?? "{}").replace(/^\uFEFF/, ""));
+		const commands = Object.values(manifest.scripts ?? {}).filter((command) => typeof command === "string" && /\bvitest\b|\bvp\s+test\b/.test(command));
+		if (!commands.length) {
+			entries.push({
+				root,
+				file: defaultConfig(sources, root),
+				implicit: true
+			});
+			continue;
+		}
+		for (const command of commands) {
+			const invocations = literalTestCommands(command)?.filter((argv) => vitestCommandArgsStart(argv) >= 0);
+			if (!invocations?.length) {
+				entries.push({
+					root,
+					uncertain: true
+				});
+				continue;
+			}
+			for (const argv of invocations) {
+				const start = vitestCommandArgsStart(argv);
+				let config;
+				let rootOverride;
+				let dirOverride;
+				let uncertain = false;
+				let browserOverride = false;
+				const projects = [];
+				for (let index = start; index < argv.length && argv[index] !== "--"; index++) {
+					const arg = argv[index];
+					const option = arg.split("=")[0];
+					browserOverride ||= /^--(?:no-)?browser(?:[.=]|$)/.test(arg);
+					if ([
+						"--config",
+						"-c",
+						"--root",
+						"-r",
+						"--dir",
+						"--project",
+						"-p"
+					].includes(option)) {
+						const value = arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : argv[++index];
+						if (!value || value.startsWith("-")) uncertain = true;
+						else if (option === "--project" || option === "-p") projects.push(value);
+						else if (option === "--config" || option === "-c") config = value;
+						else if (option === "--dir") dirOverride = path.resolve(root, value);
+						else rootOverride = path.resolve(root, value);
+					} else if (/^--(?:no-)?(?:globals|include|includeSource|exclude|workspace|setupFiles|benchmark\.(?:include|exclude|includeSource))(?:[.=]|$)/.test(arg)) uncertain = true;
+				}
+				const configRoot = rootOverride ?? root;
+				const file = config ? path.resolve(configRoot, config) : defaultConfig(sources, configRoot);
+				entries.push({
+					root,
+					file,
+					rootOverride,
+					dirOverride,
+					projects,
+					browserOverride,
+					uncertain: uncertain || !!config && !sources.has(file)
+				});
+			}
+		}
+	}
+	return entries;
+}
+function staticPatterns(node, editor) {
+	if (node?.type === "MemberExpression" && importedName(editor, node.object, TEST_CONFIG_SOURCES) === "configDefaults") {
+		if (memberName(node) === "include") return DEFAULT_TEST_INCLUDE;
+		if (memberName(node) === "exclude") return DEFAULT_TEST_EXCLUDE;
+	}
+	if (node?.type !== "ArrayExpression") return;
+	const patterns = [];
+	for (const entry of node.elements) if (isString(entry)) patterns.push(entry.value);
+	else if (entry?.type === "SpreadElement") {
+		const values = staticPatterns(entry.argument, editor);
+		if (!values) return;
+		patterns.push(...values);
+	} else return;
+	return patterns.some((pattern) => pattern.startsWith("!")) ? void 0 : patterns;
+}
+function booleanOption(node, fallback) {
+	if (!node) return fallback;
+	return isBoolean(node) ? node.value : void 0;
+}
+function benchmarkPatterns(node, inherited, editor) {
+	if (!inherited || node && !staticObject(node)) return;
+	const patterns = { ...inherited };
+	for (const key of [
+		"include",
+		"exclude",
+		"includeSource"
+	]) {
+		const value = node && objectProperty(node, key)?.value;
+		if (value) {
+			const resolved = staticPatterns(value, editor);
+			if (!resolved) return;
+			patterns[key] = [...inherited[key] ?? [], ...resolved];
+		}
+	}
+	return patterns;
+}
+function matches(file, root, pattern) {
+	return minimatch(path.relative(root, file).replaceAll("\\", "/"), pattern.replace(/^\.\//, ""), { dot: true });
+}
+function insideDirectory(file, directory) {
+	const relative = path.relative(directory, file);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function matchesProject(name, pattern) {
+	const expression = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+	return new RegExp(`^${expression}$`, "i").test(name);
+}
+function projectSelected(test, filters, inheritedBrowser) {
+	if (!filters.length) return true;
+	const name = test && objectProperty(test, "name")?.value;
+	if (!isString(name)) return;
+	const positives = filters.filter((pattern) => !pattern.startsWith("!"));
+	const excluded = (name) => filters.some((pattern) => pattern.startsWith("!") && matchesProject(name, pattern.slice(1)));
+	if (excluded(name.value)) return false;
+	if (!positives.length || positives.some((pattern) => matchesProject(name.value, pattern))) return true;
+	const browser = test && objectProperty(test, "browser")?.value;
+	if (!browser) return inheritedBrowser === false ? false : void 0;
+	if (!staticObject(browser)) return;
+	const enabled = objectProperty(browser, "enabled")?.value;
+	if (isBoolean(enabled) && !enabled.value) return false;
+	const instances = objectProperty(browser, "instances")?.value;
+	if (instances?.type !== "ArrayExpression") return;
+	for (const instance of instances.elements) {
+		if (!staticObject(instance)) return;
+		const explicitName = objectProperty(instance, "name")?.value;
+		const browserName = objectProperty(instance, "browser")?.value;
+		let instanceName;
+		if (isString(explicitName)) instanceName = explicitName.value;
+		else if (!explicitName && isString(browserName)) instanceName = name.value ? `${name.value} (${browserName.value})` : browserName.value;
+		if (!instanceName || !excluded(instanceName) && positives.some((pattern) => matchesProject(instanceName, pattern))) return;
+	}
+	return false;
+}
+/** Vitest resolves local setup entries through local-pkg/mlly with import
+* conditions, then falls back to the literal path. Do not guess TypeScript
+* extensions or package exports that cannot be resolved from scanned files. */
+function resolveSetupFile(sources, root, reference) {
+	const target = path.resolve(root, reference);
+	if (!/^\.\.?(?:[/\\]|$)/.test(reference) && !path.isAbsolute(reference)) {
+		const packageName = reference.split("/").slice(0, reference.startsWith("@") ? 2 : 1).join("/");
+		for (const parent of sources.keys()) {
+			if (path.basename(parent) !== "package.json" || !insideDirectory(root, path.dirname(parent))) continue;
+			const manifest = JSON.parse(sources.get(parent).replace(/^\uFEFF/, ""));
+			if ([
+				"dependencies",
+				"devDependencies",
+				"peerDependencies",
+				"optionalDependencies"
+			].some((key) => manifest[key]?.[packageName])) return;
+		}
+		return sources.has(target) ? target : void 0;
+	}
+	const extensions = [
+		".mjs",
+		".cjs",
+		".js",
+		".json"
+	];
+	return [
+		target,
+		...extensions.map((extension) => /[/\\]$/.test(reference) ? path.join(target, extension) : target + extension),
+		...extensions.map((extension) => path.join(target, "index" + extension))
+	].find((candidate) => sources.has(candidate));
+}
+/** Resolve only selected configs and their project references. Unknown config
+* or conflicting project globals requires review, not silent suppression. */
+function resolveVitestV5TestModes(sources, configFiles, preserveV4, entries) {
+	const scopes = [];
+	const findings = [];
+	const queue = [...entries];
+	const packageRoots = [...new Set(entries.map((entry) => entry.root))];
+	const visitedEntries = /* @__PURE__ */ new Set();
+	for (const entry of queue) {
+		const key = JSON.stringify(entry);
+		if (visitedEntries.has(key)) continue;
+		visitedEntries.add(key);
+		const unknown = () => scopes.push({ root: entry.root });
+		if (entry.uncertain) {
+			unknown();
+			continue;
+		}
+		if (!entry.file) continue;
+		let found = false;
+		let editor;
+		const visited = /* @__PURE__ */ new Set();
+		const walk = (object, directory = entry.root, base, inline = false) => {
+			found = true;
+			const resolved = resolveConfigObject(editor, object);
+			if (!resolved) {
+				unknown();
+				return;
+			}
+			object = resolved;
+			if (visited.has(object)) return;
+			visited.add(object);
+			const test = objectProperty(object, "test")?.value;
+			if (test && !staticObject(test, true)) {
+				unknown();
+				return;
+			}
+			const root = (test && objectProperty(test, "root")?.value) ?? objectProperty(object, "root")?.value;
+			if (root && !isString(root)) {
+				unknown();
+				return;
+			}
+			const resolvedRoot = !inline && entry.rootOverride || path.resolve(directory, isString(root) ? root.value : ".");
+			const projects = test && objectProperty(test, "projects")?.value;
+			const selected = projects ? true : projectSelected(test, entry.projects ?? [], base ? base.browser : false);
+			if (selected === false) return;
+			const storybook = resolveStorybookScope(editor, object, sources, entry.file, entry.cwd ?? entry.root) ?? base?.storybook;
+			const scopeRoot = test && objectProperty(test, "root") ? resolvedRoot : storybook?.root ?? resolvedRoot;
+			const dirValue = test && objectProperty(test, "dir")?.value;
+			let dir = base ? base.dir : "";
+			if (dirValue) dir = isString(dirValue) ? dirValue.value : void 0;
+			const effectiveDir = (!inline ? entry.dirOverride : void 0) ?? dir;
+			const include = test && objectProperty(test, "include")?.value;
+			const includeSource = test && objectProperty(test, "includeSource")?.value;
+			const exclude = test && objectProperty(test, "exclude")?.value;
+			const includePatterns = include ? staticPatterns(include, editor) : void 0;
+			const sourcePatterns = includeSource ? staticPatterns(includeSource, editor) : [];
+			const inheritedSourcePatterns = base ? base.includeSource : [];
+			const excludePatterns = exclude ? staticPatterns(exclude, editor) : void 0;
+			if (include && !includePatterns || exclude && !excludePatterns) {
+				unknown();
+				return;
+			}
+			const browser = test && objectProperty(test, "browser")?.value;
+			const enabled = staticObject(browser) ? objectProperty(browser, "enabled")?.value : void 0;
+			let browserMode = base ? base.browser : false;
+			if (browser) browserMode = staticObject(browser) ? booleanOption(enabled, browserMode) : void 0;
+			const globals = test && objectProperty(test, "globals")?.value;
+			const benchmark = test && objectProperty(test, "benchmark")?.value;
+			const setup = test && objectProperty(test, "setupFiles")?.value;
+			let setupFiles = [];
+			if (setup) setupFiles = isString(setup) ? [setup.value] : staticPatterns(setup, editor);
+			let discoveryRoot;
+			if (effectiveDir !== void 0) discoveryRoot = effectiveDir ? path.resolve(entry.cwd ?? entry.root, effectiveDir) : scopeRoot;
+			const projectName = test && objectProperty(test, "name")?.value;
+			const scope = {
+				storybook,
+				name: isString(projectName) ? projectName.value : path.basename(entry.file),
+				excludedRoots: entry.implicit && !inline && !root && path.basename(entry.file).startsWith("vite.config.") && (!test || test.properties.every((property) => property.type === "Property" && ["clearMocks", "fakeTimers"].includes(propertyName(property.key) ?? ""))) ? packageRoots.filter((root) => root !== entry.root && insideDirectory(root, entry.root)) : void 0,
+				root: scopeRoot,
+				dir,
+				discoveryRoot,
+				include: includePatterns ? [...base?.include ?? [], ...includePatterns] : base?.include,
+				includeSource: sourcePatterns && inheritedSourcePatterns ? [...inheritedSourcePatterns, ...sourcePatterns] : void 0,
+				exclude: excludePatterns ? [...base?.exclude ?? [], ...excludePatterns] : base?.exclude,
+				benchmark: benchmarkPatterns(benchmark, base ? base.benchmark : {}, editor),
+				setupFiles: setupFiles && (!base || base.setupFiles) ? [...base?.setupFiles ?? [], ...setupFiles] : void 0,
+				browser: entry.browserOverride ? void 0 : browserMode,
+				globals: selected === void 0 ? void 0 : booleanOption(globals, base ? base.globals : false)
+			};
+			const addScope = () => {
+				if (!scope.includeSource) editor.report(includeSource ?? test ?? object, "global-api-ownership", "Resolve test.includeSource patterns before migrating in-source global APIs. In-source test ownership is not statically known.");
+				if (scope.storybook?.reason) editor.report(objectProperty(object, "plugins")?.value ?? object, "global-api-ownership", scope.storybook.reason);
+				const resolvedSetup = scope.setupFiles?.map((reference) => resolveSetupFile(sources, scope.root, reference));
+				const unresolvedSetup = !resolvedSetup || resolvedSetup.some((file) => !file);
+				if (!scope.discoveryRoot) editor.report(dirValue ?? object, "global-api-ownership", "Resolve test.dir before migrating global APIs. The test discovery directory is not statically known.");
+				if (unresolvedSetup) editor.report(setup ?? object, "global-api-ownership", "Resolve setupFiles before migrating global APIs. A setup entry cannot be resolved safely from the scanned files.");
+				if (!scope.benchmark) editor.report(benchmark ?? object, "global-api-ownership", "Resolve test.benchmark file patterns before migrating global APIs. Benchmark file ownership is not statically known.");
+				scopes.push({
+					...scope,
+					setupFiles: resolvedSetup?.filter((file) => !!file),
+					unresolvedSetup
+				});
+			};
+			if (!projects) {
+				addScope();
+				return;
+			}
+			if (projects.type !== "ArrayExpression") {
+				unknown();
+				return;
+			}
+			const elements = projectElements(projects);
+			const excluded = elements.filter(isString).map((node) => node.value).filter((value) => value.startsWith("!")).map((value) => value.slice(1));
+			for (const project of elements) {
+				if (isString(project)) {
+					if (project.value.startsWith("!")) continue;
+					const reference = project.value.replaceAll("\\", "/").replace("<rootDir>", scope.root);
+					const target = path.resolve(scope.root, reference);
+					const candidates = /* @__PURE__ */ new Set();
+					if (sources.has(target)) candidates.add(target);
+					const directoryConfig = defaultConfig(sources, target);
+					if (directoryConfig) candidates.add(directoryConfig);
+					for (const file of configFiles) if (matches(file, scope.root, reference) || matches(path.dirname(file), scope.root, reference) && defaultConfig(sources, path.dirname(file)) === file) candidates.add(file);
+					if (!candidates.size) {
+						unknown();
+						continue;
+					}
+					for (const file of candidates) {
+						if (excluded.some((pattern) => matches(file, scope.root, pattern) || matches(path.dirname(file), scope.root, pattern))) continue;
+						if (file === entry.file) addScope();
+						else queue.push({
+							file,
+							root: path.dirname(file),
+							cwd: entry.cwd ?? entry.root,
+							projects: entry.projects,
+							browserOverride: entry.browserOverride
+						});
+					}
+					continue;
+				}
+				if (!staticObject(project)) {
+					unknown();
+					continue;
+				}
+				const extendsValue = objectProperty(project, "extends")?.value;
+				if (extendsValue && !isBoolean(extendsValue)) {
+					const baseFile = isString(extendsValue) && path.resolve(scope.root, extendsValue.value);
+					const baseSource = baseFile && sources.get(baseFile);
+					if (baseSource) {
+						const baseEditor = new SourceEditor(baseFile, baseSource);
+						const baseObject = resolveConfigObject(baseEditor, baseEditor.ast.body.find((node) => node.type === "ExportDefaultDeclaration")?.declaration);
+						if (baseObject) {
+							const baseTest = objectProperty(baseObject, "test")?.value;
+							if (!baseTest || staticObject(baseTest, true) && !SCOPE_KEYS.some((key) => objectProperty(baseTest, key))) {
+								walk(project, scope.root, void 0, true);
+								continue;
+							}
+						}
+					}
+					unknown();
+					continue;
+				}
+				const inherits = isBoolean(extendsValue) ? extendsValue.value : !preserveV4;
+				walk(project, scope.root, inherits ? scope : void 0, true);
+			}
+		};
+		try {
+			editor = new SourceEditor(entry.file, sources.get(entry.file));
+			editor.visit({
+				ExportDefaultDeclaration(node) {
+					walk(node.declaration);
+				},
+				AssignmentExpression(node) {
+					if (isModuleExports(editor, node.left)) walk(node.right);
+				}
+			});
+			findings.push(...editor.findings);
+		} catch {
+			unknown();
+		}
+		if (!found) unknown();
+	}
+	return {
+		modes: new Map([...sources.keys()].map((file) => {
+			const matching = [];
+			let benchmarkFile = false;
+			const hasInSourceTests = sources.get(file)?.includes("import.meta.vitest");
+			for (const scope of scopes) {
+				if (scope.excludedRoots?.some((root) => insideDirectory(file, root))) continue;
+				const setup = scope.setupFiles?.includes(file);
+				const inside = insideDirectory(file, scope.root);
+				const discoveryRoot = scope.discoveryRoot;
+				const sourceCandidate = hasInSourceTests && discoveryRoot && insideDirectory(file, discoveryRoot) && !(scope.exclude ?? DEFAULT_TEST_EXCLUDE).some((pattern) => matches(file, discoveryRoot, pattern));
+				const inSource = sourceCandidate && scope.includeSource?.some((pattern) => matches(file, discoveryRoot, pattern));
+				const test = scope.storybook ? discoveryRoot && scope.storybook.include?.some((pattern) => minimatch(file.replaceAll("\\", "/"), pattern, { dot: true })) && !(scope.exclude ?? DEFAULT_TEST_EXCLUDE).some((pattern) => matches(file, discoveryRoot, pattern)) : discoveryRoot && insideDirectory(file, discoveryRoot) && (scope.include ?? DEFAULT_TEST_INCLUDE).some((pattern) => matches(file, discoveryRoot, pattern)) && !(scope.exclude ?? DEFAULT_TEST_EXCLUDE).some((pattern) => matches(file, discoveryRoot, pattern));
+				const benchmark = discoveryRoot && insideDirectory(file, discoveryRoot) && scope.benchmark && !(scope.benchmark.exclude ?? DEFAULT_BENCHMARK_EXCLUDE).some((pattern) => matches(file, discoveryRoot, pattern)) && ((scope.benchmark.include ?? DEFAULT_BENCHMARK_INCLUDE).some((pattern) => matches(file, discoveryRoot, pattern)) || scope.benchmark.includeSource?.some((pattern) => matches(file, discoveryRoot, pattern)) && hasInSourceTests);
+				benchmarkFile ||= !!benchmark;
+				if (setup || test || inSource || benchmark) matching.push({
+					scope,
+					certain: true
+				});
+				else if ((!discoveryRoot || !scope.setupFiles || scope.unresolvedSetup || scope.storybook?.reason) && inside || !scope.benchmark && discoveryRoot && insideDirectory(file, discoveryRoot) || sourceCandidate && !scope.includeSource) matching.push({
+					scope,
+					certain: false
+				});
+			}
+			const browserModes = new Set(matching.map(({ scope, certain }) => certain ? scope.browser : void 0));
+			const globals = matching.length > 0 && matching.every(({ scope, certain }) => certain && scope.globals === true);
+			const ownershipReason = matching.some(({ scope }) => scope.storybook) ? matching.find(({ scope }) => scope.storybook?.reason)?.scope.storybook?.reason ?? (browserModes.size > 1 ? `Conflicting Node/browser projects: ${[...new Set(matching.map(({ scope }) => scope.name))].join(", ")}.` : void 0) : void 0;
+			return [file, {
+				benchmark: benchmarkFile,
+				browser: browserModes.size === 1 ? browserModes.values().next().value : void 0,
+				...ownershipReason ? { ownershipReason } : {},
+				globals,
+				reviewGlobals: !globals && matching.some(({ scope, certain }) => !certain || scope.globals !== false)
+			}];
+		})),
+		findings
+	};
+}
+//#endregion
+//#region src/migration/vitest-v5/benchmarks.ts
+/** Keep the workload as a separate callback: making it the test callback
+* would measure nothing, and inlining it into a new closure can change scope. */
+function migrateBenchmarks(editor, globals = false) {
+	const imports = /* @__PURE__ */ new Set();
+	const bindings = /* @__PURE__ */ new Set();
+	const calls = /* @__PURE__ */ new Set();
+	const benchIdentifiers = [];
+	let fixtureAlias;
+	let shadowedGlobalThis = false;
+	editor.visit({ Identifier(node) {
+		if (node.name === "bench") benchIdentifiers.push(node);
+		if (node.name === "globalThis" && editor.binding(node)) shadowedGlobalThis = true;
+	} });
+	function workload(node, seen = /* @__PURE__ */ new Set()) {
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration") return !!node.body && node.params.length === 0 && !node.generator;
+		if (node.type !== "Identifier" || seen.has(node)) return false;
+		seen.add(node);
+		const binding = editor.binding(node);
+		if (!binding?.constant) return false;
+		const declaration = binding.declaration;
+		if (declaration.type === "FunctionDeclaration") return workload(declaration, seen);
+		return declaration.type === "VariableDeclarator" && !!declaration.init && workload(declaration.init, seen);
+	}
+	function directCall(reference) {
+		let callee = reference;
+		let modifier;
+		const member = editor.parent(reference);
+		if (member?.type === "MemberExpression" && member.object === reference) {
+			modifier = memberName(member);
+			if (member.optional || !modifier || ![
+				"skip",
+				"only",
+				"todo"
+			].includes(modifier)) return;
+			callee = member;
+		}
+		const call = editor.parent(callee);
+		if (call?.type !== "CallExpression" || call.callee !== callee || call.optional || call.typeArguments || editor.parent(call)?.type !== "ExpressionStatement" || !call.arguments[0] || call.arguments[0].type === "SpreadElement") return;
+		const callback = call.arguments[1];
+		if (!(modifier === "todo" && call.arguments.length === 1)) {
+			if (call.arguments.length !== 2 || !callback || !workload(callback)) return;
+		}
+		let fn = editor.functionParent(call);
+		while (fn) {
+			const registration = editor.parent(fn);
+			if (fn.async || fn.generator || registration?.type !== "CallExpression" || registration.optional || !registration.arguments.includes(fn)) return;
+			let suite = registration.callee;
+			if (!["describe", "suite"].includes(testApiName(editor, suite, globals) ?? "")) {
+				if (suite.type !== "MemberExpression" || suite.optional || !["skip", "only"].includes(memberName(suite) ?? "")) return;
+				suite = suite.object;
+			}
+			if (!["describe", "suite"].includes(testApiName(editor, suite, globals) ?? "")) return;
+			fn = editor.functionParent(registration);
+		}
+		return {
+			call,
+			modifier
+		};
+	}
+	function rewrite({ call, modifier }, test) {
+		calls.add(call);
+		editor.replace(call.callee, `${test}${modifier ? `.${modifier}` : ""}`);
+		const callback = call.arguments[1];
+		if (!callback) return;
+		let name = editor.text(call.arguments[0]);
+		const captures = [];
+		if (!isString(call.arguments[0])) {
+			const captured = editor.uniqueName("benchName");
+			captures.push(`const ${captured} = (${name});`);
+			editor.replace(call.arguments[0], captured);
+			name = captured;
+		}
+		if (callback.type === "Identifier") {
+			const captured = editor.uniqueName("benchFn");
+			captures.push(`const ${captured} = ${editor.text(callback)};`);
+			editor.replace(callback, captured);
+		}
+		if (captures.length) {
+			const statement = editor.parent(call);
+			editor.edit(statement.start, statement.start, `{ ${captures.join(" ")} `);
+			editor.edit(statement.end, statement.end, " }");
+		}
+		const shadowsBench = callback.type !== "Identifier" && benchIdentifiers.some((node) => node.start >= callback.start && node.end <= callback.end);
+		let fixtureName = "bench";
+		if (shadowsBench) fixtureName = fixtureAlias ??= editor.uniqueName("bench");
+		const fixture = fixtureName === "bench" ? "bench" : `bench: ${fixtureName}`;
+		editor.edit(callback.start, callback.start, `async ({ ${fixture} }) => { await ${fixtureName}(${name}, `);
+		editor.edit(callback.end, callback.end, ").run(); }");
+	}
+	function unsupportedInSource(node) {
+		editor.report(node, "benchmark-api", "Migrate this import.meta.vitest bench reference manually: automatic migration requires direct calls with locally resolved zero-argument callbacks and no benchmark options or escaped references. Keep the import.meta.vitest guard.", "block");
+	}
+	editor.visit({
+		VariableDeclarator(node) {
+			if (node.id.type !== "ObjectPattern" || !isImportMetaVitest(node.init)) return;
+			for (const property of node.id.properties) {
+				if (property.type !== "Property" || propertyName(property.key) !== "bench") continue;
+				const binding = editor.binding(property.value);
+				const registrations = binding?.references.map(directCall);
+				if (property.computed || node.id.typeAnnotation || !binding?.constant || node.id.properties.some((prop) => prop.type === "RestElement") || !registrations || registrations.some((registration) => !registration)) {
+					unsupportedInSource(property);
+					continue;
+				}
+				const test = editor.uniqueName("test", true);
+				editor.replace(property, test === "test" ? "test" : `test: ${test}`);
+				bindings.add(property);
+				for (const registration of registrations) rewrite(registration, test);
+			}
+		},
+		ImportDeclaration(node) {
+			if (!["vitest", "vite-plus/test"].includes(node.source.value) || node.importKind === "type") return;
+			for (const specifier of node.specifiers) {
+				if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || propertyName(specifier.imported) !== "bench") continue;
+				const binding = editor.binding(specifier.local);
+				if (!binding) continue;
+				const registrations = binding.references.map(directCall);
+				if (registrations.some((registration) => !registration)) continue;
+				const test = editor.uniqueName("test", true);
+				editor.replace(specifier, test === "test" ? "test" : `test as ${test}`);
+				imports.add(specifier);
+				for (const registration of registrations) rewrite(registration, test);
+			}
+		},
+		Identifier(node) {
+			if (!globals || node.name !== "bench" || editor.binding(node) || shadowedGlobalThis) return;
+			const registration = directCall(node);
+			if (registration) rewrite(registration, "globalThis.test");
+		},
+		MemberExpression(node) {
+			const inSource = isImportMetaVitest(node.object) && memberName(node) === "bench";
+			if (!inSource && testApiName(editor, node, globals) !== "bench") return;
+			const registration = !node.optional && directCall(node);
+			if (registration && (inSource || node.object.type === "Identifier")) rewrite(registration, `${editor.text(node.object)}.test`);
+			else if (inSource) unsupportedInSource(node);
+		}
+	});
+	return {
+		imports,
+		bindings,
+		calls
+	};
+}
+//#endregion
+//#region src/migration/vitest-v5/source.ts
+const RUNNER_SYMBOLS = {
+	test: "test",
+	it: "it",
+	describe: "describe",
+	suite: "suite",
+	recordArtifact: "recordArtifact",
+	TestAPI: "TestAPI",
+	SuiteAPI: "SuiteAPI",
+	SuiteCollector: "SuiteCollector",
+	TestArtifact: "TestArtifact",
+	File: "RunnerTestFile",
+	Suite: "RunnerTestSuite",
+	Test: "RunnerTestCase",
+	Task: "RunnerTask",
+	VitestRunner: "VitestTestRunner",
+	VitestRunnerConfig: "TestRunnerConfig"
+};
+const RUNNER_METHODS = {
+	getCurrentSuite: "getCurrentSuite",
+	getCurrentTest: "getCurrentTest",
+	createTaskCollector: "createTaskCollector",
+	getFn: "getTestFn",
+	getHooks: "getSuiteHooks",
+	setFn: "setTestFn",
+	setHooks: "setSuiteHooks"
+};
+const EXPECT_SYMBOLS = /* @__PURE__ */ new Set([
+	"expect",
+	"assert",
+	"should",
+	"createExpect",
+	"Assertion",
+	"AsymmetricMatchersContaining",
+	"ExpectStatic",
+	"JestAssertion",
+	"Matcher",
+	"Matchers",
+	"MatchersObject",
+	"MatcherState"
+]);
+const RUNNER_SOURCES = /* @__PURE__ */ new Set([
+	"@vitest/runner",
+	"vitest/suite",
+	"vite-plus/test/suite",
+	"vite-plus/test/plugins/runner"
+]);
+const EXPECT_SOURCES = /* @__PURE__ */ new Set(["@vitest/expect", "vite-plus/test/plugins/expect"]);
+const RUNNERS_SOURCES = /* @__PURE__ */ new Set(["vitest/runners", "vite-plus/test/runners"]);
+const REMOVED_SOURCES = /* @__PURE__ */ new Set([
+	"vitest/internal/module-runner",
+	"vite-plus/test/internal/module-runner",
+	"@vitest/runner/utils",
+	"@vitest/runner/types",
+	"vite-plus/test/plugins/runner-utils",
+	"vite-plus/test/plugins/runner-types"
+]);
+const LEGACY_API_SOURCES = /* @__PURE__ */ new Set([
+	...RUNNER_SOURCES,
+	...RUNNERS_SOURCES,
+	...EXPECT_SOURCES,
+	...REMOVED_SOURCES
+]);
+const RENDER_SOURCES = /* @__PURE__ */ new Set(["vitest-browser-vue", "vitest-browser-svelte"]);
+const REGISTRATIONS = /* @__PURE__ */ new Set([
+	"test",
+	"it",
+	"describe",
+	"suite"
+]);
+const ASYNC_CALLBACKS = /* @__PURE__ */ new Set([
+	"test",
+	"it",
+	"beforeEach",
+	"afterEach",
+	"beforeAll",
+	"afterAll"
+]);
+const DOM_GLOBALS = /* @__PURE__ */ new Set([
+	"window",
+	"document",
+	"navigator",
+	"location",
+	"matchMedia",
+	"innerWidth",
+	"innerHeight",
+	"screen",
+	"Element",
+	"HTMLElement",
+	"Node",
+	"Event",
+	"MutationObserver",
+	"ResizeObserver",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"getComputedStyle"
+]);
+const CHILD_PROCESS_SOURCES = /* @__PURE__ */ new Set(["node:child_process", "child_process"]);
+const ENVIRONMENT_SOURCES = /* @__PURE__ */ new Set([
+	"vitest/environments",
+	"vite-plus/test/environments",
+	"vitest/runtime",
+	"vite-plus/test/runtime"
+]);
+const ASSERTION_SOURCES = /* @__PURE__ */ new Set([
+	"vitest",
+	"vite-plus/test",
+	...EXPECT_SOURCES
+]);
+/** Follow immutable bindings, including Map iteration variables, back to
+* populateGlobal. A map merely named `originals` is not a Vitest API. */
+function globalRestorationOrigin(editor, node, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(node)) return;
+	seen.add(node);
+	const origin = (value) => globalRestorationOrigin(editor, value, seen);
+	if (node.type === "CallExpression") {
+		if (importedName(editor, node.callee, ENVIRONMENT_SOURCES) === "populateGlobal") return "result";
+		if (memberName(node.callee) === "get" && node.callee.type === "MemberExpression" && origin(node.callee.object) === "originals") return "value";
+	}
+	if (node.type === "MemberExpression" && memberName(node) === "originals") return origin(node.object) === "result" ? "originals" : void 0;
+	const binding = editor.binding(node);
+	if (!binding?.constant) return;
+	const declaration = binding.declaration;
+	const parent = editor.parent(declaration);
+	if (declaration.type === "VariableDeclarator" && declaration.init) return origin(declaration.init);
+	if (declaration.type === "Property" && !declaration.computed && propertyName(declaration.key) === "originals" && parent?.type === "ObjectPattern") {
+		const variable = editor.parent(parent);
+		if (variable?.type === "VariableDeclarator" && variable.init) return origin(variable.init) === "result" ? "originals" : void 0;
+	}
+	if ((declaration.type === "ArrowFunctionExpression" || declaration.type === "FunctionExpression") && declaration.params[0]?.type === "Identifier" && editor.binding(declaration.params[0]) === binding && parent?.type === "CallExpression" && parent.arguments[0] === declaration && parent.callee.type === "MemberExpression" && memberName(parent.callee) === "forEach") return origin(parent.callee.object) === "originals" ? "value" : void 0;
+	if (declaration.type === "ArrayPattern" && declaration.elements[1]?.type === "Identifier" && editor.binding(declaration.elements[1]) === binding && parent?.type === "VariableDeclarator") {
+		const variables = editor.parent(parent);
+		const loop = variables && editor.parent(variables);
+		if (loop?.type === "ForOfStatement" && loop.left === variables) {
+			const iterable = loop.right;
+			return origin(iterable.type === "CallExpression" && iterable.callee.type === "MemberExpression" && memberName(iterable.callee) === "entries" ? iterable.callee.object : iterable) === "originals" ? "value" : void 0;
+		}
+	}
+}
+function assertionTypeName(editor, node) {
+	if (node.type === "TSQualifiedName") {
+		if (node.left.type === "Identifier" && node.left.name === "jest" && node.right.name === "Matchers") return "jest.Matchers";
+		const declaration = editor.binding(node.left)?.declaration;
+		const imported = declaration && editor.parent(declaration);
+		return declaration?.type === "ImportNamespaceSpecifier" && imported?.type === "ImportDeclaration" && ASSERTION_SOURCES.has(imported.source.value) ? node.right.name : void 0;
+	}
+	if (node.type !== "Identifier") return;
+	const declaration = editor.binding(node)?.declaration;
+	const imported = declaration && editor.parent(declaration);
+	if (declaration?.type === "ImportSpecifier" && imported?.type === "ImportDeclaration") return ASSERTION_SOURCES.has(imported.source.value) ? propertyName(declaration.imported) : void 0;
+	return node.name;
+}
+function isJestMatchers(editor, node) {
+	let block = editor.parent(node);
+	if (block?.type === "ExportNamedDeclaration") block = editor.parent(block);
+	const namespace = block && editor.parent(block);
+	return node.id.name === "Matchers" && namespace?.type === "TSModuleDeclaration" && namespace.id.type === "Identifier" && namespace.id.name === "jest";
+}
+function replacementImport(source, name) {
+	if (RUNNER_SOURCES.has(source)) return RUNNER_SYMBOLS[name];
+	if (RUNNERS_SOURCES.has(source) && name === "VitestTestRunner") return "TestRunner";
+	if (EXPECT_SOURCES.has(source) && EXPECT_SYMBOLS.has(name)) return name;
+}
+function processApiName(editor, node) {
+	const imported = importedName(editor, node, CHILD_PROCESS_SOURCES);
+	if (imported) return imported;
+	let name = memberName(node);
+	let receiver = node.type === "MemberExpression" ? node.object : node;
+	let declaration = editor.binding(receiver)?.declaration;
+	const parent = declaration && editor.parent(declaration);
+	if (declaration?.type === "ImportDefaultSpecifier" && parent?.type === "ImportDeclaration" && CHILD_PROCESS_SOURCES.has(parent.source.value)) return name;
+	if (declaration?.type === "Property" && parent?.type === "ObjectPattern") {
+		name = propertyName(declaration.key);
+		declaration = editor.parent(parent);
+	}
+	if (declaration?.type === "VariableDeclarator" && declaration.init) receiver = declaration.init;
+	return receiver.type === "CallExpression" && receiver.callee.type === "Identifier" && receiver.callee.name === "require" && !editor.binding(receiver.callee) && isString(receiver.arguments[0]) && CHILD_PROCESS_SOURCES.has(receiver.arguments[0].value) ? name : void 0;
+}
+/** A package-name string in plugin code or documentation is not a runner
+* dependency. Module references, in-source APIs, and bound process calls establish usage. */
+function hasVitestV5SourceUsage(file, source) {
+	if (!/vitest|vite-plus|\bvp\b/.test(source)) return false;
+	let editor;
+	try {
+		editor = new SourceEditor(file, source);
+	} catch {
+		return true;
+	}
+	let used = editor.comments.some(({ start, end }) => /^\/\/\/\s*<reference\s+types\s*=\s*['"](?:vitest(?:\/[^'"]*)?|@vitest\/[^'"]+|vite-plus\/test(?:\/[^'"]*)?)['"]/.test(source.slice(start, end)));
+	const moduleReference = (node) => {
+		if (isString(node) && /^(?:vitest(?:\/|$)|@vitest\/|vite-plus\/test(?:\/|$))/.test(node.value)) used = true;
+	};
+	editor.visit({
+		MemberExpression(node) {
+			if (isImportMetaVitest(node)) used = true;
+		},
+		ImportDeclaration: (node) => moduleReference(node.source),
+		ExportNamedDeclaration: (node) => moduleReference(node.source),
+		ExportAllDeclaration: (node) => moduleReference(node.source),
+		ImportExpression: (node) => moduleReference(node.source),
+		TSImportType: (node) => moduleReference(node.source),
+		TSExternalModuleReference: (node) => moduleReference(node.expression),
+		TSModuleDeclaration: (node) => moduleReference(node.id),
+		CallExpression(node) {
+			if (node.callee.type === "Identifier" && node.callee.name === "require" && !editor.binding(node.callee)) moduleReference(node.arguments[0]);
+			const command = node.arguments[0];
+			if ([
+				"exec",
+				"execSync",
+				"execFile",
+				"execFileSync",
+				"spawn",
+				"spawnSync"
+			].includes(processApiName(editor, node.callee) ?? "") && isString(command)) {
+				const args = node.arguments[1];
+				const argv = args?.type === "ArrayExpression" && args.elements.every(isString) ? args.elements.map((arg) => arg.value).join(" ") : "";
+				if (/\b(?:vitest|vp\s+test)(?:\s|$)/.test(`${command.value} ${argv}`)) used = true;
+			}
+		}
+	});
+	return used;
+}
+function looksLikeConstructorMock(editor, node) {
+	if (node.arguments.some((argument) => argument.type === "ClassExpression" || argument.type === "FunctionExpression")) return true;
+	if (memberName(node.callee) === "spyOn" && isString(node.arguments[1]) && /^[A-Z]/.test(node.arguments[1].value)) return true;
+	const parent = editor.parent(node);
+	if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+		const name = parent.id.name;
+		const binding = editor.binding(parent.id);
+		return /^[A-Z]/.test(name) || !!binding?.references.some((ref) => editor.parent(ref)?.type === "NewExpression");
+	}
+	return false;
+}
+function chain(node, isApi) {
+	const members = [];
+	const calls = [];
+	while (node.type === "MemberExpression" || node.type === "CallExpression") {
+		if (node.optional) break;
+		if (isApi(node)) break;
+		if (node.type === "MemberExpression") {
+			const name = memberName(node);
+			if (name === void 0) break;
+			members.push(name);
+			node = node.object;
+		} else {
+			calls.push(node);
+			node = node.callee;
+		}
+	}
+	return {
+		root: node,
+		members,
+		calls
+	};
+}
+function migrateVitestV5Source(file, source, options) {
+	const result = rewriteSource(file, source, options);
+	if (options.reviewGlobals && !options.globals) {
+		const withGlobals = rewriteSource(file, source, {
+			...options,
+			globals: true
+		});
+		if (result.content !== withGlobals.content || withGlobals.findings.some((finding) => !result.findings.some((existing) => existing.code === finding.code && existing.line === finding.line && existing.column === finding.column && existing.message === finding.message))) result.findings.push({
+			file,
+			line: 1,
+			column: 1,
+			severity: "review",
+			code: "global-api-ownership",
+			message: "Resolve the Vitest project ownership of this file before migrating its affected global APIs. Global API edits were not applied because config selection, file scope, or globals settings are unresolved or conflicting."
+		});
+	}
+	return result;
+}
+function rewriteSource(file, source, options) {
+	const editor = new SourceEditor(file, source);
+	const reviewV4 = options.preserveV4 || options.reviewV4;
+	const benchmarks = migrateBenchmarks(editor, options.globals);
+	const runnerAliases = [];
+	const asyncFunctions = /* @__PURE__ */ new Set();
+	function apiName(node) {
+		return testApiName(editor, node, options.globals) ?? (importedName(editor, node, EXPECT_SOURCES) === "expect" ? "expect" : void 0);
+	}
+	function canAwait(node) {
+		const fn = editor.functionParent(node);
+		if (!fn) return false;
+		if (fn.async) return true;
+		if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression" || fn.generator || fn.returnType) return false;
+		const parent = editor.parent(fn);
+		if (parent?.type !== "CallExpression" || !parent.arguments.includes(fn)) return false;
+		const { root, members } = chain(parent.callee, (node) => !!apiName(node));
+		if (!ASYNC_CALLBACKS.has(apiName(root) ?? "") || members.includes("extend")) return false;
+		if (!asyncFunctions.has(fn)) {
+			editor.edit(fn.start, fn.start, "async ");
+			asyncFunctions.add(fn);
+		}
+		return true;
+	}
+	function unsupported(node, source, symbol, typeOnly) {
+		editor.report(node, "removed-api", `Migrate ${symbol} from ${source} manually; no reviewed root v5 replacement exists.`, typeOnly ? "review" : "block");
+	}
+	function dynamicImport(node, source) {
+		if (LEGACY_API_SOURCES.has(source)) unsupported(node, source, "dynamic/CommonJS import", false);
+	}
+	editor.visit({
+		ImportDeclaration(node) {
+			const source = node.source.value;
+			if (ROOT_TEST_SOURCES.has(source)) {
+				for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier" && propertyName(specifier.imported) === "bench" && node.importKind !== "type" && specifier.importKind !== "type" && !benchmarks.imports.has(specifier)) editor.report(specifier, "benchmark-api", "Migrate these bench references manually: automatic migration requires direct calls with inline or locally resolved zero-argument callbacks and no benchmark options. Review wrappers, comparison groups, and escaped references.", "block");
+			}
+			if (source in vitest_v5_entry_points_default) {
+				editor.replace(node.source, JSON.stringify(vitest_v5_entry_points_default[source]));
+				return;
+			}
+			if (!LEGACY_API_SOURCES.has(source)) return;
+			const imports = [];
+			const constants = [];
+			const remaining = [];
+			let runnerName;
+			for (const specifier of node.specifiers) {
+				const typeOnly = node.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type";
+				const name = specifier.type === "ImportSpecifier" ? propertyName(specifier.imported) : "*";
+				const target = replacementImport(source, name);
+				if (target) imports.push(`${typeOnly ? "type " : ""}${target}${specifier.local.name === target ? "" : ` as ${specifier.local.name}`}`);
+				else if (RUNNER_SOURCES.has(source) && RUNNER_METHODS[name] && !typeOnly) {
+					if (!runnerName) {
+						runnerName = editor.uniqueName("VitestTestRunner");
+						imports.push(`TestRunner as ${runnerName}`);
+					}
+					constants.push(`const ${specifier.local.name} = ${runnerName}.${RUNNER_METHODS[name]};`);
+				} else {
+					unsupported(specifier, source, name, typeOnly);
+					remaining.push(editor.text(specifier));
+				}
+			}
+			if (!node.specifiers.length) unsupported(node, source, "side-effect import", false);
+			if (imports.length) {
+				if (node.specifiers.some((specifier) => specifier.type !== "ImportSpecifier")) return;
+				const kept = remaining.length ? `import ${node.importKind === "type" ? "type " : ""}{ ${remaining.join(", ")} } from ${JSON.stringify(source)};\n` : "";
+				editor.replace(node, `${kept}import { ${imports.join(", ")} } from 'vite-plus/test';`);
+				runnerAliases.push(...constants);
+			}
+		},
+		ExportNamedDeclaration(node) {
+			const source = node.source?.value;
+			if (!source) return;
+			if (source in vitest_v5_entry_points_default) editor.replace(node.source, JSON.stringify(vitest_v5_entry_points_default[source]));
+			else if (LEGACY_API_SOURCES.has(source)) for (const specifier of node.specifiers) unsupported(specifier, source, "re-export", node.exportKind === "type" || specifier.type === "ExportSpecifier" && specifier.exportKind === "type");
+		},
+		ExportAllDeclaration(node) {
+			const source = node.source.value;
+			if (LEGACY_API_SOURCES.has(source)) unsupported(node, source, "export *", node.exportKind === "type");
+		},
+		CallExpression(node) {
+			if (node.optional) return;
+			const parent = editor.parent(node);
+			const { root, members } = chain(node.callee, (node) => !!apiName(node));
+			const name = apiName(root);
+			if (name === "bench" && (root.type !== "Identifier" || !editor.binding(root)) && !benchmarks.calls.has(node)) editor.report(node, "benchmark-api", "Migrate this bench call manually: automatic migration requires a direct call with an inline or locally resolved zero-argument callback and no benchmark options.", "block");
+			if (REGISTRATIONS.has(name ?? "")) {
+				const seqMember = node.callee.type === "MemberExpression" && memberName(node.callee) === "sequential" ? node.callee : void 0;
+				const opts = node.arguments[1];
+				const sequentialOption = staticObject(opts) ? objectProperty(opts, "sequential") : void 0;
+				let unresolvedSequential = members.includes("sequential");
+				if (seqMember && node.arguments.length >= 2) {
+					if (staticObject(opts) && !objectProperty(opts, "concurrent") && (!sequentialOption || isBoolean(sequentialOption.value) && sequentialOption.value.value)) {
+						editor.edit(seqMember.object.end, seqMember.end, "");
+						if (!sequentialOption) editor.add(opts, "concurrent", "false");
+						unresolvedSequential = false;
+					} else if ((opts?.type === "ArrowFunctionExpression" || opts?.type === "FunctionExpression") && (node.arguments.length === 2 || node.arguments.length === 3 && node.arguments[2].type === "Literal" && typeof node.arguments[2].value === "number" && /^\s*,\s*$/.test(editor.source.slice(opts.end, node.arguments[2].start)))) {
+						const timeout = node.arguments[2];
+						editor.edit(seqMember.object.end, seqMember.end, "");
+						editor.edit(opts.start, opts.start, `{ concurrent: false${timeout ? `, timeout: ${editor.text(timeout)}` : ""} }, `);
+						if (timeout) editor.edit(opts.end, timeout.end, "");
+						unresolvedSequential = false;
+					} else editor.report(node, "sequential-api", "Replace sequential with concurrent: false after resolving the options and callback.");
+				} else if (members.includes("sequential")) editor.report(node, "sequential-api", "Review the sequential modifier chain and replace it with concurrent: false.");
+				for (const argument of node.arguments.slice(1)) {
+					if (unresolvedSequential || !staticObject(argument)) continue;
+					const sequential = objectProperty(argument, "sequential");
+					if (!sequential) continue;
+					if (isBoolean(sequential.value) && sequential.value.value && !objectProperty(argument, "concurrent")) {
+						editor.replace(sequential.key, "concurrent");
+						editor.replace(sequential.value, "false");
+					} else editor.report(sequential, "sequential-api", "Resolve sequential/concurrent options explicitly before removing sequential.");
+				}
+			}
+			if (name === "vi" || name === "vitest") {
+				const method = memberName(node.callee);
+				if ([
+					"mock",
+					"unmock",
+					"hoisted"
+				].includes(method ?? "")) {
+					let statement = parent;
+					while (statement && !statement.type.endsWith("Statement") && statement.type !== "VariableDeclaration" && statement.type !== "Program") statement = editor.parent(statement);
+					if (editor.functionParent(node) || !statement || editor.parent(statement)?.type !== "Program") editor.report(node, "nested-hoisted-mock", "Move this hoisted mock to the top level after reviewing captured scope.");
+				}
+				if (reviewV4 && (options.browser || options.browser === void 0 && options.browserPossible) && method === "mock" && node.arguments.length === 1) editor.report(node, "browser-automock", "Browser automocks now keep mock defaults; choose { spy: true } if real implementations are required.");
+				if (reviewV4 && (method === "fn" || method === "spyOn") && looksLikeConstructorMock(editor, node)) editor.report(node, "class-mock", "If this mock replaces a constructor, review its prototype, methods, and instanceof behavior.");
+				if (reviewV4 && method === "setSystemTime" && (options.temporalPolyfill || /\bTemporal\b/.test(source))) editor.report(node, "temporal-system-time", "vi.setSystemTime now changes Temporal even without fake timers; toNotFake does not preserve this behavior.");
+			}
+			if (reviewV4 && memberName(node.callee) === "mockImplementation" && looksLikeConstructorMock(editor, node)) editor.report(node, "class-mock", "Review constructor mock implementations and their inherited prototypes.");
+			if (name === "expect") {
+				const matcher = memberName(node.callee);
+				const first = node.arguments[0];
+				if (options.preserveV4 && ["toThrow", "toThrowError"].includes(matcher ?? "") && isString(first) && first.value === "") editor.replace(first, "/^$/");
+				if (reviewV4 && matcher === "toHaveTextContent") {
+					const browserAssertion = members.includes("element") || options.browser === true;
+					const literal = isString(first) || isRegExp(first);
+					if (options.preserveV4 && browserAssertion && literal) {
+						const callee = node.callee;
+						editor.replace(callee.property, callee.computed ? JSON.stringify("toMatchTextContent") : "toMatchTextContent");
+					} else if (browserAssertion && !literal) editor.report(node, "text-content", "Choose toMatchTextContent for v4 partial/regex matching after resolving the expected value.");
+					else if (options.browser === void 0 && options.browserPossible) editor.report(node, "text-content-project", options.ownershipReason ? `${options.ownershipReason} Browser assertions need toMatchTextContent for v4 partial matching; keep Node jest-dom assertions unchanged.` : "Resolve this assertion's test project: browser assertions need toMatchTextContent for v4 partial matching; keep Node jest-dom assertions unchanged.");
+				}
+				if (reviewV4 && members.includes("poll") && matcher !== "poll") editor.report(node, "poll-timeout", "Review the configured expect.poll timeout; v5 rejects assertions that finish after it.");
+				const asynchronous = members.some((member) => [
+					"resolves",
+					"rejects",
+					"poll",
+					"element",
+					"toMatchFileSnapshot",
+					"toMatchScreenshot"
+				].includes(member));
+				if (asynchronous && parent?.type === "ExpressionStatement") {
+					if (canAwait(node)) editor.edit(node.start, node.start, "await ");
+					else editor.report(node, "unawaited-assertion", "Await or return this asynchronous assertion in an async-compatible function.");
+				} else if (asynchronous && parent?.type !== "MemberExpression" && parent?.type !== "AwaitExpression" && parent?.type !== "ReturnStatement") editor.report(node, "unawaited-assertion", "Check that the result of this asynchronous assertion is awaited or returned.");
+			}
+			if (importedName(editor, node.callee, RENDER_SOURCES) === "render" && parent?.type !== "AwaitExpression" && parent?.type !== "ReturnStatement") {
+				if (canAwait(node)) {
+					editor.edit(node.start, node.start, "(await ");
+					editor.edit(node.end, node.end, ")");
+				} else editor.report(node, "async-render", "Await render from vitest-browser-vue/svelte after making the enclosing contract async-compatible.");
+			}
+			if (importedName(editor, node.callee, NODE_SOURCES) === "resolveConfig" && options.preserveV4) {
+				const declaration = parent && editor.parent(parent);
+				if (parent?.type === "AwaitExpression" && declaration?.type === "VariableDeclarator" && declaration.id.type === "ObjectPattern") {
+					const props = declaration.id.properties;
+					if (props.every((prop) => prop.type === "Property" && !prop.computed && prop.value.type === "Identifier" && ["viteConfig", "vitestConfig"].includes(propertyName(prop.key) ?? ""))) {
+						const vite = props.find((prop) => prop.type === "Property" && propertyName(prop.key) === "viteConfig");
+						const vitest = props.find((prop) => prop.type === "Property" && propertyName(prop.key) === "vitestConfig");
+						const local = vite ? editor.text(vite.value) : editor.uniqueName("viteConfig");
+						editor.replace(declaration.id, local);
+						if (vitest) editor.edit(declaration.end, declaration.end, `, ${editor.text(vitest.value)} = ${local}.test`);
+					} else editor.report(declaration, "resolve-config", "Replace resolveConfig pair destructuring with the Vite config return value and its .test property.");
+				} else editor.report(node, "resolve-config", "Review resolveConfig consumers; the v5 return value is the Vite config with Vitest options under .test.");
+			}
+			if (memberName(node.callee) === "collect") {
+				const object = node.callee.object;
+				const binding = editor.binding(object);
+				let initializer = binding?.declaration.type === "VariableDeclarator" ? binding.declaration.init : void 0;
+				if (initializer?.type === "AwaitExpression") initializer = initializer.argument;
+				const vitestRunner = initializer?.type === "CallExpression" && ["createVitest", "startVitest"].includes(importedName(editor, initializer.callee, NODE_SOURCES) ?? "");
+				const known = vitestRunner && binding?.constant;
+				const opts = node.arguments[1];
+				if (known && options.preserveV4 && node.arguments.length <= 2 && !node.arguments.some((argument) => argument.type === "SpreadElement") && (!opts || staticObject(opts))) {
+					if (staticObject(opts)) editor.add(opts, "staticParse", "false");
+					else editor.edit(node.end - 1, node.end - 1, `${node.arguments.length ? ", " : "undefined, "}{ staticParse: false }`);
+				} else if (reviewV4 && vitestRunner && (!known || node.arguments.some((argument) => argument.type === "SpreadElement") || opts && !staticObject(opts))) editor.report(node, "static-collect", "If this is Vitest.collect(), review staticParse and set it to false to retain runtime collection.");
+			}
+			if (node.callee.type === "Identifier" && node.callee.name === "require" && !editor.binding(node.callee) && isString(node.arguments[0])) dynamicImport(node, node.arguments[0].value);
+		},
+		ImportExpression(node) {
+			if (isString(node.source)) dynamicImport(node, node.source.value);
+		},
+		MemberExpression(node) {
+			if (reviewV4 && ["VITEST_POOL_ID", "VITEST_WORKER_ID"].includes(memberName(node) ?? "")) editor.report(node, "worker-id", "Review worker/pool ID arithmetic and indexing: IDs now start at 1, not 0.");
+		},
+		VariableDeclarator(node) {
+			if (reviewV4 && node.id.type === "ObjectPattern") {
+				for (const prop of node.id.properties) if (prop.type === "Property" && ["VITEST_POOL_ID", "VITEST_WORKER_ID"].includes(propertyName(prop.key) ?? "")) editor.report(prop, "worker-id", "Review worker/pool ID arithmetic and indexing: IDs now start at 1, not 0.");
+			}
+		},
+		AssignmentExpression(node) {
+			if (reviewV4 && globalRestorationOrigin(editor, node.right) === "value") editor.report(node, "global-descriptors", "populateGlobal().originals stores descriptors; restore them with Object.defineProperty, not assignment.");
+			const left = node.left;
+			if (reviewV4 && (left.type === "MemberExpression" && left.object.type === "Identifier" && !editor.binding(left.object) && [
+				"window",
+				"globalThis",
+				"global"
+			].includes(editor.text(left.object)) && DOM_GLOBALS.has(memberName(left) ?? "") || left.type === "Identifier" && DOM_GLOBALS.has(left.name) && !editor.binding(left))) editor.report(node, "dom-global", "In jsdom/happy-dom, global assignment also updates the window; review this DOM override.");
+		},
+		TSInterfaceDeclaration(node) {
+			if (reviewV4 && (isJestMatchers(editor, node) || ["Assertion", "Matchers"].includes(node.id.name) && (node.typeParameters?.params.length ?? 0) < 2)) editor.report(node, "assertion-types", "Update custom matcher declarations for the v5 return and received type parameters; review jest.Matchers augmentations.");
+		},
+		TSTypeReference(node) {
+			const name = assertionTypeName(editor, node.typeName);
+			if (reviewV4 && (name === "jest.Matchers" || ["Assertion", "Matchers"].includes(name ?? "") && (node.typeArguments?.params.length ?? 0) < 2)) editor.report(node, "assertion-types", "Review old assertion generics; v5 includes return and received types.");
+		},
+		TSImportType(node) {
+			const source = node.source.value;
+			if (LEGACY_API_SOURCES.has(source)) unsupported(node, source, "type import", true);
+		},
+		Literal(node) {
+			if (!isString(node)) return;
+			const value = node.value;
+			if (/\/__vitest__\//.test(value) && !/[?&]token=/.test(value)) editor.report(node, "ui-token", "Use the authenticated UI URL printed by Vitest, including its token.");
+			if (/\/__vitest_test__\//.test(value) && !/[?&]sessionId=/.test(value)) editor.report(node, "browser-session", "Use the browser orchestrator URL opened by Vitest, including its sessionId.");
+		}
+	});
+	if (runnerAliases.length) {
+		const firstStatement = editor.ast.body.find((node) => node.type !== "ImportDeclaration" && !(node.type === "ExpressionStatement" && node.directive));
+		const offset = firstStatement?.start ?? source.length;
+		editor.edit(offset, offset, `${firstStatement ? "" : "\n"}${runnerAliases.join("\n")}\n`);
+	}
+	const result = editor.finish();
+	const benchmark = benchmarks.imports.values().next().value ?? benchmarks.bindings.values().next().value ?? benchmarks.calls.values().next().value;
+	if (benchmark && result.content === source) editor.report(benchmark, "benchmark-api", "The benchmark rewrite was discarded. Migrate the remaining legacy bench API manually before upgrading to Vitest v5.", "block");
+	return result;
+}
+//#endregion
+//#region src/migration/vitest-v5/webdriverio.ts
+const MIN_VERSION = "5.0.0";
+const DEFAULT_SPEC = "^5.0.0";
+const REGISTRY_ALIAS = `npm:${WEBDRIVERIO_PROVIDER}@`;
+const INSTALL_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies"
+];
+/** Narrow mixed ranges without discarding the user's newer allowed versions. */
+function webdriverioMigrationSpec(spec) {
+	if (spec.startsWith(REGISTRY_ALIAS)) {
+		const migrated = webdriverioMigrationSpec(spec.slice(REGISTRY_ALIAS.length));
+		return migrated === void 0 ? void 0 : `${REGISTRY_ALIAS}${migrated}`;
+	}
+	if (!import_semver.default.validRange(spec)) return;
+	const branches = new import_semver.default.Range(spec).set.map((set) => set.map((item) => item.value).join(" "));
+	if (branches.every((branch) => {
+		const min = import_semver.default.minVersion(branch);
+		return min && import_semver.default.gte(min, MIN_VERSION);
+	})) return spec;
+	const narrowed = branches.map((branch) => `${branch} >=${MIN_VERSION}`.trim()).filter((branch) => import_semver.default.minVersion(branch) !== null);
+	return narrowed.length ? narrowed.join(" || ") : DEFAULT_SPEC;
+}
+function object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+/** Compose dependency edits into the versioned preflight's in-memory sources.
+* No writes or network resolution: unresolved custom specs block before install. */
+function migrateWebdriverioDependencies(workspace, sources, inputs) {
+	const findings = [];
+	const rootManifest = path.join(workspace.rootDir, "package.json");
+	const manifests = [rootManifest, ...(workspace.packages ?? []).map((pkg) => path.resolve(workspace.rootDir, pkg.path, "package.json"))];
+	const read = (file) => {
+		const source = sources.get(file);
+		if (source === void 0) return {};
+		return object(file.endsWith(".json") ? parse(source) : (0, import_dist.parseDocument)(source).toJS());
+	};
+	const get = (file, keys) => keys.reduce((value, key) => object(value)[key], read(file));
+	const set = (file, keys, value) => {
+		if (get(file, keys) === value) return;
+		const source = sources.get(file);
+		if (file.endsWith(".json")) sources.set(file, applyEdits(source, modify(source, keys, value, { formattingOptions: {
+			insertSpaces: true,
+			tabSize: 2
+		} })));
+		else {
+			const doc = (0, import_dist.parseDocument)(source);
+			if (value === void 0) doc.deleteIn(keys);
+			else doc.setIn(keys, value);
+			sources.set(file, doc.toString());
+		}
+	};
+	const block = (file, label, spec) => {
+		findings.push({
+			file,
+			line: 1,
+			column: 1,
+			code: "browser-provider",
+			severity: "block",
+			message: `Cannot ensure ${label} (${spec}) uses ${WEBDRIVERIO_PROVIDER} >=${MIN_VERSION}. Select a compatible provider version, then re-run migration.`
+		});
+	};
+	const catalogEntry = (spec, name) => {
+		const catalog = spec.slice(8);
+		const keys = catalog && catalog !== "default" ? [
+			"catalogs",
+			catalog,
+			name
+		] : ["catalog", name];
+		if (workspace.packageManager === PackageManager.bun) {
+			for (const prefix of [["workspaces"], []]) if (typeof get(rootManifest, [...prefix, ...keys]) === "string") return {
+				file: rootManifest,
+				keys: [...prefix, ...keys]
+			};
+			return;
+		}
+		const file = path.join(workspace.rootDir, workspace.packageManager === PackageManager.yarn ? ".yarnrc.yml" : "pnpm-workspace.yaml");
+		return typeof get(file, keys) === "string" ? {
+			file,
+			keys
+		} : void 0;
+	};
+	const update = (file, keys, directory, seen = /* @__PURE__ */ new Set()) => {
+		const spec = get(file, keys);
+		if (typeof spec !== "string") return;
+		const location = `${file}:${keys.join(".")}`;
+		if (seen.has(location)) {
+			block(file, keys.join("."), spec);
+			return;
+		}
+		seen.add(location);
+		if (spec.startsWith("catalog:")) {
+			const entry = catalogEntry(spec, WEBDRIVERIO_PROVIDER);
+			if (entry) update(entry.file, entry.keys, directory, seen);
+			else block(file, keys.join("."), spec);
+			return;
+		}
+		if (spec.startsWith("$")) {
+			const name = spec.slice(1);
+			const field = INSTALL_FIELDS.find((field) => typeof get(rootManifest, [field, name]) === "string");
+			if (field && name === "@vitest/browser-webdriverio") update(rootManifest, [field, name], workspace.rootDir, seen);
+			else block(file, keys.join("."), spec);
+			return;
+		}
+		const migrated = webdriverioMigrationSpec(spec);
+		if (migrated !== void 0) {
+			set(file, keys, migrated);
+			return;
+		}
+		if (/^(?:file:|link:|workspace:)/.test(spec)) {
+			const local = spec.startsWith("workspace:") ? manifests.find((manifest) => read(manifest).name === WEBDRIVERIO_PROVIDER) : path.resolve(directory, spec.slice(spec.indexOf(":") + 1), "package.json");
+			if (local && fs.existsSync(local)) {
+				const text = fs.readFileSync(local, "utf8");
+				inputs.set(local, text);
+				const pkg = object(parse(text));
+				if (pkg.name === "@vitest/browser-webdriverio" && typeof pkg.version === "string" && import_semver.default.valid(pkg.version) && import_semver.default.gte(pkg.version, MIN_VERSION)) return;
+			}
+		}
+		block(file, keys.join("."), spec);
+	};
+	const selected = manifests.filter((file) => {
+		const pkg = read(file);
+		return [...INSTALL_FIELDS, "peerDependencies"].some((field) => typeof object(pkg[field])["@vitest/browser-webdriverio"] === "string") || usesWebdriverioProvider(path.dirname(file));
+	});
+	if (!selected.length) return findings;
+	for (const file of selected) {
+		const directory = path.dirname(file);
+		let installed = false;
+		for (const field of INSTALL_FIELDS) if (typeof get(file, [field, "@vitest/browser-webdriverio"]) === "string") {
+			update(file, [field, WEBDRIVERIO_PROVIDER], directory);
+			installed = true;
+		}
+		if (!installed) {
+			const peer = get(file, ["peerDependencies", WEBDRIVERIO_PROVIDER]);
+			const inherited = file !== rootManifest ? INSTALL_FIELDS.map((field) => get(rootManifest, [field, WEBDRIVERIO_PROVIDER])).find((spec) => typeof spec === "string") : void 0;
+			let spec = typeof peer === "string" ? peer : inherited;
+			if (spec?.startsWith("catalog:") && typeof peer === "string") {
+				const entry = catalogEntry(spec, WEBDRIVERIO_PROVIDER);
+				const resolved = entry && get(entry.file, entry.keys);
+				spec = typeof resolved === "string" ? resolved : spec;
+			}
+			set(file, ["devDependencies", WEBDRIVERIO_PROVIDER], spec ?? DEFAULT_SPEC);
+			update(file, ["devDependencies", WEBDRIVERIO_PROVIDER], directory);
+		}
+		if (!INSTALL_FIELDS.some((field) => typeof get(file, [field, "webdriverio"]) === "string")) {
+			let peer = "*";
+			const pkg = read(file);
+			for (const name of [
+				"webdriverio",
+				"@wdio/cli",
+				"@wdio/globals"
+			]) {
+				const spec = [...INSTALL_FIELDS, "peerDependencies"].map((field) => object(pkg[field])[name]).find((spec) => typeof spec === "string");
+				if (!spec) continue;
+				const entry = spec.startsWith("catalog:") ? catalogEntry(spec, name) : void 0;
+				const resolved = entry ? get(entry.file, entry.keys) : spec;
+				if (typeof resolved === "string" && import_semver.default.validRange(resolved)) {
+					peer = name === "webdriverio" ? spec : resolved;
+					break;
+				}
+			}
+			const metadata = peer === "*" ? detectPackageMetadata(directory, "webdriverio") : void 0;
+			if (metadata && import_semver.default.valid(metadata.version)) {
+				const metadataFile = path.join(metadata.path, "package.json");
+				inputs.set(metadataFile, fs.readFileSync(metadataFile, "utf8"));
+				peer = `^${metadata.version}`;
+			}
+			set(file, ["devDependencies", "webdriverio"], peer);
+		}
+		if (workspace.packageManager === PackageManager.npm && VITE_PLUS_OVERRIDE_PACKAGES.vite && !INSTALL_FIELDS.some((field) => get(file, [field, "vite"]) !== void 0)) set(file, ["devDependencies", "vite"], VITE_PLUS_OVERRIDE_PACKAGES.vite);
+	}
+	const projectNames = selected.map((file) => read(file).name).filter((name) => typeof name === "string");
+	function matchesProject(parents) {
+		const concrete = parents.filter((parent) => parent !== "**");
+		if (concrete.length === 0) return true;
+		if (concrete.length !== 1) return false;
+		const pattern = concrete[0].split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+		const expression = new RegExp(`^${pattern}$`);
+		return projectNames.some((name) => expression.test(name));
+	}
+	const overrideMap = (file, keys, parents = []) => {
+		for (const [key, value] of Object.entries(object(get(file, keys)))) {
+			const target = extractOverrideTargetName(key);
+			const ancestors = [...parents, ...extractOverrideParentSegments(key) ?? []];
+			const entry = [...keys, key];
+			if (target === "@vitest/browser-webdriverio" && matchesProject(ancestors)) {
+				const versionPath = typeof value === "string" ? entry : [...entry, "."];
+				const before = get(file, versionPath);
+				const catalog = typeof before === "string" && before.startsWith("catalog:") ? catalogEntry(before, WEBDRIVERIO_PROVIDER) : void 0;
+				const pin = catalog ? get(catalog.file, catalog.keys) : before;
+				const pinnedRange = typeof pin === "string" ? import_semver.default.validRange(pin.startsWith(REGISTRY_ALIAS) ? pin.slice(REGISTRY_ALIAS.length) : pin) : null;
+				if (pinnedRange && !import_semver.default.intersects(pinnedRange, `>=${MIN_VERSION}`)) {
+					set(file, versionPath, void 0);
+					continue;
+				}
+				update(file, versionPath, workspace.rootDir);
+				if (workspace.packageManager === PackageManager.npm && keys[0] === "overrides" && ancestors.length === 0 && selected.includes(rootManifest) && typeof before === "string") {
+					const after = get(file, versionPath);
+					const field = INSTALL_FIELDS.find((field) => get(rootManifest, [field, WEBDRIVERIO_PROVIDER]) !== void 0);
+					if (typeof after === "string" && !after.startsWith("$") && webdriverioMigrationSpec(after) === after) {
+						const direct = get(rootManifest, [field, WEBDRIVERIO_PROVIDER]);
+						if (typeof direct === "string" && webdriverioMigrationSpec(before) !== before && webdriverioMigrationSpec(direct) === direct) set(file, versionPath, `$${WEBDRIVERIO_PROVIDER}`);
+						else if (direct === after) continue;
+						else if (typeof direct === "string" && import_semver.default.validRange(direct) && import_semver.default.validRange(after) && import_semver.default.intersects(direct, after)) {
+							set(rootManifest, [field, WEBDRIVERIO_PROVIDER], after);
+							set(file, versionPath, `$${WEBDRIVERIO_PROVIDER}`);
+						} else block(file, versionPath.join("."), after);
+					}
+				}
+			}
+			if (value !== null && typeof value === "object") overrideMap(file, entry, [...ancestors, target]);
+		}
+	};
+	overrideMap(rootManifest, ["overrides"]);
+	overrideMap(rootManifest, ["resolutions"]);
+	overrideMap(rootManifest, ["pnpm", "overrides"]);
+	overrideMap(path.join(workspace.rootDir, "pnpm-workspace.yaml"), ["overrides"]);
+	return findings;
+}
+//#endregion
+//#region src/migration/migrator/vitest-v5.ts
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".vite",
+	".vitest",
+	".vite-plus",
+	".cache",
+	".yarn",
+	"dist",
+	"build",
+	"out",
+	"coverage",
+	".next",
+	".nuxt",
+	".svelte-kit"
+]);
+const CODE_FILE = /\.[cm]?[jt]sx?$/;
+const VITEST_SIGNAL = /(?:['"](?:vitest(?:\/[^'"]*)?|@vitest\/[^'"]+|vite-plus\/test[^'"]*)['"]|\bvp\s+test\b|\bvitest\s+(?:run|list|bench)|\bimport\s*\.\s*meta\s*\.\s*vitest\b)/;
+const VITEST_COMMAND = /\b(?:vp\s+test|vitest)(?:\s|$)/;
+const BROWSER_SIGNAL = /@vitest\/browser|(?:vitest|vite-plus\/test)\/browser|vitest-browser-|browser\s*:\s*\{|--browser(?:[.=\s'"]|$)/;
+const LEGACY_RUNNER = "@voidzero-dev/vite-plus-test";
+const DEFERRED_SOURCE_REVIEWS = /* @__PURE__ */ new Set([
+	"resolve-config",
+	"overlapping-edits",
+	"unsafe-syntax"
+]);
+function workspaceFromPlan(plan) {
+	return {
+		rootDir: plan.rootDir,
+		packageManager: plan.packageManager,
+		packages: plan.projects.slice(1).map((project) => ({
+			name: "",
+			path: path.relative(plan.rootDir, project.directory)
+		}))
+	};
+}
+function readJson(file) {
+	return parseJson(fs.readFileSync(file, "utf8"));
+}
+function parseJson(source) {
+	return JSON.parse(source.replace(/^\uFEFF/, ""));
+}
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function dependency(pkg, name) {
+	for (const field of [
+		"dependencies",
+		"devDependencies",
+		"optionalDependencies",
+		"peerDependencies"
+	]) {
+		const spec = record(pkg[field])?.[name];
+		if (typeof spec === "string") return spec;
+	}
+}
+function filesInProject(directory) {
+	const files = [];
+	const walk = (current) => {
+		if (current !== directory && fs.existsSync(path.join(current, "package.json"))) return;
+		for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+			const file = path.join(current, entry.name);
+			if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) walk(file);
+			else if (entry.isFile() && ![".pnp.cjs", ".pnp.loader.mjs"].includes(entry.name) && (CODE_FILE.test(file) || /\.(?:json|ya?ml|sh)$/.test(file) || /^Dockerfile(?:\.|$)|^Containerfile(?:\.|$)/.test(entry.name) || [
+				".node-version",
+				".nvmrc",
+				".gitignore",
+				"yarn.lock",
+				"bun.lock"
+			].includes(entry.name))) files.push(file);
+		}
+	};
+	walk(directory);
+	return files.toSorted();
+}
+function finding(file, code, message, severity = "review", source = "", offset = 0) {
+	const prefix = source.slice(0, offset);
+	return {
+		file,
+		line: prefix.split("\n").length,
+		column: offset - prefix.lastIndexOf("\n"),
+		code,
+		severity,
+		message
+	};
+}
+/** Follow this project's dependency edges, never an unrelated transitive runner. */
+function lockedSourceVersion(directory, root, pkg, manager, expectedRunnerPackage) {
+	if (manager !== void 0 && manager !== PackageManager.pnpm) {
+		const spec = dependency(pkg, "vitest");
+		return spec && !expectedRunnerPackage ? lockedVitestVersion(root, directory, manager, spec) : void 0;
+	}
+	const lockfile = path.join(root, "pnpm-lock.yaml");
+	if (!fs.existsSync(lockfile)) return;
+	try {
+		const document = (0, import_dist.parseDocument)(fs.readFileSync(lockfile, "utf8"));
+		if (document.errors.length) return;
+		const lock = record(document.toJS());
+		const importer = record(record(lock?.importers)?.[path.relative(root, directory).replaceAll("\\", "/") || "."]);
+		if (!importer) return;
+		const name = dependency(pkg, "vitest") ? "vitest" : "vite-plus";
+		const spec = dependency(pkg, name);
+		if (!spec) return;
+		const entry = [
+			"dependencies",
+			"devDependencies",
+			"optionalDependencies"
+		].map((field) => record(importer[field])?.[name]).find((value) => value !== void 0);
+		const metadata = record(entry);
+		if (typeof metadata?.specifier === "string" && metadata.specifier !== spec) return;
+		const follow = (name, value, depth = 0) => {
+			const reference = typeof value === "string" ? value : record(value)?.version;
+			if (typeof reference !== "string" || depth > 3) return;
+			if (name === "vitest" && expectedRunnerPackage && !reference.startsWith(`${expectedRunnerPackage}@`)) return;
+			if (reference.startsWith(`${LEGACY_RUNNER}@`)) return follow(LEGACY_RUNNER, reference.slice(29), depth + 1);
+			const version = reference.split("(")[0];
+			if (!import_semver.default.valid(version)) return;
+			if (name === "vitest") return version;
+			if (name === LEGACY_RUNNER) {
+				const runnerVersion = record(record(record(lock?.packages)?.[`${name}@${version}`])?.peerDependencies)?.["@vitest/ui"];
+				return typeof runnerVersion === "string" ? import_semver.default.valid(runnerVersion) ?? void 0 : void 0;
+			}
+			const dependencies = record(record(record(lock?.snapshots)?.[`${name}@${reference}`])?.dependencies);
+			return follow("vitest", dependencies?.vitest, depth + 1) ?? follow(LEGACY_RUNNER, dependencies?.[LEGACY_RUNNER], depth + 1);
+		};
+		return follow(name, entry);
+	} catch {
+		return;
+	}
+}
+function unambiguousRunnerVersion(range) {
+	if (!import_semver.default.validRange(range) || !import_semver.default.subset(range, "<5.0.0-0", { includePrerelease: true }) && !import_semver.default.subset(range, ">=5.0.0-0", { includePrerelease: true })) return;
+	return import_semver.default.minVersion(range)?.version;
+}
+function installedSourceVersion(directory, name, expectedPackage, expectedRange) {
+	const installed = detectPackageMetadata(directory, name);
+	if (!installed || expectedPackage && installed.name !== expectedPackage) return;
+	if (expectedRange && import_semver.default.validRange(expectedRange) && !import_semver.default.satisfies(installed.version, expectedRange, { includePrerelease: true })) return;
+	if (installed.name === "vitest") return import_semver.default.valid(installed.version) ?? void 0;
+	const pkg = readJson(path.join(installed.path, "package.json"));
+	if (installed.name === LEGACY_RUNNER) {
+		const version = record(pkg.peerDependencies)?.["@vitest/ui"];
+		return typeof version === "string" ? import_semver.default.valid(version) ?? void 0 : void 0;
+	}
+	if (installed.name !== "vite-plus") return;
+	const bundled = dependency(pkg, "vitest");
+	if (bundled?.startsWith("catalog:")) return installedSourceVersion(installed.path, "vitest");
+	if (bundled && import_semver.default.validRange(bundled)) {
+		const version = installedSourceVersion(installed.path, "vitest");
+		return version && import_semver.default.satisfies(version, bundled, { includePrerelease: true }) ? version : unambiguousRunnerVersion(bundled);
+	}
+	return dependency(pkg, LEGACY_RUNNER) ? installedSourceVersion(installed.path, LEGACY_RUNNER) : void 0;
+}
+function sourceVersion(directory, root, pkg, manager) {
+	const catalog = createCatalogDependencyResolver(root, manager ?? PackageManager.pnpm);
+	const vitePlus = dependency(pkg, "vite-plus");
+	const vitePlusRange = vitePlus?.startsWith("catalog:") ? catalog?.(vitePlus, "vite-plus") : vitePlus;
+	let spec = dependency(pkg, "vitest");
+	if (spec?.startsWith("catalog:")) spec = catalog?.(spec, "vitest");
+	const legacyAlias = spec?.startsWith(`npm:${LEGACY_RUNNER}@`);
+	if (spec?.startsWith("npm:vitest@")) spec = spec.slice(11);
+	if (![
+		"dependencies",
+		"devDependencies",
+		"optionalDependencies"
+	].some((field) => typeof record(pkg[field])?.vitest === "string") && vitePlus) {
+		const bundled = installedSourceVersion(directory, "vite-plus", "vite-plus", vitePlusRange);
+		if (bundled) return bundled;
+	}
+	const expectedRunnerPackage = legacyAlias ? LEGACY_RUNNER : void 0;
+	const locked = lockedSourceVersion(directory, root, pkg, manager, expectedRunnerPackage);
+	if (locked && (!spec || legacyAlias || !import_semver.default.validRange(spec) || import_semver.default.satisfies(locked, spec, { includePrerelease: true }))) return locked;
+	const installed = installedSourceVersion(directory, "vitest", expectedRunnerPackage);
+	if (installed && (!spec || legacyAlias || import_semver.default.satisfies(installed, spec, { includePrerelease: true }))) return installed;
+	if (legacyAlias) return "4.0.0";
+	if (spec && import_semver.default.validRange(spec)) return unambiguousRunnerVersion(spec);
+	if (vitePlus) {
+		const bundled = installedSourceVersion(directory, "vite-plus", "vite-plus", vitePlusRange);
+		if (bundled) return bundled;
+	}
+	if (directory !== root) return sourceVersion(root, root, readJson(path.join(root, "package.json")), manager);
+}
+function checkNodeRange(file, value, label, findings, publicContract = false) {
+	if (!publicContract && [
+		"lts/*",
+		"lts",
+		"latest",
+		"current",
+		"node",
+		"stable"
+	].includes(value)) return;
+	const range = import_semver.default.validRange(value);
+	if (publicContract && range) {
+		const minimum = import_semver.default.minVersion(range);
+		if (minimum) {
+			const majorRange = `${minimum.major}.x`;
+			if (import_semver.default.satisfies(minimum, engines.node) || import_semver.default.subset(majorRange, range) && import_semver.default.intersects(majorRange, engines.node)) return;
+		}
+	}
+	let message = `Resolve ${label} (${value}) and select Node ${engines.node}.`;
+	if (range && !publicContract && !import_semver.default.intersects(range, engines.node)) {
+		const current = import_semver.default.minVersion(range);
+		const upgrade = current && new import_semver.default.Range(engines.node).set.map((comparators) => import_semver.default.minVersion(comparators.map(({ value }) => value).join(" "))).filter((version) => version !== null).toSorted(import_semver.default.compare).find((version) => import_semver.default.gte(version, current));
+		if (upgrade) return upgrade.version;
+	} else if (range) {
+		if (import_semver.default.subset(range, engines.node) || !publicContract && !/[<>|*]/.test(value)) return;
+		message = `${label} (${value}) includes unsupported test runtimes. Pin the test/CI runtime to Node ${engines.node}; keep the library's public engine contract separate.`;
+	}
+	findings.push(finding(file, "node-runtime", message));
+}
+function migrateNode(file, source, findings) {
+	const base = path.basename(file);
+	if (base === ".node-version" || base === ".nvmrc") {
+		const value = source.trim();
+		const upgrade = checkNodeRange(file, value.replace(/^v/, ""), base, findings);
+		if (upgrade) {
+			const start = source.indexOf(value);
+			return source.slice(0, start) + (value.startsWith("v") ? "v" : "") + upgrade + source.slice(start + value.length);
+		}
+	}
+	if (base === "package.json") {
+		const pkg = parseJson(source);
+		const tree = parseTree(source.replace(/^\uFEFF/, " "));
+		const edits = [];
+		const checkRuntime = (value, label, keys) => {
+			const upgrade = checkNodeRange(file, value, label, findings);
+			const node = tree && findNodeAtLocation(tree, keys);
+			if (upgrade && node) edits.push({
+				offset: node.offset,
+				length: node.length,
+				content: JSON.stringify(upgrade)
+			});
+		};
+		if (typeof pkg.engines?.node === "string") checkNodeRange(file, pkg.engines.node, "engines.node", findings, true);
+		const runtime = pkg.devEngines?.runtime;
+		for (const [index, entry] of (Array.isArray(runtime) ? runtime : [runtime]).entries()) if (entry?.name === "node" && typeof entry.version === "string") checkRuntime(entry.version, "devEngines.runtime", [
+			"devEngines",
+			"runtime",
+			...Array.isArray(runtime) ? [index] : [],
+			"version"
+		]);
+		if (typeof pkg.volta?.node === "string" && ![".node-version", ".nvmrc"].some((name) => fs.existsSync(path.join(path.dirname(file), name)))) checkRuntime(pkg.volta.node, "volta.node", ["volta", "node"]);
+		return applyEdits(source, edits);
+	}
+	return source;
+}
+function scanAndRewriteFile(file, source, project, testMode, mergedConfig) {
+	const findings = [];
+	if (!project.active) return {
+		content: migrateNode(file, source, findings),
+		findings
+	};
+	let content = source;
+	if (CODE_FILE.test(file) && (testMode.benchmark || testMode.globals || testMode.reviewGlobals || VITEST_SIGNAL.test(source) || /\.(?:test|spec)\./.test(file) || project.configFiles.has(file))) try {
+		const sourceResult = migrateVitestV5Source(file, content, {
+			...project.options,
+			...testMode
+		});
+		content = sourceResult.content;
+		findings.push(...sourceResult.findings);
+		const pending = project.pendingSourceReviews?.[path.relative(project.directory, file).replaceAll("\\", "/")];
+		if (!project.options.preserveV4 && pending?.length) {
+			const review = migrateVitestV5Source(file, content, {
+				...project.options,
+				...testMode,
+				preserveV4: true
+			});
+			findings.push(...review.findings.filter(({ code }) => pending.includes(code)));
+		}
+		if (project.configFiles.has(file)) {
+			const configResult = migrateVitestV5Config(file, content, project.options, mergedConfig);
+			content = configResult.content;
+			findings.push(...configResult.findings);
+		}
+	} catch (error) {
+		content = source;
+		findings.push(finding(file, "source-parse", `Parse and review this file before migration: ${error instanceof Error ? error.message : String(error)}`));
+		if (/['"](?:@vitest\/(?:runner|expect)|(?:vitest|vite-plus\/test)\/(?:runners|suite|internal\/module-runner))/.test(source)) findings.push(finding(file, "removed-api", "This unparsed file references removed APIs. Resolve it before changing dependencies.", "block"));
+	}
+	else if (path.basename(file) === "package.json") {
+		const pkg = parseJson(source);
+		const tree = parseTree(source.replace(/^\uFEFF/, " "));
+		const edits = [];
+		for (const [name, command] of Object.entries(record(pkg.scripts) ?? {})) {
+			if (typeof command !== "string") continue;
+			const node = tree && findNodeAtLocation(tree, ["scripts", name]);
+			if (!node) continue;
+			const result = migrateVitestV5Command(file, command, project.options.preserveV4, source.slice(0, node.offset).split("\n").length, project.options.preserveV4 || project.options.reviewV4);
+			findings.push(...result.findings);
+			if (result.content !== command) edits.push({
+				offset: node.offset,
+				length: node.length,
+				content: JSON.stringify(result.content)
+			});
+		}
+		content = applyEdits(source, edits);
+	} else if (/^tsconfig(?:\..+)?\.json$/.test(path.basename(file))) {
+		const types = record(record(parse(source))?.compilerOptions)?.types;
+		if (Array.isArray(types) && types.includes("@testing-library/jest-dom") && !types.includes("@testing-library/jest-dom/vitest")) findings.push(finding(file, "jest-dom-types", "If this config checks Vitest tests, load @testing-library/jest-dom/vitest in compilerOptions.types or an included TypeScript setup file. The root jest-dom type entry augments Jest, not Vitest v5."));
+	} else if (/\.ya?ml$/.test(file)) {
+		const document = (0, import_dist.parseDocument)(source);
+		let changed = false;
+		(0, import_dist.visit)(document, { Pair(_key, pair) {
+			if (!(0, import_dist.isScalar)(pair.key) || ![
+				"run",
+				"script",
+				"command"
+			].includes(String(pair.key.value)) || !(0, import_dist.isScalar)(pair.value) || typeof pair.value.value !== "string") return;
+			const value = pair.value.value;
+			const result = migrateVitestV5Command(file, value.includes("\n") ? `(${value})` : value, project.options.preserveV4, source.slice(0, pair.key.range?.[0] ?? 0).split("\n").length, project.options.preserveV4 || project.options.reviewV4);
+			findings.push(...result.findings);
+			if (!value.includes("\n") && result.content !== value) {
+				pair.value.value = result.content;
+				changed = true;
+			}
+		} });
+		if (changed) content = document.toString();
+	} else if (file.endsWith(".sh")) findings.push(...migrateVitestV5Command(file, `(${source})`, project.options.preserveV4, 1, project.options.preserveV4 || project.options.reviewV4).findings);
+	return {
+		content: migrateNode(file, content, findings),
+		findings
+	};
+}
+/** Read-only preflight. Call before package-manager conversion, installs,
+* catalog updates, or generic import rewrites can erase the source version. */
+function planVitestV5Migration(workspace, originalProjects) {
+	const findings = [];
+	const directories = [workspace.rootDir, ...(workspace.packages ?? []).map((pkg) => path.resolve(workspace.rootDir, pkg.path))];
+	const projects = [];
+	const projectSources = new Map([...new Set(directories)].map((directory) => [directory, new Map(filesInProject(directory).map((file) => [file, fs.readFileSync(file, "utf8")]))]));
+	const allSources = /* @__PURE__ */ new Map();
+	for (const sources of projectSources.values()) for (const [file, source] of sources) allSources.set(file, source);
+	const rewrittenSources = new Map(allSources);
+	const configEntries = findVitestV5ConfigEntries(allSources, projectSources.keys());
+	const allConfigs = findVitestV5ConfigFiles(allSources, configEntries.flatMap((entry) => entry.file ? [entry.file] : []));
+	const mergedConfigs = findVitestV5MergedConfigFiles(allSources, allConfigs);
+	const browserPossible = [...allSources.values()].some((source) => BROWSER_SIGNAL.test(source));
+	const browserCliOverride = [...allSources].some(([file, source]) => /\.(?:ya?ml|sh)$/.test(file) && /\b(?:vitest|vp\s+test)\b[^\n]*--(?:no-)?browser(?:[.=\s'"]|$)/.test(source));
+	const testModesByVersion = /* @__PURE__ */ new Map();
+	const inputs = new Map(allSources);
+	for (const [directory, sources] of projectSources) {
+		const pkg = readJson(path.join(directory, "package.json"));
+		const configFiles = new Set([...allConfigs].filter((file) => sources.has(file)));
+		const original = originalProjects?.get(directory);
+		const version = original ? original.sourceVersion : sourceVersion(directory, workspace.rootDir, pkg, workspace.packageManager);
+		const active = original?.active ?? (!!dependency(pkg, "vitest") || Object.values(record(pkg.scripts) ?? {}).some((command) => typeof command === "string" && VITEST_COMMAND.test(command)) || [...sources].some(([file, source]) => CODE_FILE.test(file) && hasVitestV5SourceUsage(file, source) || configFiles.has(file) && /\btest\s*:/.test(source)));
+		const options = {
+			preserveV4: original?.options.preserveV4 ?? (!!version && import_semver.default.major(version) < 5),
+			reviewV4: !!version && import_semver.default.major(version) < 5,
+			browser: [...sources.values()].some((source) => BROWSER_SIGNAL.test(source)),
+			browserPossible,
+			temporalPolyfill: [...sources.values()].some((source) => /(?:['"]temporal-polyfill\/global['"]|(?:globalThis|global)\.Temporal\s*=|Object\.(?:assign|defineProperty)\(globalThis,\s*(?:\{\s*Temporal|['"]Temporal['"]))/.test(source))
+		};
+		if (active && !version) findings.push(finding(path.join(directory, "package.json"), "source-version", "Cannot determine the original Vitest version. Install the original lockfile, then re-run migration so v4 defaults are not applied to a v5 project.", "block"));
+		if (active && version && import_semver.default.major(version) < 4) findings.push(finding(path.join(directory, "package.json"), "source-version", "Upgrade the original project to Vitest 4 before running this migration.", "block"));
+		const project = {
+			directory,
+			sourceVersion: version,
+			active,
+			options,
+			configFiles,
+			pendingSourceReviews: original?.pendingSourceReviews
+		};
+		projects.push(project);
+		let testModes = testModesByVersion.get(options.preserveV4);
+		if (!testModes) {
+			testModes = resolveVitestV5TestModes(allSources, allConfigs, options.preserveV4, configEntries);
+			testModesByVersion.set(options.preserveV4, testModes);
+		}
+		for (const [file, source] of sources) {
+			if (/[/\\](?:pnpm-lock\.yaml|package-lock\.json|yarn\.lock|bun\.lock)$/.test(file)) continue;
+			const result = scanAndRewriteFile(file, source, project, {
+				...testModes.modes.get(file),
+				...browserCliOverride ? { browser: void 0 } : {}
+			}, mergedConfigs.has(file));
+			findings.push(...testModes.findings.filter((item) => item.file === file));
+			findings.push(...result.findings);
+			if (source !== result.content) rewrittenSources.set(file, result.content);
+		}
+	}
+	findings.push(...migrateWebdriverioDependencies(workspace, rewrittenSources, inputs));
+	return {
+		rootDir: workspace.rootDir,
+		packageManager: workspace.packageManager,
+		projects,
+		findings,
+		changes: [...rewrittenSources].flatMap(([file, after]) => {
+			const before = allSources.get(file);
+			return before !== after ? [{
+				file,
+				before,
+				after
+			}] : [];
+		}),
+		inputs
+	};
+}
+function formatVitestV5Findings(plan) {
+	const unique = [...new Map(plan.findings.map((item) => [`${item.file}:${item.line}:${item.column}:${item.code}:${item.message}`, item])).values()];
+	if (!unique.length) return "";
+	const blocks = unique.filter((item) => item.severity === "block").length;
+	const lines = [`Vitest v5: ${unique.length} review item${unique.length === 1 ? "" : "s"}${blocks ? ` (${blocks} block dependency updates)` : ""}`];
+	let previous = "";
+	for (const item of unique.toSorted((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column)) {
+		if (item.file !== previous) {
+			lines.push(`\n${path.relative(plan.rootDir, item.file) || "."}`);
+			previous = item.file;
+		}
+		lines.push(`  ${item.line}:${item.column} ${item.severity === "block" ? "BLOCK" : "REVIEW"} [${item.code}] ${item.message}`, `    Docs: ${vitestV5Documentation(item.code)}`);
+	}
+	return lines.join("\n");
+}
+/** Apply a fully checked compatibility plan. Refuse stale input so an editor
+* change cannot be overwritten between phases. */
+function applyVitestV5Migration(plan) {
+	if (plan.findings.some((item) => item.severity === "block")) throw new Error("Vitest v5 preflight has blocking findings. No migration edits were applied.");
+	for (const [file, before] of plan.inputs) if ((fs.existsSync(file) ? fs.readFileSync(file, "utf8") : null) !== before) throw new Error(`Migration input changed: ${file}. Re-run vp migrate.`);
+	for (const change of plan.changes) fs.writeFileSync(change.file, change.after);
+	return plan.changes.length;
+}
+/** Upgrade runtime declarations before installers or tool migrators start.
+* Keep source/config edits deferred until the tool version gates pass. */
+function applyVitestV5NodeMigration(plan) {
+	const changes = [];
+	for (const [file, before] of plan.inputs) {
+		if (before === null || ![
+			".node-version",
+			".nvmrc",
+			"package.json"
+		].includes(path.basename(file))) continue;
+		const after = migrateNode(file, before, []);
+		if (after !== before) changes.push({
+			file,
+			before,
+			after
+		});
+	}
+	return applyVitestV5Migration({
+		...plan,
+		changes
+	});
+}
+/** Earlier setup/install steps can change manifests and configs. Re-plan from
+* their current text without losing the runner version captured before install.
+* Apply immediately afterward, so the normal stale-input guard still protects
+* every write. Run this after the earlier tool migration gates have passed. */
+function refreshVitestV5Migration(plan) {
+	return planVitestV5Migration(workspaceFromPlan(plan), new Map(plan.projects.map((project) => [project.directory, project])));
+}
+function vitestV5NeedsMigration(plan) {
+	return plan.changes.length > 0 || plan.projects.some((project) => project.active && project.options.preserveV4);
+}
+function currentProjectConfigs(plan) {
+	const filesByProject = new Map(plan.projects.map((project) => [project.directory, filesInProject(project.directory)]));
+	const sources = new Map([...filesByProject.values()].flat().map((file) => [file, fs.readFileSync(file, "utf8")]));
+	const configs = findVitestV5ConfigFiles(sources, findVitestV5ConfigEntries(sources, filesByProject.keys()).flatMap((entry) => entry.file ? [entry.file] : []));
+	return new Map([...filesByProject].map(([directory, files]) => [directory, files.filter((file) => configs.has(file))]));
+}
+/** Run after other migration steps create or merge configs. Keep the source
+* version and deferred reviews in memory until the final report; no state file. */
+function finishVitestV5Migration(plan) {
+	const findings = [];
+	const completedProjects = /* @__PURE__ */ new Map();
+	const projectConfigs = currentProjectConfigs(plan);
+	const configSources = new Map([...projectConfigs.values()].flat().map((file) => [file, fs.readFileSync(file, "utf8")]));
+	const mergedConfigs = findVitestV5MergedConfigFiles(configSources, new Set(configSources.keys()));
+	for (const project of plan.projects) {
+		if (!project.active || !project.sourceVersion) continue;
+		const configs = projectConfigs.get(project.directory);
+		for (const file of configs) {
+			const before = fs.readFileSync(file, "utf8");
+			try {
+				const result = migrateVitestV5Config(file, before, project.options, mergedConfigs.has(file));
+				findings.push(...result.findings);
+				if (!result.findings.some((finding) => finding.severity === "block") && result.content !== before) fs.writeFileSync(file, result.content);
+			} catch (error) {
+				findings.push(finding(file, "source-parse", `Review this config: ${String(error)}`));
+			}
+		}
+		if (!isDirectoryGitignored(findGitRoot(project.directory) ?? plan.rootDir, path.join(project.directory, ".vitest"))) {
+			const ignore = path.join(project.directory, ".gitignore");
+			const ignored = fs.existsSync(ignore) ? fs.readFileSync(ignore, "utf8") : "";
+			fs.writeFileSync(ignore, `${ignored}${ignored && !ignored.endsWith("\n") ? "\n" : ""}.vitest/\n`);
+		}
+		const pendingSourceReviews = {};
+		for (const item of plan.findings) {
+			if (!DEFERRED_SOURCE_REVIEWS.has(item.code) || !item.file.startsWith(`${project.directory}${path.sep}`)) continue;
+			if (plan.projects.some((other) => other !== project && other.directory.startsWith(`${project.directory}${path.sep}`) && item.file.startsWith(`${other.directory}${path.sep}`))) continue;
+			const relative = path.relative(project.directory, item.file).replaceAll("\\", "/");
+			pendingSourceReviews[relative] ??= [];
+			if (!pendingSourceReviews[relative].includes(item.code)) pendingSourceReviews[relative].push(item.code);
+		}
+		completedProjects.set(project.directory, {
+			...project,
+			options: {
+				...project.options,
+				preserveV4: false
+			},
+			pendingSourceReviews
+		});
+	}
+	const after = planVitestV5Migration(workspaceFromPlan(plan), new Map(plan.projects.map((project) => [project.directory, completedProjects.get(project.directory) ?? project])));
+	return [...findings, ...after.findings];
+}
+//#endregion
+//#region src/migration/compat/runner.ts
 /**
 * Resolve the isolated compat worker emitted at `migration/compat/worker.js`.
 *
@@ -677,7 +3741,25 @@ async function downloadSupportedPackageManager(options) {
 	}
 	return downloadResult;
 }
-async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, preExistingChangedPaths) {
+function completeVitestV5Migration(plan, report) {
+	const findings = finishVitestV5Migration(plan);
+	report.warnings = report.warnings.filter((warning) => !warning.startsWith("Vitest v5:"));
+	const summary = formatVitestV5Findings({
+		rootDir: plan.rootDir,
+		findings
+	});
+	if (summary) addMigrationWarning(report, summary);
+}
+function applyRefreshedVitestV5Migration(plan) {
+	const refreshed = refreshVitestV5Migration(plan);
+	if (refreshed.findings.some((finding) => finding.severity === "block")) {
+		log$1.warn(formatVitestV5Findings(refreshed));
+		cancelAndExit("Resolve the blocking Vitest v5 findings, then re-run `vp migrate`. Earlier setup steps may have changed project files; Vitest v5 edits were not applied.", 1);
+	}
+	applyVitestV5Migration(refreshed);
+	return refreshed;
+}
+async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, vitestV5Plan, preExistingChangedPaths) {
 	const report = createMigrationReport();
 	const migrationProgress = interactive ? spinner({ indicator: "timer" }) : void 0;
 	let migrationProgressStarted = false;
@@ -702,6 +3784,7 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, pr
 			migrationProgressStarted = false;
 		}
 	};
+	applyVitestV5NodeMigration(vitestV5Plan);
 	const downloadResult = await downloadSupportedPackageManager({
 		rootDir: workspaceInfoOptional.rootDir,
 		packageManager: plan.packageManager,
@@ -722,7 +3805,8 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, pr
 	}
 	if (plan.migrateNodeVersionFile && plan.nodeVersionDetection) {
 		updateMigrationProgress("Migrating node version file");
-		migrateNodeVersionManagerFile(workspaceInfo.rootDir, plan.nodeVersionDetection, report);
+		const detection = detectNodeVersionManagerFile(workspaceInfo.rootDir);
+		if (detection) migrateNodeVersionManagerFile(workspaceInfo.rootDir, detection, report);
 	}
 	updateMigrationProgress("Updating setup-vp workflows");
 	migrateSetupVpVersion(workspaceInfo.rootDir, report);
@@ -771,10 +3855,13 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, pr
 			cancelAndExit("Complete the tsup migration manually, then re-run `vp migrate`.", 1);
 		}
 	}
+	vitestV5Plan = applyRefreshedVitestV5Migration(vitestV5Plan);
 	const skipStagedMigration = shouldSkipStagedMigrationForHooks(workspaceInfo.rootDir, plan.shouldSetupHooks, plan.packageManager, workspaceInfo.packages);
 	updateMigrationProgress("Rewriting configs");
 	if (workspaceInfo.isMonorepo) rewriteMonorepo(workspaceInfo, skipStagedMigration, true, report);
 	else rewriteStandaloneProject(workspaceInfo.rootDir, workspaceInfo, skipStagedMigration, true, report);
+	clearMigrationProgress();
+	completeVitestV5Migration(vitestV5Plan, report);
 	if (plan.shouldSetupHooks) {
 		updateMigrationProgress("Configuring git hooks");
 		installGitHooks(workspaceInfo.rootDir, true, report, plan.packageManager, workspaceInfo.packages);
@@ -826,10 +3913,17 @@ async function main() {
 	const initialChangedPaths = await collectChangedFormatPaths(workspaceInfoOptional.rootDir);
 	const preExistingChangedPaths = initialChangedPaths ? new Set(initialChangedPaths) : void 0;
 	const resolvedPackageManager = workspaceInfoOptional.packageManager ?? "unknown";
+	let vitestV5Plan = planVitestV5Migration(workspaceInfoOptional);
+	const vitestV5Preflight = formatVitestV5Findings(vitestV5Plan);
+	if (vitestV5Plan.findings.some((finding) => finding.severity === "block")) {
+		log$1.warn(vitestV5Preflight);
+		cancelAndExit("Resolve the blocking Vitest v5 findings, then re-run `vp migrate`. No project files were changed.", 1);
+	}
 	const rootPkg = readNearestPackageJson(workspaceInfoOptional.rootDir);
 	if (hasVitePlusDependency(rootPkg) && !isForceOverrideMode()) {
 		let convertYarnPnp = await confirmYarnNodeModulesMode(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, workspaceInfoOptional.packageManagerVersion, options.interactive);
-		let didMigrate = false;
+		let didMigrate = vitestV5NeedsMigration(vitestV5Plan);
+		const nodeUpgrades = applyVitestV5NodeMigration(vitestV5Plan);
 		let installDurationMs = 0;
 		let finalInstallOk = true;
 		let canFormatMigratedProject = !process.env.VP_SKIP_INSTALL;
@@ -887,11 +3981,12 @@ async function main() {
 		report.dependencyUpgrades = await collectToolchainVersionChanges(workspaceInfoOptional.rootDir);
 		updateMigrationProgress("Rewriting toolchain imports across the workspace");
 		const coreMigrationResult = finalizeCoreMigrationForExistingVitePlus(workspaceInfoOptional, true, report, pendingCoreMigration);
-		if (coreMigrationResult.scripts || coreMigrationResult.tsconfigTypes || coreMigrationResult.imports || coreMigrationResult.tsdownConfig) didMigrate = true;
+		if (coreMigrationResult.dependencies || coreMigrationResult.scripts || coreMigrationResult.tsconfigTypes || coreMigrationResult.imports || coreMigrationResult.tsdownConfig) didMigrate = true;
 		clearMigrationProgress();
 		const fullSetup = options.full === true;
 		const skippedSetupCandidates = !fullSetup && !hasExplicitExistingVitePlusSetupRequest(options) && hasExistingVitePlusMigrationCandidates(workspaceInfoOptional, options);
 		if (!didMigrate && !convertYarnPnp && report.warnings.length === 0 && !vitePlusBootstrapPending && !(fullSetup ? hasExistingVitePlusMigrationCandidates(workspaceInfoOptional, options) : hasExplicitExistingVitePlusSetupRequest(options))) {
+			if (vitestV5Preflight) log$1.warn(vitestV5Preflight);
 			if (skippedSetupCandidates) log(FULL_MIGRATION_HINT);
 			outro(`This project is already using Vite+! ${accent("Happy coding!")}`);
 			return;
@@ -899,7 +3994,7 @@ async function main() {
 		const setupOptions = getExistingVitePlusSetupOptions(options, fullSetup);
 		const plan = await collectMigrationSetupPlan(workspaceInfoOptional.rootDir, packageManager, setupOptions, workspaceInfoOptional.packages, fullSetup);
 		const frameworkShimFrameworks = fullSetup ? await collectFrameworkShimFrameworks(workspaceInfoOptional.rootDir, options, workspaceInfoOptional.packages) : void 0;
-		let needsInstall = false;
+		let needsInstall = coreMigrationResult.dependencies || nodeUpgrades > 0;
 		if (vitePlusBootstrapPending) {
 			const downloadResult = await ensureExistingPackageManager();
 			if (downloadResult && packageManager) {
@@ -991,6 +4086,12 @@ async function main() {
 			}
 		}
 		if (addFrameworkShimsForWorkspace(workspaceInfoOptional.rootDir, frameworkShimFrameworks, workspaceInfoOptional.packages, report, updateMigrationProgress)) didMigrate = true;
+		vitestV5Plan = applyRefreshedVitestV5Migration(vitestV5Plan);
+		needsInstall ||= vitestV5Plan.changes.some(({ file }) => [
+			"package.json",
+			"pnpm-workspace.yaml",
+			".yarnrc.yml"
+		].includes(path.basename(file)));
 		if (eslintMigrated || prettierMigrated || tsupMigrated) {
 			updateMigrationProgress("Rewriting configs");
 			mergeViteConfigFiles(workspaceInfoOptional.rootDir, true, report, workspaceInfoOptional.packages);
@@ -1013,6 +4114,8 @@ async function main() {
 			}
 		}
 		if (needsInstall) {
+			clearMigrationProgress();
+			completeVitestV5Migration(vitestV5Plan, report);
 			const resolved = await ensureExistingPackageManager();
 			updateMigrationProgress("Installing dependencies");
 			const resolvedVersion = resolved?.version ?? packageManagerVersion;
@@ -1053,6 +4156,10 @@ async function main() {
 			});
 			didMigrate = true;
 		}
+		if (!needsInstall) {
+			clearMigrationProgress();
+			completeVitestV5Migration(vitestV5Plan, report);
+		}
 		await checkWorkspaceRolldownCompatibility(workspaceInfoOptional, report, updateMigrationProgress);
 		if (didMigrate && finalInstallOk && canFormatMigratedProject && canFormatWithOxfmt(prettierProject.hasDependency, prettierMigrated)) {
 			clearMigrationProgress();
@@ -1078,7 +4185,7 @@ async function main() {
 		return;
 	}
 	const plan = await collectMigrationPlan(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, workspaceInfoOptional.packageManagerVersion, options, workspaceInfoOptional.packages);
-	const result = await executeMigrationPlan(workspaceInfoOptional, plan, options.interactive, preExistingChangedPaths);
+	const result = await executeMigrationPlan(workspaceInfoOptional, plan, options.interactive, vitestV5Plan, preExistingChangedPaths);
 	showMigrationSummary({
 		projectRoot: workspaceInfoOptional.rootDir,
 		packageManager: plan.packageManager,