vite-plus 0.2.1 → 0.2.2

package/dist/migration/bin.js

@@ -1,17 +1,400 @@
-import { r as __toESM } from "../rolldown-runtime-DnnnRqeS.js";
-import { u as isForceOverrideMode } from "../constants-CrfJQIUX.js";
-import { A as select, C as require_semver, D as log, P as R, S as PackageManager, T as confirm, c as cancelAndExit, d as promptGitHooks, g as upgradeYarn, h as selectPackageManager, i as hasBaseUrlInTsconfig, j as spinner, k as outro, l as defaultInteractive, m as runViteInstall, r as fixBaseUrlInTsconfig, t as confirmBaseUrlFix, u as downloadPackageManager } from "../tsconfig-BWQPmGKz.js";
+import { r as __toESM } from "../rolldown-runtime-C7HZzL1F.js";
+import { d as isForceOverrideMode, l as VITE_PLUS_VERSION } from "../constants-NeTOxrzV.js";
+import { B as runCommandSilently, D as require_semver, E as PackageManager, F as spinner, N as outro, P as select, R as isCancel, _ as upgradeYarn, d as downloadPackageManager, f as promptGitHooks, g as selectPackageManager, h as runViteInstall, i as hasBaseUrlInTsconfig, j as log, k as confirm, l as cancelAndExit, m as runViteFmt, r as fixBaseUrlInTsconfig, t as confirmBaseUrlFix, u as defaultInteractive } from "../tsconfig-fvpxgUq2.js";
 import { a as printHeader, i as muted, r as log$1, s as warnMsg, t as accent } from "../terminal-uTv0ZaMr.js";
+import { a as writeJsonFile, i as readJsonFile } from "../json-DiRs8ceZ.js";
 import { t as lib_default } from "../lib-L3DWSRQp.js";
-import { a as readNearestPackageJson, i as hasVitePlusDependency } from "../package-BHirM1_v.js";
-import { A as mergeViteConfigFiles, C as ensureVitePlusBootstrap, H as warnLegacyEslintConfig, L as rewriteMonorepo, M as migrateNodeVersionManagerFile, N as migratePrettierToOxfmt, O as injectLintTypeCheckDefaults, P as preflightGitHooksSetup, T as hasFrameworkShim, U as warnPackageLevelEslint, V as warnIncompatibleEslintIntegration, W as warnPackageLevelPrettier, _ as detectLegacyGitHooksMigrationCandidate, b as detectPrettierProject, d as checkVitestVersion, f as confirmEslintMigration, g as detectIncompatibleEslintIntegration, h as detectFramework, i as selectAgentTargetPaths, j as migrateEslintToOxlint, k as installGitHooks, l as addFrameworkShim, m as detectEslintProject, n as detectAgentConflicts, p as confirmPrettierMigration, q as displayRelative, r as detectExistingAgentTargetPaths, s as writeAgentInstructions, u as checkViteVersion, v as detectNodeVersionManagerFile, w as finalizeCoreMigrationForExistingVitePlus, x as detectVitePlusBootstrapPending, y as detectPendingCoreMigration, z as rewriteStandaloneProject } from "../agent--cKmgD_n.js";
-import { n as addMigrationWarning, r as createMigrationReport } from "../report-BHSkWqRR.js";
-import { a as detectEditorConflicts, l as writeEditorConfigs, s as selectEditor, t as detectWorkspace } from "../workspace-D0AVy4fu.js";
+import { a as readNearestPackageJson, i as hasVitePlusDependency } from "../package-CU2g7URl.js";
+import { A as detectWorkspace, B as warnIncompatibleEslintIntegration, C as injectLintTypeCheckDefaults, D as ensureVitePlusBootstrap, E as detectVitePlusBootstrapPending, F as detectEslintProject, H as warnPackageLevelEslint, I as detectIncompatibleEslintIntegration, K as checkViteVersion, L as migrateEslintToOxlint, O as configureYarnNodeModulesMode, P as confirmEslintMigration, T as collectToolchainVersionChanges, V as warnLegacyEslintConfig, Y as displayRelative, _ as detectLegacyGitHooksMigrationCandidate, b as preflightGitHooksSetup, d as rewriteStandaloneProject, f as detectPendingCoreMigration, h as migrateNodeVersionManagerFile, i as selectAgentTargetPaths, k as detectYarnPnpMode, l as rewriteMonorepo, m as detectNodeVersionManagerFile, n as detectAgentConflicts, p as finalizeCoreMigrationForExistingVitePlus, q as checkVitestVersion, r as detectExistingAgentTargetPaths, s as writeAgentInstructions, w as mergeViteConfigFiles, y as installGitHooks } from "../agent-D7O7mSeO.js";
+import { n as addMigrationWarning, r as createMigrationReport } from "../report-BS7ULx7A.js";
+import { a as writeEditorConfigs, c as hasFrameworkShim, d as migratePrettierToOxfmt, l as confirmPrettierMigration, o as addFrameworkShim, p as warnPackageLevelPrettier, r as selectEditor, s as detectFramework, t as detectEditorConflicts, u as detectPrettierProject } from "../editor-CPzssglc.js";
 import { t as renderCliDoc } from "../help-YP84FSEz.js";
+import { t as ROLLDOWN_COMPAT_RESULT_PREFIX } from "../protocol-D99W10Qi.js";
 import path from "node:path";
+import fs, { existsSync } from "node:fs";
 import { styleText } from "node:util";
-//#region src/migration/bin.ts
+import { fileURLToPath } from "node:url";
+//#region src/migration/compat/runner.ts
 var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
+/**
+* Resolve the isolated compat worker emitted at `migration/compat/worker.js`.
+*
+* The worker is a sibling of this module in source (`src/migration/compat/`),
+* so `./worker.js` is the correct relative path. The bundler, however, inlines
+* this runner into the parent `migration/bin.js` entry, which sits one level up
+* from the emitted `migration/compat/worker.js`; there the worker lives in the
+* nested `./compat/` directory. A fixed literal can only satisfy one layout:
+* `./compat/worker.js` doubles to `compat/compat/worker.js` in source, while
+* `./worker.js` misses the bundled worker. Probe for the nested
+* `./compat/worker.js` next to this module to pick the right prefix for
+* whichever layout this code is running in.
+*/
+function resolveWorkerPath() {
+	const nestedWorker = new URL("./compat/worker.js", import.meta.url);
+	if (existsSync(nestedWorker)) return fileURLToPath(nestedWorker);
+	return fileURLToPath(new URL("./worker.js", import.meta.url));
+}
+const WORKER_TIMEOUT_MS = 3e4;
+function parseRolldownCompatibilityResult(stdout) {
+	const output = stdout.toString();
+	const markerIndex = output.lastIndexOf(ROLLDOWN_COMPAT_RESULT_PREFIX);
+	if (markerIndex === -1) return;
+	const resultStart = markerIndex + ROLLDOWN_COMPAT_RESULT_PREFIX.length;
+	const resultEnd = output.indexOf("\n", resultStart);
+	const serialized = output.slice(resultStart, resultEnd === -1 ? void 0 : resultEnd).trim();
+	try {
+		const result = JSON.parse(serialized);
+		if (!Array.isArray(result.warnings) || !result.warnings.every((item) => typeof item === "string")) return;
+		return { warnings: result.warnings };
+	} catch {
+		return;
+	}
+}
+/**
+* Resolve a project's Vite config in a child process before checking it for
+* Rolldown-incompatible options. Config files execute arbitrary project code;
+* isolating them prevents process-level handlers, explicit exits, and
+* asynchronous crashes from terminating the migration itself.
+*/
+async function checkRolldownCompatibility(rootDir, report) {
+	try {
+		const workerPath = resolveWorkerPath();
+		const result = await runCommandSilently({
+			command: process.execPath,
+			args: [workerPath, rootDir],
+			cwd: rootDir,
+			envs: process.env,
+			timeoutMs: WORKER_TIMEOUT_MS
+		});
+		if (result.exitCode !== 0) return;
+		const compatibilityResult = parseRolldownCompatibilityResult(result.stdout);
+		for (const warning of compatibilityResult?.warnings ?? []) addMigrationWarning(report, warning);
+	} catch {}
+}
+//#endregion
+//#region src/migration/format.ts
+const FORMAT_FAILURE_MESSAGE = "Automatic formatting failed. Run `vp fmt` manually after migration.";
+const MAX_FORMAT_ARG_BYTES = process.platform === "win32" ? 24e3 : 1e5;
+function chunkPathsByArgLength(paths) {
+	const chunks = [];
+	let current = [];
+	let currentBytes = 0;
+	for (const filePath of paths) {
+		const bytes = Buffer.byteLength(filePath) + 1;
+		if (current.length > 0 && currentBytes + bytes > MAX_FORMAT_ARG_BYTES) {
+			chunks.push(current);
+			current = [];
+			currentBytes = 0;
+		}
+		current.push(filePath);
+		currentBytes += bytes;
+	}
+	if (current.length > 0) chunks.push(current);
+	return chunks;
+}
+function parseNullDelimitedPaths(output) {
+	return output.toString().split("\0").filter(Boolean);
+}
+function isExistingFile(projectRoot, relativePath) {
+	const absolutePath = path.join(projectRoot, relativePath);
+	try {
+		return fs.statSync(absolutePath).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Limit automatic formatting to files changed in the current Git worktree.
+* This prevents migration from reformatting unrelated source trees while still
+* covering manifests, generated config, and rewritten imports.
+*
+* Return `undefined` outside a Git worktree so non-Git projects retain the
+* existing full-project formatting behavior.
+*/
+async function collectChangedFormatPaths(projectRoot, excludedPaths) {
+	try {
+		const git = (args) => runCommandSilently({
+			command: "git",
+			args,
+			cwd: projectRoot,
+			envs: process.env
+		});
+		const worktree = await git(["rev-parse", "--is-inside-work-tree"]);
+		if (worktree.exitCode !== 0) return worktree.stderr.toString().includes("not a git repository") ? void 0 : [];
+		if (worktree.stdout.toString().trim() !== "true") return;
+		const [unstaged, staged, untracked] = await Promise.all([
+			git([
+				"diff",
+				"--name-only",
+				"--relative",
+				"-z",
+				"--diff-filter=ACMRTUXB",
+				"--",
+				"."
+			]),
+			git([
+				"diff",
+				"--cached",
+				"--name-only",
+				"--relative",
+				"-z",
+				"--diff-filter=ACMRTUXB",
+				"--",
+				"."
+			]),
+			git([
+				"ls-files",
+				"--others",
+				"--exclude-standard",
+				"-z",
+				"--",
+				"."
+			])
+		]);
+		if (unstaged.exitCode !== 0 || staged.exitCode !== 0 || untracked.exitCode !== 0) return [];
+		return [.../* @__PURE__ */ new Set([
+			...parseNullDelimitedPaths(unstaged.stdout),
+			...parseNullDelimitedPaths(staged.stdout),
+			...parseNullDelimitedPaths(untracked.stdout)
+		])].filter((file) => !excludedPaths?.has(file) && isExistingFile(projectRoot, file)).toSorted();
+	} catch {
+		return [];
+	}
+}
+/**
+* Do not apply Oxfmt to a project that still uses Prettier. Their formatting
+* rules can conflict, especially when Prettier is enforced through ESLint.
+*/
+function canFormatWithOxfmt(hasPrettierDependency, prettierMigrated) {
+	return !hasPrettierDependency || prettierMigrated;
+}
+/**
+* Format a successfully migrated project without turning a formatter problem
+* into an unhandled migration failure. The formatter already prints its
+* stdout/stderr when it exits nonzero; the report keeps the manual follow-up
+* visible in the final migration summary.
+*/
+async function formatMigratedProject(projectRoot, interactive, report, options = {}) {
+	const { format = runViteFmt, collectPaths = collectChangedFormatPaths, excludedPaths } = options;
+	try {
+		const paths = await collectPaths(projectRoot, excludedPaths);
+		if (paths?.length === 0) return true;
+		const cliEntry = process.argv[1] ? path.resolve(process.cwd(), process.argv[1]) : void 0;
+		const formatOptions = {
+			silent: false,
+			...cliEntry ? {
+				command: process.execPath,
+				commandArgs: [...process.execArgv, cliEntry]
+			} : {}
+		};
+		const batches = paths === void 0 ? [void 0] : chunkPathsByArgLength(paths);
+		let allFormatted = true;
+		for (const batch of batches) if ((await format(projectRoot, interactive, batch, formatOptions)).status !== "formatted") {
+			allFormatted = false;
+			break;
+		}
+		if (allFormatted) return true;
+	} catch {}
+	addMigrationWarning(report, FORMAT_FAILURE_MESSAGE);
+	return false;
+}
+//#endregion
+//#region src/migration/npm-reinstall.ts
+const VITE_PLUS_CORE_PACKAGE = "@voidzero-dev/vite-plus-core";
+function isViteInstallPath(packagePath) {
+	return packagePath === "node_modules/vite" || packagePath.endsWith("/node_modules/vite");
+}
+function isVitePlusCorePackage(pkg) {
+	return pkg?.name === VITE_PLUS_CORE_PACKAGE || pkg?.resolved?.includes("/@voidzero-dev/vite-plus-core/") === true;
+}
+const STALE_VITE_BACKUP_NAME = ".vite-plus-migrate-stale-vite";
+function removeStaleInstalledVite(packagePath, moved) {
+	const packageJsonPath = path.join(packagePath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return false;
+	try {
+		if (readJsonFile(packageJsonPath).name === VITE_PLUS_CORE_PACKAGE) return false;
+	} catch {}
+	const backupPath = path.join(path.dirname(packagePath), STALE_VITE_BACKUP_NAME);
+	try {
+		fs.rmSync(backupPath, {
+			recursive: true,
+			force: true
+		});
+		fs.renameSync(packagePath, backupPath);
+		moved.push({
+			originalPath: packagePath,
+			backupPath
+		});
+	} catch {
+		fs.rmSync(packagePath, {
+			recursive: true,
+			force: true
+		});
+	}
+	return true;
+}
+/**
+* npm does not replace an already-installed package when its dependency changes
+* from `vite` to the `@voidzero-dev/vite-plus-core` npm alias. Even `npm
+* install --force` can exit successfully while retaining the real Vite package
+* and its stale package-lock entry. Move those stale Vite installs aside (and
+* drop their lock entries) before the migration's final install so npm resolves
+* the managed alias afresh; the caller commits or restores them depending on
+* whether the install succeeded, so a failed install does not strand the
+* project without any vite package.
+*/
+function prepareNpmViteAliasReinstall(rootDir, projectPaths = [rootDir]) {
+	const packageLockPath = path.join(rootDir, "package-lock.json");
+	const moved = [];
+	let changed = false;
+	if (fs.existsSync(packageLockPath)) try {
+		const packageLock = readJsonFile(packageLockPath);
+		let lockChanged = false;
+		for (const [packagePath, pkg] of Object.entries(packageLock.packages ?? {})) {
+			if (!isViteInstallPath(packagePath)) continue;
+			const installPath = path.resolve(rootDir, packagePath);
+			const relativeInstallPath = path.relative(rootDir, installPath);
+			if (relativeInstallPath.startsWith("..") || path.isAbsolute(relativeInstallPath)) continue;
+			if (!isVitePlusCorePackage(pkg)) {
+				delete packageLock.packages?.[packagePath];
+				lockChanged = true;
+				removeStaleInstalledVite(installPath, moved);
+			} else changed = removeStaleInstalledVite(installPath, moved) || changed;
+		}
+		if (lockChanged) {
+			writeJsonFile(packageLockPath, packageLock);
+			changed = true;
+		}
+	} catch {}
+	for (const projectPath of projectPaths) changed = removeStaleInstalledVite(path.join(projectPath, "node_modules", "vite"), moved) || changed;
+	return {
+		changed,
+		commit: () => {
+			for (const { backupPath } of moved) try {
+				fs.rmSync(backupPath, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		},
+		restore: () => {
+			for (const { originalPath, backupPath } of moved) try {
+				fs.rmSync(originalPath, {
+					recursive: true,
+					force: true
+				});
+				fs.renameSync(backupPath, originalPath);
+			} catch {}
+		}
+	};
+}
+//#endregion
+//#region src/migration/setup-plan.ts
+async function collectGitHooksDecision(rootDir, packageManager, options) {
+	let shouldSetupHooks = await promptGitHooks(options);
+	if (shouldSetupHooks) {
+		const reason = preflightGitHooksSetup(rootDir, packageManager);
+		if (reason) {
+			log.warn(`⚠ ${reason}`);
+			shouldSetupHooks = false;
+		}
+	}
+	return shouldSetupHooks;
+}
+async function collectAgentInstructionPlan(rootDir, options) {
+	const existingAgentTargetPaths = options.agent !== void 0 || !options.interactive ? void 0 : detectExistingAgentTargetPaths(rootDir);
+	const selectedAgentTargetPaths = existingAgentTargetPaths !== void 0 ? existingAgentTargetPaths : await selectAgentTargetPaths({
+		interactive: options.interactive,
+		agent: options.agent,
+		onCancel: () => cancelAndExit()
+	});
+	const agentConflicts = await detectAgentConflicts({
+		projectRoot: rootDir,
+		targetPaths: selectedAgentTargetPaths
+	});
+	const agentConflictDecisions = /* @__PURE__ */ new Map();
+	for (const conflict of agentConflicts) if (options.interactive) {
+		const action = await select({
+			message: `Agent instructions already exist at ${conflict.targetPath}.\n  ` + styleText("gray", "The Vite+ template includes guidance on `vp` commands, the build pipeline, and project conventions."),
+			options: [{
+				label: "Append",
+				value: "append",
+				hint: "Add template content to the end"
+			}, {
+				label: "Skip",
+				value: "skip",
+				hint: "Leave existing file unchanged"
+			}],
+			initialValue: "skip"
+		});
+		if (isCancel(action)) cancelAndExit();
+		agentConflictDecisions.set(conflict.targetPath, action);
+	} else agentConflictDecisions.set(conflict.targetPath, "skip");
+	return {
+		selectedAgentTargetPaths,
+		agentConflictDecisions
+	};
+}
+async function collectEditorConfigPlan(rootDir, options) {
+	const selectedEditor = await selectEditor({
+		interactive: options.interactive,
+		editor: options.editor,
+		onCancel: () => cancelAndExit()
+	});
+	const editorConflicts = detectEditorConflicts({
+		projectRoot: rootDir,
+		editorId: selectedEditor
+	});
+	const editorConflictDecisions = /* @__PURE__ */ new Map();
+	for (const conflict of editorConflicts) if (options.interactive) {
+		const action = await select({
+			message: `${conflict.displayPath} already exists.\n  ` + styleText("gray", "Vite+ adds editor settings for the built-in linter and formatter. Merge adds new keys without overwriting existing ones."),
+			options: [{
+				label: "Merge",
+				value: "merge",
+				hint: "Merge new settings into existing file"
+			}, {
+				label: "Skip",
+				value: "skip",
+				hint: "Leave existing file unchanged"
+			}],
+			initialValue: "skip"
+		});
+		if (isCancel(action)) cancelAndExit();
+		editorConflictDecisions.set(conflict.fileName, action);
+	} else editorConflictDecisions.set(conflict.fileName, "merge");
+	return {
+		selectedEditor,
+		editorConflictDecisions
+	};
+}
+async function collectEslintMigrationDecision(rootDir, options, packages) {
+	const eslintProject = detectEslintProject(rootDir, packages);
+	const incompatibleEslintIntegration = detectIncompatibleEslintIntegration(rootDir, packages);
+	let migrateEslint = false;
+	if (incompatibleEslintIntegration) warnIncompatibleEslintIntegration(incompatibleEslintIntegration);
+	else if (eslintProject.hasDependency && !eslintProject.configFile && eslintProject.legacyConfigFile) warnLegacyEslintConfig(eslintProject.legacyConfigFile);
+	else if (eslintProject.hasDependency && eslintProject.configFile) migrateEslint = await confirmEslintMigration(options.interactive);
+	else if (eslintProject.hasDependency) warnPackageLevelEslint();
+	return {
+		migrateEslint,
+		eslintConfigFile: eslintProject.configFile
+	};
+}
+async function collectMigrationSetupPlan(rootDir, packageManager, options, packages, includeEslint = true) {
+	const shouldSetupHooks = await collectGitHooksDecision(rootDir, packageManager, options);
+	const agentPlan = await collectAgentInstructionPlan(rootDir, options);
+	const editorPlan = await collectEditorConfigPlan(rootDir, options);
+	const eslintPlan = includeEslint ? await collectEslintMigrationDecision(rootDir, options, packages) : { migrateEslint: false };
+	return {
+		shouldSetupHooks,
+		...agentPlan,
+		...editorPlan,
+		...eslintPlan
+	};
+}
+//#endregion
+//#region src/migration/bin.ts
 async function confirmNodeVersionFileMigration(interactive, detection) {
 	const message = {
 		"package.json": "Migrate Volta node version (package.json) to .node-version?",
@@ -22,7 +405,7 @@ async function confirmNodeVersionFileMigration(interactive, detection) {
 			message,
 			initialValue: true
 		});
-		if (R(confirmed)) cancelAndExit();
+		if (isCancel(confirmed)) cancelAndExit();
 		return confirmed;
 	}
 	return true;
@@ -37,11 +420,27 @@ async function confirmFrameworkShim(framework, interactive) {
 			message: `Add TypeScript shim for ${name} component files (*.${framework})?\n  ` + styleText("gray", `Lets TypeScript recognize .${framework} files until vp check fully supports them.`),
 			initialValue: true
 		});
-		if (R(confirmed)) cancelAndExit();
+		if (isCancel(confirmed)) cancelAndExit();
 		return confirmed;
 	}
 	return true;
 }
+async function confirmYarnNodeModulesMode(rootDir, packageManager, packageManagerVersion, interactive) {
+	if (packageManager !== PackageManager.yarn) return false;
+	const pnp = detectYarnPnpMode(rootDir, packageManagerVersion);
+	if (!pnp) return false;
+	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({
+			message: "Switch this project to Yarn node-modules mode and continue?",
+			initialValue: true
+		});
+		if (isCancel(confirmed)) cancelAndExit();
+		if (!confirmed) cancelAndExit("Migration cancelled. Vite+ requires Yarn node-modules mode.");
+	}
+	return true;
+}
 async function fixBaseUrlForWorkspace(workspaceInfo, fixBaseUrl, updateProgress, report) {
 	if (!fixBaseUrl) return [];
 	const fixedProjectPaths = [];
@@ -61,11 +460,16 @@ function getWorkspaceProjectPaths(workspaceInfo) {
 	return [workspaceInfo.rootDir, ...(workspaceInfo.packages ?? []).map((pkg) => path.join(workspaceInfo.rootDir, pkg.path))];
 }
 function hasBaseUrlInWorkspace(workspaceInfo) {
-	for (const projectPath of getWorkspaceProjectPaths(workspaceInfo)) {
-		if (!hasBaseUrlInTsconfig(projectPath)) continue;
-		return true;
+	return getWorkspaceProjectPaths(workspaceInfo).some(hasBaseUrlInTsconfig);
+}
+async function checkWorkspaceRolldownCompatibility(workspaceInfo, report, updateProgress) {
+	const projectPaths = getWorkspaceProjectPaths(workspaceInfo);
+	for (const [index, projectPath] of projectPaths.entries()) {
+		const counter = projectPaths.length > 1 ? ` (${index + 1}/${projectPaths.length})` : "";
+		const label = displayRelative(projectPath, workspaceInfo.rootDir);
+		updateProgress?.(`Checking config compatibility${counter}${label ? `: ${label}` : ""}`);
+		await checkRolldownCompatibility(projectPath, report);
 	}
-	return false;
 }
 const helpMessage = renderCliDoc({
 	usage: "vp migrate [PATH] [OPTIONS]",
@@ -106,6 +510,10 @@ const helpMessage = renderCliDoc({
 					label: "--no-hooks",
 					description: "Skip pre-commit hooks setup"
 				},
+				{
+					label: "--full",
+					description: "Existing Vite+ projects: also run the full setup (hooks, editor, agent files, ESLint/Prettier migration, framework shims, tsconfig baseUrl, .node-version). Without it, `vp migrate` only upgrades the toolchain version."
+				},
 				{
 					label: "--no-interactive",
 					description: "Run in non-interactive mode (skip prompts and use defaults)"
@@ -178,7 +586,8 @@ function parseArgs() {
 		boolean: [
 			"help",
 			"interactive",
-			"hooks"
+			"hooks",
+			"full"
 		],
 		default: { interactive: defaultInteractive() }
 	});
@@ -193,7 +602,8 @@ function parseArgs() {
 			help: parsed.help,
 			agent: parsed.agent,
 			editor: parsed.editor,
-			hooks: parsed.hooks
+			hooks: parsed.hooks,
+			full: parsed.full
 		}
 	};
 }
@@ -244,120 +654,18 @@ function hasExistingVitePlusMigrationCandidates(workspaceInfo, options) {
 	const prettierProject = detectPrettierProject(workspaceInfo.rootDir, workspaceInfo.packages);
 	return hasExplicitExistingVitePlusSetupRequest(options) || detectLegacyGitHooksMigrationCandidate(workspaceInfo.rootDir) || hasBaseUrlInWorkspace(workspaceInfo) || eslintProject.hasDependency || prettierProject.hasDependency || detectNodeVersionManagerFile(workspaceInfo.rootDir) !== void 0 || getFrameworkShimCandidates(workspaceInfo.rootDir, workspaceInfo.packages).length > 0;
 }
-async function collectGitHooksDecision(rootDir, packageManager, options) {
-	let shouldSetupHooks = await promptGitHooks(options);
-	if (shouldSetupHooks) {
-		const reason = preflightGitHooksSetup(rootDir, packageManager);
-		if (reason) {
-			log.warn(`⚠ ${reason}`);
-			shouldSetupHooks = false;
-		}
-	}
-	return shouldSetupHooks;
-}
-async function collectAgentInstructionPlan(rootDir, options) {
-	const existingAgentTargetPaths = options.agent !== void 0 || !options.interactive ? void 0 : detectExistingAgentTargetPaths(rootDir);
-	const selectedAgentTargetPaths = existingAgentTargetPaths !== void 0 ? existingAgentTargetPaths : await selectAgentTargetPaths({
-		interactive: options.interactive,
-		agent: options.agent,
-		onCancel: () => cancelAndExit()
-	});
-	const agentConflicts = await detectAgentConflicts({
-		projectRoot: rootDir,
-		targetPaths: selectedAgentTargetPaths
-	});
-	const agentConflictDecisions = /* @__PURE__ */ new Map();
-	for (const conflict of agentConflicts) if (options.interactive) {
-		const action = await select({
-			message: `Agent instructions already exist at ${conflict.targetPath}.\n  ` + styleText("gray", "The Vite+ template includes guidance on `vp` commands, the build pipeline, and project conventions."),
-			options: [{
-				label: "Append",
-				value: "append",
-				hint: "Add template content to the end"
-			}, {
-				label: "Skip",
-				value: "skip",
-				hint: "Leave existing file unchanged"
-			}],
-			initialValue: "skip"
-		});
-		if (R(action)) cancelAndExit();
-		agentConflictDecisions.set(conflict.targetPath, action);
-	} else agentConflictDecisions.set(conflict.targetPath, "skip");
-	return {
-		selectedAgentTargetPaths,
-		agentConflictDecisions
-	};
-}
-async function collectEditorConfigPlan(rootDir, options) {
-	const selectedEditor = await selectEditor({
-		interactive: options.interactive,
-		editor: options.editor,
-		onCancel: () => cancelAndExit()
-	});
-	const editorConflicts = detectEditorConflicts({
-		projectRoot: rootDir,
-		editorId: selectedEditor
-	});
-	const editorConflictDecisions = /* @__PURE__ */ new Map();
-	for (const conflict of editorConflicts) if (options.interactive) {
-		const action = await select({
-			message: `${conflict.displayPath} already exists.\n  ` + styleText("gray", "Vite+ adds editor settings for the built-in linter and formatter. Merge adds new keys without overwriting existing ones."),
-			options: [{
-				label: "Merge",
-				value: "merge",
-				hint: "Merge new settings into existing file"
-			}, {
-				label: "Skip",
-				value: "skip",
-				hint: "Leave existing file unchanged"
-			}],
-			initialValue: "skip"
-		});
-		if (R(action)) cancelAndExit();
-		editorConflictDecisions.set(conflict.fileName, action);
-	} else editorConflictDecisions.set(conflict.fileName, "merge");
-	return {
-		selectedEditor,
-		editorConflictDecisions
-	};
-}
-async function collectEslintMigrationDecision(rootDir, options, packages) {
-	const eslintProject = detectEslintProject(rootDir, packages);
-	const incompatibleEslintIntegration = detectIncompatibleEslintIntegration(rootDir, packages);
-	let migrateEslint = false;
-	if (incompatibleEslintIntegration) warnIncompatibleEslintIntegration(incompatibleEslintIntegration);
-	else if (eslintProject.hasDependency && !eslintProject.configFile && eslintProject.legacyConfigFile) warnLegacyEslintConfig(eslintProject.legacyConfigFile);
-	else if (eslintProject.hasDependency && eslintProject.configFile) migrateEslint = await confirmEslintMigration(options.interactive);
-	else if (eslintProject.hasDependency) warnPackageLevelEslint();
-	return {
-		migrateEslint,
-		eslintConfigFile: eslintProject.configFile
-	};
-}
-async function collectMigrationSetupPlan(rootDir, packageManager, options, packages, includeEslint = true) {
-	const shouldSetupHooks = await collectGitHooksDecision(rootDir, packageManager, options);
-	const agentPlan = await collectAgentInstructionPlan(rootDir, options);
-	const editorPlan = await collectEditorConfigPlan(rootDir, options);
-	const eslintPlan = includeEslint ? await collectEslintMigrationDecision(rootDir, options, packages) : { migrateEslint: false };
-	return {
-		shouldSetupHooks,
-		...agentPlan,
-		...editorPlan,
-		...eslintPlan
-	};
-}
-function getExistingVitePlusSetupOptions(options, legacyGitHooksMigrationCandidate, useFullMigrationDefaults = false) {
+function getExistingVitePlusSetupOptions(options, useFullMigrationDefaults = false) {
 	if (useFullMigrationDefaults) return options;
 	return {
 		...options,
-		hooks: options.hooks ?? (legacyGitHooksMigrationCandidate ? options.interactive ? void 0 : true : false),
+		hooks: options.hooks ?? false,
 		agent: options.agent ?? false,
 		editor: options.editor ?? false
 	};
 }
-async function collectMigrationPlan(rootDir, detectedPackageManager, options, packages) {
+async function collectMigrationPlan(rootDir, detectedPackageManager, detectedPackageManagerVersion, options, packages) {
 	const packageManager = detectedPackageManager ?? await selectPackageManager(options.interactive, true);
+	const convertYarnPnp = await confirmYarnNodeModulesMode(rootDir, packageManager, detectedPackageManager ? detectedPackageManagerVersion : "latest", options.interactive);
 	const setupPlan = await collectMigrationSetupPlan(rootDir, packageManager, options, packages);
 	const prettierProject = detectPrettierProject(rootDir, packages);
 	let migratePrettier = false;
@@ -373,8 +681,10 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, options, pa
 	const frameworkShimFrameworks = await collectFrameworkShimFrameworks(rootDir, options, packages);
 	return {
 		packageManager,
+		convertYarnPnp,
 		...setupPlan,
 		migratePrettier,
+		hasPrettierDependency: prettierProject.hasDependency,
 		prettierConfigFile: prettierProject.configFile,
 		fixBaseUrl,
 		migrateNodeVersionFile,
@@ -409,12 +719,19 @@ function handleInstallResult(installSummary, rootDir, report, options) {
 	}
 	return 0;
 }
+const FULL_MIGRATION_HINT = `${styleText("gray", "•")} Skipped editor, hooks, and lint setup. Run \`vp migrate --full\` to apply them.`;
 function showMigrationSummary(options) {
-	const { projectRoot, packageManager, packageManagerVersion, installDurationMs, finalInstallOk, report, updatedExistingVitePlus } = 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;
-	log$1(`${styleText("magenta", "◇")} ${updatedExistingVitePlus ? "Updated" : "Migrated"} ${accent(projectLabel)}${updatedExistingVitePlus ? "" : " to Vite+"}`);
+	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$1(`${styleText("gray", "•")} Dependencies:`);
+		for (const change of report.dependencyUpgrades) log$1(`    ${change.name.padEnd(nameWidth)}  ${muted((change.from ?? "").padEnd(fromWidth))} → ${styleText("green", change.to)}`);
+	}
 	if (finalInstallOk && installDurationMs > 0) log$1(`${styleText("green", "✓")} Dependencies installed in ${formatDuration(installDurationMs)}`);
 	if (configUpdates > 0 || report.rewrittenImportFileCount > 0) {
 		const parts = [];
@@ -422,6 +739,7 @@ function showMigrationSummary(options) {
 		if (report.rewrittenImportFileCount > 0) parts.push(`${report.rewrittenImportFileCount} ${report.rewrittenImportFileCount === 1 ? "file had" : "files had"} imports rewritten`);
 		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.nodeVersionFileMigrated) log$1(`${styleText("gray", "•")} Node version manager file migrated to .node-version`);
@@ -429,6 +747,7 @@ function showMigrationSummary(options) {
 	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);
 	if (report.warnings.length > 0) {
 		log$1(`${styleText("yellow", "!")} Warnings:`);
 		for (const warning of report.warnings) log$1(`  - ${warning}`);
@@ -438,17 +757,6 @@ function showMigrationSummary(options) {
 		for (const step of report.manualSteps) log$1(`  - ${step}`);
 	}
 }
-async function checkRolldownCompatibility(rootDir, report) {
-	try {
-		const { resolveConfig } = await import("../index.js");
-		const { checkManualChunksCompat } = await import("../compat-Cql3K40m.js");
-		checkManualChunksCompat((await resolveConfig({
-			root: rootDir,
-			logLevel: "silent",
-			configLoader: "runner"
-		}, "build")).build?.rollupOptions?.output, report);
-	} catch {}
-}
 async function downloadSupportedPackageManager(options) {
 	const { rootDir, packageManager, packageManagerVersion, interactive, updateMigrationProgress, failMigrationProgress } = options;
 	updateMigrationProgress("Preparing migration");
@@ -467,7 +775,7 @@ async function downloadSupportedPackageManager(options) {
 	}
 	return downloadResult;
 }
-async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
+async function executeMigrationPlan(workspaceInfoOptional, plan, interactive, preExistingChangedPaths) {
 	const report = createMigrationReport();
 	const migrationProgress = interactive ? spinner({ indicator: "timer" }) : void 0;
 	let migrationProgressStarted = false;
@@ -505,6 +813,11 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
 		packageManager: plan.packageManager,
 		downloadPackageManager: downloadResult
 	};
+	if (plan.convertYarnPnp) {
+		updateMigrationProgress("Configuring Yarn node-modules mode");
+		report.packageManagerBootstrapConfigured = configureYarnNodeModulesMode(workspaceInfo.rootDir);
+		if (report.packageManagerBootstrapConfigured) log.success("✔ Switched Yarn to node-modules mode");
+	}
 	if (plan.migrateNodeVersionFile && plan.nodeVersionDetection) {
 		updateMigrationProgress("Migrating node version file");
 		migrateNodeVersionManagerFile(workspaceInfo.rootDir, plan.nodeVersionDetection, report);
@@ -522,9 +835,7 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
 		failMigrationProgress("Migration failed");
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
 	}
-	updateMigrationProgress("Checking config compatibility");
-	await checkRolldownCompatibility(workspaceInfo.rootDir, report);
-	if (workspaceInfo.packages) for (const pkg of workspaceInfo.packages) await checkRolldownCompatibility(path.join(workspaceInfo.rootDir, pkg.path), report);
+	await checkWorkspaceRolldownCompatibility(workspaceInfo, report, updateMigrationProgress);
 	await fixBaseUrlForWorkspace(workspaceInfo, plan.fixBaseUrl, updateMigrationProgress, report);
 	if (plan.migrateEslint) {
 		updateMigrationProgress("Migrating ESLint");
@@ -572,15 +883,21 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
 	});
 	addFrameworkShimsForWorkspace(workspaceInfo.rootDir, plan.frameworkShimFrameworks, workspaceInfo.packages, report, updateMigrationProgress);
 	const installArgs = plan.packageManager === PackageManager.npm || plan.packageManager === PackageManager.bun ? ["--force"] : ["--no-frozen-lockfile"];
+	const npmReinstallPreparation = plan.packageManager === PackageManager.npm ? prepareNpmViteAliasReinstall(workspaceInfo.rootDir, getWorkspaceProjectPaths(workspaceInfo)) : void 0;
 	updateMigrationProgress("Installing dependencies");
 	const finalInstallSummary = await runViteInstall(workspaceInfo.rootDir, interactive, installArgs, {
 		silent: true,
 		packageManager: workspaceInfo.packageManager,
 		packageManagerVersion: workspaceInfo.downloadPackageManager.version
 	});
+	if (finalInstallSummary.status === "failed") npmReinstallPreparation?.restore();
+	else npmReinstallPreparation?.commit();
 	clearMigrationProgress();
+	const initialInstallDurationMs = handleInstallResult(initialInstallSummary, workspaceInfo.rootDir, report, { propagateExitCode: false });
+	const finalInstallDurationMs = handleInstallResult(finalInstallSummary, workspaceInfo.rootDir, report);
+	if (finalInstallSummary.status === "installed" && canFormatWithOxfmt(plan.hasPrettierDependency, plan.migratePrettier)) await formatMigratedProject(workspaceInfo.rootDir, interactive, report, { excludedPaths: preExistingChangedPaths });
 	return {
-		installDurationMs: handleInstallResult(initialInstallSummary, workspaceInfo.rootDir, report, { propagateExitCode: false }) + handleInstallResult(finalInstallSummary, workspaceInfo.rootDir, report),
+		installDurationMs: initialInstallDurationMs + finalInstallDurationMs,
 		finalInstallOk: finalInstallSummary.status === "installed",
 		packageManagerVersion: downloadResult.version,
 		report
@@ -595,11 +912,15 @@ async function main() {
 	}
 	printHeader();
 	const workspaceInfoOptional = await detectWorkspace(projectPath);
+	const initialChangedPaths = await collectChangedFormatPaths(workspaceInfoOptional.rootDir);
+	const preExistingChangedPaths = initialChangedPaths ? new Set(initialChangedPaths) : void 0;
 	const resolvedPackageManager = workspaceInfoOptional.packageManager ?? "unknown";
 	if (hasVitePlusDependency(readNearestPackageJson(workspaceInfoOptional.rootDir)) && !isForceOverrideMode()) {
+		let convertYarnPnp = await confirmYarnNodeModulesMode(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, workspaceInfoOptional.packageManagerVersion, options.interactive);
 		let didMigrate = false;
 		let installDurationMs = 0;
 		let finalInstallOk = true;
+		let canFormatMigratedProject = !process.env.VP_SKIP_INSTALL;
 		const report = createMigrationReport();
 		const migrationProgress = options.interactive ? spinner({ indicator: "timer" }) : void 0;
 		let migrationProgressStarted = false;
@@ -625,8 +946,7 @@ async function main() {
 			}
 		};
 		const pendingCoreMigration = detectPendingCoreMigration(workspaceInfoOptional);
-		const legacyGitHooksMigrationCandidate = detectLegacyGitHooksMigrationCandidate(workspaceInfoOptional.rootDir);
-		const vitePlusBootstrapPending = detectVitePlusBootstrapPending(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager);
+		const vitePlusBootstrapPending = detectVitePlusBootstrapPending(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, workspaceInfoOptional.packages, workspaceInfoOptional.packageManagerVersion);
 		let packageManager = vitePlusBootstrapPending ? workspaceInfoOptional.packageManager ?? await selectPackageManager(options.interactive, true) : workspaceInfoOptional.packageManager;
 		let downloadedPackageManager;
 		let packageManagerVersion = workspaceInfoOptional.packageManagerVersion;
@@ -648,16 +968,23 @@ async function main() {
 			return downloadExistingPackageManager();
 		};
 		if (vitePlusBootstrapPending) await ensureExistingPackageManager();
+		clearMigrationProgress();
+		if (!convertYarnPnp && workspaceInfoOptional.packageManager === void 0 && packageManager === PackageManager.yarn) convertYarnPnp = await confirmYarnNodeModulesMode(workspaceInfoOptional.rootDir, packageManager, packageManagerVersion, options.interactive);
+		report.dependencyUpgrades = await collectToolchainVersionChanges(workspaceInfoOptional.rootDir);
+		updateMigrationProgress("Rewriting toolchain imports across the workspace");
 		const coreMigrationResult = finalizeCoreMigrationForExistingVitePlus(workspaceInfoOptional, true, report, pendingCoreMigration);
 		if (coreMigrationResult.scripts || coreMigrationResult.tsconfigTypes || coreMigrationResult.imports) didMigrate = true;
-		if (!didMigrate && report.warnings.length === 0 && !vitePlusBootstrapPending && !hasExistingVitePlusMigrationCandidates(workspaceInfoOptional, options)) {
+		clearMigrationProgress();
+		const fullSetup = options.full === true;
+		const skippedSetupCandidates = !fullSetup && !hasExplicitExistingVitePlusSetupRequest(options) && hasExistingVitePlusMigrationCandidates(workspaceInfoOptional, options);
+		if (!didMigrate && !convertYarnPnp && report.warnings.length === 0 && !vitePlusBootstrapPending && !(fullSetup ? hasExistingVitePlusMigrationCandidates(workspaceInfoOptional, options) : hasExplicitExistingVitePlusSetupRequest(options))) {
+			if (skippedSetupCandidates) log$1(FULL_MIGRATION_HINT);
 			outro(`This project is already using Vite+! ${accent("Happy coding!")}`);
 			return;
 		}
-		const fullMigrationSummary = vitePlusBootstrapPending || coreMigrationResult.scripts || coreMigrationResult.tsconfigTypes || coreMigrationResult.imports;
-		const setupOptions = getExistingVitePlusSetupOptions(options, legacyGitHooksMigrationCandidate, options.interactive && fullMigrationSummary);
-		const plan = await collectMigrationSetupPlan(workspaceInfoOptional.rootDir, packageManager, setupOptions, workspaceInfoOptional.packages);
-		const frameworkShimFrameworks = await collectFrameworkShimFrameworks(workspaceInfoOptional.rootDir, options, workspaceInfoOptional.packages);
+		const setupOptions = getExistingVitePlusSetupOptions(options, fullSetup);
+		const plan = await collectMigrationSetupPlan(workspaceInfoOptional.rootDir, packageManager, setupOptions, workspaceInfoOptional.packages, fullSetup);
+		const frameworkShimFrameworks = fullSetup ? await collectFrameworkShimFrameworks(workspaceInfoOptional.rootDir, options, workspaceInfoOptional.packages) : void 0;
 		let needsInstall = false;
 		if (vitePlusBootstrapPending) {
 			const downloadResult = await ensureExistingPackageManager();
@@ -672,7 +999,12 @@ async function main() {
 				needsInstall = bootstrapResult.changed || needsInstall;
 			}
 		}
-		const fixedBaseUrlProjectPaths = await fixBaseUrlForWorkspace(workspaceInfoOptional, hasBaseUrlInWorkspace(workspaceInfoOptional) ? await confirmBaseUrlFix(options.interactive) : false, updateMigrationProgress, report);
+		let fixBaseUrl = false;
+		if (fullSetup && hasBaseUrlInWorkspace(workspaceInfoOptional)) {
+			if (options.interactive) clearMigrationProgress();
+			fixBaseUrl = await confirmBaseUrlFix(options.interactive);
+		}
+		const fixedBaseUrlProjectPaths = await fixBaseUrlForWorkspace(workspaceInfoOptional, fixBaseUrl, updateMigrationProgress, report);
 		if (fixedBaseUrlProjectPaths.length > 0) {
 			updateMigrationProgress("Updating lint defaults");
 			for (const projectPath of fixedBaseUrlProjectPaths) injectLintTypeCheckDefaults(projectPath, true, report);
@@ -694,23 +1026,38 @@ async function main() {
 		}
 		const prettierProject = detectPrettierProject(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages);
 		let prettierMigrated = false;
-		if (prettierProject.hasDependency && prettierProject.configFile) {
-			if (await confirmPrettierMigration(options.interactive)) {
-				await ensureExistingPackageManager();
-				updateMigrationProgress("Migrating Prettier");
-				if (!await migratePrettierToOxfmt(workspaceInfoOptional.rootDir, options.interactive, prettierProject.configFile, workspaceInfoOptional.packages, {
-					silent: true,
-					report
-				})) {
-					clearMigrationProgress();
-					cancelAndExit("Prettier migration failed. Fix the issue and re-run `vp migrate`.", 1);
+		if (fullSetup) {
+			if (prettierProject.hasDependency && prettierProject.configFile) {
+				if (options.interactive) clearMigrationProgress();
+				if (await confirmPrettierMigration(options.interactive)) {
+					await ensureExistingPackageManager();
+					updateMigrationProgress("Migrating Prettier");
+					if (!await migratePrettierToOxfmt(workspaceInfoOptional.rootDir, options.interactive, prettierProject.configFile, workspaceInfoOptional.packages, {
+						silent: true,
+						report
+					})) {
+						clearMigrationProgress();
+						cancelAndExit("Prettier migration failed. Fix the issue and re-run `vp migrate`.", 1);
+					}
+					prettierMigrated = true;
 				}
-				prettierMigrated = true;
+			} else if (prettierProject.hasDependency) warnPackageLevelPrettier();
+		}
+		if (fullSetup) {
+			const nodeVersionDetection = detectNodeVersionManagerFile(workspaceInfoOptional.rootDir);
+			if (nodeVersionDetection) {
+				if (options.interactive) clearMigrationProgress();
+				if (await confirmNodeVersionFileMigration(options.interactive, nodeVersionDetection) && migrateNodeVersionManagerFile(workspaceInfoOptional.rootDir, nodeVersionDetection, report)) didMigrate = true;
+			}
+		}
+		if (convertYarnPnp) {
+			updateMigrationProgress("Configuring Yarn node-modules mode");
+			if (configureYarnNodeModulesMode(workspaceInfoOptional.rootDir)) {
+				log.success("✔ Switched Yarn to node-modules mode");
+				report.packageManagerBootstrapConfigured = true;
+				didMigrate = true;
+				needsInstall = true;
 			}
-		} else if (prettierProject.hasDependency) warnPackageLevelPrettier();
-		const nodeVersionDetection = detectNodeVersionManagerFile(workspaceInfoOptional.rootDir);
-		if (nodeVersionDetection) {
-			if (await confirmNodeVersionFileMigration(options.interactive, nodeVersionDetection) && migrateNodeVersionManagerFile(workspaceInfoOptional.rootDir, nodeVersionDetection, report)) didMigrate = true;
 		}
 		if (addFrameworkShimsForWorkspace(workspaceInfoOptional.rootDir, frameworkShimFrameworks, workspaceInfoOptional.packages, report, updateMigrationProgress)) didMigrate = true;
 		if (eslintMigrated || prettierMigrated) {
@@ -733,12 +1080,18 @@ async function main() {
 			const resolved = await ensureExistingPackageManager();
 			updateMigrationProgress("Installing dependencies");
 			const resolvedVersion = resolved?.version ?? packageManagerVersion;
+			const npmReinstallPreparation = packageManager === PackageManager.npm ? prepareNpmViteAliasReinstall(workspaceInfoOptional.rootDir, getWorkspaceProjectPaths(workspaceInfoOptional)) : void 0;
 			const installSummary = await runViteInstall(workspaceInfoOptional.rootDir, options.interactive, packageManager === PackageManager.npm || packageManager === PackageManager.bun ? ["--force"] : ["--no-frozen-lockfile"], {
 				silent: true,
 				packageManager,
 				packageManagerVersion: resolvedVersion
 			});
-			if (installSummary.status === "failed") clearMigrationProgress();
+			if (installSummary.status === "failed") {
+				clearMigrationProgress();
+				npmReinstallPreparation?.restore();
+			} else npmReinstallPreparation?.commit();
+			finalInstallOk = installSummary.status !== "failed";
+			canFormatMigratedProject = finalInstallOk && canFormatMigratedProject;
 			installDurationMs += handleInstallResult(installSummary, workspaceInfoOptional.rootDir, report);
 		}
 		if (plan.selectedAgentTargetPaths && plan.selectedAgentTargetPaths.length > 0) {
@@ -763,8 +1116,11 @@ async function main() {
 			});
 			didMigrate = true;
 		}
-		await checkRolldownCompatibility(workspaceInfoOptional.rootDir, report);
-		if (workspaceInfoOptional.packages) for (const pkg of workspaceInfoOptional.packages) await checkRolldownCompatibility(path.join(workspaceInfoOptional.rootDir, pkg.path), report);
+		await checkWorkspaceRolldownCompatibility(workspaceInfoOptional, report, updateMigrationProgress);
+		if (didMigrate && finalInstallOk && canFormatMigratedProject && canFormatWithOxfmt(prettierProject.hasDependency, prettierMigrated)) {
+			clearMigrationProgress();
+			await formatMigratedProject(workspaceInfoOptional.rootDir, options.interactive, report, { excludedPaths: preExistingChangedPaths });
+		}
 		if (didMigrate || report.warnings.length > 0) {
 			clearMigrationProgress();
 			showMigrationSummary({
@@ -774,13 +1130,18 @@ async function main() {
 				installDurationMs,
 				finalInstallOk,
 				report,
-				updatedExistingVitePlus: !fullMigrationSummary
+				updatedExistingVitePlus: true,
+				suggestFullMigration: skippedSetupCandidates
 			});
-		} else outro(`This project is already using Vite+! ${accent("Happy coding!")}`);
+		} else {
+			clearMigrationProgress();
+			if (skippedSetupCandidates) log$1(FULL_MIGRATION_HINT);
+			outro(`This project is already using Vite+! ${accent("Happy coding!")}`);
+		}
 		return;
 	}
-	const plan = await collectMigrationPlan(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, options, workspaceInfoOptional.packages);
-	const result = await executeMigrationPlan(workspaceInfoOptional, plan, options.interactive);
+	const plan = await collectMigrationPlan(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, workspaceInfoOptional.packageManagerVersion, options, workspaceInfoOptional.packages);
+	const result = await executeMigrationPlan(workspaceInfoOptional, plan, options.interactive, preExistingChangedPaths);
 	showMigrationSummary({
 		projectRoot: workspaceInfoOptional.rootDir,
 		packageManager: plan.packageManager,