vite-plus 1.4.0 → 1.5.0

package/dist/migration/bin.js

@@ -1,52 +1,36 @@
-import { t as documentationUrl$1 } from "../documentation-cv_y0Auv.js";
-import { a as muted, c as warnMsg, i as log, o as printHeader, r as formatDuration, t as accent } from "../terminal-BcuPUy-j.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-DRUnJ_Dz.js";
-import { a as writeJsonFile, c as modify, i as readJsonFile, l as parse, n as editJsonFile, o as applyEdits, r as isJsonFile, s as findNodeAtLocation, u as parseTree } from "../json-kl84kDyH.js";
-import { a as hasVitePlusDependency, i as hasPackageManagerDeclaration, n as detectPackageMetadata, o as readNearestPackageJson } from "../package-DzsomcUD.js";
-import { t as vitest_v5_entry_points_default } from "../vitest-v5-entry-points-NyJsFeux.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-GL1vj0wk.js";
-import { _ as isGreaterThanOrEqual, p as compare } from "../comparison-CmVirWIW-UlEf2maz.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-D8oxxhVR.js";
-import { n as addMigrationWarning, r as createMigrationReport } from "../report-DLHO30yZ.js";
-import { A as detectVitePlusBootstrapPending, C as removeMigratedOxlintConfigs, Ct as warnMigration, 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 readPackageJsonIfExists, T as injectLintTypeCheckDefaults, U as minimatch, W as findGitRoot, X as confirmTsupMigration, Y as hasFrameworkShim, Z as detectTsupProject, _ as hasExistingViteHooksPolicy, _t as WEBDRIVERIO_PROVIDER, at as warnPackageLevelPrettier, b as preflightGitHooksSetup, bt as getCommandStartIndex, ct as detectIncompatibleEslintIntegration, d as finalizeCoreMigrationForExistingVitePlus, dt as warnIncompatibleEslintIntegration, et as warnMissingTsupConfig, f as detectNodeVersionManagerFile, ft as warnLegacyEslintConfig, g as detectLegacyGitHooksMigrationCandidate, gt as SHELL_STATE_COMMANDS, ht as RETENTION_SCAN_SKIP_DIRS, i as selectEditor, j as ensureVitePlusBootstrap, k as collectToolchainVersionChanges, l as rewriteStandaloneProject, lt as migrateEslintToOxlint, m as migrateSetupVpVersion, mt as LINT_STAGED_JSON_CONFIG_FILES, 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 checkViteVersion, x as shouldSkipStagedMigrationForHooks, xt as isPlainRecord, y as isViteHooksSetupComplete, yt as checkVitestVersion } from "../editor-ClL78D8u.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 { a as hasBaseUrlInTsconfig, i as fixBaseUrlInTsconfig, t as confirmBaseUrlFix } from "../tsconfig-LE_mAwe_.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 { t as unwrapCliParseOutcome } from "../cli-parse-aeUeFDlC.js";
-import { t as ROLLDOWN_COMPAT_RESULT_PREFIX } from "../protocol-CkNmY-Mr.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { analyzeMigrationSource, isDirectoryGitignored, parseLiteralCommands, 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";
 import os from "node:os";
 // src/migration/migrator/tsx.ts
 const TSX_COMMAND = /(?:^|[\s;&|("'=/\\`])tsx(?:\.(?:cmd|exe|ps1))?(?:\/(?:esm|cjs))?(?=$|[\s;&|)"'`])/i;
-const LOADER_OPTIONS = /* @__PURE__ */ new Set([
-	"--import",
-	"--loader",
-	"--experimental-loader",
-	"--require",
-	"-r"
-]);
 const TSX_LOADER = /^tsx(?:\/(?:esm|cjs))?$/;
-const LOADER_SETTINGS = /* @__PURE__ */ new Set([
-	"import",
-	"loader",
-	"require"
-]);
 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 = "`vpx` does not start a TypeScript REPL";
+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_SHELL = "the command uses shell syntax that vp migrate does not rewrite, such as pipes, variables, or subshells";
-const KEEP_OTHER = "vp migrate does not rewrite this use of tsx";
-const KEEP_TSX_TSCONFIG = "`TSX_TSCONFIG_PATH` selects the tsconfig for tsx only; pass it to `vpx` as `--tsconfig`";
 const KEEP_NODE_OPTIONS = "`NODE_OPTIONS` loads tsx, whose hooks would compete with those of `vpx`; remove it first";
-const KEEP_WATCH_TEST = "`vpx --watch` does not run `--test`";
 const KEEP_OPTIONS = /* @__PURE__ */ new Map([
 	["-e", KEEP_EVAL],
 	["--eval", KEEP_EVAL],
@@ -55,12 +39,11 @@ const KEEP_OPTIONS = /* @__PURE__ */ new Map([
 	["-pe", KEEP_EVAL],
 	["-c", KEEP_CHECK],
 	["--check", KEEP_CHECK],
-	["-i", KEEP_REPL],
-	["--interactive", KEEP_REPL],
+	["-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 SHEBANG_ENTRY = "./shebang.ts";
 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([
@@ -70,12 +53,209 @@ const TSX_CODE_REFERENCE = new RegExp([
 	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 (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`;
+}
+/** `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",
@@ -129,22 +309,6 @@ const USE_SCAN_SKIP_DIRS = /* @__PURE__ */ new Set([
 	".vite",
 	"coverage"
 ]);
-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 shellCommand = (previous) => /^-[a-z]*c$/.test(previous);
 const COMMAND_LAUNCHERS = /* @__PURE__ */ new Map([
 	["bash", shellCommand],
@@ -154,15 +318,11 @@ const COMMAND_LAUNCHERS = /* @__PURE__ */ new Map([
 	["zsh", shellCommand]
 ]);
 /**
-* Rewrite the tsx invocations in a command to `vpx`: `tsx a.ts` becomes `vpx a.ts`,
-* `tsx watch a.ts` becomes `vpx --watch a.ts` (`vpx watch` runs the npm package `watch`),
-* and `node --import tsx a.ts` becomes `vpx a.ts`. Package-manager wrappers such as
-* `npx tsx` go away with tsx, since `vpx` is a bin of vite-plus. A form `vpx` cannot run
-* stays as it is, with the reason in `kept`. With `cwd`, the directory the command runs
-* in, the scripts it runs are checked for syntax `vpx` runs differently.
+* Rewrite supported runner and Node.js loader invocations while preserving shell
+* syntax and arguments. Unsupported forms remain, with their reasons in `kept`.
 */
-function rewriteTsxCommand(command, cwd) {
-	if (!TSX_COMMAND.test(command)) return {
+function rewriteScriptRunnerCommand(runner, command, cwd, environment = [], checkingScripts = /* @__PURE__ */ new Set()) {
+	if (!runner.commandPattern.test(command) && !runner.envKeepReason(environment)) return {
 		command,
 		kept: []
 	};
@@ -174,8 +334,10 @@ function rewriteTsxCommand(command, cwd) {
 	const rewrite = {
 		command,
 		cwd,
+		environment,
 		edits: [],
-		kept: []
+		kept: [],
+		checkingScripts
 	};
 	for (const tokens of segments) {
 		const name = tokens[0].value;
@@ -183,17 +345,16 @@ function rewriteTsxCommand(command, cwd) {
 			rewrite.cwd = void 0;
 			continue;
 		}
-		rewriteSegment(rewrite, tokens);
+		rewriteSegment(runner, rewrite, tokens);
 	}
-	let rewritten = command;
-	for (const edit of rewrite.edits.toSorted((a, b) => b.start - a.start)) rewritten = rewritten.slice(0, edit.start) + edit.text + rewritten.slice(edit.end);
-	if (!rewrite.kept.length && TSX_COMMAND.test(rewritten)) rewrite.kept.push(KEEP_OTHER);
+	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
 	};
 }
-function rewriteSegment(rewrite, tokens) {
+function rewriteSegment(runner, rewrite, tokens) {
 	const values = tokens.map(({ value }) => value);
 	let first = 0;
 	const skipAssignments = () => {
@@ -205,24 +366,160 @@ function rewriteSegment(rewrite, tokens) {
 		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 envReason = envKeepReason(values.slice(0, first));
+	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] === "tsx") rewriteTsx(rewrite, tokens, first, start, envReason);
-	else if (values[start] === "node") rewriteNodeLoader(rewrite, tokens, first, start, envReason);
-	else if (shell) for (const token of tokens.slice(start)) rewriteQuotedCommand(rewrite, token, envReason);
-	else if (launcher) {
-		for (let index = start + 1; index < tokens.length; index++) if (launcher(values[index - 1])) rewriteQuotedCommand(rewrite, tokens[index], envReason);
+	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"
+	].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}`
+	};
 }
-/**
-* 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) => /^TSX_TSCONFIG_PATH=/i.test(value))) return KEEP_TSX_TSCONFIG;
-	if (assignments.some((value) => /^NODE_OPTIONS=/i.test(value) && TSX_COMMAND.test(value.slice(13)))) return KEEP_NODE_OPTIONS;
+/** 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
@@ -235,75 +532,42 @@ function optionName(arg) {
 /** Remove `tokens[index]` with the space before it. */
 function removal(tokens, index) {
 	return {
-		start: tokens[index - 1].end,
+		start: tokens[index - 1]?.end ?? tokens[index].start,
 		end: tokens[index].end,
 		text: ""
 	};
 }
 /**
-* 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 scriptKeepReason(cwd, script) {
-	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;
-	}
-	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 tsx 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`;
-}
-/** `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));
-}
-/**
-* Why `vpx` cannot run what tsx or `node --import tsx` runs: `positionals` are the entry
+* 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(cwd, test, positionals, preloads) {
+function runKeepReason(runner, cwd, test, positionals, preloads) {
 	const [entry] = positionals;
-	if (entry === void 0) return test ? KEEP_TEST_GLOBS : KEEP_REPL;
+	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 = scriptKeepReason(cwd, script);
+		const reason = runner.scriptKeepReason?.(cwd, script);
 		if (reason) return reason;
 	}
 }
-function rewriteTsx(rewrite, tokens, first, start, keepReason) {
+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 = tokens[index]?.value === "watch";
+	const watch = runner.watchSubcommand !== false && tokens[index]?.value === "watch";
 	if (watch) index++;
-	const scanned = scanOptions(tokens, index, true);
-	const reason = runReason(rewrite.cwd, tokens, scanned, watch);
+	const scanned = scanOptions(runner, tokens, index, true);
+	const reason = runReason(runner, rewrite.cwd, tokens, scanned, watch);
 	if (reason) {
 		rewrite.kept.push(reason);
 		return;
@@ -312,15 +576,39 @@ function rewriteTsx(rewrite, tokens, first, start, keepReason) {
 		start: tokens[first].start,
 		end: tokens[index - 1].end,
 		text: watch ? "vpx --watch" : "vpx"
-	}, ...scanned.removals);
-}
-function rewriteNodeLoader(rewrite, tokens, first, start, keepReason) {
-	const scanned = scanOptions(tokens, start + 1, false);
+	}, ...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 === KEEP_NODE_OPTIONS) rewrite.kept.push(keepReason);
+		if (keepReason) rewrite.kept.push(keepReason);
 		return;
 	}
-	const reason = keepReason ?? runReason(rewrite.cwd, tokens, scanned, false);
+	const reason = keepReason ?? runReason(runner, rewrite.cwd, tokens, scanned, false);
 	if (reason) {
 		rewrite.kept.push(reason);
 		return;
@@ -329,14 +617,85 @@ function rewriteNodeLoader(rewrite, tokens, first, start, keepReason) {
 		start: tokens[first].start,
 		end: tokens[start].end,
 		text: "vpx"
-	}, ...scanned.removals);
+	}, ...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
+	};
 }
-/** Read the options of `tsx` (`tsx` true) or `node` from `tokens[index]` up to the entry. */
-function scanOptions(tokens, index, tsx) {
+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
@@ -349,52 +708,82 @@ function scanOptions(tokens, index, tsx) {
 		}
 		const name = optionName(value);
 		const inline = value.includes("=");
-		if (tsx && name === "--no-cache") {
+		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 = inline ? value.slice(value.indexOf("=") + 1) : tokens[index + 1]?.value;
-			if (loader !== void 0 && TSX_LOADER.test(loader)) {
+			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++;
-			} else if (loader !== void 0 && (loader.startsWith(".") || path.isAbsolute(loader))) scanned.preloads.push(loader);
+				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 ??= KEEP_OPTIONS.get(name);
+		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";
-		if (!inline && (NODE_OPTIONS_WITH_VALUE.has(name) || tsx && (WATCH_OPTIONS_WITH_VALUE.has(name) || name === "--tsconfig"))) index++;
+		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(cwd, tokens, scanned, watch) {
+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(cwd, scanned.test, tokens.slice(scanned.entryIndex).map(({ value }) => value), scanned.preloads);
+	return runKeepReason(runner, cwd, scanned.test, tokens.slice(scanned.entryIndex).map(({ value }) => value), scanned.preloads);
 }
-/**
-* Rewrite a command that a launcher runs, given as one quoted argument. `inherited` keeps
-* tsx for it, as when the launcher passes on `TSX_TSCONFIG_PATH`.
-*/
-function rewriteQuotedCommand(rewrite, token, inherited) {
+/** 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;
-	const inner = rewriteTsxCommand(token.value, rewrite.cwd);
+	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) return;
-	if (inherited) rewrite.kept.push(inherited);
-	else if (!inner.command.includes(quote)) rewrite.edits.push({
-		start: token.start,
-		end: token.end,
-		text: `${quote}${inner.command}${quote}`
-	});
+	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) {
@@ -409,38 +798,37 @@ 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 tsx outside devDependencies keeps it: its published code or
-* production scripts can need tsx, and `vpx` comes from the vite-plus devDependency.
+* 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 ownsTsxAtRuntime(pkg) {
-	return pkg.dependencies?.tsx !== void 0 || pkg.optionalDependencies?.tsx !== void 0 || pkg.peerDependencies?.tsx !== void 0;
+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))];
 }
 /**
-* Whether a script, lint-staged task, or `#!/usr/bin/env tsx` shebang runs tsx in a form
-* `vpx` replaces.
+* Detect supported invocations, or retained uses when the profile requests warnings.
 */
-function detectTsxProject(rootDir, packages) {
+function detectScriptRunnerProject(runner, rootDir, packages) {
 	return packageDirs(rootDir, packages).some((dir) => {
 		const pkg = readPackageJsonIfExists(path.join(dir, "package.json"));
-		if (!pkg || ownsTsxAtRuntime(pkg)) return false;
-		return [...packageCommands(pkg), ...lintStagedJsonFiles(dir).flatMap((file) => recordCommands(readJsonFile(file)))].some((command) => rewriteTsxCommand(command, dir).command !== command) || sourceTreeMatches(dir, (content, file) => {
-			const result = rewriteTsxShebang(content, file);
+		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(record, label, cwd, report) {
+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 = rewriteTsxCommand(command, cwd);
-			for (const reason of result.kept) warnMigration(`Kept tsx in ${label} "${key}": ${reason}.`, report);
+			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])) {
@@ -451,98 +839,144 @@ function rewriteCommandRecord(record, label, cwd, report) {
 	return edited;
 }
 /**
-* The `vpx` version of a script file's tsx shebang, or why it keeps tsx; undefined when
-* the file has no `#!/usr/bin/env tsx` shebang.
+* The migrated runner or Node.js preload shebang, or its retention reason.
 */
-function rewriteTsxShebang(content, file) {
-	const match = TSX_ENV_SHEBANG.exec(content);
+function rewriteRunnerShebang(runner, content, file, packageDir) {
+	const match = runner.envShebang.exec(content);
 	if (!match) return;
 	const [line, prefix, command] = match;
-	const result = rewriteTsxCommand(`${command.trimEnd()} ${SHEBANG_ENTRY}`);
-	const reason = result.kept[0] ?? scriptKeepReason(path.dirname(file), `./${path.basename(file)}`);
+	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 };
-	return { content: `${prefix}${result.command.slice(0, -` ${SHEBANG_ENTRY}`.length)}${content.slice(line.length)}` };
+	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)}` };
 }
-/** Point `#!/usr/bin/env tsx` shebangs of a package's script files at `vpx`. */
-function rewriteTsxShebangs(dir, report) {
+/** 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 = rewriteTsxShebang(content, file);
-		if (result && "reason" in result) warnMigration(`Kept tsx in the shebang of ${displayRelative(file)}: ${result.reason}.`, report);
+		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;
 }
 /**
-* What still runs or imports tsx under `dir`, or undefined. The scan crosses into nested
-* packages, which can resolve this package's tsx, and reads build output, which can
-* still load it.
+* Find a remaining use, including nested packages and build output that can resolve
+* the package's runner dependencies.
 */
-function findTsxUse(dir) {
+function findRunnerUse(runner, dir, retainUnverified = true) {
 	let found;
 	sourceTreeMatches(dir, (content, file) => {
 		if (LOCKFILES.has(path.basename(file))) return false;
-		const uses = fileUsesTsx(content, file);
-		if (uses) found = `${displayRelative(file)} still uses tsx`;
-		return uses;
+		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) && jsonUsesTsx(value, [
+			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 tsx`;
-			return field !== void 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;
 }
-/** Whether `file` runs, imports, or loads tsx. */
-function fileUsesTsx(content, file) {
-	if (TSX_SHEBANG.test(content)) return true;
+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 (LINT_STAGED_JSON_CONFIG_FILES.some((config) => config === name) && jsonUsesTsx(parse(content), true)) return true;
+	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 jsonUsesTsx(parse(content), false);
-	if (CODE_EXTENSIONS.has(extension)) return TSX_CODE_REFERENCE.test(content);
-	return TSX_TEXT_REFERENCE.test(content) || extension === "" && TSX_CODE_REFERENCE.test(content);
-}
-/**
-* Whether a JSON value holds a string that runs or loads tsx: a tsx command with an
-* argument, a loader flag such as `--import=tsx` or `["--import", "tsx"]`, or a subpath
-* such as `tsx/cjs`. A bare `tsx` counts only in `commands` (scripts, lint-staged tasks,
-* and `imports` aliases) and as a loader setting such as Mocha's `"import": "tsx"`;
-* elsewhere it is often a file extension, as in `moduleFileExtensions`.
-*/
-function jsonUsesTsx(value, commands) {
-	if (typeof value === "string") return commands && TSX_COMMAND.test(value) || TSX_CONFIG_VALUE.test(value);
-	if (Array.isArray(value)) return value.some((item, index) => jsonUsesTsx(item, commands) || typeof item === "string" && LOADER_OPTIONS.has(item) && TSX_LOADER.test(String(value[index + 1])));
-	return isPlainRecord(value) && Object.entries(value).some(([key, item]) => jsonUsesTsx(item, commands) || LOADER_SETTINGS.has(key) && [item].flat().some((loader) => TSX_LOADER.test(String(loader))));
-}
-/**
-* Move tsx scripts to `vpx`: rewrite package.json scripts, lint-staged tasks, and
-* `#!/usr/bin/env tsx` shebangs, then remove the tsx devDependency from each package
-* where nothing uses tsx anymore.
-*/
-function migrateTsxToVpx(rootDir, packages, report) {
+	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 (ownsTsxAtRuntime(pkg)) {
-			if (packageCommands(pkg).some((c) => TSX_COMMAND.test(c))) warnMigration(`Kept tsx in ${displayRelative(packageJsonPath)}: it is listed in dependencies, optionalDependencies, or peerDependencies there, and \`vpx\` comes from the vite-plus devDependency.`, report);
+		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);
@@ -550,51 +984,538 @@ function migrateTsxToVpx(rootDir, packages, report) {
 			let edited = false;
 			for (const field of ["scripts", "lint-staged"]) {
 				const record = json[field];
-				if (isPlainRecord(record) && rewriteCommandRecord(record, `${displayRelative(packageJsonPath)} ${field}`, dir, report)) edited = true;
+				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(config, displayRelative(file), dir, report);
+			const edited = rewriteCommandRecord(runner, config, displayRelative(file), dir, report);
 			changed ||= edited;
 			return edited ? config : void 0;
 		});
-		if (rewriteTsxShebangs(dir, report)) changed = true;
+		if (rewriteRunnerShebangs(runner, dir, report)) changed = true;
 	}
 	let dependencyRemoved = false;
 	for (const dir of migrated) {
 		const packageJsonPath = path.join(dir, "package.json");
-		if (readPackageJsonIfExists(packageJsonPath)?.devDependencies?.tsx === void 0) continue;
-		const use = findTsxUse(dir);
+		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 tsx devDependency in ${displayRelative(packageJsonPath)}: ${use}.`, report);
+			warnMigration(`Kept the ${runner.dependencies.join(" / ")} devDependency in ${displayRelative(packageJsonPath)}: ${use}.`, report);
 			continue;
 		}
 		editJsonFile(packageJsonPath, (json) => {
-			delete json.devDependencies.tsx;
+			for (const dependency of runner.dependencies) delete json.devDependencies[dependency];
 			return json;
 		});
 		dependencyRemoved = true;
 	}
-	if (report && changed) report.tsxMigrated = true;
 	return {
 		changed: changed || dependencyRemoved,
-		dependencyRemoved
+		dependencyRemoved,
+		scriptsChanged: changed
 	};
 }
-async function confirmTsxMigration(interactive) {
+// 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 tsx scripts to vpx?\n  " + styleText("gray", "vpx is Vite+'s built-in TypeScript script runner: `tsx <file>` becomes `vpx <file>`, `tsx watch` becomes `vpx --watch`, and the tsx dependency is removed once nothing uses it."),
+			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$1.info("tsx scripts detected. Auto-migrating to vpx...");
+	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) {
@@ -1547,6 +2468,44 @@ 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 [
@@ -1562,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;
@@ -1571,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;
@@ -1587,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;
@@ -2916,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
 		} })));
@@ -3182,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";
@@ -3249,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;
@@ -3266,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;
@@ -3276,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 && [
@@ -3338,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;
 }
@@ -3391,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."));
@@ -3422,6 +4374,7 @@ 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 = [];
@@ -3440,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),
@@ -3897,13 +4850,13 @@ function prepareNpmViteAliasReinstall(rootDir, projectPaths = [rootDir]) {
 async function collectGitHooksDecision(rootDir, packageManager, options, packages = []) {
 	const hasExistingHooks = options.hooks === void 0 && hasExistingViteHooksPolicy(rootDir);
 	if (hasExistingHooks && isViteHooksSetupComplete(rootDir)) {
-		log(`${muted("•")} Git hooks already configured, skipping`);
+		log$1(`${muted("•")} Git hooks already configured, skipping`);
 		return false;
 	}
 	if (!hasExistingHooks && !await promptGitHooks(options)) return false;
 	const reason = preflightGitHooksSetup(rootDir, packageManager, packages);
 	if (reason) {
-		log$1.warn(`⚠ ${reason}`);
+		log.warn(`⚠ ${reason}`);
 		return false;
 	}
 	return true;
@@ -4042,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({
@@ -4146,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 || detectTsxProject(workspaceInfo.rootDir, workspaceInfo.packages) || 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;
@@ -4167,6 +5120,8 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, detectedPac
 	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
@@ -4185,6 +5140,8 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, detectedPac
 		migrateTsup,
 		tsupConfigFile,
 		migrateTsx,
+		migrateOxnode,
+		migrateTsNode,
 		fixBaseUrl,
 		migrateNodeVersionFile,
 		nodeVersionDetection,
@@ -4196,52 +5153,56 @@ 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(", ")}`);
-	}
-	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.tsxMigrated) log(`${styleText("gray", "•")} tsx scripts migrated to \`vpx\``);
-	if (report.nodeVersionFileMigrated) log(`${styleText("gray", "•")} Node version manager file migrated to .node-version`);
+		log$1(`${styleText("gray", "•")} ${parts.join(", ")}`);
+	}
+	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");
@@ -4251,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;
@@ -4272,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);
@@ -4280,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) => {
@@ -4320,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");
@@ -4378,6 +5340,14 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, vi
 		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");
@@ -4443,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);
@@ -4456,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) => {
@@ -4515,12 +5486,14 @@ async function main() {
 		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);
@@ -4610,6 +5583,24 @@ async function main() {
 				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) {
@@ -4620,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;
@@ -4723,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;
@@ -4740,7 +5731,7 @@ async function main() {
 	});
 }
 main().catch((err) => {
-	log$1.error(err.message);
+	log.error(err.message);
 	console.error(err);
 	process.exit(1);
 });