vite-plus 1.3.0 → 1.5.0

package/dist/migration/bin.js

@@ -1,129 +1,1544 @@
-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 { _ as engines, a as SETUP_VP_VERSION, d as VITE_PLUS_OVERRIDE_PACKAGES, f as VITE_PLUS_VERSION, m as isForceOverrideMode } from "../constants-DR55DpRm.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 hasVitePlusDependency, i as hasPackageManagerDeclaration, n as detectPackageMetadata, o as readNearestPackageJson } from "../package-CQDXTm6j.js";
-import { t as vitest_v5_entry_points_default } from "../vitest-v5-entry-points-DthU1e_O.js";
-import { C as confirm, D as outro, M as isCancel, O as select, S as normalize$1, T as log$1, c as selectPackageManager, i as promptGitHooks, k as spinner, l as upgradeYarn, n as defaultInteractive, o as runViteFmt, r as downloadPackageManager$1, s as runViteInstall, t as cancelAndExit, x as getMajor, y as PackageManager } from "../prompts-1xNz_ne0.js";
-import { _ as isGreaterThanOrEqual, p as compare } from "../comparison-CmVirWIW-DUGaiYqF.js";
-import { a as rangeToComparators, i as normalizeRange, n as findMinimumForRange, o as rangesIntersect, r as isRangeSubset, s as satisfies, t as extractOverrideTargetName } from "../package-overrides-D1RcXSFl.js";
-import { i as selectAgentTargetPaths, l as displayRelative, n as detectAgentConflicts, r as detectExistingAgentTargetPaths, s as writeAgentInstructions } from "../agent-97KmGCyL.js";
-import { n as addMigrationWarning, r as createMigrationReport } from "../report-NhQk8VHb.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-CtJGQP7C.js";
-import { n as runCommandSilently } from "../command-CdMBoZFD.js";
-import { t as require_dist } from "../dist-DIpm7mot.js";
-import { a as hasBaseUrlInTsconfig, i as fixBaseUrlInTsconfig, t as confirmBaseUrlFix } from "../tsconfig-BZu7kl-x.js";
-import { t as unwrapCliParseOutcome } from "../cli-parse-DHE8NrBU.js";
-import { t as ROLLDOWN_COMPAT_RESULT_PREFIX } from "../protocol-D99W10Qi.js";
+import { C as confirm, D as outro, M as isCancel, O as select, S as normalize$1, T as log, c as selectPackageManager, i as promptGitHooks, k as spinner, l as upgradeYarn, n as defaultInteractive, o as runViteFmt, r as downloadPackageManager$1, s as runViteInstall, t as cancelAndExit, x as getMajor, y as PackageManager } from "../prompts-C7DI63WP.js";
+import { a as rangeToComparators, i as normalizeRange, n as findMinimumForRange, o as rangesIntersect, r as isRangeSubset, s as satisfies, t as extractOverrideTargetName } from "../package-overrides-Ci8GXouY.js";
+import { i as selectAgentTargetPaths, l as displayRelative, n as detectAgentConflicts, r as detectExistingAgentTargetPaths, s as writeAgentInstructions } from "../agent-DkQD3xqe.js";
+import { t as unwrapCliParseOutcome } from "../cli-parse-aeUeFDlC.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-D2P2aVKb.js";
+import { A as detectVitePlusBootstrapPending, C as removeMigratedOxlintConfigs, Ct as readPackageJsonIfExists, D as mergeViteConfigFiles, E as mergeTsdownConfigFile, F as detectYarnPnpMode, I as createCatalogDependencyResolver, J as detectFramework, K as extractOverrideParentSegments, M as sourceTreeMatches, N as usesWebdriverioProvider, O as retryPreservedOxlintConfigs, P as configureYarnNodeModulesMode, Q as migrateTsupToTsdown, R as detectWorkspace$1, S as prepareOxlintConfigs, St as isPlainRecord, T as injectLintTypeCheckDefaults, U as minimatch, W as findGitRoot, X as confirmTsupMigration, Y as hasFrameworkShim, Z as detectTsupProject, _ as hasExistingViteHooksPolicy, _t as SHELL_STATE_COMMANDS, at as warnPackageLevelPrettier, b as preflightGitHooksSetup, bt as checkVitestVersion, ct as detectIncompatibleEslintIntegration, d as finalizeCoreMigrationForExistingVitePlus, dt as warnIncompatibleEslintIntegration, et as warnMissingTsupConfig, f as detectNodeVersionManagerFile, ft as warnLegacyEslintConfig, g as detectLegacyGitHooksMigrationCandidate, gt as RETENTION_SCAN_SKIP_DIRS, ht as LINT_STAGED_JSON_CONFIG_FILES, i as selectEditor, j as ensureVitePlusBootstrap, k as collectToolchainVersionChanges, l as rewriteStandaloneProject, lt as migrateEslintToOxlint, m as migrateSetupVpVersion, mt as detectMigrationWarnings, nt as detectPrettierProject, o as writeEditorConfigs, ot as confirmEslintMigration, p as migrateNodeVersionManagerFile, pt as warnPackageLevelEslint, q as addFrameworkShim, r as isJsonLikeFile, rt as migratePrettierToOxfmt, s as rewriteMonorepo, st as detectEslintProject, t as detectEditorConflicts, tt as confirmPrettierMigration, u as detectPendingCoreMigration, v as installGitHooks, vt as WEBDRIVERIO_PROVIDER, wt as warnMigration, x as shouldSkipStagedMigrationForHooks, xt as getCommandStartIndex, y as isViteHooksSetupComplete, yt as checkViteVersion } from "../editor-aOy1T15H.js";
+import { a as hasVitePlusDependency, i as hasPackageManagerDeclaration, n as detectPackageMetadata, o as readNearestPackageJson } from "../package-DfFo6-E-.js";
+import { a as muted, c as warnMsg, i as log$1, o as printHeader, r as formatDuration, t as accent } from "../terminal-BcuPUy-j.js";
+import { a as hasBaseUrlInTsconfig, i as fixBaseUrlInTsconfig, t as confirmBaseUrlFix } from "../tsconfig-shNmmCE_.js";
+import { i as runCommandSilently } from "../command-rY79K5NI.js";
+import { n as addMigrationWarning, r as createMigrationReport } from "../report-BEdpIQvC.js";
+import { t as ROLLDOWN_COMPAT_RESULT_PREFIX } from "../protocol-CkNmY-Mr.js";
+import { a as writeJsonFile, c as modify, i as readJsonFile, l as parse, n as editJsonFile, o as applyEdits$1, r as isJsonFile, s as findNodeAtLocation, u as parseTree } from "../json-kl84kDyH.js";
+import { _ as isGreaterThanOrEqual, p as compare } from "../comparison-CmVirWIW-UlEf2maz.js";
+import { t as require_dist } from "../dist-Bs0SObNC.js";
+import { t as documentationUrl$1 } from "../documentation-cv_y0Auv.js";
+import { t as vitest_v5_entry_points_default } from "../vitest-v5-entry-points-NyJsFeux.js";
+import { i as WATCH_OPTIONS_WITH_VALUE, n as SCRIPT_EXTENSIONS, t as NODE_OPTIONS_WITH_VALUE } from "../vpx-script-EXgV5QOf.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { analyzeMigrationSource, isDirectoryGitignored, parseMigrateArgs } from "../../binding/index.js";
+import { ResolverFactory, analyzeMigrationSource, isDirectoryGitignored, parseLiteralCommands, parseMigrateArgs, parseSync } from "../../binding/index.js";
 import { styleText } from "node:util";
 import fs, { existsSync } from "node:fs";
-//#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;
-		}
+import os from "node:os";
+// src/migration/migrator/tsx.ts
+const TSX_COMMAND = /(?:^|[\s;&|("'=/\\`])tsx(?:\.(?:cmd|exe|ps1))?(?:\/(?:esm|cjs))?(?=$|[\s;&|)"'`])/i;
+const TSX_LOADER = /^tsx(?:\/(?:esm|cjs))?$/;
+const KEEP_EVAL = "`vpx` does not run TypeScript passed to --eval or --print";
+const KEEP_CHECK = "`vpx` does not transform TypeScript for -c or --check";
+const KEEP_REPL$1 = "`vpx` does not start a TypeScript REPL";
+const KEEP_TEST_GLOBS = "`--test` without files finds `.ts` tests with tsx globs; list the test files for `vpx --test`";
+const KEEP_WATCH_PATH = "`--watch-path` has no `vpx` equivalent; use `--include`";
+const KEEP_NODE_OPTIONS = "`NODE_OPTIONS` loads tsx, whose hooks would compete with those of `vpx`; remove it first";
+const KEEP_OPTIONS = /* @__PURE__ */ new Map([
+	["-e", KEEP_EVAL],
+	["--eval", KEEP_EVAL],
+	["-p", KEEP_EVAL],
+	["--print", KEEP_EVAL],
+	["-pe", KEEP_EVAL],
+	["-c", KEEP_CHECK],
+	["--check", KEEP_CHECK],
+	["-i", KEEP_REPL$1],
+	["--interactive", KEEP_REPL$1],
+	["--watch-path", KEEP_WATCH_PATH]
+]);
+const TSX_ENV_SHEBANG = /^(#!\s*\S*\benv\s+(?:-S\s+)?)(tsx(?=[ \t\r\n]|$)[^\r\n]*)/;
+const TSX_SHEBANG = /^#![^\n]*[\s/]tsx(?=\s|$)/;
+const TSX_LOADER_FLAG = /(?:(?:--import|--loader|--experimental-loader|--require|-r)[= \t]+|(?<![\w-])(?:import|loader|experimental-loader|require)=)['"]?tsx(?:\/(?:esm|cjs))?(?![\w./-])/;
+const TSX_CODE_REFERENCE = new RegExp([
+	/(?:\bfrom|\bimport|\bimport\.meta\.resolve|\brequire(?:\.resolve)?)\s*\(?\s*(?:\/\*[\s\S]*?\*\/\s*)*['"`]tsx(?:\/[^'"`]*)?['"`]/.source,
+	/['"`](?:npx |pnpm (?:exec )?|yarn |bunx )?tsx\s/.source,
+	/\(\s*\[?\s*['"`]tsx['"`]\s*[,)\]]/.source,
+	TSX_LOADER_FLAG.source,
+	/['"`](?:--import|--loader|--experimental-loader|--require|-r)['"`]\s*,\s*['"`]tsx(?:\/(?:esm|cjs))?['"`]/.source
+].join("|"));
+const JSDOC_TYPE_TAG = /(?:^|\s)@(arg|argument|augments|enum|extends|implements|import|param|prop|property|return|returns|satisfies|template|this|type|typedef)\b\s*/g;
+const JSDOC_PARAMETER_NAME = /^[^\s{[=]+(?:\[\])?(?:\.[^\s{[=]+)*/;
+const JSDOC_TEMPLATE_PARAMETER_NAME = /^(?:(?:in|out|const)\s+)*[$\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*/u;
+const TSX_IMPORT_TYPE = /\bimport\s*\(\s*(['"])tsx(?:\/[^'"]*)?\1\s*(?:,|\))/;
+const TSX_JSDOC_IMPORT = /^(?:[^\s{},]+\s*,\s*)?(?:\{[^}]*\}|\*\s+as\s+[^\s{},]+|[^\s{},]+)\s+from\s*(['"])tsx(?:\/[^'"]*)?\1/;
+const TSX_TEXT_REFERENCE = new RegExp([/(?:^|[\s;&|("'=/\\`])tsx(?:\.(?:cmd|exe|ps1))?(?:\/(?:esm|cjs))?['"]?(?:[ \t]+\S|[ \t]*$)/.source, TSX_LOADER_FLAG.source].join("|"), "m");
+const TSX_CONFIG_VALUE = new RegExp([
+	/(?:^|[\s;&|("'=/\\`])tsx(?:\.(?:cmd|exe|ps1))?[ \t]+\S/.source,
+	TSX_LOADER_FLAG.source,
+	/^tsx\//.source
+].join("|"), "i");
+const ESM_SYNTAX = /(?:^|;)\s*(?:import(?![\w$])\s*(?![\w$]+\s*=)[\w*{'"]|export(?![\w$])\s*[\w*{])|\bimport\.meta\b/m;
+const COMMONJS_GLOBALS = [
+	["__dirname", /(?<![.\w$])__dirname\b/],
+	["__filename", /(?<![.\w$])__filename\b/],
+	["require", /(?<![.\w$])require\s*(?:\(|\.\s*[\w$])/],
+	["exports", /(?<![.\w$'"`])exports(?![\w$'"`]|\s*:)/],
+	["module", /(?<![.\w$])module\s*(?:\.\s*[\w$]|\[)/]
+];
+const EXPORT_ASSIGNMENT = /(?:^|;)\s*export\s*=/m;
+const RELATIVE_REQUIRE = /(?<![.\w$])require\s*\(\s*['"`](\.{1,2}\/[^'"`]+?)\.(js|cjs|mjs|jsx)['"`]/g;
+const TYPESCRIPT_EXTENSIONS = {
+	js: ["ts", "tsx"],
+	cjs: ["cts"],
+	mjs: ["mts"],
+	jsx: ["tsx"]
+};
+const TSX_RUNNER = {
+	name: "tsx",
+	dependencies: ["tsx"],
+	commandPattern: TSX_COMMAND,
+	loaderPattern: TSX_LOADER,
+	isRegister: (option, value) => option === "--import" && value === "tsx",
+	envShebang: TSX_ENV_SHEBANG,
+	shebangPattern: TSX_SHEBANG,
+	codeReference: TSX_CODE_REFERENCE,
+	codeUsesRunner: codeUsesTsx,
+	textReference: TSX_TEXT_REFERENCE,
+	configValue: TSX_CONFIG_VALUE,
+	keepOptions: KEEP_OPTIONS,
+	dropOptions: /* @__PURE__ */ new Set(["--no-cache"]),
+	optionsWithValue: /* @__PURE__ */ new Set([...WATCH_OPTIONS_WITH_VALUE, "--tsconfig"]),
+	testWithoutFilesReason: KEEP_TEST_GLOBS,
+	envKeepReason,
+	scriptKeepReason: (cwd, script) => typescriptScriptKeepReason(cwd, script, "tsx")
+};
+function detectTsxProject(rootDir, packages) {
+	return detectScriptRunnerProject(TSX_RUNNER, rootDir, packages);
+}
+function migrateTsxToVpx(rootDir, packages, report) {
+	const result = migrateScriptRunnerToVpx(TSX_RUNNER, rootDir, packages, report);
+	if (report && result.scriptsChanged) report.tsxMigrated = true;
+	return {
+		changed: result.changed,
+		dependencyRemoved: result.dependencyRemoved
+	};
+}
+/**
+* Why environment assignments keep tsx for the command they apply to, or undefined.
+* Names match in any case, as on Windows.
+*/
+function envKeepReason(assignments) {
+	if (assignments.some((value) => /^NODE_OPTIONS=/i.test(value) && TSX_COMMAND.test(value.slice(13)))) return KEEP_NODE_OPTIONS;
+}
+/**
+* Why `vpx` would fail on a script that tsx runs, judged from its source. tsx resolves
+* `require('./a.js')` to `a.ts`, and compiles ES module syntax to CommonJS in a `.cts`
+* file and in a package without `"type": "module"`. `vpx` resolves `require()` as
+* Node.js does, rejects ES module syntax in a `.cts` file, and runs the other files as ES
+* modules, so `__dirname`, `__filename`, and `require` are not defined.
+*/
+function typescriptScriptKeepReason(cwd, script, runner) {
+	if (cwd === void 0 || /[*?[{]/.test(script) || !SCRIPT_EXTENSIONS.some((extension) => script.endsWith(extension))) return;
+	const file = script.startsWith("~/") ? path.join(os.homedir(), script.slice(2)) : path.resolve(cwd, script);
+	let source;
+	try {
+		source = fs.readFileSync(file, "utf8");
+	} catch (error) {
+		return error.code === "ENOENT" ? `\`${script}\` does not exist yet, so vp migrate cannot check it` : void 0;
 	}
-	if (quote) return;
-	if (active) tokens.push({
-		value,
-		start,
-		end: command.length
-	});
-	return tokens;
+	if (runner === "tsx") for (const [, base, extension] of source.matchAll(RELATIVE_REQUIRE)) {
+		const resolve = (ext) => path.resolve(path.dirname(file), `${base}.${ext}`);
+		const typescript = fs.existsSync(resolve(extension)) ? void 0 : TYPESCRIPT_EXTENSIONS[extension].find((ext) => fs.existsSync(resolve(ext)));
+		if (typescript) return `\`${script}\` requires \`${base}.${extension}\`, which only ${runner} resolves to \`${base}.${typescript}\`; write the TypeScript extension`;
+	}
+	const code = stripComments(source);
+	if (!/\.(?:c?ts|tsx|jsx?)$/.test(script) || !(ESM_SYNTAX.test(source) || ESM_SYNTAX.test(code))) return;
+	if (script.endsWith(".cts")) return `\`${script}\` uses import or export, which \`vpx\` does not compile to CommonJS; rename it to .mts`;
+	if ((usesCommonJsGlobals(code) || EXPORT_ASSIGNMENT.test(code)) && readNearestPackageJson(path.dirname(file))?.type !== "module") return `\`${script}\` mixes import or export with CommonJS globals such as __dirname, require, or module.exports, and \`vpx\` runs it as an ES module; use import.meta.dirname, import.meta.filename, createRequire(), or export`;
 }
-/** 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;
+/** `source` without comments; a string that only looks like one, as in `'http://x'`, stays. */
+function stripComments(source) {
+	return source.replaceAll(/("(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'|`(?:\\.|[^`\\])*`)|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, (_, string) => string ?? "");
+}
+/**
+* Whether `code`, without comments, uses a CommonJS global it does not declare or import
+* at module level, as in `const require = createRequire(import.meta.url)` or `import
+* module from 'node:module'`. A declaration inside a function, which an unindented line
+* does not start, covers only that function.
+*/
+function usesCommonJsGlobals(code) {
+	return COMMONJS_GLOBALS.some(([name, use]) => use.test(code) && !new RegExp(`^(?:(?:export\\s+)?(?:const|let|var|function|class)\\s+${name}\\b|import\\s+(?:\\*\\s+as\\s+)?${name}\\b)`, "m").test(code));
+}
+/** Whether a JSDoc type annotation or import tag needs tsx's declarations. */
+function jsdocUsesTsx(value) {
+	if (!value.startsWith("*")) return false;
+	const text = value.replaceAll(/^\s*\* ?/gm, "").replaceAll(/```[\s\S]*?(?:```|$)|~~~[\s\S]*?(?:~~~|$)/g, "");
+	for (const match of text.matchAll(JSDOC_TYPE_TAG)) {
+		const [tag, name] = match;
+		if (jsdocTagUsesTsx(name, text.slice(match.index + tag.length))) return true;
+	}
+	return false;
+}
+function jsdocTagUsesTsx(name, body) {
+	if (name === "import") return TSX_JSDOC_IMPORT.test(body);
+	if (/^(?:arg|argument|param|prop|property)$/.test(name) && !body.startsWith("{")) {
+		const end = body.startsWith("[") ? jsdocDelimitedEnd(body) : JSDOC_PARAMETER_NAME.exec(body)?.[0].length;
+		if (end === void 0) return false;
+		body = body.slice(end).trimStart();
+	}
+	if (body.startsWith("{")) {
+		const end = jsdocDelimitedEnd(body);
+		if (end === void 0) return false;
+		if (TSX_IMPORT_TYPE.test(body.slice(0, end))) return true;
+		body = body.slice(end).trimStart();
+	} else if (/^(?:type|this|enum|augments|extends|implements)$/.test(name)) return jsdocUnbracedTypeUsesTsx(body);
+	if (name !== "template") return false;
+	while (body) {
+		const hasDefault = body.startsWith("[");
+		const end = hasDefault ? jsdocDelimitedEnd(body) : JSDOC_TEMPLATE_PARAMETER_NAME.exec(body)?.[0].length;
+		if (end === void 0) return false;
+		if (hasDefault && TSX_IMPORT_TYPE.test(body.slice(0, end))) return true;
+		body = body.slice(end).trimStart();
+		if (!body.startsWith(",")) return false;
+		body = body.slice(1).trimStart();
+	}
+	return false;
+}
+/** End of a braced type or bracketed name/default, excluding trailing prose. */
+function jsdocDelimitedEnd(body) {
+	const open = body[0];
+	const close = open === "{" ? "}" : "]";
+	let depth = 0;
+	for (const token of body.matchAll(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|[{}[\]]/g)) if (token[0] === open) depth++;
+	else if (token[0] === close && --depth === 0) return token.index + 1;
+}
+/** Find the complete unbraced type before a tag's description or the next tag. */
+function jsdocUnbracedTypeUsesTsx(body) {
+	if (!TSX_IMPORT_TYPE.test(body)) return false;
+	const boundaries = Array.from(body.matchAll(/\s+|$/g)).toReversed();
+	for (const boundary of boundaries) {
+		const type = body.slice(0, boundary.index);
+		if (parseSync("jsdoc.ts", `type T = (${type});`).errors.length > 0) continue;
+		if (TSX_IMPORT_TYPE.test(type)) return true;
+		const rest = body.slice(boundary.index).trimStart();
+		return /^(?:[|&<.([?!:]|extends\b|is\b)/.test(rest) && TSX_IMPORT_TYPE.test(rest);
+	}
+	return true;
+}
+/** Whether source code or JSDoc types still need tsx. */
+function codeUsesTsx(content, file) {
+	if (!content.includes("tsx")) return false;
+	if (!SCRIPT_EXTENSIONS.includes(path.extname(file))) return TSX_CODE_REFERENCE.test(content);
+	const parsed = parseSync(file, content);
+	if (parsed.errors.length > 0) return TSX_CODE_REFERENCE.test(content);
+	const isJavaScript = /\.(?:[cm]?js|jsx)$/.test(file);
+	let codeWithoutComments = "";
+	let offset = 0;
+	for (const comment of parsed.comments) {
+		if (isJavaScript && comment.type === "Block" && jsdocUsesTsx(comment.value)) return true;
+		codeWithoutComments += `${content.slice(offset, comment.start)} `;
+		offset = comment.end;
+	}
+	return TSX_CODE_REFERENCE.test(codeWithoutComments + content.slice(offset));
+}
+async function confirmTsxMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate tsx scripts to Vite+?\n  " + styleText("gray", "`tsx <file>` becomes `vpx <file>`, `tsx watch` becomes `vpx --watch`, and `node --import tsx` uses `vite-plus/register`. The tsx dependency is removed once nothing uses it."),
+			initialValue: true
+		});
+		if (isCancel(confirmed)) cancelAndExit();
+		return confirmed;
+	}
+	log.info("tsx scripts detected. Auto-migrating to Vite+...");
+	return true;
+}
+// src/migration/migrator/script-runner.ts
+const LOADER_OPTIONS = /* @__PURE__ */ new Set([
+	"--import",
+	"--loader",
+	"--experimental-loader",
+	"--require",
+	"-r"
+]);
+const LOADER_SETTINGS = /* @__PURE__ */ new Set([
+	"import",
+	"loader",
+	"require"
+]);
+const KEEP_REPL = "`vpx` does not start a TypeScript REPL";
+const KEEP_SHELL = "the command uses shell syntax that vp migrate does not rewrite, such as pipes, variables, or subshells";
+const KEEP_WATCH_TEST = "`vpx --watch` does not run `--test`";
+const IGNORED_FIELDS = /* @__PURE__ */ new Set([
+	"bundleDependencies",
+	"bundledDependencies",
+	"dependencies",
+	"description",
+	"devDependencies",
+	"keywords",
+	"name",
+	"optionalDependencies",
+	"overrides",
+	"peerDependencies",
+	"peerDependenciesMeta",
+	"pnpm",
+	"resolutions"
+]);
+const CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+	...SCRIPT_EXTENSIONS,
+	".astro",
+	".svelte",
+	".vue"
+]);
+const REFERENCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	...CODE_EXTENSIONS,
+	".json",
+	".jsonc",
+	".toml",
+	".yml",
+	".yaml",
+	".sh",
+	".bash",
+	".zsh",
+	".fish",
+	".ps1",
+	".cmd",
+	".bat"
+]);
+const LOCKFILES = /* @__PURE__ */ new Set([
+	"bun.lock",
+	"npm-shrinkwrap.json",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"yarn.lock"
+]);
+const USE_SCAN_SKIP_DIRS = /* @__PURE__ */ new Set([
+	...RETENTION_SCAN_SKIP_DIRS,
+	".cache",
+	".next",
+	".nuxt",
+	".svelte-kit",
+	".turbo",
+	".vite",
+	"coverage"
+]);
+const shellCommand = (previous) => /^-[a-z]*c$/.test(previous);
+const COMMAND_LAUNCHERS = /* @__PURE__ */ new Map([
+	["bash", shellCommand],
+	["concurrently", () => true],
+	["nodemon", (previous) => previous === "--exec" || previous === "-x"],
+	["sh", shellCommand],
+	["zsh", shellCommand]
+]);
+/**
+* Rewrite supported runner and Node.js loader invocations while preserving shell
+* syntax and arguments. Unsupported forms remain, with their reasons in `kept`.
+*/
+function rewriteScriptRunnerCommand(runner, command, cwd, environment = [], checkingScripts = /* @__PURE__ */ new Set()) {
+	if (!runner.commandPattern.test(command) && !runner.envKeepReason(environment)) return {
+		command,
+		kept: []
+	};
+	const segments = parseLiteralCommands(command, true);
+	if (!segments || /%\w+%/.test(command)) return {
+		command,
+		kept: [KEEP_SHELL]
 	};
-	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;
+	const rewrite = {
+		command,
+		cwd,
+		environment,
+		edits: [],
+		kept: [],
+		checkingScripts
+	};
+	for (const tokens of segments) {
+		const name = tokens[0].value;
+		if (SHELL_STATE_COMMANDS.includes(name) || name === "chdir") {
+			rewrite.cwd = void 0;
+			continue;
 		}
+		rewriteSegment(runner, rewrite, tokens);
 	}
-	return !quote && append(command.length) ? commands : void 0;
+	const rewritten = applyEdits(command, rewrite.edits);
+	if (!rewrite.kept.length && runner.commandPattern.test(rewritten)) rewrite.kept.push(`vp migrate does not rewrite this use of ${runner.name}`);
+	return {
+		command: rewritten,
+		kept: rewrite.kept
+	};
 }
-/** Locate the runner's arguments after a supported package-manager wrapper. */
-function vitestCommandArgsStart(values) {
-	let start = 0;
+function rewriteSegment(runner, rewrite, tokens) {
+	const values = tokens.map(({ value }) => value);
+	let first = 0;
+	const skipAssignments = () => {
+		while (/^[A-Za-z_]\w*=/.test(values[first] ?? "")) first++;
+	};
+	skipAssignments();
+	const shell = values[first] === "cross-env-shell";
+	if (values[first] === "cross-env" || shell) {
+		first++;
+		skipAssignments();
+	}
+	let unknownEnvironment = false;
+	while (values[first] === "env") {
+		first++;
+		if (values[first] === "--") first++;
+		if (values[first]?.startsWith("-")) {
+			unknownEnvironment = true;
+			break;
+		}
+		skipAssignments();
+	}
+	if (first >= values.length) return;
+	const assignments = [...rewrite.environment, ...values.slice(0, first)];
+	const envReason = runner.envKeepReason(assignments);
+	const environment = scanEnvironmentOptions(runner, assignments);
+	if (unknownEnvironment) environment.keepReason ??= inheritedOptionsKeepReason(runner);
+	environment.keepReason ??= runner.registerEnvKeepReason?.(assignments);
+	environment.keepReason ??= environment.preloads.map((script) => runner.scriptKeepReason?.(rewrite.cwd, script)).find((reason) => reason !== void 0);
+	const editStart = rewrite.edits.length;
+	const keptStart = rewrite.kept.length;
+	const start = first + getCommandStartIndex(values.slice(first));
 	if ([
+		"env",
+		"cross-env",
+		"cross-env-shell"
+	].includes(values[start])) environment.keepReason ??= inheritedOptionsKeepReason(runner);
+	const launcher = COMMAND_LAUNCHERS.get(values[start]);
+	if (values[start] === runner.name || runner.aliases?.includes(values[start])) rewriteRunner(runner, rewrite, tokens, first, start, envReason ?? environment.keepReason, assignments);
+	else if (values[start] === "node") rewriteNodeLoader(runner, rewrite, tokens, first, start, envReason, assignments, environment);
+	else if (shell || launcher) {
+		const commands = shell ? tokens.slice(start) : tokens.slice(start + 1).filter((_, index) => launcher(values[start + index]));
+		let checked = commands.length > 0;
+		for (const token of commands) if (!rewriteQuotedCommand(runner, rewrite, token, assignments)) checked = false;
+		if (!checked && environment.replacements.length && runner.registerEnvRequiresNode) rewrite.kept.push(`vp migrate only replaces ${runner.name} in NODE_OPTIONS when every launcher target is a quoted literal node command`);
+	} else if (values.slice(start).some((value) => runner.commandPattern.test(value))) rewrite.kept.push(`vp migrate does not rewrite this use of ${runner.name}`);
+	else if (environment.replacements.length && runner.registerEnvRequiresNode) rewrite.kept.push(`vp migrate only replaces ${runner.name} in NODE_OPTIONS for a literal node command`);
+	if (!environment.replacements.length) return;
+	const taskStart = [
+		"npm",
 		"pnpm",
+		"yarn",
+		"bun"
+	].includes(values[start]) ? start : first;
+	const reason = environment.keepReason ?? packageTaskKeepReason(runner, rewrite, values.slice(taskStart), assignments);
+	if (reason && rewrite.kept.length === keptStart) rewrite.kept.push(reason);
+	if (rewrite.kept.length !== keptStart) {
+		rewrite.edits.length = editStart;
+		return;
+	}
+	for (const replacement of environment.replacements) {
+		const index = replacement.index - rewrite.environment.length;
+		if (index >= 0) rewrite.edits.push(literalEdit(rewrite.command, tokens[index], replacement.value));
+	}
+}
+function inheritedOptionsKeepReason(runner) {
+	return `\`NODE_OPTIONS\` loads ${runner.name} into a child command that vp migrate cannot check`;
+}
+/** Check package scripts that inherit a preload without changing their definitions here. */
+function taskKeepReason(runner, rewrite, name, inherited, lifecycle) {
+	if (!name || !rewrite.cwd) return inheritedOptionsKeepReason(runner);
+	const scripts = readNearestPackageJson(rewrite.cwd)?.scripts;
+	if (!isPlainRecord(scripts) || typeof scripts[name] !== "string") return inheritedOptionsKeepReason(runner);
+	const names = lifecycle ? [
+		`pre${name}`,
+		name,
+		`post${name}`
+	] : [name];
+	for (const task of names) {
+		const command = scripts[task];
+		if (typeof command !== "string") continue;
+		const key = `${rewrite.cwd}\0${task}`;
+		if (rewrite.checkingScripts.has(key)) return inheritedOptionsKeepReason(runner);
+		const checking = /* @__PURE__ */ new Set([...rewrite.checkingScripts, key]);
+		const migrated = rewriteScriptRunnerCommand(runner, command, rewrite.cwd, [], checking);
+		const reason = migrated.kept[0] ?? rewriteScriptRunnerCommand(runner, migrated.command, rewrite.cwd, inherited, checking).kept[0];
+		if (reason) return `script \`${task}\` needs ${runner.name}: ${reason}`;
+	}
+}
+function packageTaskKeepReason(runner, rewrite, values, inherited) {
+	const [manager, command] = values;
+	if (![
 		"npm",
+		"pnpm",
 		"yarn",
-		"bun",
-		"npx",
-		"bunx"
-	].includes(values[0])) {
-		start = 1;
-		if (values[start] === "exec" || values[start] === "x") start++;
-		if (values[start] === "--") start++;
+		"bun"
+	].includes(manager)) return;
+	if ([
+		"exec",
+		"x",
+		"dlx"
+	].includes(command)) return;
+	const explicitRun = command === "run" || command === "run-script";
+	const name = explicitRun ? values[2] : command;
+	const expectedLength = explicitRun ? 3 : 2;
+	if (values.length !== expectedLength || name?.startsWith("-")) return inheritedOptionsKeepReason(runner);
+	return taskKeepReason(runner, rewrite, name, inherited, true);
+}
+function applyEdits(command, pending) {
+	let rewritten = command;
+	const edits = [];
+	for (const edit of pending.toSorted((a, b) => b.start - a.start || b.end - a.end)) {
+		const previous = edits.at(-1);
+		if (previous?.text === "" && edit.text === "" && edit.end >= previous.start) {
+			previous.start = Math.min(previous.start, edit.start);
+			previous.end = Math.max(previous.end, edit.end);
+		} else edits.push({ ...edit });
+	}
+	for (const edit of edits) rewritten = rewritten.slice(0, edit.start) + edit.text + rewritten.slice(edit.end);
+	return rewritten;
+}
+/** Preserve the surrounding quote style when replacing one complete shell token. */
+function literalEdit(command, token, value) {
+	const raw = command.slice(token.start, token.end);
+	const prefix = /^([A-Za-z_]\w*=)/.exec(raw)?.[1] ?? "";
+	const quote = raw[prefix.length];
+	const preserveQuote = prefix !== "" || raw.endsWith(quote);
+	let content = value.slice(prefix.length);
+	if (quote === "'" && preserveQuote) content = `'${content.replaceAll("'", "'\\''")}'`;
+	else if (quote === "\"" && preserveQuote || !/^[\w./=:-]+$/.test(content)) content = `"${content.replaceAll(/[\\"$`]/g, "\\$&")}"`;
+	return {
+		start: token.start,
+		end: token.end,
+		text: `${prefix}${content}`
+	};
+}
+/** NODE_OPTIONS uses double quotes and spaces, not shell single quotes or tab separators. */
+function scanEnvironmentOptions(runner, assignments) {
+	const result = {
+		replacements: [],
+		preloads: [],
+		args: []
+	};
+	for (const [index, assignment] of assignments.entries()) {
+		if (!/^NODE_OPTIONS=/i.test(assignment)) continue;
+		const value = assignment.slice(13);
+		const segments = value.includes("'") || value.replaceAll(/"[^"]*"/g, "").includes("	") ? void 0 : parseLiteralCommands(value, false);
+		if (!segments || segments.length !== 1) {
+			result.args = void 0;
+			if (runner.commandPattern.test(value)) result.keepReason = runner.envKeepReason([assignment]) ?? `NODE_OPTIONS loads ${runner.name} hooks that vp migrate cannot replace`;
+			continue;
+		}
+		result.args?.push(...segments[0].map(({ value }) => value));
+		const scanned = scanOptions(runner, segments[0], 0, false);
+		result.preloads.push(...scanned.preloads);
+		result.keepReason ??= scanned.registerKeepReason;
+		if (scanned.loaders !== scanned.imports.length || scanned.entryIndex !== segments[0].length) {
+			if (runner.commandPattern.test(value)) result.keepReason = runner.envKeepReason([assignment]) ?? `NODE_OPTIONS loads ${runner.name} hooks that vp migrate cannot replace`;
+			continue;
+		}
+		if (scanned.imports.length) result.replacements.push({
+			index,
+			value: `${assignment.slice(0, 13)}${applyEdits(value, importEdits(value, scanned))}`
+		});
+	}
+	return result;
+}
+/**
+* An option's name without `=value`. Node.js reads `_` as `-` in long option names, as
+* in `--watch_path`, and so does `vpx`.
+*/
+function optionName(arg) {
+	const name = arg.split("=", 1)[0];
+	return name.startsWith("--") ? `--${name.slice(2).replaceAll("_", "-")}` : name;
+}
+/** Remove `tokens[index]` with the space before it. */
+function removal(tokens, index) {
+	return {
+		start: tokens[index - 1]?.end ?? tokens[index].start,
+		end: tokens[index].end,
+		text: ""
+	};
+}
+/**
+* Why `vpx` cannot run an invocation: `positionals` are the entry
+* and its arguments, or with `--test`, the test files; `preloads` are local `--require`
+* and `--import` modules, which load first.
+*/
+function runKeepReason(runner, cwd, test, positionals, preloads) {
+	const [entry] = positionals;
+	if (entry === void 0) return test ? runner.testWithoutFilesReason : KEEP_REPL;
+	if (!test && !SCRIPT_EXTENSIONS.some((extension) => entry.endsWith(extension))) return `\`${entry}\` has no file extension, which \`vpx\` needs to run it as a script`;
+	const scripts = test ? positionals.filter((value) => !value.startsWith("-")) : [entry];
+	for (const script of [...preloads, ...scripts]) {
+		const reason = runner.scriptKeepReason?.(cwd, script);
+		if (reason) return reason;
+	}
+}
+function rewriteRunner(runner, rewrite, tokens, first, start, keepReason, environment) {
+	if (keepReason) {
+		rewrite.kept.push(keepReason);
+		return;
+	}
+	const prepared = prepareRun(runner, rewrite, tokens, start, environment, false);
+	if (prepared.keepReason) {
+		rewrite.kept.push(prepared.keepReason);
+		return;
+	}
+	tokens = prepared.tokens;
+	let index = start + 1;
+	const watch = runner.watchSubcommand !== false && tokens[index]?.value === "watch";
+	if (watch) index++;
+	const scanned = scanOptions(runner, tokens, index, true);
+	const reason = runReason(runner, rewrite.cwd, tokens, scanned, watch);
+	if (reason) {
+		rewrite.kept.push(reason);
+		return;
+	}
+	rewrite.edits.push({
+		start: tokens[first].start,
+		end: tokens[index - 1].end,
+		text: watch ? "vpx --watch" : "vpx"
+	}, ...prepared.edits, ...scanned.removals);
+}
+function rewriteNodeLoader(runner, rewrite, tokens, first, start, keepReason, environment, environmentOptions) {
+	const original = scanOptions(runner, tokens, start + 1, false);
+	if (runner.isRegister && original.loaders === original.imports.length && (original.imports.length || environmentOptions.replacements.length)) {
+		const prepared = prepareRun(runner, rewrite, tokens, start, environment, true, environmentOptions);
+		const scanned = scanOptions(runner, prepared.tokens, start + 1, false);
+		const scripts = scanned.inlineCode ? [] : prepared.tokens.slice(scanned.entryIndex).map(({ value }) => value);
+		let reason = environmentOptions.keepReason ?? prepared.keepReason ?? scanned.registerKeepReason;
+		if (reason === void 0 && environmentOptions.replacements.length && scanned.runScript !== void 0) reason = taskKeepReason(runner, rewrite, scanned.entryIndex < prepared.tokens.length ? void 0 : scanned.runScript, environment, false);
+		reason ??= [...scanned.preloads, ...scanned.test ? scripts : scripts.slice(0, 1)].map((script) => runner.scriptKeepReason?.(rewrite.cwd, script)).find((reason) => reason !== void 0);
+		if (reason) rewrite.kept.push(reason);
+		else rewrite.edits.push(...prepared.edits, ...importEdits(rewrite.command, scanned));
+		return;
+	}
+	if (!original.loaders) {
+		const environmentLoader = environment.some((assignment) => /^NODE_OPTIONS=/i.test(assignment) && runner.commandPattern.test(assignment.slice(13)));
+		const reason = original.runnerLoader ? original.keepReason : environmentLoader ? keepReason : void 0;
+		if (reason) rewrite.kept.push(reason);
+		return;
+	}
+	const prepared = prepareRun(runner, rewrite, tokens, start, environment, true);
+	if (prepared.keepReason) {
+		rewrite.kept.push(prepared.keepReason);
+		return;
+	}
+	tokens = prepared.tokens;
+	const scanned = scanOptions(runner, tokens, start + 1, false);
+	if (!scanned.loaders) {
+		if (keepReason) rewrite.kept.push(keepReason);
+		return;
+	}
+	const reason = keepReason ?? runReason(runner, rewrite.cwd, tokens, scanned, false);
+	if (reason) {
+		rewrite.kept.push(reason);
+		return;
+	}
+	rewrite.edits.push({
+		start: tokens[first].start,
+		end: tokens[start].end,
+		text: "vpx"
+	}, ...prepared.edits, ...scanned.removals);
+}
+/** Preserve original source ranges while normalizing runner-specific options. */
+function prepareRun(runner, rewrite, tokens, start, environment, nodeLoader, publicRegister) {
+	const prepared = runner.prepareRun?.(tokens.slice(start + 1).map(({ value }) => value), {
+		cwd: rewrite.cwd,
+		environment,
+		nodeLoader,
+		executable: tokens[start].value,
+		publicRegister: publicRegister !== void 0,
+		nodeOptionsArgs: publicRegister?.args
+	});
+	const edits = [];
+	const added = prepared?.prependArgs?.map(quoteArgument) ?? [];
+	if (added.some((value) => value === void 0) || prepared?.edits?.some((edit) => edit.value !== void 0 && quoteArgument(edit.value) === void 0)) return {
+		tokens,
+		edits,
+		keepReason: "a rewritten argument needs shell escaping that vp migrate does not support"
+	};
+	const changes = new Map(prepared?.edits?.map((edit) => [start + 1 + edit.index, edit]));
+	const normalized = tokens.flatMap((token, index) => {
+		const change = changes.get(index);
+		if (!change) return [token];
+		if (change.value === void 0) {
+			edits.push(removal(tokens, index));
+			return [];
+		}
+		const text = quoteArgument(change.value);
+		edits.push({
+			start: token.start,
+			end: token.end,
+			text
+		});
+		return [{
+			...token,
+			value: change.value
+		}];
+	});
+	if (prepared?.prependArgs?.length) {
+		const position = tokens[start].end;
+		edits.push({
+			start: position,
+			end: position,
+			text: ` ${added.join(" ")}`
+		});
+		normalized.splice(start + 1, 0, ...prepared.prependArgs.map((value) => ({
+			...tokens[start],
+			value,
+			start: position,
+			end: position
+		})));
+	}
+	return {
+		tokens: normalized,
+		edits,
+		keepReason: prepared?.keepReason
+	};
+}
+function quoteArgument(value) {
+	if (/^[\w./:=@+-]+$/.test(value)) return value;
+	return /^[\w./:=@+ -]+$/.test(value) ? `"${value}"` : void 0;
+}
+function importEdits(command, scanned) {
+	const edits = [];
+	for (const { token, value, option } of scanned.imports) {
+		if (option) edits.push(literalEdit(command, option, "--import"));
+		edits.push(literalEdit(command, token, value));
+	}
+	return edits;
+}
+/** Read options from the executable to the entry file. */
+function scanOptions(runner, tokens, index, directRunner) {
+	const scanned = {
+		entryIndex: tokens.length,
+		removals: [],
+		loaders: 0,
+		runnerLoader: false,
+		imports: [],
+		inlineCode: false,
+		preloads: [],
+		test: false,
+		watch: false
+	};
+	for (; index < tokens.length; index++) {
+		const { value } = tokens[index];
+		if (value === "--" || !value.startsWith("-")) {
+			scanned.entryIndex = value === "--" ? index + 1 : index;
+			break;
+		}
+		const name = optionName(value);
+		const inline = value.includes("=");
+		const argument = inline ? value.slice(value.indexOf("=") + 1) : tokens[index + 1]?.value;
+		if (directRunner && runner.dropOptions?.has(name)) {
+			scanned.removals.push(removal(tokens, index));
+			continue;
+		}
+		if (LOADER_OPTIONS.has(name)) {
+			const loader = argument;
+			if (loader !== void 0 && runner.loaderPattern.test(loader)) {
+				scanned.runnerLoader = true;
+				if (runner.isLoader && !runner.isLoader(name, loader)) {
+					scanned.keepReason ??= `vp migrate does not rewrite ${name} ${loader}`;
+					scanned.registerKeepReason ??= scanned.keepReason;
+					if (!inline) index++;
+					continue;
+				}
+				scanned.removals.push({
+					...removal(tokens, index),
+					end: tokens[inline ? index : index + 1].end
+				});
+				scanned.loaders++;
+				if (runner.isRegister?.(name, loader)) scanned.imports.push({
+					token: tokens[inline ? index : index + 1],
+					value: inline ? "--import=vite-plus/register" : "vite-plus/register",
+					option: !inline && name !== "--import" ? tokens[index] : void 0
+				});
+			} else if (loader !== void 0) {
+				const reason = runner.registerPreloadKeepReason?.(name, loader);
+				scanned.registerKeepReason ??= reason;
+				if (directRunner) scanned.keepReason ??= reason;
+				if (loader.startsWith(".") || path.isAbsolute(loader)) scanned.preloads.push(loader);
+			}
+			if (!inline) index++;
+			continue;
+		}
+		scanned.keepReason ??= runner.keepOptions.get(name);
+		scanned.registerKeepReason ??= runner.registerKeepOptions?.get(name);
+		if (runner.registerInlineCodeKeepReason) {
+			const code = [
+				"-e",
+				"-p",
+				"-pe",
+				"--eval",
+				"--print"
+			].includes(name) ? argument : /^-(?:pe|ep|e|p)(.+)$/.exec(value)?.[1];
+			if (code !== void 0) scanned.registerKeepReason ??= runner.registerInlineCodeKeepReason(code);
+		}
+		scanned.test ||= name === "--test";
+		scanned.watch ||= name === "--watch";
+		scanned.inlineCode ||= [
+			"-e",
+			"-p",
+			"-pe",
+			"--eval",
+			"--print",
+			"--run"
+		].includes(name);
+		if (name === "--run") scanned.runScript = argument ?? "";
+		if (!inline && (NODE_OPTIONS_WITH_VALUE.has(name) || directRunner && runner.optionsWithValue?.has(name))) index++;
+	}
+	return scanned;
+}
+/** Why `vpx` cannot run what the scanned options and the scripts after them run. */
+function runReason(runner, cwd, tokens, scanned, watch) {
+	if (scanned.keepReason) return scanned.keepReason;
+	if ((watch || scanned.watch) && scanned.test) return KEEP_WATCH_TEST;
+	return runKeepReason(runner, cwd, scanned.test, tokens.slice(scanned.entryIndex).map(({ value }) => value), scanned.preloads);
+}
+/** Rewrite a quoted launcher command with the environment it inherits. */
+function rewriteQuotedCommand(runner, rewrite, token, environment) {
+	const raw = rewrite.command.slice(token.start, token.end);
+	const quote = raw[0];
+	if (quote !== "\"" && quote !== "'" || raw.length < 2 || !raw.endsWith(quote)) return false;
+	const inner = rewriteScriptRunnerCommand(runner, token.value, rewrite.cwd, environment, rewrite.checkingScripts);
+	rewrite.kept.push(...inner.kept);
+	if (inner.command !== token.value) rewrite.edits.push(literalEdit(rewrite.command, token, inner.command));
+	return token.value.trim() !== "";
+}
+/** The commands in a scripts or lint-staged record. */
+function recordCommands(record) {
+	if (!isPlainRecord(record)) return [];
+	return Object.values(record).flatMap((value) => Array.isArray(value) ? value : [value]).filter((command) => typeof command === "string");
+}
+/** The commands a package.json runs: its scripts and lint-staged tasks. */
+function packageCommands(pkg) {
+	return [...recordCommands(pkg.scripts), ...recordCommands(pkg["lint-staged"])];
+}
+function lintStagedJsonFiles(dir) {
+	return LINT_STAGED_JSON_CONFIG_FILES.map((name) => path.join(dir, name)).filter((file) => fs.existsSync(file) && isJsonFile(file));
+}
+/**
+* A package that lists a runner outside devDependencies keeps it: published code or
+* production scripts can need it, and `vpx` comes from the vite-plus devDependency.
+*/
+function ownsRunnerAtRuntime(runner, pkg) {
+	return runner.dependencies.some((dependency) => pkg.dependencies?.[dependency] !== void 0 || pkg.optionalDependencies?.[dependency] !== void 0 || pkg.peerDependencies?.[dependency] !== void 0);
+}
+function packageDirs(rootDir, packages) {
+	return [rootDir, ...(packages ?? []).map((pkg) => path.join(rootDir, pkg.path))];
+}
+/**
+* Detect supported invocations, or retained uses when the profile requests warnings.
+*/
+function detectScriptRunnerProject(runner, rootDir, packages) {
+	return packageDirs(rootDir, packages).some((dir) => {
+		const pkg = readPackageJsonIfExists(path.join(dir, "package.json"));
+		if (!pkg || !runner.detectKeptUses && ownsRunnerAtRuntime(runner, pkg)) return false;
+		return [...packageCommands(pkg), ...lintStagedJsonFiles(dir).flatMap((file) => recordCommands(readJsonFile(file)))].some((command) => runner.detectKeptUses ? runner.commandPattern.test(command) : rewriteScriptRunnerCommand(runner, command, dir).command !== command) || runner.detectKeptUses && findRunnerUse(runner, dir, ownsRunnerAtRuntime(runner, pkg) || runner.dependencies.some((dependency) => pkg.devDependencies?.[dependency] !== void 0)) !== void 0 || sourceTreeMatches(dir, (content, file) => {
+			const result = rewriteRunnerShebang(runner, content, file, dir);
+			return result !== void 0 && "content" in result;
+		}, { includeExtensionless: runner.includeExtensionlessShebangs });
+	});
+}
+/** Rewrite each command of a scripts or lint-staged record; returns whether one changed. */
+function rewriteCommandRecord(runner, record, label, cwd, report) {
+	let edited = false;
+	for (const [key, value] of Object.entries(record)) {
+		const commands = Array.isArray(value) ? value : [value];
+		const rewritten = commands.map((command) => {
+			if (typeof command !== "string") return command;
+			const result = rewriteScriptRunnerCommand(runner, command, cwd);
+			for (const reason of result.kept) warnMigration(`Kept ${runner.name} in ${label} "${key}": ${reason}.`, report);
+			return result.command;
+		});
+		if (rewritten.some((command, index) => command !== commands[index])) {
+			record[key] = Array.isArray(value) ? rewritten : rewritten[0];
+			edited = true;
+		}
+	}
+	return edited;
+}
+/**
+* The migrated runner or Node.js preload shebang, or its retention reason.
+*/
+function rewriteRunnerShebang(runner, content, file, packageDir) {
+	const match = runner.envShebang.exec(content);
+	if (!match) return;
+	const [line, prefix, command] = match;
+	const entry = quoteArgument(`./${path.basename(file)}`);
+	if (entry === void 0) return { reason: "the script path needs shell escaping that vp migrate does not support" };
+	const shebangRunner = runner.prepareRun ? {
+		...runner,
+		prepareRun: (args, context) => runner.prepareRun(args, {
+			...context,
+			cwd: path.dirname(file),
+			shebang: true
+		})
+	} : runner;
+	const original = `${command} ${entry}`;
+	const result = rewriteScriptRunnerCommand(shebangRunner, original);
+	if (result.command === original && !result.kept.length) return;
+	const tokens = parseLiteralCommands(command, true)?.[0];
+	const executable = tokens?.[0]?.value;
+	const directRunner = executable === runner.name || executable !== void 0 && runner.aliases?.includes(executable) === true;
+	const optionsStart = directRunner && runner.watchSubcommand !== false && tokens?.[1]?.value === "watch" ? 2 : 1;
+	const preloads = tokens && (executable === "node" || directRunner) ? scanOptions(runner, tokens, optionsStart, directRunner).preloads : [];
+	const reason = result.kept[0] ?? preloads.map((script) => runner.scriptKeepReason?.(packageDir, script)).find((reason) => reason !== void 0) ?? runner.scriptKeepReason?.(path.dirname(file), `./${path.basename(file)}`);
+	if (reason) return { reason };
+	const rewritten = result.command.slice(0, -` ${entry}`.length);
+	if (!path.extname(file) && /^vpx(?:\s|$)/.test(rewritten)) return;
+	return { content: `${prefix}${rewritten}${content.slice(line.length)}` };
+}
+/** Rewrite matching runner and Node.js preload shebangs in a package's scripts. */
+function rewriteRunnerShebangs(runner, dir, report) {
+	let changed = false;
+	sourceTreeMatches(dir, (content, file) => {
+		const result = rewriteRunnerShebang(runner, content, file, dir);
+		if (result && "reason" in result) warnMigration(`Kept ${runner.name} in the shebang of ${displayRelative(file)}: ${result.reason}.`, report);
+		else if (result) {
+			fs.writeFileSync(file, result.content);
+			changed = true;
+		}
+		return false;
+	}, { includeExtensionless: runner.includeExtensionlessShebangs });
+	return changed;
+}
+/**
+* Find a remaining use, including nested packages and build output that can resolve
+* the package's runner dependencies.
+*/
+function findRunnerUse(runner, dir, retainUnverified = true) {
+	let found;
+	sourceTreeMatches(dir, (content, file) => {
+		if (LOCKFILES.has(path.basename(file))) return false;
+		if (fileUsesRunner(runner, content, file)) found = `${displayRelative(file)} still uses ${runner.name}`;
+		else if (path.basename(file) !== "package.json") found = environmentFileUse(runner, content, void 0, retainUnverified);
+		return found !== void 0;
+	}, {
+		crossPackageBoundaries: true,
+		extensions: REFERENCE_EXTENSIONS,
+		fileNamePattern: runner.referenceFileNamePattern,
+		includeExtensionless: true,
+		includePackageReferences: true,
+		matchesPackage: (packageDir, pkg) => {
+			const field = Object.entries(pkg).find(([key, value]) => !IGNORED_FIELDS.has(key) && jsonUsesRunner(runner, value, [
+				"imports",
+				"lint-staged",
+				"scripts"
+			].includes(key)))?.[0];
+			if (field !== void 0) found = `\`${field}\` in ${displayRelative(path.join(packageDir, "package.json"))} still uses ${runner.name}`;
+			else {
+				found = packageCommands(pkg).map((command) => environmentFileUse(runner, command, packageDir, retainUnverified)).find((reason) => reason !== void 0);
+				found ??= environmentFileUse(runner, JSON.stringify(Object.fromEntries(Object.entries(pkg).filter(([key]) => !IGNORED_FIELDS.has(key) && key !== "scripts" && key !== "lint-staged"))), void 0, retainUnverified);
+			}
+			return found !== void 0;
+		},
+		skipDirs: USE_SCAN_SKIP_DIRS
+	});
+	return found;
+}
+const ENV_FILE_OPTION = /--env[-_]file(?:[-_]if[-_]exists)?(?=$|[=\s'"])/;
+/** Explicit Node.js environment inputs need checking regardless of their extension. */
+function environmentFileUse(runner, command, cwd, retainUnverified = true) {
+	if (!ENV_FILE_OPTION.test(command)) return;
+	const unchecked = retainUnverified ? `an explicit Node.js env file could load ${runner.name}, but vp migrate cannot check it` : void 0;
+	const segments = parseLiteralCommands(command, true);
+	if (!cwd || !segments || /%\w+%/.test(command)) return unchecked;
+	for (const tokens of segments) {
+		const values = tokens.map(({ value }) => value);
+		if (SHELL_STATE_COMMANDS.includes(values[0]) || values[0] === "chdir") cwd = void 0;
+		if (!values.some((value) => ENV_FILE_OPTION.test(value))) continue;
+		const start = getCommandStartIndex(values);
+		if (!cwd || values[start] !== "node") return unchecked;
+		for (let index = start + 1; index < values.length; index++) {
+			const value = values[index];
+			if (value === "--" || !value.startsWith("-")) break;
+			const name = optionName(value);
+			const inline = value.includes("=");
+			const takesArgument = NODE_OPTIONS_WITH_VALUE.has(name);
+			const argument = inline ? value.slice(value.indexOf("=") + 1) : values[index + 1];
+			if (name === "--env-file" || name === "--env-file-if-exists") {
+				if (!argument) return unchecked;
+				const file = path.resolve(cwd, argument);
+				try {
+					if (runner.textReference.test(fs.readFileSync(file, "utf8"))) return `${displayRelative(file)} still uses ${runner.name}`;
+				} catch {
+					if (retainUnverified) return `the env file ${displayRelative(file)} could load ${runner.name}, but vp migrate cannot read it`;
+				}
+			} else if (ENV_FILE_OPTION.test(value) || takesArgument && argument && ENV_FILE_OPTION.test(argument)) return unchecked;
+			if (!inline && takesArgument) index++;
+		}
+	}
+}
+/** Whether a file still runs, imports, or loads the runner. */
+function fileUsesRunner(runner, content, file) {
+	if (runner.shebangPattern.test(content)) return true;
+	const name = path.basename(file);
+	if (runner.referenceFileNamePattern?.test(name)) return runner.textReference.test(content);
+	if (LINT_STAGED_JSON_CONFIG_FILES.some((config) => config === name) && jsonUsesRunner(runner, parse(content), true)) return true;
+	const extension = path.extname(file);
+	if (extension === ".json" || extension === ".jsonc") return jsonUsesRunner(runner, parse(content), false);
+	if (CODE_EXTENSIONS.has(extension)) return runner.codeUsesRunner?.(content, file) ?? runner.codeReference.test(content);
+	return runner.textReference.test(content) || extension === "" && runner.codeReference.test(content);
+}
+/** Recognize command strings and loader references in structured configuration. */
+function jsonUsesRunner(runner, value, commands) {
+	if (typeof value === "string") return commands && runner.commandPattern.test(value) || runner.configValue.test(value);
+	if (Array.isArray(value)) return value.some((item, index) => jsonUsesRunner(runner, item, commands) || typeof item === "string" && LOADER_OPTIONS.has(item) && runner.loaderPattern.test(String(value[index + 1])));
+	return isPlainRecord(value) && Object.entries(value).some(([key, item]) => jsonUsesRunner(runner, item, commands) || LOADER_SETTINGS.has(key) && [item].flat().some((loader) => runner.loaderPattern.test(String(loader))));
+}
+/** Rewrite known command surfaces, then remove dependencies with no remaining uses. */
+function migrateScriptRunnerToVpx(runner, rootDir, packages, report) {
+	let changed = false;
+	const migrated = [];
+	for (const dir of packageDirs(rootDir, packages)) {
+		const packageJsonPath = path.join(dir, "package.json");
+		const pkg = readPackageJsonIfExists(packageJsonPath);
+		if (!pkg) continue;
+		if (ownsRunnerAtRuntime(runner, pkg)) {
+			if (packageCommands(pkg).some((c) => runner.commandPattern.test(c))) warnMigration(`Kept ${runner.name} in ${displayRelative(packageJsonPath)}: it is listed in dependencies, optionalDependencies, or peerDependencies there, and \`vpx\` comes from the vite-plus devDependency.`, report);
+			continue;
+		}
+		migrated.push(dir);
+		editJsonFile(packageJsonPath, (json) => {
+			let edited = false;
+			for (const field of ["scripts", "lint-staged"]) {
+				const record = json[field];
+				if (isPlainRecord(record) && rewriteCommandRecord(runner, record, `${displayRelative(packageJsonPath)} ${field}`, dir, report)) edited = true;
+			}
+			changed ||= edited;
+			return edited ? json : void 0;
+		});
+		for (const file of lintStagedJsonFiles(dir)) editJsonFile(file, (config) => {
+			const edited = rewriteCommandRecord(runner, config, displayRelative(file), dir, report);
+			changed ||= edited;
+			return edited ? config : void 0;
+		});
+		if (rewriteRunnerShebangs(runner, dir, report)) changed = true;
+	}
+	let dependencyRemoved = false;
+	for (const dir of migrated) {
+		const packageJsonPath = path.join(dir, "package.json");
+		const devDependencies = readPackageJsonIfExists(packageJsonPath)?.devDependencies;
+		if (!runner.dependencies.some((dependency) => devDependencies?.[dependency] !== void 0)) continue;
+		const use = findRunnerUse(runner, dir);
+		if (use) {
+			warnMigration(`Kept the ${runner.dependencies.join(" / ")} devDependency in ${displayRelative(packageJsonPath)}: ${use}.`, report);
+			continue;
+		}
+		editJsonFile(packageJsonPath, (json) => {
+			for (const dependency of runner.dependencies) delete json.devDependencies[dependency];
+			return json;
+		});
+		dependencyRemoved = true;
+	}
+	return {
+		changed: changed || dependencyRemoved,
+		dependencyRemoved,
+		scriptsChanged: changed
+	};
+}
+// src/migration/migrator/oxnode.ts
+const OXNODE_COMMAND = /(?:^|[\s;&|("'=/\\`])oxnode(?:\.(?:cmd|exe|ps1))?(?=$|[@\s;&|)"'`])|@oxc-node\/core(?:\/[^\s'"`]+)?/i;
+const OXNODE_LOADER = /^@oxc-node\/core(?:\/.*)?$/;
+const OXNODE_PACKAGE_REFERENCE = /@oxc-node\/(?:cli|core)(?=$|[\s/'"`])/;
+const OXNODE_CODE_REFERENCE = new RegExp([OXNODE_COMMAND.source, OXNODE_PACKAGE_REFERENCE.source].join("|"), "i");
+const OXNODE_TEXT_REFERENCE = new RegExp([OXNODE_COMMAND.source, OXNODE_PACKAGE_REFERENCE.source].join("|"), "im");
+const KEEP_NODE_WATCH = "oxnode --watch starts the Node.js watcher, while `vpx --watch` uses its own watcher; use oxnode watch to migrate it";
+const KEEP_TRANSFORM_DEPS = "`OXC_TRANSFORM_ALL` changes dependency transforms, while the Vite+ loader always transforms only TypeScript dependencies";
+const REGISTER_KEEP_OPTIONS = /* @__PURE__ */ new Map([
+	["--env-file", "an env file can configure oxc-node hooks or dependency transforms; migrate it manually"],
+	["--env-file-if-exists", "an env file can configure oxc-node hooks or dependency transforms; migrate it manually"],
+	["--config-file", "a Node.js config file can load additional hooks; migrate it manually"],
+	["--experimental-config-file", "a Node.js config file can load additional hooks; migrate it manually"],
+	["--experimental-default-config-file", "a Node.js config file can load additional hooks; migrate it manually"]
+]);
+function isOxnodeRegister(option, value) {
+	return option === "--import" && /^@oxc-node\/core\/register(?:\.mjs)?$/.test(value);
+}
+function oxnodeEnvironmentReason(assignments) {
+	for (const assignment of assignments) {
+		const separator = assignment.indexOf("=");
+		const name = assignment.slice(0, separator).toUpperCase();
+		const value = assignment.slice(separator + 1);
+		if (name === "OXC_TRANSFORM_ALL" && value !== "typescript") return KEEP_TRANSFORM_DEPS;
+		if ((name === "VP_SCRIPT_TSCONFIG" || name === "TSX_TSCONFIG_PATH") && value) return `\`${name}\` would select a different configuration for the Vite+ loader`;
+	}
+}
+const OXNODE_RUNNER = {
+	name: "oxnode",
+	dependencies: ["@oxc-node/cli", "@oxc-node/core"],
+	commandPattern: OXNODE_COMMAND,
+	loaderPattern: OXNODE_LOADER,
+	isLoader: isOxnodeRegister,
+	isRegister: isOxnodeRegister,
+	registerEnvKeepReason: oxnodeEnvironmentReason,
+	registerKeepOptions: REGISTER_KEEP_OPTIONS,
+	registerPreloadKeepReason(option, value) {
+		if (option === "--loader" || option === "--experimental-loader" || option === "--import" && value === "vite-plus/register") return;
+		return "an additional startup preload can configure oxc-node hooks or dependency transforms; migrate it manually";
+	},
+	registerInlineCodeKeepReason(code) {
+		if (OXNODE_PACKAGE_REFERENCE.test(code)) return "inline code uses a standalone oxc-node API or loader that does not configure the bundled Vite+ loader";
+	},
+	envShebang: /^(#!\s*\S*\benv\s+(?:-S\s+)?)((?:oxnode|node)(?=[ \t\r\n]|$)[^\r\n]*)/,
+	includeExtensionlessShebangs: true,
+	shebangPattern: /^#![^\n]*[\s/]oxnode(?=\s|$)/,
+	codeReference: OXNODE_CODE_REFERENCE,
+	textReference: OXNODE_TEXT_REFERENCE,
+	configValue: OXNODE_TEXT_REFERENCE,
+	referenceFileNamePattern: /^\.env(?:\.|$)/,
+	keepOptions: new Map([
+		...REGISTER_KEEP_OPTIONS,
+		["-e", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["--eval", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["-p", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["-pe", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["--print", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["-c", "`vpx -c` selects package shell mode instead of Node.js syntax checking"],
+		["--check", "`vpx` does not transform TypeScript for --check"],
+		["-i", "`vpx` does not start a TypeScript REPL"],
+		["--interactive", "`vpx` does not start a TypeScript REPL"],
+		["--watch", KEEP_NODE_WATCH],
+		["--watch-path", KEEP_NODE_WATCH],
+		["--node-help", "`vpx` does not support oxnode --node-help"],
+		["-h", "oxnode and `vpx` have different help output"],
+		["--help", "oxnode and `vpx` have different help output"],
+		["-v", "oxnode and `vpx` have different versions"],
+		["--version", "oxnode and `vpx` have different versions"]
+	]),
+	optionsWithValue: /* @__PURE__ */ new Set([...WATCH_OPTIONS_WITH_VALUE, "--tsconfig"]),
+	testWithoutFilesReason: "list the test files explicitly before migrating to `vpx --test`",
+	envKeepReason(assignments) {
+		const reason = oxnodeEnvironmentReason(assignments);
+		if (reason) return reason;
+		for (const assignment of assignments) {
+			const separator = assignment.indexOf("=");
+			const name = assignment.slice(0, separator).toUpperCase();
+			const value = assignment.slice(separator + 1);
+			if (name === "NODE_OPTIONS" && /@oxc-node\/core/.test(value)) return "`NODE_OPTIONS` loads oxc-node hooks that would compete with those of `vpx`; remove it first";
+		}
+	},
+	scriptKeepReason(cwd, script) {
+		if (/[*?[{]/.test(script)) return;
+		let file;
+		if (script.startsWith("~/")) file = path.join(os.homedir(), script.slice(2));
+		else if (path.isAbsolute(script)) file = script;
+		else if (cwd !== void 0) file = path.resolve(cwd, script);
+		else return;
+		try {
+			const source = fs.readFileSync(file, "utf8");
+			if (OXNODE_PACKAGE_REFERENCE.test(source.replace(/^#![^\r\n]*/, ""))) return `\`${script}\` uses a standalone oxc-node API or loader that does not configure the bundled \`vpx\` loader`;
+		} catch {}
+	},
+	detectKeptUses: true
+};
+function detectOxnodeProject(rootDir, packages) {
+	return detectScriptRunnerProject(OXNODE_RUNNER, rootDir, packages);
+}
+function migrateOxnodeToVpx(rootDir, packages, report) {
+	const result = migrateScriptRunnerToVpx(OXNODE_RUNNER, rootDir, packages, report);
+	if (report && result.scriptsChanged) report.oxnodeMigrated = true;
+	return {
+		changed: result.changed,
+		dependencyRemoved: result.dependencyRemoved
+	};
+}
+async function confirmOxnodeMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate oxnode scripts to Vite+?\n  " + styleText("gray", "`oxnode <file>` becomes `vpx <file>`, and `oxnode watch` becomes `vpx --watch`. Node.js imports use `vite-plus/register`. Standalone oxc-node dependencies are removed once nothing uses them."),
+			initialValue: true
+		});
+		if (isCancel(confirmed)) cancelAndExit();
+		return confirmed;
 	}
+	log.info("oxnode scripts detected. Auto-migrating to Vite+...");
+	return true;
+}
+// src/migration/migrator/ts-node.ts
+const TS_NODE_REFERENCE = /(?:^|[\s;&|("'=/\\`])ts-node(?:-(?:cwd|esm|script|transpile-only))?(?:\.(?:cmd|exe|ps1))?(?=$|[@/\s;&|)"'`])/i;
+const TS_NODE_LOADERS = /^ts-node(?:\/.*)?$/;
+/** Check module metadata only; migration must not execute a project's dependencies. */
+function incompatibleModuleSource(file, source) {
+	file = fs.realpathSync(file);
+	const { ast } = JSON.parse(analyzeMigrationSource(file, source));
+	let requireResolver;
+	let importResolver;
+	for (const node of ast.node.body) {
+		let specifier;
+		let namedOnly = false;
+		if (node.type === "ImportDeclaration" && node.importKind !== "type") {
+			const bindings = node.specifiers.filter((binding) => binding.type !== "ImportSpecifier" || binding.importKind !== "type");
+			if (!bindings.length) continue;
+			specifier = node.source.value;
+			namedOnly = bindings.every((binding) => binding.type === "ImportSpecifier" && (binding.imported.type === "Identifier" ? binding.imported.name : binding.imported.value) !== "default");
+		} else if (node.type === "ExportNamedDeclaration" && node.source && node.exportKind !== "type") {
+			const bindings = node.specifiers.filter((binding) => binding.exportKind !== "type");
+			if (!bindings.length) continue;
+			specifier = node.source.value;
+			namedOnly = bindings.every((binding) => (binding.local.type === "Identifier" ? binding.local.name : binding.local.value) !== "default");
+		} else if (node.type === "ExportAllDeclaration" && node.exportKind !== "type") specifier = node.source.value;
+		else continue;
+		requireResolver ??= new ResolverFactory({
+			conditionNames: [
+				"node",
+				"require",
+				"module-sync",
+				"node-addons"
+			],
+			builtinModules: true,
+			moduleType: true,
+			nodePath: false
+		});
+		importResolver ??= requireResolver.cloneWithOptions({
+			conditionNames: [
+				"node",
+				"import",
+				"module-sync",
+				"node-addons"
+			],
+			builtinModules: true,
+			moduleType: true,
+			nodePath: false
+		});
+		const required = requireResolver.sync(path.dirname(file), specifier);
+		const imported = importResolver.sync(path.dirname(file), specifier);
+		if (namedOnly && required.builtin && required.builtin.resolved === imported.builtin?.resolved) continue;
+		if (required.path && required.path === imported.path && String(required.moduleType) === "module" && String(imported.moduleType) === "module") continue;
+		return specifier;
+	}
+}
+function isTsNodeLoader(option, value) {
+	return (option === "-r" || option === "--require" || option === "--import") && /^ts-node\/register(?:\/(?:transpile-only|type-check|files))?$/.test(value) || (option === "--loader" || option === "--experimental-loader") && /^ts-node\/esm(?:\/transpile-only)?(?:\.mjs)?$/.test(value);
+}
+const TS_NODE_RUNNER = {
+	name: "ts-node",
+	aliases: ["ts-node-esm", "ts-node-transpile-only"],
+	watchSubcommand: false,
+	dependencies: ["ts-node"],
+	commandPattern: TS_NODE_REFERENCE,
+	loaderPattern: TS_NODE_LOADERS,
+	isLoader: isTsNodeLoader,
+	isRegister: isTsNodeLoader,
+	registerEnvRequiresNode: true,
+	envShebang: /^(#!\s*\S*\benv\s+(?:-S\s+)?)(ts-node(?:-(?:esm|transpile-only))?(?=[ \t\r\n]|$)[^\r\n]*)/,
+	shebangPattern: /^#![^\n]*[\s/]ts-node(?:-(?:cwd|esm|script|transpile-only))?(?=\s|$)/,
+	codeReference: TS_NODE_REFERENCE,
+	textReference: TS_NODE_REFERENCE,
+	configValue: TS_NODE_REFERENCE,
+	referenceFileNamePattern: /^\.env(?:\.|$)/,
+	keepOptions: /* @__PURE__ */ new Map([
+		["-e", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["--eval", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["-p", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["--print", "`vpx` does not run TypeScript passed to --eval or --print"],
+		["-c", "`vpx -c` selects package shell mode instead of Node.js syntax checking"],
+		["--check", "`vpx` does not transform TypeScript for --check"],
+		["-i", "`vpx` does not start a TypeScript REPL"],
+		["--interactive", "`vpx` does not start a TypeScript REPL"],
+		["--watch", "Node.js watch mode and `vpx --watch` use different watchers"],
+		["--watch-path", "Node.js watch mode and `vpx --watch` use different watchers"],
+		["-h", "ts-node and `vpx` have different help output"],
+		["--help", "ts-node and `vpx` have different help output"],
+		["-v", "ts-node and `vpx` have different versions"],
+		["--version", "ts-node and `vpx` have different versions"]
+	]),
+	optionsWithValue: /* @__PURE__ */ new Set(["--tsconfig"]),
+	testWithoutFilesReason: "list the test files explicitly before migrating to `vpx --test`",
+	envKeepReason(assignments) {
+		if (assignments.some((assignment) => /^NODE_OPTIONS=/i.test(assignment) && TS_NODE_REFERENCE.test(assignment.slice(13)))) return "`NODE_OPTIONS` loads ts-node hooks that would compete with those of `vpx`; remove it first";
+		if (assignments.some((assignment) => /^NODE_OPTIONS=.+/i.test(assignment))) return "`NODE_OPTIONS` can change ts-node startup or load configuration preloads; review it before migrating";
+	},
+	prepareRun: (args, context) => prepareTsNodeRun(args, context),
+	scriptKeepReason(cwd, script) {
+		const reason = typescriptScriptKeepReason(cwd, script, "ts-node");
+		if (reason) return reason;
+		if (cwd !== void 0 && !/[*?[{]/.test(script)) try {
+			const file = script.startsWith("~/") ? path.join(os.homedir(), script.slice(2)) : path.resolve(cwd, script);
+			const source = fs.readFileSync(file, "utf8").replace(/^#![^\n]*\n?/, "");
+			if (TS_NODE_REFERENCE.test(source)) return `\`${script}\` uses a standalone ts-node API or loader that does not configure the bundled \`vpx\` loader`;
+			const incompatible = incompatibleModuleSource(file, source);
+			if (incompatible !== void 0) return `\`${script}\` has runtime bindings from \`${incompatible}\` whose CommonJS interop or import/require resolution may change with \`vpx\`; migrate the bindings manually`;
+		} catch {
+			return `\`${script}\` cannot be read or parsed, so vp migrate cannot check its CommonJS interop`;
+		}
+	},
+	detectKeptUses: true
+};
+function detectTsNodeProject(rootDir, packages) {
+	return detectScriptRunnerProject(TS_NODE_RUNNER, rootDir, packages);
+}
+function migrateTsNodeToVpx(rootDir, packages, report) {
+	const result = migrateScriptRunnerToVpx(TS_NODE_RUNNER, rootDir, packages, report);
+	if (report && result.scriptsChanged) report.tsNodeMigrated = true;
+	return {
+		changed: result.changed,
+		dependencyRemoved: result.dependencyRemoved
+	};
+}
+async function confirmTsNodeMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate ts-node scripts to Vite+?\n  " + styleText("gray", "Commands with type-checking disabled become `vpx`. Supported Node.js preloads become `vite-plus/register`. Commands that type-check or use custom ts-node settings stay unchanged. The ts-node devDependency is removed once nothing uses it."),
+			initialValue: true
+		});
+		if (isCancel(confirmed)) cancelAndExit();
+		return confirmed;
+	}
+	log.info("ts-node scripts detected. Auto-migrating supported commands to Vite+...");
+	return true;
+}
+// src/migration/migrator/ts-node-config.ts
+const KEEP_TYPE_CHECK = "this ts-node command type-checks before execution; `vpx` does not type-check. Keep a separate type-check command before changing this script";
+const KEEP_CWD = "the working directory is unknown, so the ts-node configuration cannot be checked";
+const TS_NODE_LOADER = /^ts-node\/(?:register(?:\/(?:transpile-only|type-check|files))?|esm(?:\/transpile-only)?(?:\.mjs)?)$/;
+const PRELOAD_OPTIONS = /* @__PURE__ */ new Set([
+	"-r",
+	"--require",
+	"--import",
+	"--loader",
+	"--experimental-loader"
+]);
+const BOOLEAN_OPTIONS = /* @__PURE__ */ new Map([
+	["-T", "transpileOnly"],
+	["--transpileOnly", "transpileOnly"],
+	["--transpile-only", "transpileOnly"],
+	["--typeCheck", "typeCheck"],
+	["--type-check", "typeCheck"],
+	["--esm", "esm"],
+	["--files", "files"]
+]);
+const CONFIG_OPTIONS = /* @__PURE__ */ new Set([
+	"transpileOnly",
+	"typeCheck",
+	"esm",
+	"files"
+]);
+function booleanEnvironment(value) {
+	if (/^(?:y|yes|true|1)$/i.test(value)) return true;
+	if (/^(?:n|no|false|0)$/i.test(value)) return false;
+}
+function nearestTsconfig(dir) {
+	for (;;) {
+		const file = path.join(dir, "tsconfig.json");
+		if (fs.existsSync(file)) return file;
+		const parent = path.dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+}
+function readTsNodeEnvironment(context) {
+	const options = {};
+	let project;
+	for (const assignment of context.environment) {
+		const separator = assignment.indexOf("=");
+		if (separator < 0) continue;
+		const originalName = assignment.slice(0, separator);
+		const name = originalName.toUpperCase();
+		const value = assignment.slice(separator + 1);
+		if (originalName !== name && (name.startsWith("TS_NODE_") || context.publicRegister && name === "NODE_OPTIONS")) return { keepReason: `\`${originalName}\` uses platform-dependent environment variable casing` };
+		if (name === "TS_NODE_PROJECT") project = value || void 0;
+		else if (name === "TS_NODE_TRANSPILE_ONLY" || name === "TS_NODE_TYPE_CHECK") {
+			const parsed = booleanEnvironment(value);
+			if (parsed === void 0) return { keepReason: `\`${name}\` does not have a literal boolean value` };
+			options[name === "TS_NODE_TRANSPILE_ONLY" ? "transpileOnly" : "typeCheck"] = parsed;
+		} else if (name.startsWith("TS_NODE_")) return { keepReason: `\`${name}\` configures ts-node behavior that vp migrate does not translate` };
+		else if ([
+			"OXC_TSCONFIG_PATH",
+			"TSX_TSCONFIG_PATH",
+			"VP_SCRIPT_TSCONFIG"
+		].includes(name) && value) return { keepReason: `\`${name}\` would select a different configuration for the Vite+ loader` };
+	}
+	return {
+		options,
+		project
+	};
+}
+/** Read only data; migration must not load ts-node or a project's compiler. */
+function readTsNodeOptions(file, ancestors = /* @__PURE__ */ new Set()) {
+	const keepConfig = (reason) => ({ keepReason: `the ts-node configuration in \`${file}\` ${reason}` });
+	if (ancestors.has(file)) return keepConfig("has circular inheritance");
+	const chain = new Set(ancestors).add(file);
+	let config;
+	try {
+		const errors = [];
+		config = parse(fs.readFileSync(file, "utf8"), errors, { allowTrailingComma: true });
+		if (errors.length || !isPlainRecord(config)) return keepConfig("cannot be parsed");
+	} catch {
+		return keepConfig("cannot be read");
+	}
+	let inherited = {};
+	let compilerOptions = {};
+	if (config.extends !== void 0) {
+		if (typeof config.extends !== "string" || !config.extends.startsWith(".") && !path.isAbsolute(config.extends)) return keepConfig("uses inheritance that vp migrate cannot resolve");
+		let base = path.resolve(path.dirname(file), config.extends);
+		if (!fs.existsSync(base) && !base.endsWith(".json")) base += ".json";
+		const result = readTsNodeOptions(base, chain);
+		if (result.keepReason) return result;
+		inherited = result.options ?? {};
+		compilerOptions = result.compilerOptions ?? {};
+	}
+	if (config.compilerOptions !== void 0) {
+		if (!isPlainRecord(config.compilerOptions)) return keepConfig("has an invalid `compilerOptions` object");
+		compilerOptions = {
+			...compilerOptions,
+			...config.compilerOptions
+		};
+	}
+	const settings = config["ts-node"];
+	if (settings === void 0) return {
+		options: inherited,
+		compilerOptions
+	};
+	if (!isPlainRecord(settings)) return keepConfig("has an invalid `ts-node` object");
+	for (const [key, value] of Object.entries(settings)) {
+		if (!CONFIG_OPTIONS.has(key)) return keepConfig(`uses \`ts-node.${key}\`, which vp migrate does not translate`);
+		if (typeof value !== "boolean") return keepConfig(`has a non-boolean \`ts-node.${key}\` value`);
+	}
+	return {
+		options: {
+			...inherited,
+			...settings
+		},
+		compilerOptions
+	};
+}
+/**
+* Translate the supported ts-node options before the shared runner scans Node options.
+* ts-node merges environment < inherited config < CLI/API, then typeCheck overrides
+* transpileOnly. Keep all other compiler behavior for manual migration.
+*/
+function prepareTsNodeRun(args, context) {
+	const { cwd, nodeLoader, executable } = context;
+	if (!cwd) return { keepReason: KEEP_CWD };
+	if (context.publicRegister) {
+		if (context.nodeOptionsArgs === void 0 && context.environment.some((assignment) => /^NODE_OPTIONS=.+/i.test(assignment))) return { keepReason: "the literal NODE_OPTIONS arguments cannot be checked for ts-node settings" };
+		args = [...context.nodeOptionsArgs ?? [], ...args];
+	}
+	const environment = readTsNodeEnvironment(context);
+	if ("keepReason" in environment) return environment;
+	const explicit = {};
+	if (executable === "ts-node-transpile-only") explicit.transpileOnly = true;
+	else if (executable !== "ts-node" && executable !== "ts-node-esm" && !nodeLoader) return { keepReason: `vp migrate does not translate the \`${executable}\` execution mode` };
+	const edits = [];
+	let project;
+	let entry;
+	let loaders = 0;
+	for (let index = 0; index < args.length; index++) {
+		const value = args[index];
+		if (value === "--") {
+			entry = args[index + 1];
+			break;
+		}
+		if (!value.startsWith("-")) {
+			entry = value;
+			break;
+		}
+		const equals = value.indexOf("=");
+		const originalOption = equals < 0 ? value : value.slice(0, equals);
+		const name = nodeLoader && originalOption.startsWith("--") ? originalOption.replaceAll("_", "-") : originalOption;
+		const inline = equals < 0 ? void 0 : value.slice(equals + 1);
+		if (context.publicRegister && name === "--run") return { keepReason: "vp migrate cannot check the ts-node settings of a package script run by Node.js" };
+		if (context.publicRegister && (name === "--eval" || name === "--print" || /^-[ep]/.test(name) || name === "-i" || name === "--interactive")) return { keepReason: "vp migrate does not translate ts-node inline code or REPL execution" };
+		if (nodeLoader && (name === "--env-file" || name === "--env-file-if-exists")) return { keepReason: `\`${name}\` can configure ts-node through environment variables; vp migrate does not translate those settings` };
+		if (nodeLoader && [
+			"--config-file",
+			"--experimental-config-file",
+			"--experimental-default-config-file"
+		].includes(name)) return { keepReason: `\`${name}\` can load preloads that configure ts-node; migrate it manually` };
+		const booleanOption = BOOLEAN_OPTIONS.get(name);
+		if (!nodeLoader && booleanOption) {
+			if (inline !== void 0) return { keepReason: `ts-node treats \`${name}=value\` as an enabled flag; use an explicit configuration value before migrating` };
+			explicit[booleanOption] = true;
+			edits.push({ index });
+			continue;
+		}
+		if (!nodeLoader && (name === "-P" || name === "--project")) {
+			if (project !== void 0) return { keepReason: "the command selects a ts-node project more than once" };
+			const projectPath = inline ?? args[index + 1];
+			if (!projectPath || projectPath.startsWith("-")) return { keepReason: `\`${name}\` does not name a tsconfig` };
+			project = {
+				path: projectPath,
+				index,
+				inline: inline !== void 0
+			};
+			if (!project.inline) index++;
+			continue;
+		}
+		if (PRELOAD_OPTIONS.has(name)) {
+			if (!nodeLoader && name !== "-r" && name !== "--require") return { keepReason: `\`${name}\` uses ts-node behavior that vp migrate does not translate` };
+			const preload = inline ?? args[index + 1];
+			if (!preload || preload.startsWith("-")) return { keepReason: `\`${name}\` does not name a preload` };
+			if (TS_NODE_LOADER.test(preload)) {
+				if (!nodeLoader || ++loaders > 1) return { keepReason: "the command registers ts-node more than once" };
+				if (/\/transpile-only(?:\.mjs)?$/.test(preload)) explicit.transpileOnly = true;
+				else if (preload.endsWith("/type-check")) explicit.typeCheck = true;
+			} else return { keepReason: `the additional preload \`${preload}\` can configure ts-node before execution; migrate it manually` };
+			if (inline === void 0) index++;
+			continue;
+		}
+		if (!nodeLoader) return { keepReason: `\`${name}\` uses ts-node behavior that vp migrate does not translate` };
+		if (inline === void 0 && NODE_OPTIONS_WITH_VALUE.has(name)) index++;
+	}
+	if (!entry || entry === "-") return { keepReason: "vp migrate only replaces ts-node commands that name a script file" };
+	const selectedProject = project?.path ?? environment.project;
+	if (context.shebang && selectedProject !== void 0) return { keepReason: "the ts-node shebang selects a tsconfig relative to the caller; migrate it manually" };
+	let configFile;
+	if (selectedProject) {
+		configFile = path.resolve(cwd, selectedProject);
+		if (fs.statSync(configFile, { throwIfNoEntry: false })?.isDirectory()) {
+			if (project === void 0) return { keepReason: "`TS_NODE_PROJECT` names a directory; `vpx` requires the tsconfig file path" };
+			configFile = path.join(configFile, "tsconfig.json");
+			project.path = path.join(project.path, "tsconfig.json");
+		}
+	} else {
+		let searchDir = cwd;
+		if (!nodeLoader) try {
+			searchDir = path.dirname(fs.realpathSync(path.resolve(cwd, entry)));
+		} catch {
+			return { keepReason: `\`${entry}\` cannot be resolved, so its ts-node configuration cannot be checked` };
+		}
+		configFile = nearestTsconfig(searchDir);
+		if (context.publicRegister && !configFile) {
+			let entryConfig;
+			try {
+				entryConfig = nearestTsconfig(path.dirname(fs.realpathSync(path.resolve(cwd, entry))));
+			} catch {
+				return { keepReason: `\`${entry}\` cannot be resolved, so its ts-node configuration cannot be checked` };
+			}
+			if (entryConfig) return { keepReason: "the Node.js preload would discover an entrypoint tsconfig that ts-node does not use; select the intended config with TS_NODE_PROJECT before migrating" };
+		}
+	}
+	const config = configFile ? readTsNodeOptions(configFile) : { options: {} };
+	if (config.keepReason) return { keepReason: config.keepReason };
+	if (context.shebang && configFile) return { keepReason: "the ts-node shebang needs a pinned tsconfig, whose path depends on the caller; migrate it manually" };
+	const options = {
+		...environment.options,
+		...config.options,
+		...explicit
+	};
+	if (options.transpileOnly !== true || options.typeCheck === true) return { keepReason: KEEP_TYPE_CHECK };
+	if (configFile && config.compilerOptions?.target == null && typeof config.compilerOptions?.useDefineForClassFields !== "boolean") return { keepReason: "the ts-node config defaults to assignment class fields, while the Vite+ loader defaults to define semantics; set compilerOptions.useDefineForClassFields explicitly before migrating" };
+	if (project !== void 0) {
+		edits.push({
+			index: project.index,
+			value: `--tsconfig=${project.path.split(path.sep).join("/")}`
+		});
+		if (!project.inline) edits.push({ index: project.index + 1 });
+	}
+	if (configFile && selectedProject === void 0) {
+		if (context.publicRegister) return { keepReason: "the Node.js preload needs the ts-node config pinned explicitly; set TS_NODE_PROJECT to its file path before migrating" };
+		return {
+			edits,
+			prependArgs: [`--tsconfig=${path.relative(fs.realpathSync(cwd), fs.realpathSync(configFile)).split(path.sep).join("/")}`]
+		};
+	}
+	return { edits };
+}
+// src/migration/vitest-v5/commands.ts
+/** Read test commands without evaluating shell state or directory changes. */
+function literalTestCommands(command) {
+	const commands = parseLiteralCommands(command, true);
+	if (!commands) return;
+	const result = [];
+	for (const tokens of commands) {
+		const values = tokens.map(({ value }) => value);
+		while (/^[A-Za-z_]\w*=/.test(values[0] ?? "")) values.shift();
+		if (!values.length || SHELL_STATE_COMMANDS.includes(values[0])) return;
+		result.push(values);
+	}
+	return result;
+}
+/** Locate the runner's arguments after a supported package-manager wrapper. */
+function vitestCommandArgsStart(values) {
+	const start = getCommandStartIndex(values);
 	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);
+	const argv = parseLiteralCommands(command, false)?.[0];
 	if (!argv) return command;
 	const values = argv.map(({ value }) => value);
 	const start = vitestCommandArgsStart(values);
@@ -182,7 +1597,7 @@ function migrateVitestV5Command(file, command, preserveV4, line = 1, reviewV4 =
 		findings
 	};
 	command = migrateBenchmarkOutput(command);
-	const argv = literalArgv(command);
+	const argv = parseLiteralCommands(command, false)?.[0];
 	const values = argv?.map(({ value }) => value);
 	const runner = values ? vitestCommandArgsStart(values) : -1;
 	let removedFlag = /(?:^|\s)(?:--compare|--outputJson)(?:\s|=|$)/.test(command);
@@ -230,8 +1645,7 @@ function migrateVitestV5Command(file, command, preserveV4, line = 1, reviewV4 =
 		findings
 	};
 }
-//#endregion
-//#region src/migration/vitest-v5/ast.ts
+// src/migration/vitest-v5/ast.ts
 function isNode(value) {
 	return typeof value === "object" && value !== null && "type" in value && "start" in value;
 }
@@ -505,7 +1919,7 @@ var SourceEditor = class {
 				}
 			}
 			const propertyIndent = multilinePrefix && object.properties.length ? indent : `${objectIndent}  `;
-			const entries = [...additions.values()].map((property) => printAddedProperty(property, propertyIndent, newline));
+			const entries = Array.from(additions.values(), (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 ? "," : ""} `);
 		}
@@ -538,8 +1952,7 @@ var SourceEditor = class {
 		};
 	}
 };
-//#endregion
-//#region src/migration/vitest-v5/benchmark-config.ts
+// src/migration/vitest-v5/benchmark-config.ts
 const REPORTERS = /* @__PURE__ */ new Set([
 	"default",
 	"verbose",
@@ -607,8 +2020,7 @@ function migrateBenchmarkConfig(editor, test) {
 		oldJson
 	]) if (prop) editor.remove(benchmark, prop);
 }
-//#endregion
-//#region src/migration/vitest-v5/compatibility.ts
+// src/migration/vitest-v5/compatibility.ts
 const settings = {
 	clearMocks: {
 		value: "false",
@@ -656,8 +2068,7 @@ function compatibilityProperty(key) {
 		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
+// src/migration/vitest-v5/config-object.ts
 const CONFIG_KEYS = /* @__PURE__ */ new Set([
 	"root",
 	"test",
@@ -703,8 +2114,7 @@ function resolveConfigObject(editor, node) {
 	}
 	return node;
 }
-//#endregion
-//#region src/migration/vitest-v5/config.ts
+// src/migration/vitest-v5/config.ts
 function isTrue(node) {
 	return isBoolean(node) && node.value;
 }
@@ -1001,8 +2411,7 @@ function migrateConfig(file, source, options, mergedConfig, benchmarkOnly = fals
 	});
 	return editor.finish();
 }
-//#endregion
-//#region src/migration/vitest-v5/documentation.ts
+// src/migration/vitest-v5/documentation.ts
 const guide = documentationUrl$1("/guide/vitest-v5");
 const upstream = "https://vitest.dev/guide/migration/";
 const sections = {
@@ -1054,12 +2463,49 @@ 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
+// src/migration/vitest-v5/lockfile.ts
 var import_dist = require_dist();
 function record$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
+/** Create one reader per preflight, with a single parser for each lockfile path. */
+function createLockfileReader() {
+	const locks = /* @__PURE__ */ new Map();
+	return (file, parse) => {
+		if (!locks.has(file)) {
+			locks.set(file, void 0);
+			try {
+				locks.set(file, parse(fs.readFileSync(file, "utf8").replace(/^\uFEFF/, "")));
+			} catch {}
+		}
+		return locks.get(file);
+	};
+}
+function parseYarnLockfile(text) {
+	if (/^__metadata:/m.test(text)) {
+		const document = (0, import_dist.parseDocument)(text);
+		if (document.errors.length) return;
+		return {
+			modern: true,
+			entries: record$1(document.toJS()) ?? {}
+		};
+	}
+	const entries = [];
+	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)) entries.push({
+			keys,
+			version: /^  version "([^"]+)"\r?$/m.exec(block)?.[1]
+		});
+	}
+	return {
+		modern: false,
+		entries
+	};
+}
 function declaredVitest(pkg) {
 	const manifest = record$1(pkg);
 	for (const field of [
@@ -1075,7 +2521,7 @@ function declaredVitest(pkg) {
 /** 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) {
+function lockedVitestVersion(root, directory, manager, spec, readLockfile) {
 	const range = spec.replace(/^npm:vitest@/, "");
 	const validRange = normalizeRange(range);
 	if (!validRange && !/^[\w.-]+$/.test(range)) return;
@@ -1084,10 +2530,9 @@ function lockedVitestVersion(root, directory, manager, spec) {
 		return !validRange || 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);
+			const packages = record$1(readLockfile(path.join(root, fs.existsSync(path.join(root, "npm-shrinkwrap.json")) ? "npm-shrinkwrap.json" : "package-lock.json"), (source) => record$1(JSON.parse(source)))?.packages);
 			if (!packages) return;
 			if (declaredVitest(packages[relative]) !== spec) return;
 			let owner = relative;
@@ -1100,34 +2545,29 @@ function lockedVitestVersion(root, directory, manager, spec) {
 			}
 		}
 		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 lock = readLockfile(path.join(root, "yarn.lock"), parseYarnLockfile);
+			if (!lock) return;
+			if (lock.modern) {
 				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)));
+				const entries = Object.entries(lock.entries).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);
-				}
+			for (const { keys, version } of lock.entries) if (keys.includes(`vitest@${spec}`)) {
+				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 lock = readLockfile(path.join(root, "bun.lock"), (source) => {
+				const errors = [];
+				const parsed = record$1(parse(source, errors, { allowTrailingComma: true }));
+				return errors.length ? void 0 : parsed;
+			});
+			if (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;
@@ -1143,8 +2583,7 @@ function lockedVitestVersion(root, directory, manager, spec) {
 		}
 	} catch {}
 }
-//#endregion
-//#region src/migration/vitest-v5/storybook.ts
+// 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"]);
@@ -1268,8 +2707,7 @@ function resolveStorybookScope(editor, object, sources, file, cwd) {
 		return unknown(`cannot parse ${label}/main`);
 	}
 }
-//#endregion
-//#region src/migration/vitest-v5/scopes.ts
+// 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)"];
@@ -1659,7 +3097,7 @@ function resolveVitestV5TestModes(sources, configFiles, preserveV4, entries) {
 		if (!found) unknown();
 	}
 	return {
-		modes: new Map([...sources.keys()].map((file) => {
+		modes: new Map(Array.from(sources.keys(), (file) => {
 			const matching = [];
 			let benchmarkFile = false;
 			const hasInSourceTests = sources.get(file)?.includes("import.meta.vitest");
@@ -1696,8 +3134,7 @@ function resolveVitestV5TestModes(sources, configFiles, preserveV4, entries) {
 		findings
 	};
 }
-//#endregion
-//#region src/migration/vitest-v5/benchmarks.ts
+// 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) {
@@ -1840,8 +3277,7 @@ function migrateBenchmarks(editor, globals = false) {
 		calls
 	};
 }
-//#endregion
-//#region src/migration/vitest-v5/source.ts
+// src/migration/vitest-v5/source.ts
 const RUNNER_SYMBOLS = {
 	test: "test",
 	it: "it",
@@ -2074,6 +3510,45 @@ function looksLikeConstructorMock(editor, node) {
 	}
 	return false;
 }
+function unwrapTypeExpression(node) {
+	while (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression" || node.type === "TSTypeAssertion") node = node.expression;
+	return node;
+}
+/** Recognize a local promise consumed by a later statement without crossing
+* control flow or function boundaries. Ambiguous paths still need review. */
+function isAssertionBindingHandled(editor, node) {
+	let initializer = node;
+	let declarator = editor.parent(initializer);
+	while (declarator && unwrapTypeExpression(declarator) === node) {
+		initializer = declarator;
+		declarator = editor.parent(initializer);
+	}
+	if (declarator?.type !== "VariableDeclarator" || declarator.init !== initializer || declarator.id.type !== "Identifier") return false;
+	const binding = editor.binding(declarator.id);
+	const declaration = editor.parent(declarator);
+	const block = declaration && editor.parent(declaration);
+	const fn = editor.functionParent(node);
+	if (!binding?.constant || declaration?.type !== "VariableDeclaration" || declaration.kind !== "const" || block?.type !== "BlockStatement" || !fn || fn.generator) return false;
+	for (let ancestor = editor.parent(block); ancestor && ancestor !== fn; ancestor = editor.parent(ancestor)) if (ancestor.type === "TryStatement") return false;
+	for (const statement of block.body.slice(block.body.indexOf(declaration) + 1)) switch (statement.type) {
+		case "ReturnStatement": {
+			if (!statement.argument) return false;
+			let expression = unwrapTypeExpression(statement.argument);
+			if (expression.type === "AwaitExpression") expression = unwrapTypeExpression(expression.argument);
+			return editor.binding(expression) === binding;
+		}
+		case "ExpressionStatement": {
+			const expression = unwrapTypeExpression(statement.expression);
+			if (expression.type === "AwaitExpression" && editor.binding(unwrapTypeExpression(expression.argument)) === binding) return true;
+			break;
+		}
+		case "VariableDeclaration":
+		case "FunctionDeclaration":
+		case "EmptyStatement": break;
+		default: return false;
+	}
+	return false;
+}
 function chain(node, isApi) {
 	const members = [];
 	const calls = [];
@@ -2268,7 +3743,7 @@ function rewriteSource(file, source, options) {
 				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.");
+				} else if (asynchronous && parent?.type !== "MemberExpression" && parent?.type !== "AwaitExpression" && parent?.type !== "ReturnStatement" && !isAssertionBindingHandled(editor, node)) 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)) {
@@ -2352,8 +3827,7 @@ function rewriteSource(file, source, options) {
 	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
+// src/migration/vitest-v5/webdriverio.ts
 const MIN_VERSION = "5.0.0";
 const DEFAULT_SPEC = "^5.0.0";
 const REGISTRY_ALIAS = `npm:${WEBDRIVERIO_PROVIDER}@`;
@@ -2395,7 +3869,7 @@ function migrateWebdriverioDependencies(workspace, sources, inputs) {
 	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: {
+		if (file.endsWith(".json")) sources.set(file, applyEdits$1(source, modify(source, keys, value, { formattingOptions: {
 			insertSpaces: true,
 			tabSize: 2
 		} })));
@@ -2573,8 +4047,7 @@ function migrateWebdriverioDependencies(workspace, sources, inputs) {
 	overrideMap(path.join(workspace.rootDir, "pnpm-workspace.yaml"), ["overrides"]);
 	return findings;
 }
-//#endregion
-//#region src/migration/migrator/vitest-v5.ts
+// src/migration/migrator/vitest-v5.ts
 const SKIP_DIRS = /* @__PURE__ */ new Set([
 	"node_modules",
 	".git",
@@ -2662,17 +4135,16 @@ function finding(file, code, message, severity = "review", source = "", offset =
 	};
 }
 /** Follow this project's dependency edges, never an unrelated transitive runner. */
-function lockedSourceVersion(directory, root, pkg, manager, expectedRunnerPackage) {
+function lockedSourceVersion(directory, root, pkg, readLockfile, manager, expectedRunnerPackage) {
 	if (manager !== void 0 && manager !== PackageManager.pnpm) {
 		const spec = dependency(pkg, "vitest");
-		return spec && !expectedRunnerPackage ? lockedVitestVersion(root, directory, manager, spec) : void 0;
+		return spec && !expectedRunnerPackage ? lockedVitestVersion(root, directory, manager, spec, readLockfile) : 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 lock = readLockfile(path.join(root, "pnpm-lock.yaml"), (source) => {
+			const document = (0, import_dist.parseDocument)(source);
+			return document.errors.length ? void 0 : 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";
@@ -2729,7 +4201,7 @@ function installedSourceVersion(directory, name, expectedPackage, expectedRange)
 	}
 	return dependency(pkg, LEGACY_RUNNER) ? installedSourceVersion(installed.path, LEGACY_RUNNER) : void 0;
 }
-function sourceVersion(directory, root, pkg, manager) {
+function sourceVersion(directory, root, pkg, readLockfile, manager) {
 	const catalog = createCatalogDependencyResolver(root, manager ?? PackageManager.pnpm);
 	const vitePlus = dependency(pkg, "vite-plus");
 	const vitePlusRange = vitePlus?.startsWith("catalog:") ? catalog?.(vitePlus, "vite-plus") : vitePlus;
@@ -2746,7 +4218,7 @@ function sourceVersion(directory, root, pkg, manager) {
 		if (bundled) return bundled;
 	}
 	const expectedRunnerPackage = legacyAlias ? LEGACY_RUNNER : void 0;
-	const locked = lockedSourceVersion(directory, root, pkg, manager, expectedRunnerPackage);
+	const locked = lockedSourceVersion(directory, root, pkg, readLockfile, manager, expectedRunnerPackage);
 	if (locked && (!spec || legacyAlias || !normalizeRange(spec) || satisfies(locked, spec, { includePrerelease: true }))) return locked;
 	const installed = installedSourceVersion(directory, "vitest", expectedRunnerPackage);
 	if (installed && (!spec || legacyAlias || satisfies(installed, spec, { includePrerelease: true }))) return installed;
@@ -2756,7 +4228,7 @@ function sourceVersion(directory, root, pkg, manager) {
 		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);
+	if (directory !== root) return sourceVersion(root, root, readJson(path.join(root, "package.json")), readLockfile, manager);
 }
 function checkNodeRange(file, value, label, findings, publicContract = false) {
 	if (!publicContract && [
@@ -2818,7 +4290,7 @@ function migrateNode(file, source, findings) {
 			"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 applyEdits$1(source, edits);
 	}
 	return source;
 }
@@ -2871,7 +4343,7 @@ function scanAndRewriteFile(file, source, project, testMode, mergedConfig) {
 				content: JSON.stringify(result.content)
 			});
 		}
-		content = applyEdits(source, edits);
+		content = applyEdits$1(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."));
@@ -2902,10 +4374,11 @@ function scanAndRewriteFile(file, source, project, testMode, mergedConfig) {
 /** 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 readLockfile = createLockfileReader();
 	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 projectSources = new Map(Array.from(new Set(directories), (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);
@@ -2920,7 +4393,7 @@ function planVitestV5Migration(workspace, originalProjects) {
 		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 version = original ? original.sourceVersion : sourceVersion(directory, workspace.rootDir, pkg, readLockfile, 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 && getMajor(version) < 5),
@@ -3032,7 +4505,7 @@ 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))]));
+	return new Map(Array.from(filesByProject, ([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. */
@@ -3080,8 +4553,7 @@ function finishVitestV5Migration(plan) {
 	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
+// src/migration/compat/runner.ts
 /**
 * Resolve the isolated compat worker emitted at `migration/compat/worker.js`.
 *
@@ -3137,8 +4609,7 @@ async function checkRolldownCompatibility(rootDir, report) {
 		for (const warning of compatibilityResult?.warnings ?? []) addMigrationWarning(report, warning);
 	} catch {}
 }
-//#endregion
-//#region src/migration/format.ts
+// src/migration/format.ts
 const FORMAT_FAILURE_MESSAGE = "Automatic formatting failed. Run `vp fmt` manually after migration.";
 const MAX_FORMAT_ARG_BYTES = process.platform === "win32" ? 24e3 : 1e5;
 function chunkPathsByArgLength(paths) {
@@ -3264,8 +4735,29 @@ async function formatMigratedProject(projectRoot, interactive, report, options =
 	addMigrationWarning(report, FORMAT_FAILURE_MESSAGE);
 	return false;
 }
-//#endregion
-//#region src/migration/npm-reinstall.ts
+// src/migration/install-result.ts
+/**
+* Reconcile a CommandRunSummary from `runViteInstall` with the migration's
+* duration counter and exit-code state. `runViteInstall` returns
+* `{ status: 'failed', exitCode }` without throwing; treating that as a success
+* (incrementing duration unconditionally) would let the migration claim
+* "Dependencies installed" while node_modules is desynced from the just-mutated
+* package.json. This helper centralizes the right handling: credit duration on
+* success, warn + flip exitCode on failure, stay silent on skip.
+*/
+function handleInstallResult(installSummary, rootDir, report, options) {
+	if (installSummary.status === "installed") return installSummary.durationMs;
+	if (installSummary.status === "failed") {
+		const exitCode = installSummary.exitCode ?? 1;
+		const message = `Dependency installation failed (exit code ${exitCode}). Run \`vp install\` manually in ${rootDir} to resync node_modules.`;
+		warnMsg(message);
+		report.warnings.push(message);
+		if (options?.propagateExitCode !== false) process.exitCode = exitCode;
+		return 0;
+	}
+	return 0;
+}
+// src/migration/npm-reinstall.ts
 const VITE_PLUS_CORE_PACKAGE = "@voidzero-dev/vite-plus-core";
 function isViteInstallPath(packagePath) {
 	return packagePath === "node_modules/vite" || packagePath.endsWith("/node_modules/vite");
@@ -3354,18 +4846,20 @@ function prepareNpmViteAliasReinstall(rootDir, projectPaths = [rootDir]) {
 		}
 	};
 }
-//#endregion
-//#region src/migration/setup-plan.ts
+// src/migration/setup-plan.ts
 async function collectGitHooksDecision(rootDir, packageManager, options, packages = []) {
-	let shouldSetupHooks = await promptGitHooks(options);
-	if (shouldSetupHooks) {
-		const reason = preflightGitHooksSetup(rootDir, packageManager, packages);
-		if (reason) {
-			log$1.warn(`⚠ ${reason}`);
-			shouldSetupHooks = false;
-		}
+	const hasExistingHooks = options.hooks === void 0 && hasExistingViteHooksPolicy(rootDir);
+	if (hasExistingHooks && isViteHooksSetupComplete(rootDir)) {
+		log$1(`${muted("•")} Git hooks already configured, skipping`);
+		return false;
 	}
-	return shouldSetupHooks;
+	if (!hasExistingHooks && !await promptGitHooks(options)) return false;
+	const reason = preflightGitHooksSetup(rootDir, packageManager, packages);
+	if (reason) {
+		log.warn(`⚠ ${reason}`);
+		return false;
+	}
+	return true;
 }
 async function collectAgentInstructionPlan(rootDir, options) {
 	const existingAgentTargetPaths = options.agent !== void 0 || !options.interactive ? void 0 : detectExistingAgentTargetPaths(rootDir);
@@ -3469,13 +4963,9 @@ async function collectMigrationSetupPlan(rootDir, packageManager, options, packa
 		...eslintPlan
 	};
 }
-//#endregion
-//#region src/migration/bin.ts
+// src/migration/bin.ts
 async function confirmNodeVersionFileMigration(interactive, detection) {
-	const message = {
-		"package.json": "Migrate Volta node version (package.json) to .node-version?",
-		".nvmrc": "Migrate .nvmrc to .node-version?"
-	}[detection.file];
+	const message = { "package.json": "Migrate Volta node version (package.json) to .node-version?" }[detection.file];
 	if (interactive) {
 		const confirmed = await confirm({
 			message,
@@ -3505,7 +4995,7 @@ async function confirmYarnNodeModulesMode(rootDir, packageManager, packageManage
 	if (packageManager !== PackageManager.yarn) return false;
 	const pnp = detectYarnPnpMode(rootDir, packageManagerVersion);
 	if (!pnp) return false;
-	log$1.warn(`⚠ Vite+ does not currently support Yarn Plug'n'Play (PnP).`);
+	log.warn(`⚠ Vite+ does not currently support Yarn Plug'n'Play (PnP).`);
 	if (pnp.source === "environment") cancelAndExit("YARN_NODE_LINKER=pnp overrides project configuration. Set it to node-modules or unset it, then re-run `vp migrate`.", 1);
 	if (interactive) {
 		const confirmed = await confirm({
@@ -3609,7 +5099,7 @@ function hasExistingVitePlusMigrationCandidates(workspaceInfo, options) {
 	const eslintProject = detectEslintProject(workspaceInfo.rootDir, workspaceInfo.packages);
 	const prettierProject = detectPrettierProject(workspaceInfo.rootDir, workspaceInfo.packages);
 	const tsupProject = detectTsupProject(workspaceInfo.rootDir, workspaceInfo.packages);
-	return hasExplicitExistingVitePlusSetupRequest(options) || detectLegacyGitHooksMigrationCandidate(workspaceInfo.rootDir) || hasBaseUrlInWorkspace(workspaceInfo) || eslintProject.hasDependency || prettierProject.hasDependency || tsupProject.hasDependency || detectNodeVersionManagerFile(workspaceInfo.rootDir) !== void 0 || getFrameworkShimCandidates(workspaceInfo.rootDir, workspaceInfo.packages).length > 0;
+	return hasExplicitExistingVitePlusSetupRequest(options) || detectLegacyGitHooksMigrationCandidate(workspaceInfo.rootDir) || hasBaseUrlInWorkspace(workspaceInfo) || eslintProject.hasDependency || prettierProject.hasDependency || tsupProject.hasDependency || detectTsxProject(workspaceInfo.rootDir, workspaceInfo.packages) || detectOxnodeProject(workspaceInfo.rootDir, workspaceInfo.packages) || detectTsNodeProject(workspaceInfo.rootDir, workspaceInfo.packages) || detectNodeVersionManagerFile(workspaceInfo.rootDir) !== void 0 || getFrameworkShimCandidates(workspaceInfo.rootDir, workspaceInfo.packages).length > 0;
 }
 function getExistingVitePlusSetupOptions(options, useFullMigrationDefaults = false) {
 	if (useFullMigrationDefaults) return options;
@@ -3629,6 +5119,9 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, detectedPac
 	if (prettierProject.hasDependency && prettierProject.configFile) migratePrettier = await confirmPrettierMigration(options.interactive);
 	else if (prettierProject.hasDependency) warnPackageLevelPrettier();
 	const { migrateTsup, tsupConfigFile } = await collectTsupMigrationDecision(rootDir, options, packages);
+	const migrateTsx = detectTsxProject(rootDir, packages) && await confirmTsxMigration(options.interactive);
+	const migrateOxnode = detectOxnodeProject(rootDir, packages) && await confirmOxnodeMigration(options.interactive);
+	const migrateTsNode = detectTsNodeProject(rootDir, packages) && await confirmTsNodeMigration(options.interactive);
 	const fixBaseUrl = hasBaseUrlInWorkspace({
 		rootDir,
 		packages
@@ -3646,83 +5139,70 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, detectedPac
 		prettierConfigFile: prettierProject.configFile,
 		migrateTsup,
 		tsupConfigFile,
+		migrateTsx,
+		migrateOxnode,
+		migrateTsNode,
 		fixBaseUrl,
 		migrateNodeVersionFile,
 		nodeVersionDetection,
 		frameworkShimFrameworks
 	};
 }
-/**
-* Reconcile a CommandRunSummary from `runViteInstall` with the migration's
-* duration counter and exit-code state. `runViteInstall` returns
-* `{ status: 'failed', exitCode }` without throwing; treating that as a success
-* (incrementing duration unconditionally) would let the migration claim
-* "Dependencies installed" while node_modules is desynced from the just-mutated
-* package.json. This helper centralizes the right handling: credit duration on
-* success, warn + flip exitCode on failure, stay silent on skip.
-*/
-function handleInstallResult(installSummary, rootDir, report, options) {
-	if (installSummary.status === "installed") return installSummary.durationMs;
-	if (installSummary.status === "failed") {
-		const exitCode = installSummary.exitCode ?? 1;
-		const message = `Dependency installation failed (exit code ${exitCode}). Run \`vp install\` manually in ${rootDir} to resync node_modules.`;
-		warnMsg(message);
-		report.warnings.push(message);
-		if (options?.propagateExitCode !== false) process.exitCode = exitCode;
-		return 0;
-	}
-	return 0;
-}
 const FULL_MIGRATION_HINT = `${styleText("gray", "•")} Skipped editor, hooks, and lint setup. Run \`vp migrate --full\` to apply them.`;
 function showMigrationSummary(options) {
 	const { projectRoot, packageManager, packageManagerVersion, installDurationMs, finalInstallOk, report, updatedExistingVitePlus, suggestFullMigration } = options;
 	const projectLabel = displayRelative(projectRoot) || ".";
 	const configUpdates = report.createdViteConfigCount + report.mergedConfigCount + report.mergedStagedConfigCount + report.inlinedLintStagedConfigCount + report.removedConfigCount + report.tsdownImportCount + report.wrappedPluginConfigCount + report.migratedTaskCacheConfigCount;
-	log(`${styleText("magenta", "◇")} ${updatedExistingVitePlus ? "Updated" : "Migrated"} ${accent(projectLabel)} to Vite+ ${VITE_PLUS_VERSION}`);
-	log(`${styleText("gray", "•")} Node ${process.versions.node}  ${packageManager} ${packageManagerVersion}`);
+	log$1(`${styleText("magenta", "◇")} ${updatedExistingVitePlus ? "Updated" : "Migrated"} ${accent(projectLabel)} to Vite+ ${VITE_PLUS_VERSION}`);
+	log$1(`${styleText("gray", "•")} Node ${process.versions.node}  ${packageManager} ${packageManagerVersion}`);
 	if (report.dependencyUpgrades.length > 0) {
 		const nameWidth = Math.max(...report.dependencyUpgrades.map((change) => change.name.length));
 		const fromWidth = Math.max(...report.dependencyUpgrades.map((change) => (change.from ?? "").length));
-		log(`${styleText("gray", "•")} Dependencies:`);
+		log$1(`${styleText("gray", "•")} Dependencies:`);
 		for (const change of report.dependencyUpgrades) {
 			const name = change.name.padEnd(nameWidth);
 			const from = muted((change.from ?? "").padEnd(fromWidth));
 			const to = styleText("green", change.to);
-			log(`    ${name}  ${from} → ${to}`);
+			log$1(`    ${name}  ${from} → ${to}`);
 		}
 	}
-	if (finalInstallOk && installDurationMs > 0) log(`${styleText("green", "✓")} Dependencies installed in ${formatDuration(installDurationMs)}`);
+	if (finalInstallOk && installDurationMs > 0) log$1(`${styleText("green", "✓")} Dependencies installed in ${formatDuration(installDurationMs)}`);
 	if (configUpdates > 0 || report.rewrittenImportFileCount > 0) {
 		const parts = [];
 		if (configUpdates > 0) parts.push(`${configUpdates} ${configUpdates === 1 ? "config update" : "config updates"} applied`);
 		if (report.rewrittenImportFileCount > 0) parts.push(`${report.rewrittenImportFileCount} ${report.rewrittenImportFileCount === 1 ? "file had" : "files had"} imports rewritten`);
-		log(`${styleText("gray", "•")} ${parts.join(", ")}`);
+		log$1(`${styleText("gray", "•")} ${parts.join(", ")}`);
 	}
-	if (report.preservedUpstreamVitestImportFileCount > 0) log(`${styleText("gray", "•")} Kept upstream \`vitest\` imports in ${report.preservedUpstreamVitestImportFileCount} ${report.preservedUpstreamVitestImportFileCount === 1 ? "file" : "files"} for @nuxt/test-utils compatibility`);
-	if (report.eslintMigrated) log(`${styleText("gray", "•")} ESLint rules migrated to Oxlint`);
-	if (report.prettierMigrated) log(`${styleText("gray", "•")} Prettier migrated to Oxfmt`);
-	if (report.tsupMigrated) log(`${styleText("gray", "•")} tsup config migrated to tsdown (\`vp pack\`)`);
-	if (report.nodeVersionFileMigrated) log(`${styleText("gray", "•")} Node version manager file migrated to .node-version`);
+	if (report.preservedUpstreamVitestImportFileCount > 0) log$1(`${styleText("gray", "•")} Kept upstream \`vitest\` imports in ${report.preservedUpstreamVitestImportFileCount} ${report.preservedUpstreamVitestImportFileCount === 1 ? "file" : "files"} for @nuxt/test-utils compatibility`);
+	if (report.eslintMigrated) log$1(`${styleText("gray", "•")} ESLint rules migrated to Oxlint`);
+	if (report.prettierMigrated) log$1(`${styleText("gray", "•")} Prettier migrated to Oxfmt`);
+	if (report.tsupMigrated) log$1(`${styleText("gray", "•")} tsup config migrated to tsdown (\`vp pack\`)`);
+	if (report.tsxMigrated) log$1(`${styleText("gray", "•")} tsx scripts migrated to Vite+`);
+	if (report.oxnodeMigrated) log$1(`${styleText("gray", "•")} oxnode scripts migrated to Vite+`);
+	if (report.tsNodeMigrated) log$1(`${styleText("gray", "•")} ts-node scripts migrated to Vite+`);
+	if (report.nodeVersionFileMigrated) log$1(`${styleText("gray", "•")} Node version manager file migrated to .node-version`);
 	const setupVpFileCount = report.setupVpVersionUpdatedFileCount;
 	if (setupVpFileCount > 0) {
 		const fileLabel = setupVpFileCount === 1 ? "file" : "files";
-		log(`${styleText("gray", "•")} setup-vp updated to ${SETUP_VP_VERSION} in ${setupVpFileCount} GitHub Actions ${fileLabel}`);
-	}
-	if (report.wrappedPluginConfigCount > 0) log(`${styleText("gray", "•")} Inline Vite plugins wrapped with lazyPlugins for check/lint/fmt`);
-	if (report.migratedTaskCacheConfigCount > 0) log(`${styleText("gray", "•")} Task cache settings moved under \`cache\``);
-	if (report.gitHooksConfigured) log(`${styleText("gray", "•")} Git hooks configured`);
-	if (report.frameworkShimAdded) log(`${styleText("gray", "•")} TypeScript shim added for framework component files`);
-	if (report.packageManagerBootstrapConfigured) log(`${styleText("gray", "•")} Package manager settings configured`);
-	if (suggestFullMigration) log(FULL_MIGRATION_HINT);
-	if (report.warnings.length > 0) {
-		log(`${styleText("yellow", "!")} Warnings:`);
-		for (const warning of report.warnings) log(`  - ${warning}`);
+		log$1(`${styleText("gray", "•")} setup-vp updated to ${SETUP_VP_VERSION} in ${setupVpFileCount} GitHub Actions ${fileLabel}`);
 	}
+	if (report.wrappedPluginConfigCount > 0) log$1(`${styleText("gray", "•")} Inline Vite plugins wrapped with lazyPlugins for check/lint/fmt`);
+	if (report.migratedTaskCacheConfigCount > 0) log$1(`${styleText("gray", "•")} Task cache settings moved under \`cache\``);
+	if (report.gitHooksConfigured) log$1(`${styleText("gray", "•")} Git hooks configured`);
+	if (report.frameworkShimAdded) log$1(`${styleText("gray", "•")} TypeScript shim added for framework component files`);
+	if (report.packageManagerBootstrapConfigured) log$1(`${styleText("gray", "•")} Package manager settings configured`);
+	if (suggestFullMigration) log$1(FULL_MIGRATION_HINT);
+	showMigrationWarnings(report.warnings);
 	if (report.manualSteps.length > 0) {
-		log(`${styleText("blue", "→")} Manual follow-up:`);
-		for (const step of report.manualSteps) log(`  - ${step}`);
+		log$1(`${styleText("blue", "→")} Manual follow-up:`);
+		for (const step of report.manualSteps) log$1(`  - ${step}`);
 	}
 }
+function showMigrationWarnings(warnings) {
+	if (warnings.length === 0) return;
+	log$1(`${styleText("yellow", "!")} Warnings:`);
+	for (const warning of warnings) log$1(`  - ${warning}`);
+}
 async function downloadSupportedPackageManager(options) {
 	const { rootDir, packageManager, packageManagerVersion, interactive, updateMigrationProgress, failMigrationProgress } = options;
 	updateMigrationProgress("Preparing migration");
@@ -3732,11 +5212,11 @@ async function downloadSupportedPackageManager(options) {
 		await upgradeYarn(rootDir, interactive, true);
 	} else if (packageManager === PackageManager.pnpm && satisfies(downloadResult.version, "< 9.5.0")) {
 		failMigrationProgress("Migration failed");
-		log$1.error(`✘ pnpm@${downloadResult.version} is not supported by auto migration, please upgrade pnpm to >=9.5.0 first`);
+		log.error(`✘ pnpm@${downloadResult.version} is not supported by auto migration, please upgrade pnpm to >=9.5.0 first`);
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
 	} else if (packageManager === PackageManager.npm && satisfies(downloadResult.version, "< 8.3.0")) {
 		failMigrationProgress("Migration failed");
-		log$1.error(`✘ npm@${downloadResult.version} is not supported by auto migration, please upgrade npm to >=8.3.0 first`);
+		log.error(`✘ npm@${downloadResult.version} is not supported by auto migration, please upgrade npm to >=8.3.0 first`);
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
 	}
 	return downloadResult;
@@ -3753,7 +5233,7 @@ function completeVitestV5Migration(plan, report) {
 function applyRefreshedVitestV5Migration(plan) {
 	const refreshed = refreshVitestV5Migration(plan);
 	if (refreshed.findings.some((finding) => finding.severity === "block")) {
-		log$1.warn(formatVitestV5Findings(refreshed));
+		log.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);
@@ -3761,6 +5241,7 @@ function applyRefreshedVitestV5Migration(plan) {
 }
 async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, vitestV5Plan, preExistingChangedPaths) {
 	const report = createMigrationReport();
+	report.warnings.push(...detectMigrationWarnings(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages));
 	const migrationProgress = interactive ? spinner({ indicator: "timer" }) : void 0;
 	let migrationProgressStarted = false;
 	const updateMigrationProgress = (message) => {
@@ -3801,7 +5282,7 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, vi
 	if (plan.convertYarnPnp) {
 		updateMigrationProgress("Configuring Yarn node-modules mode");
 		report.packageManagerBootstrapConfigured = configureYarnNodeModulesMode(workspaceInfo.rootDir);
-		if (report.packageManagerBootstrapConfigured) log$1.success("✔ Switched Yarn to node-modules mode");
+		if (report.packageManagerBootstrapConfigured) log.success("✔ Switched Yarn to node-modules mode");
 	}
 	if (plan.migrateNodeVersionFile && plan.nodeVersionDetection) {
 		updateMigrationProgress("Migrating node version file");
@@ -3855,6 +5336,18 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, vi
 			cancelAndExit("Complete the tsup migration manually, then re-run `vp migrate`.", 1);
 		}
 	}
+	if (plan.migrateTsx) {
+		updateMigrationProgress("Migrating tsx scripts");
+		migrateTsxToVpx(workspaceInfo.rootDir, workspaceInfo.packages, report);
+	}
+	if (plan.migrateOxnode) {
+		updateMigrationProgress("Migrating oxnode scripts");
+		migrateOxnodeToVpx(workspaceInfo.rootDir, workspaceInfo.packages, report);
+	}
+	if (plan.migrateTsNode) {
+		updateMigrationProgress("Migrating ts-node scripts");
+		migrateTsNodeToVpx(workspaceInfo.rootDir, workspaceInfo.packages, report);
+	}
 	vitestV5Plan = applyRefreshedVitestV5Migration(vitestV5Plan);
 	const skipStagedMigration = shouldSkipStagedMigrationForHooks(workspaceInfo.rootDir, plan.shouldSetupHooks, plan.packageManager, workspaceInfo.packages);
 	updateMigrationProgress("Rewriting configs");
@@ -3920,11 +5413,11 @@ async function main() {
 	let vitestV5Plan = planVitestV5Migration(workspaceInfoOptional);
 	const vitestV5Preflight = formatVitestV5Findings(vitestV5Plan);
 	if (vitestV5Plan.findings.some((finding) => finding.severity === "block")) {
-		log$1.warn(vitestV5Preflight);
+		log.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 (workspaceInfoOptional.packageManager && !hasPackageManagerDeclaration(rootPkg)) log$1.warn(`No package manager is declared in package.json; using ${workspaceInfoOptional.packageManager} for this migration without adding a pin. Run \`vp env pin\` to declare it explicitly.`);
+	if (workspaceInfoOptional.packageManager && !hasPackageManagerDeclaration(rootPkg)) log.warn(`No package manager is declared in package.json; using ${workspaceInfoOptional.packageManager} for this migration without adding a pin. Run \`vp env pin\` to declare it explicitly.`);
 	if (hasVitePlusDependency(rootPkg) && !isForceOverrideMode()) {
 		let convertYarnPnp = await confirmYarnNodeModulesMode(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, workspaceInfoOptional.packageManagerVersion, options.interactive);
 		let didMigrate = vitestV5NeedsMigration(vitestV5Plan);
@@ -3933,6 +5426,7 @@ async function main() {
 		let finalInstallOk = true;
 		let canFormatMigratedProject = !process.env.VP_SKIP_INSTALL;
 		const report = createMigrationReport();
+		const migrationWarnings = options.full ? detectMigrationWarnings(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages) : [];
 		const migrationProgress = options.interactive ? spinner({ indicator: "timer" }) : void 0;
 		let migrationProgressStarted = false;
 		const updateMigrationProgress = (message) => {
@@ -3987,16 +5481,19 @@ async function main() {
 		updateMigrationProgress("Rewriting toolchain imports across the workspace");
 		const coreMigrationResult = finalizeCoreMigrationForExistingVitePlus(workspaceInfoOptional, true, report, pendingCoreMigration);
 		if (coreMigrationResult.dependencies || coreMigrationResult.scripts || coreMigrationResult.tsconfigTypes || coreMigrationResult.imports || coreMigrationResult.tsdownConfig || coreMigrationResult.taskCacheConfig) didMigrate = true;
+		if (retryPreservedOxlintConfigs(workspaceInfoOptional.rootDir, true, report, workspaceInfoOptional.packages)) 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);
-			for (const warning of coreMigrationResult.taskCacheWarnings) log$1.warn(warning);
-			if (skippedSetupCandidates) log(FULL_MIGRATION_HINT);
+			showMigrationWarnings(migrationWarnings);
+			if (vitestV5Preflight) log.warn(vitestV5Preflight);
+			for (const warning of coreMigrationResult.taskCacheWarnings) log.warn(warning);
+			if (skippedSetupCandidates) log$1(FULL_MIGRATION_HINT);
 			outro(`This project is already using Vite+! ${accent("Happy coding!")}`);
 			return;
 		}
+		report.warnings.push(...migrationWarnings);
 		for (const warning of coreMigrationResult.taskCacheWarnings) addMigrationWarning(report, warning);
 		const setupOptions = getExistingVitePlusSetupOptions(options, fullSetup);
 		const plan = await collectMigrationSetupPlan(workspaceInfoOptional.rootDir, packageManager, setupOptions, workspaceInfoOptional.packages, fullSetup);
@@ -4077,6 +5574,33 @@ async function main() {
 				tsupMigrated = true;
 			}
 		}
+		if (fullSetup && detectTsxProject(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages)) {
+			if (options.interactive) clearMigrationProgress();
+			if (await confirmTsxMigration(options.interactive)) {
+				updateMigrationProgress("Migrating tsx scripts");
+				const tsxResult = migrateTsxToVpx(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages, report);
+				didMigrate ||= tsxResult.changed;
+				needsInstall ||= tsxResult.dependencyRemoved;
+			}
+		}
+		if (fullSetup && detectOxnodeProject(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages)) {
+			if (options.interactive) clearMigrationProgress();
+			if (await confirmOxnodeMigration(options.interactive)) {
+				updateMigrationProgress("Migrating oxnode scripts");
+				const oxnodeResult = migrateOxnodeToVpx(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages, report);
+				didMigrate ||= oxnodeResult.changed;
+				needsInstall ||= oxnodeResult.dependencyRemoved;
+			}
+		}
+		if (fullSetup && detectTsNodeProject(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages)) {
+			if (options.interactive) clearMigrationProgress();
+			if (await confirmTsNodeMigration(options.interactive)) {
+				updateMigrationProgress("Migrating ts-node scripts");
+				const tsNodeResult = migrateTsNodeToVpx(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages, report);
+				didMigrate ||= tsNodeResult.changed;
+				needsInstall ||= tsNodeResult.dependencyRemoved;
+			}
+		}
 		if (fullSetup) {
 			const nodeVersionDetection = detectNodeVersionManagerFile(workspaceInfoOptional.rootDir);
 			if (nodeVersionDetection) {
@@ -4087,7 +5611,7 @@ async function main() {
 		if (convertYarnPnp) {
 			updateMigrationProgress("Configuring Yarn node-modules mode");
 			if (configureYarnNodeModulesMode(workspaceInfoOptional.rootDir)) {
-				log$1.success("✔ Switched Yarn to node-modules mode");
+				log.success("✔ Switched Yarn to node-modules mode");
 				report.packageManagerBootstrapConfigured = true;
 				didMigrate = true;
 				needsInstall = true;
@@ -4102,7 +5626,10 @@ async function main() {
 		].includes(path.basename(file)));
 		if (eslintMigrated || prettierMigrated || tsupMigrated) {
 			updateMigrationProgress("Rewriting configs");
-			mergeViteConfigFiles(workspaceInfoOptional.rootDir, true, report, workspaceInfoOptional.packages);
+			const rootDir = workspaceInfoOptional.rootDir;
+			const oxlintConfigs = workspaceInfoOptional.isMonorepo ? prepareOxlintConfigs([rootDir, ...workspaceInfoOptional.packages.map((pkg) => path.join(rootDir, pkg.path))]) : void 0;
+			mergeViteConfigFiles(rootDir, true, report, workspaceInfoOptional.packages, rootDir, oxlintConfigs);
+			if (oxlintConfigs) removeMigratedOxlintConfigs(oxlintConfigs);
 			if (tsupMigrated) {
 				mergeTsdownConfigFile(workspaceInfoOptional.rootDir, true, report);
 				for (const pkg of workspaceInfoOptional.packages ?? []) mergeTsdownConfigFile(path.join(workspaceInfoOptional.rootDir, pkg.path), true, report);
@@ -4187,7 +5714,7 @@ async function main() {
 			});
 		} else {
 			clearMigrationProgress();
-			if (skippedSetupCandidates) log(FULL_MIGRATION_HINT);
+			if (skippedSetupCandidates) log$1(FULL_MIGRATION_HINT);
 			outro(`This project is already using Vite+! ${accent("Happy coding!")}`);
 		}
 		return;
@@ -4204,9 +5731,8 @@ async function main() {
 	});
 }
 main().catch((err) => {
-	log$1.error(err.message);
+	log.error(err.message);
 	console.error(err);
 	process.exit(1);
 });
-//#endregion
 export {};