vite-plus 0.2.9 → 0.3.1

package/dist/client/client.mjs

@@ -1 +1 @@
-export * from '@voidzero-dev/vite-plus-core/dist/client/client.mjs';
+export * from 'vite/dist/client/client.mjs';

package/dist/client/env.mjs

@@ -1 +1 @@
-export * from '@voidzero-dev/vite-plus-core/dist/client/env.mjs';
+export * from 'vite/dist/client/env.mjs';

package/dist/client.d.ts

@@ -1 +1 @@
-/// <reference types="@voidzero-dev/vite-plus-core/client" />
+/// <reference types="vite/client" />

package/dist/command-CLJK5jGW.js

@@ -0,0 +1,2 @@
+import { n as runCommandSilently } from "./command-CguLh2KL.js";
+export { runCommandSilently };

package/dist/command-CguLh2KL.js

@@ -0,0 +1,471 @@
+import { n as __require, r as __toESM, t as __commonJSMin } from "./rolldown-runtime-CMFfr-1z.js";
+import { constants } from "node:os";
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$2 = __require("fs");
+	function checkPathExt(path, options) {
+		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+		if (!pathext) return true;
+		pathext = pathext.split(";");
+		if (pathext.indexOf("") !== -1) return true;
+		for (var i = 0; i < pathext.length; i++) {
+			var p = pathext[i].toLowerCase();
+			if (p && path.substr(-p.length).toLowerCase() === p) return true;
+		}
+		return false;
+	}
+	function checkStat(stat, path, options) {
+		if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+		return checkPathExt(path, options);
+	}
+	function isexe(path, options, cb) {
+		fs$2.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, path, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$2.statSync(path), path, options);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$1 = __require("fs");
+	function isexe(path, options, cb) {
+		fs$1.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$1.statSync(path), options);
+	}
+	function checkStat(stat, options) {
+		return stat.isFile() && checkMode(stat, options);
+	}
+	function checkMode(stat, options) {
+		var mod = stat.mode;
+		var uid = stat.uid;
+		var gid = stat.gid;
+		var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+		var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+		var u = parseInt("100", 8);
+		var g = parseInt("010", 8);
+		var o = parseInt("001", 8);
+		var ug = u | g;
+		return mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	__require("fs");
+	var core;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) core = require_windows();
+	else core = require_mode();
+	module.exports = isexe;
+	isexe.sync = sync;
+	function isexe(path, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		if (!cb) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(resolve, reject) {
+				isexe(path, options || {}, function(er, is) {
+					if (er) reject(er);
+					else resolve(is);
+				});
+			});
+		}
+		core(path, options || {}, function(er, is) {
+			if (er) {
+				if (er.code === "EACCES" || options && options.ignoreErrors) {
+					er = null;
+					is = false;
+				}
+			}
+			cb(er, is);
+		});
+	}
+	function sync(path, options) {
+		try {
+			return core.sync(path, options || {});
+		} catch (er) {
+			if (options && options.ignoreErrors || er.code === "EACCES") return false;
+			else throw er;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const path$2 = __require("path");
+	const COLON = isWindows ? ";" : ":";
+	const isexe = require_isexe();
+	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
+	const getPathInfo = (cmd, opt) => {
+		const colon = opt.colon || COLON;
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || 
+		/* istanbul ignore next: very unusual */ "").split(colon)];
+		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+		if (isWindows) {
+			if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") pathExt.unshift("");
+		}
+		return {
+			pathEnv,
+			pathExt,
+			pathExtExe
+		};
+	};
+	const which = (cmd, opt, cb) => {
+		if (typeof opt === "function") {
+			cb = opt;
+			opt = {};
+		}
+		if (!opt) opt = {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		const step = (i) => new Promise((resolve, reject) => {
+			if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$2.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			resolve(subStep(p, i, 0));
+		});
+		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+			if (ii === pathExt.length) return resolve(step(i + 1));
+			const ext = pathExt[ii];
+			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+				if (!er && is) {
+					if (opt.all) found.push(p + ext);
+					else return resolve(p + ext);
+				}
+				return resolve(subStep(p, i, ii + 1));
+			});
+		});
+		return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+	};
+	const whichSync = (cmd, opt) => {
+		opt = opt || {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		for (let i = 0; i < pathEnv.length; i++) {
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$2.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			for (let j = 0; j < pathExt.length; j++) {
+				const cur = p + pathExt[j];
+				try {
+					if (isexe.sync(cur, { pathExt: pathExtExe })) {
+						if (opt.all) found.push(cur);
+						else return cur;
+					}
+				} catch (ex) {}
+			}
+		}
+		if (opt.all && found.length) return found;
+		if (opt.nothrow) return null;
+		throw getNotFoundError(cmd);
+	};
+	module.exports = which;
+	which.sync = whichSync;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pathKey = (options = {}) => {
+		const environment = options.env || process.env;
+		if ((options.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+	};
+	module.exports = pathKey;
+	module.exports.default = pathKey;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$1 = __require("path");
+	const which = require_which();
+	const getPathKey = require_path_key();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+		const env = parsed.options.env || process.env;
+		const cwd = process.cwd();
+		const hasCustomCwd = parsed.options.cwd != null;
+		const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+		if (shouldSwitchCwd) try {
+			process.chdir(parsed.options.cwd);
+		} catch (err) {}
+		let resolved;
+		try {
+			resolved = which.sync(parsed.command, {
+				path: env[getPathKey({ env })],
+				pathExt: withoutPathExt ? path$1.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (shouldSwitchCwd) process.chdir(cwd);
+		}
+		if (resolved) resolved = path$1.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		return resolved;
+	}
+	function resolveCommand(parsed) {
+		return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	module.exports = resolveCommand;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+		arg = `${arg}`;
+		arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		arg = `"${arg}"`;
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	module.exports.command = escapeCommand;
+	module.exports.argument = escapeArgument;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = /^#!(.*)/;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const shebangRegex = require_shebang_regex();
+	module.exports = (string = "") => {
+		const match = string.match(shebangRegex);
+		if (!match) return null;
+		const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+		const binary = path.split("/").pop();
+		if (binary === "env") return argument;
+		return argument ? `${binary} ${argument}` : binary;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("fs");
+	const shebangCommand = require_shebang_command();
+	function readShebang(command) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd;
+		try {
+			fd = fs.openSync(command, "r");
+			fs.readSync(fd, buffer, 0, size, 0);
+			fs.closeSync(fd);
+		} catch (e) {}
+		return shebangCommand(buffer.toString());
+	}
+	module.exports = readShebang;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const resolveCommand = require_resolveCommand();
+	const escape = require_escape();
+	const readShebang = require_readShebang();
+	const isWin = process.platform === "win32";
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+		parsed.file = resolveCommand(parsed);
+		const shebang = parsed.file && readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+		return parsed.file;
+	}
+	function parseNonShell(parsed) {
+		if (!isWin) return parsed;
+		const commandFile = detectShebang(parsed);
+		const needsShell = !isExecutableRegExp.test(commandFile);
+		if (parsed.options.forceShell || needsShell) {
+			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+			parsed.command = path.normalize(parsed.command);
+			parsed.command = escape.command(parsed.command);
+			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+			parsed.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
+			];
+			parsed.command = process.env.comspec || "cmd.exe";
+			parsed.options.windowsVerbatimArguments = true;
+		}
+		return parsed;
+	}
+	function parse(command, args, options) {
+		if (args && !Array.isArray(args)) {
+			options = args;
+			args = null;
+		}
+		args = args ? args.slice(0) : [];
+		options = Object.assign({}, options);
+		const parsed = {
+			command,
+			args,
+			options,
+			file: void 0,
+			original: {
+				command,
+				args
+			}
+		};
+		return options.shell ? parsed : parseNonShell(parsed);
+	}
+	module.exports = parse;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWin = process.platform === "win32";
+	function notFoundError(original, syscall) {
+		return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${syscall} ${original.command}`,
+			path: original.command,
+			spawnargs: original.args
+		});
+	}
+	function hookChildProcess(cp, parsed) {
+		if (!isWin) return;
+		const originalEmit = cp.emit;
+		cp.emit = function(name, arg1) {
+			if (name === "exit") {
+				const err = verifyENOENT(arg1, parsed);
+				if (err) return originalEmit.call(cp, "error", err);
+			}
+			return originalEmit.apply(cp, arguments);
+		};
+	}
+	function verifyENOENT(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+		return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+		return null;
+	}
+	module.exports = {
+		hookChildProcess,
+		verifyENOENT,
+		verifyENOENTSync,
+		notFoundError
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const cp = __require("child_process");
+	const parse = require_parse();
+	const enoent = require_enoent();
+	function spawn(command, args, options) {
+		const parsed = parse(command, args, options);
+		const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+		enoent.hookChildProcess(spawned, parsed);
+		return spawned;
+	}
+	function spawnSync(command, args, options) {
+		const parsed = parse(command, args, options);
+		const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+		result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+		return result;
+	}
+	module.exports = spawn;
+	module.exports.spawn = spawn;
+	module.exports.sync = spawnSync;
+	module.exports._parse = parse;
+	module.exports._enoent = enoent;
+}));
+//#endregion
+//#region src/utils/command.ts
+var import_cross_spawn = /* @__PURE__ */ __toESM(require_cross_spawn(), 1);
+function exitCodeFromClose(code, signal) {
+	if (code !== null) return code;
+	const signalNumber = signal && constants.signals[signal];
+	return signalNumber ? 128 + signalNumber : 1;
+}
+async function runCommandSilently(options) {
+	const child = (0, import_cross_spawn.default)(options.command, options.args, {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		cwd: options.cwd,
+		env: options.envs
+	});
+	return await new Promise((resolve, reject) => {
+		const stdout = [];
+		const stderr = [];
+		let timedOut = false;
+		const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGKILL");
+		}, options.timeoutMs);
+		timer?.unref();
+		child.stdout?.on("data", (data) => {
+			stdout.push(data);
+		});
+		child.stderr?.on("data", (data) => {
+			stderr.push(data);
+		});
+		child.on("close", (code, signal) => {
+			clearTimeout(timer);
+			if (timedOut) {
+				reject(/* @__PURE__ */ new Error(`Command timed out after ${options.timeoutMs}ms: ${options.command}`));
+				return;
+			}
+			resolve({
+				exitCode: exitCodeFromClose(code, signal),
+				stdout: Buffer.concat(stdout),
+				stderr: Buffer.concat(stderr)
+			});
+		});
+		child.on("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+	});
+}
+async function runCommand(options) {
+	const child = (0, import_cross_spawn.default)(options.command, options.args, {
+		stdio: "inherit",
+		cwd: options.cwd,
+		env: options.envs
+	});
+	return new Promise((resolve, reject) => {
+		child.on("close", (code, signal) => {
+			resolve({ exitCode: exitCodeFromClose(code, signal) });
+		});
+		child.on("error", (err) => {
+			reject(err);
+		});
+	});
+}
+//#endregion
+export { runCommandSilently as n, require_cross_spawn as r, runCommand as t };

package/dist/config/bin.js

@@ -1,66 +1,96 @@
-import { i as log, l as renderCliDoc, o as printHeader } from "../terminal-Bz-ps6rJ.js";
-import { i as promptGitHooks, n as defaultInteractive } from "../prompts-CHz_98bJ.js";
-import { t as lib_default } from "../lib-L3DWSRQp.js";
-import { o as updateExistingAgentInstructions } from "../agent-DQU8uS6P.js";
-import { c as resolveHooksLocation, o as install, s as isHooksUserDisabled } from "../hooks-pNCBWtFT.js";
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-//#region src/config/bin.ts
-async function main() {
-	const args = lib_default(process.argv.slice(3), {
-		boolean: [
-			"help",
-			"hooks",
-			"agent"
-		],
-		string: ["hooks-dir"],
-		alias: { h: "help" }
-	});
-	if (args.help) {
-		const helpMessage = renderCliDoc({
-			usage: "vp config [OPTIONS]",
-			summary: "Configure Vite+ for the current project (hook dispatcher + agent integration).",
-			documentationUrl: "https://viteplus.dev/guide/commit-hooks",
-			sections: [{
-				title: "Options",
-				rows: [
-					{
-						label: "--hooks-dir <path>",
-						description: "Custom hooks directory (default: .vite-hooks, or last used in this clone)"
-					},
-					{
-						label: "--no-hooks",
-						description: "Skip hook dispatcher installation"
-					},
-					{
-						label: "--no-agent",
-						description: "Skip updating coding agent instructions"
-					},
-					{
-						label: "-h, --help",
-						description: "Show this help message"
-					}
-				]
-			}, {
-				title: "Environment",
-				rows: [{
-					label: "VP_GIT_HOOKS=0",
-					description: "Skip hook dispatcher installation"
-				}]
-			}]
-		});
-		printHeader();
-		log(helpMessage);
+import { i as log, n as errorMsg } from "../terminal-MKGAuy-p.js";
+import { i as promptGitHooks, n as defaultInteractive } from "../prompts-CtzEgFY-.js";
+import { o as updateExistingAgentInstructions } from "../agent-C5jMYVfB.js";
+import { t as require_dist } from "../dist-BDYZP12R.js";
+import { a as install, c as resolveHooksLocation, o as isGitHooksEnvDisabled, s as isHooksUserDisabled } from "../hooks-C-4gykWR.js";
+import { t as unwrapCliParseOutcome } from "../cli-parse-DHE8NrBU.js";
+import path, { join, relative } from "node:path";
+import { parseConfigArgs } from "../../binding/index.js";
+import fs, { existsSync } from "node:fs";
+//#region src/utils/legacy-vitest-alias.ts
+var import_dist = require_dist();
+const LEGACY_VITEST_ALIAS = "npm:@voidzero-dev/vite-plus-test";
+function containsLegacyVitestAlias(value, visited = /* @__PURE__ */ new Set()) {
+	if (typeof value === "string") return value === LEGACY_VITEST_ALIAS || value.startsWith(`${LEGACY_VITEST_ALIAS}@`);
+	if (value === null || typeof value !== "object" || visited.has(value)) return false;
+	visited.add(value);
+	return Object.values(value).some((entry) => containsLegacyVitestAlias(entry, visited));
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function containsAliasInFields(config, fields) {
+	const record = asRecord(config);
+	return fields.some((field) => containsLegacyVitestAlias(record?.[field]));
+}
+function containsPackageAlias(config) {
+	return containsAliasInFields(config, [
+		"dependencies",
+		"devDependencies",
+		"optionalDependencies",
+		"peerDependencies",
+		"overrides",
+		"resolutions",
+		"catalog",
+		"catalogs"
+	]) || containsAliasInFields(config?.pnpm, ["overrides"]) || containsAliasInFields(config?.workspaces, ["catalog", "catalogs"]);
+}
+function readConfigFile(filePath) {
+	try {
+		const source = fs.readFileSync(filePath, "utf8");
+		return asRecord(path.basename(filePath) === "package.json" ? JSON.parse(source) : (0, import_dist.parse)(source));
+	} catch {
 		return;
 	}
-	const dir = args["hooks-dir"];
+}
+/**
+* Find a package-manager setting that still aliases Vitest to the deleted
+* `@voidzero-dev/vite-plus-test` wrapper. Check the nearest package and its
+* workspace root, without inspecting unrelated ancestor package settings.
+*/
+function findLegacyVitestAliasConfig(startDir) {
+	let currentDir = path.resolve(startDir);
+	let foundPackage = false;
+	while (true) {
+		const packagePath = path.join(currentDir, "package.json");
+		const pkg = readConfigFile(packagePath);
+		const isNearestPackage = !foundPackage && fs.existsSync(packagePath);
+		if (isNearestPackage) foundPackage = true;
+		const workspacePath = path.join(currentDir, "pnpm-workspace.yaml");
+		const isWorkspaceRoot = fs.existsSync(workspacePath) || pkg !== void 0 && Object.hasOwn(pkg, "workspaces");
+		if ((isNearestPackage || isWorkspaceRoot) && containsPackageAlias(pkg)) return packagePath;
+		if (isWorkspaceRoot) {
+			if (containsAliasInFields(readConfigFile(workspacePath), [
+				"catalog",
+				"catalogs",
+				"overrides"
+			])) return workspacePath;
+			return;
+		}
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return;
+		currentDir = parentDir;
+	}
+}
+//#endregion
+//#region src/config/bin.ts
+async function main() {
+	const args = unwrapCliParseOutcome(parseConfigArgs(process.argv.slice(3)));
+	const dir = args.hooksDir;
 	const skipHooks = args.hooks === false;
 	const skipAgent = args.agent === false;
 	const interactive = defaultInteractive();
 	const lifecycleEvent = process.env.npm_lifecycle_event;
 	const isLifecycleScript = lifecycleEvent === "prepare" || lifecycleEvent === "postinstall";
 	const root = process.cwd();
-	if (!skipHooks) {
+	const staleVitestAliasConfig = findLegacyVitestAliasConfig(root);
+	if (staleVitestAliasConfig) {
+		const relativeConfigPath = relative(root, staleVitestAliasConfig);
+		errorMsg(`Found a stale Vitest alias in ${relativeConfigPath} that points to the removed \`@voidzero-dev/vite-plus-test\` package. Run \`vp migrate\` to update the project before installing dependencies.`);
+		process.exit(1);
+	}
+	if (!skipHooks && isGitHooksEnvDisabled()) log("skip install (git hooks disabled)");
+	else if (!skipHooks) {
 		const location = resolveHooksLocation(dir);
 		if ("isError" in location) {
 			if (location.message) log(location.message);

package/dist/{constants-CG513DRa.js → constants-0IAVgpox.js}

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 //#region package.json
-var version = "0.2.9";
+var version = "0.3.1";
 //#endregion
 //#region src/utils/constants.ts
 const VITE_PLUS_NAME = "vite-plus";
@@ -13,7 +13,9 @@ const VITE_CONFIG_FILES = [
 	"vite.config.mts",
 	"vite.config.cts"
 ];
-const VITEST_VERSION = "4.1.10";
+const VITEST_VERSION = "4.1.11";
+const SETUP_VP_VERSION = "v1.19.0";
+const TSDOWN_MIGRATION_SKILL_URL = "https://github.com/rolldown/tsdown/blob/main/skills/tsdown-migrate/SKILL.md";
 const VITE_PLUS_OVERRIDE_PACKAGES = process.env.VP_OVERRIDE_PACKAGES ? JSON.parse(process.env.VP_OVERRIDE_PACKAGES) : {
 	vite: `npm:@voidzero-dev/vite-plus-core@${VITE_PLUS_VERSION}`,
 	vitest: VITEST_VERSION
@@ -75,4 +77,4 @@ const DEFAULT_ENVS = {
 };
 const CONFIG_METADATA_ENV = "VP_RESOLVING_CONFIG_METADATA";
 //#endregion
-export { VITEST_AGE_GATE_EXEMPT_PACKAGES as a, VITE_PLUS_NAME as c, createBaseUrlTsconfigFixArgs as d, isForceOverrideMode as f, version as h, DEFAULT_ENVS as i, VITE_PLUS_OVERRIDE_PACKAGES as l, resolveBundled as m, BASEURL_TSCONFIG_WARNING as n, VITEST_VERSION as o, resolve as p, CONFIG_METADATA_ENV as r, VITE_CONFIG_FILES as s, BASEURL_TSCONFIG_FIX_PACKAGE as t, VITE_PLUS_VERSION as u };
+export { version as _, SETUP_VP_VERSION as a, VITEST_VERSION as c, VITE_PLUS_OVERRIDE_PACKAGES as d, VITE_PLUS_VERSION as f, resolveBundled as g, resolve as h, DEFAULT_ENVS as i, VITE_CONFIG_FILES as l, isForceOverrideMode as m, BASEURL_TSCONFIG_WARNING as n, TSDOWN_MIGRATION_SKILL_URL as o, createBaseUrlTsconfigFixArgs as p, CONFIG_METADATA_ENV as r, VITEST_AGE_GATE_EXEMPT_PACKAGES as s, BASEURL_TSCONFIG_FIX_PACKAGE as t, VITE_PLUS_NAME as u };