vite-plus 0.2.9 → 0.3.1

package/binding/index.d.cts

@@ -174,6 +174,38 @@ export interface MangleOptionsKeepNames {
   class: boolean;
 }
 
+export interface ManglePropertiesOptions {
+  /**
+   * JavaScript `RegExp` selecting property names to mangle. The source and flags are compiled
+   * with Rust's regex engine. Flags `i`, `m`, `s`, and `u` are supported.
+   */
+  include: RegExp;
+  /** JavaScript `RegExp` excluding property names selected by `include`. */
+  exclude?: RegExp;
+  /** Exact names that are neither mangled nor emitted as automatic output names. */
+  reserved?: Array<string>;
+  /**
+   * Mangle quoted property occurrences in addition to unquoted occurrences.
+   *
+   * @default false
+   */
+  quoted?: boolean;
+  /**
+   * Generate readable `_$name$_`-style output names.
+   *
+   * @default false
+   */
+  debug?: boolean;
+  /**
+   * Stable mappings from original names to output names. `false` reserves an original name.
+   * Entries that do not match `include`, or that match `exclude`, remain inert but are
+   * preserved in the returned `mangleCache`. String targets must be `IdentifierName` values
+   * other than `__proto__`, `constructor`, or `prototype`. The original name `__proto__` is
+   * always reserved and cannot be used as a cache key.
+   */
+  cache?: Record<string, string | false>;
+}
+
 /**
  * Minify asynchronously.
  *
@@ -190,6 +222,12 @@ export interface MinifyOptions {
   module?: boolean;
   compress?: boolean | CompressOptions;
   mangle?: boolean | MangleOptions;
+  /**
+   * Mangle matching property names independently of identifier mangling. Properties owned by
+   * unminified code, imported module namespaces, globals, or host APIs must be excluded or
+   * reserved.
+   */
+  mangleProps?: ManglePropertiesOptions;
   codegen?: boolean | CodegenOptions;
   sourcemap?: boolean;
 }
@@ -203,6 +241,11 @@ export interface MinifyResult {
    * Only populated when `codegen.legalComments` is `"linked"` or `"external"`.
    */
   legalComments: Array<string>;
+  /**
+   * Updated property-name cache sorted by original name. Present when `mangleProps` ran on a
+   * parse without errors.
+   */
+  mangleCache?: Record<string, string | false>;
 }
 
 /** Minify synchronously. */
@@ -1651,6 +1694,12 @@ export declare class BindingDevEngine {
    * actual module and its dependencies.
    */
   compileEntry(moduleId: string, clientId: string): Promise<BindingLazyChunkOutput>;
+  /**
+   * Same data the plugin-context `getModuleInfo` returns, readable from the engine
+   * handle at any time (no hook context needed).
+   */
+  getModuleInfo(moduleId: string): BindingModuleInfo | null;
+  getModuleIds(): Array<string>;
 }
 
 export declare class BindingLoadPluginContext {
@@ -1959,8 +2008,8 @@ export declare class TraceSubscriberGuard {
 }
 
 export declare class TsconfigCache {
-  /** Create a new transform cache with auto tsconfig discovery enabled. */
-  constructor(yarnPnp: boolean);
+  /** Create a new transform cache with auto or manual tsconfig discovery enabled. */
+  constructor(yarnPnp: boolean, pathToTsconfig?: string | undefined | null);
   /**
    * Clear the cache.
    *
@@ -2063,6 +2112,7 @@ export interface BindingChecksOptions {
   ineffectiveDynamicImport?: boolean;
   largeBarrelModules?: boolean;
   sourcemapBroken?: boolean;
+  namespaceConflict?: boolean;
 }
 
 export interface BindingChunkImportMap {
@@ -2244,9 +2294,10 @@ export interface BindingEnhancedTransformOptions {
   /**
    * Configure tsconfig handling.
    * - true: Auto-discover and load the nearest tsconfig.json
+   * - string: Use the tsconfig at the provided path
    * - TsconfigRawOptions: Use the provided inline tsconfig options
    */
-  tsconfig?: boolean | BindingTsconfigRawOptions;
+  tsconfig?: boolean | string | BindingTsconfigRawOptions;
   /** An input source map to collapse with the output source map. */
   inputMap?: SourceMap;
 }
@@ -2657,8 +2708,8 @@ export interface BindingManualCodeSplittingOptions {
 }
 
 export interface BindingMatchGroup {
-  name: string | ((id: string, ctx: BindingChunkingContext) => VoidNullable<string>);
-  test?: string | RegExp | ((id: string) => VoidNullable<boolean>);
+  name: string | ((ids: Array<string>, ctx: BindingChunkingContext) => Array<VoidNullable<string>>);
+  test?: string | RegExp | ((ids: Array<string>) => Uint8Array);
   priority?: number;
   minSize?: number;
   minShareCount?: number;
@@ -2682,6 +2733,22 @@ export interface BindingModuleSideEffectsRule {
   external?: boolean;
 }
 
+/**
+ * Counters of the Rust-side tracking allocator. V8 never allocates through
+ * the Rust global allocator, so these numbers exclude the JS heap and GC
+ * noise completely, unlike `process.memoryUsage()`.
+ */
+export interface BindingNativeMemoryStats {
+  /** Bytes currently allocated and not yet freed, since process start. */
+  liveBytes: number;
+  /** Highest `live_bytes` seen since process start or the last reset. */
+  peakBytes: number;
+  /** Successful `alloc` calls since the last reset. */
+  allocCount: number;
+  /** Successful `realloc` calls since the last reset. */
+  reallocCount: number;
+}
+
 export interface BindingOptimization {
   inlineConst?: boolean | BindingInlineConstConfig;
   pifeForModuleWrappers?: boolean;
@@ -2742,6 +2809,7 @@ export interface BindingOutputOptions {
 export interface BindingOutputs {
   chunks: Array<BindingOutputChunk>;
   assets: Array<BindingOutputAsset>;
+  mangleCache?: Record<string, string | false>;
 }
 
 export interface BindingOverwriteOptions {
@@ -2853,14 +2921,14 @@ export interface BindingPluginOptions {
   renderErrorMeta?: BindingPluginHookMeta;
   generateBundle?: (
     ctx: BindingPluginContext,
-    bundle: BindingErrorsOr<BindingOutputs>,
+    bundle: BindingResult<BindingOutputs>,
     isWrite: boolean,
     opts: BindingNormalizedOptions,
   ) => MaybePromise<VoidNullable<JsChangedOutputs>>;
   generateBundleMeta?: BindingPluginHookMeta;
   writeBundle?: (
     ctx: BindingPluginContext,
-    bundle: BindingErrorsOr<BindingOutputs>,
+    bundle: BindingResult<BindingOutputs>,
     opts: BindingNormalizedOptions,
   ) => MaybePromise<VoidNullable<JsChangedOutputs>>;
   writeBundleMeta?: BindingPluginHookMeta;
@@ -3154,6 +3222,7 @@ export interface BindingViteReporterPluginConfig {
 
 export interface BindingViteResolvePluginConfig {
   resolveOptions: BindingViteResolvePluginResolveOptions;
+  tsconfig?: string;
   environmentConsumer: string;
   environmentName: string;
   builtins: Array<BindingStringOrRegex>;
@@ -3199,6 +3268,7 @@ export interface BindingViteResolvePluginResolveOptions {
 
 export interface BindingViteTransformPluginConfig {
   root: string;
+  tsconfig?: string;
   include?: Array<BindingStringOrRegex>;
   exclude?: Array<BindingStringOrRegex>;
   jsxRefreshInclude?: Array<BindingStringOrRegex>;
@@ -3268,6 +3338,13 @@ export declare const enum FilterTokenKind {
   QueryValue = 'QueryValue',
 }
 
+/**
+ * Returns the Rust-side allocator counters, or `None` when this binding was
+ * built without the `tracking_allocator` cargo feature (the default —
+ * tracking costs a few atomic operations per allocation).
+ */
+export declare function getNativeMemoryStats(): BindingNativeMemoryStats | null;
+
 export declare function initTraceSubscriber(): TraceSubscriberGuard | null;
 
 export interface JsChangedOutputs {
@@ -3321,7 +3398,7 @@ export interface PreRenderedChunk {
   /** Whether this chunk is a dynamic entry point. */
   isDynamicEntry: boolean;
   /** The id of a module that this chunk corresponds to. */
-  facadeModuleId?: string;
+  facadeModuleId: string | null;
   /** The list of ids of modules included in this chunk. */
   moduleIds: Array<string>;
   /** Exported variable names from this chunk. */
@@ -3330,6 +3407,13 @@ export interface PreRenderedChunk {
 
 export declare function registerPlugins(id: number, plugins: Array<BindingPluginWithIndex>): void;
 
+/**
+ * Starts a new measuring window: the peak restarts from the current live
+ * bytes and the counts restart from zero. No-op when the binding was built
+ * without the `tracking_allocator` cargo feature.
+ */
+export declare function resetNativeMemoryStats(): void;
+
 export declare function resolveTsconfig(
   filename: string,
   cache: TsconfigCache | undefined | null,
@@ -3366,17 +3450,21 @@ export interface BatchRewriteResult {
   preservedVitestFiles: Array<string>;
   /** Files that had errors */
   errors: Array<BatchRewriteError>;
+  /** Pack configurations that need manual migration */
+  warnings: Array<BatchRewriteError>;
 }
 
 /** Configuration options passed from JavaScript to Rust. */
 export interface CliOptions {
-  lint: (err: Error | null) => Promise<JsCommandResolvedResult>;
-  fmt: (err: Error | null) => Promise<JsCommandResolvedResult>;
-  vite: (err: Error | null) => Promise<JsCommandResolvedResult>;
-  test: (err: Error | null) => Promise<JsCommandResolvedResult>;
-  pack: (err: Error | null) => Promise<JsCommandResolvedResult>;
-  doc: (err: Error | null) => Promise<JsCommandResolvedResult>;
+  lint: (err: Error | null, arg: JsCommandContext) => Promise<JsCommandResolvedResult>;
+  fmt: (err: Error | null, arg: JsCommandContext) => Promise<JsCommandResolvedResult>;
+  vite: (err: Error | null, arg: JsCommandContext) => Promise<JsCommandResolvedResult>;
+  test: (err: Error | null, arg: JsCommandContext) => Promise<JsCommandResolvedResult>;
+  pack: (err: Error | null, arg: JsCommandContext) => Promise<JsCommandResolvedResult>;
+  doc: (err: Error | null, arg: JsCommandContext) => Promise<JsCommandResolvedResult>;
   cwd?: string;
+  /** Whether the user supplied the global `-C` option. */
+  explicitChdir?: boolean;
   /** CLI arguments (should be process.argv.slice(2) from JavaScript) */
   args?: Array<string>;
   /** Generated toolchain manifest shipped with this vite-plus package. */
@@ -3387,6 +3475,32 @@ export interface CliOptions {
   resolveUniversalViteConfig: (err: Error | null, arg: string) => Promise<string>;
 }
 
+export interface CliParseError {
+  kind: string;
+  message: string;
+}
+
+export interface ConfigArgs {
+  hooksDir?: string;
+  hooks?: boolean;
+  agent?: boolean;
+}
+
+export interface CreateArgs {
+  templateName?: string;
+  directory?: string;
+  agent?: false | string | Array<string>;
+  editor?: false | string;
+  git?: boolean;
+  hooks?: boolean;
+  packageManager?: 'pnpm' | 'npm' | 'yarn' | 'bun';
+  approveBuilds?: boolean;
+  verbose?: boolean;
+  interactive?: boolean;
+  list?: boolean;
+  templateArgs: Array<string>;
+}
+
 /**
  * Detect the workspace root and package manager type and version
  *
@@ -3475,6 +3589,14 @@ export interface DownloadPackageManagerResult {
 /** Re-enable blocking stdio after Node.js has initialized its lazy standard streams. */
 export declare function ensureBlockingStdio(): void;
 
+/**
+ * Resolved on-disk category roots from [`vp_shared::EnvConfig`].
+ *
+ * JavaScript must not read `VP_HOME` / `VP_*_DIR` / `XDG_*` itself;
+ * this is the JS surface of the same `EnvConfig::get().dirs` Rust uses.
+ */
+export declare function getVpDirs(): VpDirsJs;
+
 /**
  * Whether `config_key` is already declared as a top-level property in the
  * vite config's `defineConfig({...})` (or equivalent) object literal.
@@ -3485,6 +3607,17 @@ export declare function ensureBlockingStdio(): void;
  */
 export declare function hasConfigKey(viteConfigPath: string, configKey: string): boolean;
 
+export interface HooksArgs {
+  command: 'enable' | 'disable' | 'status';
+  hooksDir?: string;
+}
+
+/** Execution context after command dispatch selects the working directory. */
+export interface JsCommandContext {
+  cwd: string;
+  args: Array<string>;
+}
+
 /** Result returned by JavaScript resolver functions. */
 export interface JsCommandResolvedResult {
   binPath: string;
@@ -3567,6 +3700,50 @@ export declare function mergeTsdownConfig(
   tsdownConfigPath: string,
 ): MergeJsonConfigResult;
 
+export interface MigrateArgs {
+  path?: string;
+  agent?: false | string | Array<string>;
+  editor?: false | string;
+  hooks?: boolean;
+  interactive?: boolean;
+  full?: boolean;
+}
+
+export declare function parseConfigArgs(argv: Array<string>): ParseConfigArgsOutcome;
+
+export type ParseConfigArgsOutcome =
+  | { status: 'ok'; value: ConfigArgs }
+  | { status: 'exit'; code: number }
+  | { status: 'error'; error: CliParseError };
+
+export declare function parseCreateArgs(argv: Array<string>): ParseCreateArgsOutcome;
+
+export type ParseCreateArgsOutcome =
+  | { status: 'ok'; value: CreateArgs }
+  | { status: 'exit'; code: number }
+  | { status: 'error'; error: CliParseError };
+
+export declare function parseHooksArgs(argv: Array<string>): ParseHooksArgsOutcome;
+
+export type ParseHooksArgsOutcome =
+  | { status: 'ok'; value: HooksArgs }
+  | { status: 'exit'; code: number }
+  | { status: 'error'; error: CliParseError };
+
+export declare function parseMigrateArgs(argv: Array<string>): ParseMigrateArgsOutcome;
+
+export type ParseMigrateArgsOutcome =
+  | { status: 'ok'; value: MigrateArgs }
+  | { status: 'exit'; code: number }
+  | { status: 'error'; error: CliParseError };
+
+export declare function parseStagedArgs(argv: Array<string>): ParseStagedArgsOutcome;
+
+export type ParseStagedArgsOutcome =
+  | { status: 'ok'; value: StagedArgs }
+  | { status: 'exit'; code: number }
+  | { status: 'error'; error: CliParseError };
+
 /** Access modes for a path. */
 export interface PathAccess {
   /** Whether the path was read */
@@ -3751,6 +3928,24 @@ export interface RunCommandResult {
  */
 export declare function shouldPrintVitePlusHeader(): boolean;
 
+export interface StagedArgs {
+  allowEmpty?: boolean;
+  concurrent?: boolean | number;
+  continueOnError?: boolean;
+  cwd?: string;
+  debug?: boolean;
+  diff?: string;
+  diffFilter?: string;
+  failOnChanges?: boolean;
+  hidePartiallyStaged?: boolean;
+  hideUnstaged?: boolean;
+  quiet?: boolean;
+  relative?: boolean;
+  revert?: boolean;
+  stash?: boolean;
+  verbose?: boolean;
+}
+
 /**
  * Set the value of a top-level config key in a vite config file (upsert)
  *
@@ -3793,6 +3988,15 @@ export declare function upsertJsonConfig(
 /** Render the Vite+ header using the Rust implementation. */
 export declare function vitePlusHeader(): string;
 
+/** Resolved on-disk category roots from [`vp_shared::EnvConfig`]. */
+export interface VpDirsJs {
+  bin: string;
+  data: string;
+  cache: string;
+  config: string;
+  state: string;
+}
+
 /**
  * Wrap safe inline `plugins: [...]` arrays in recognized Vite config objects
  * with `lazyPlugins(() => [...])` and add a `lazyPlugins` import from

package/dist/{agent-DQU8uS6P.js → agent-C5jMYVfB.js}

@@ -1,4 +1,5 @@
-import { A as isCancel, C as log, E as select, w as multiselect } from "./prompts-CHz_98bJ.js";
+import { a as SETUP_VP_VERSION } from "./constants-0IAVgpox.js";
+import { C as multiselect, S as log, T as select, k as isCancel } from "./prompts-CtzEgFY-.js";
 import path from "node:path";
 import { styleText } from "node:util";
 import fs from "node:fs";
@@ -110,7 +111,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Set up Vite+
-        uses: voidzero-dev/setup-vp@v1
+        uses: voidzero-dev/setup-vp@${SETUP_VP_VERSION}
         with:
           cache: true
           run-install: true

package/dist/bin.js

@@ -1,14 +1,15 @@
-import { c as warnMsg, i as log, l as renderCliDoc, n as errorMsg, o as printHeader, t as accent } from "./terminal-Bz-ps6rJ.js";
-import { c as VITE_PLUS_NAME, i as DEFAULT_ENVS, m as resolveBundled, n as BASEURL_TSCONFIG_WARNING, p as resolve$1, r as CONFIG_METADATA_ENV, s as VITE_CONFIG_FILES } from "./constants-CG513DRa.js";
-import { r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-BEZ9IUf7.js";
-import { M as runCommandSilently } from "./prompts-CHz_98bJ.js";
-import { i as hasBaseUrlInTsconfig, r as fixBaseUrlInTsconfig } from "./tsconfig-7v_BHagU.js";
+import { t as renderCliDoc } from "./help-BmKpeOP9.js";
+import { c as warnMsg, i as log, n as errorMsg, o as printHeader, t as accent } from "./terminal-MKGAuy-p.js";
+import { g as resolveBundled, h as resolve$1, i as DEFAULT_ENVS, l as VITE_CONFIG_FILES, n as BASEURL_TSCONFIG_WARNING, r as CONFIG_METADATA_ENV, u as VITE_PLUS_NAME } from "./constants-0IAVgpox.js";
+import { r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-Drdl67Xp.js";
 import { t as resolveTsgolintExecutable } from "./tsgolint-path-CbDReEOx.js";
-import { i as resolveUniversalViteConfig } from "./resolve-vite-config-Dmeyeyj-.js";
-import path, { dirname, join } from "node:path";
+import { a as readNearestPackageJson } from "./package-BZz2Ij68.js";
+import { t as cac } from "./dist-DfmT__Aw.js";
+import { createRequire } from "node:module";
+import path, { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ensureBlockingStdio, hasConfigKey, mergeJsonConfig, run } from "../binding/index.js";
-import fs, { readFileSync } from "node:fs";
+import fs, { existsSync, readFileSync } from "node:fs";
 //#region src/help.ts
 const commandHelpDocs = {
 	dev: {
@@ -935,6 +936,10 @@ const commandHelpDocs = {
 						label: "--fix",
 						description: "Auto-fix format and lint issues"
 					},
+					{
+						label: "--quiet",
+						description: "Disable reporting on warnings, only errors are reported"
+					},
 					{
 						label: "--no-fmt",
 						description: "Skip format check"
@@ -978,6 +983,10 @@ const commandHelpDocs = {
 			{
 				title: "Options",
 				rows: [
+					{
+						label: "--no-config",
+						description: "Disable config file"
+					},
 					{
 						label: "-f, --format <format>",
 						description: "Bundle format: esm, cjs, iife, umd (default: esm)"
@@ -1090,10 +1099,6 @@ const commandHelpDocs = {
 						label: "--copy <dir>",
 						description: "Copy files to output dir"
 					},
-					{
-						label: "--public-dir <dir>",
-						description: "Alias for --copy, deprecated"
-					},
 					{
 						label: "--tsconfig <tsconfig>",
 						description: "Set tsconfig path"
@@ -1453,6 +1458,7 @@ export default defineConfig({});
 	return viteConfigPath;
 }
 async function vpFmt(cwd, filePath) {
+	const { runCommandSilently } = await import("./command-CLJK5jGW.js");
 	const { binPath, envs } = await fmt();
 	const result = await runCommandSilently({
 		command: binPath,
@@ -1511,6 +1517,7 @@ async function applyToolInitConfigToViteConfig(command, args, projectPath = proc
 	}
 	if (spec.configKey === "lint" && hasTriggerFlag(args, ["--init"])) {
 		const lintInitConfigPath = path.join(projectPath, ".vite-plus-lint-init.oxlintrc.json");
+		const { fixBaseUrlInTsconfig, hasBaseUrlInTsconfig } = await import("./tsconfig-VAbm4ZzJ.js");
 		await fixBaseUrlInTsconfig(projectPath);
 		const hasBaseUrl = hasBaseUrlInTsconfig(projectPath);
 		const initConfig = createDefaultVitePlusLintConfig({ includeTypeAwareDefaults: !hasBaseUrl });
@@ -1613,26 +1620,49 @@ async function lint() {
 	};
 }
 //#endregion
+//#region src/resolve-core.ts
+const CORE_PACKAGE_NAME = "@voidzero-dev/vite-plus-core";
+function checkCoreVersion(packageJsonPath, expectedVersion) {
+	const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+	if (pkg.name !== CORE_PACKAGE_NAME || pkg.version !== expectedVersion) throw new Error(`Expected ${CORE_PACKAGE_NAME}@${expectedVersion}, but found ${pkg.name}@${pkg.version} at ${packageJsonPath}. Run \`vp migrate\` to align the Vite alias, then run \`vp install\`.`);
+}
+function checkProjectCoreVersion(cwd, corePackageJsonPath, expectedVersion) {
+	const projectPackage = readNearestPackageJson(cwd);
+	if (![
+		"dependencies",
+		"devDependencies",
+		"optionalDependencies",
+		"peerDependencies"
+	].some((field) => Object.hasOwn(projectPackage?.[field] ?? {}, "vite"))) return;
+	const projectRequire = createRequire(join(cwd, "package.json"));
+	let projectPackageJsonPath;
+	try {
+		projectPackageJsonPath = projectRequire.resolve("vite/package.json");
+	} catch (cause) {
+		if (cause.code !== "MODULE_NOT_FOUND") throw cause;
+	}
+	if (projectPackageJsonPath && projectPackageJsonPath !== corePackageJsonPath) checkCoreVersion(projectPackageJsonPath, expectedVersion);
+}
+/** Resolve the same core dependency as the CLI's static `vite` re-exports. */
+function resolveCore(subpath = "", cwd = process.cwd(), modulePath = import.meta.url) {
+	const cliRequire = createRequire(modulePath);
+	const { version: expectedVersion } = JSON.parse(readFileSync(cliRequire.resolve("vite-plus/package.json"), "utf8"));
+	let corePackageJsonPath;
+	try {
+		corePackageJsonPath = cliRequire.resolve("vite/package.json");
+	} catch (cause) {
+		throw new Error("Could not resolve the bundled Vite dependency. Run `vp install`.", { cause });
+	}
+	checkCoreVersion(corePackageJsonPath, expectedVersion);
+	checkProjectCoreVersion(cwd, corePackageJsonPath, expectedVersion);
+	return cliRequire.resolve(`vite${subpath}`);
+}
+//#endregion
 //#region src/resolve-pack.ts
-/**
-* Tsdown tool resolver for the vite-plus CLI.
-*
-* This module exports a function that resolves the Tsdown binary path
-* using Node.js module resolution. The resolved path is passed back
-* to the Rust core, which then executes Tsdown for running pack.
-*
-* Used for: `vite-plus pack` command
-*/
-/**
-* Resolves the Tsdown binary path and environment variables.
-*
-* @returns Promise containing:
-*   - binPath: Absolute path to the Tsdown CLI entry point
-*   - envs: Environment variables to set when executing Tsdown
-*
-* Tsdown is a tool that provides a library for building JavaScript/TypeScript libraries.
-*/
-async function pack() {
+/** Validate the target project's core alias before starting the bundled pack entry. */
+async function pack(err, { cwd }) {
+	if (err) throw err;
+	resolveCore("/pack", cwd);
 	return {
 		binPath: join(import.meta.dirname, "pack-bin.js"),
 		envs: { ...DEFAULT_ENVS }
@@ -1682,35 +1712,39 @@ async function test() {
 }
 //#endregion
 //#region src/resolve-vite.ts
-/**
-* Vite tool resolver for the vite-plus CLI.
-*
-* This module exports a function that resolves the Vite binary path
-* using Node.js module resolution. The resolved path is passed back
-* to the Rust core, which then executes Vite with the appropriate
-* command and arguments.
-*
-* Used for: `vite-plus build` and potentially `vite-plus dev` commands
-*/
-/**
-* Resolves the Vite binary path and environment variables.
-*
-* @returns Promise containing:
-*   - binPath: Absolute path to the Vite CLI entry point (vite.js)
-*   - envs: Environment variables to set when executing Vite
-*
-* The function first tries to resolve vite package, then falls back
-* to vite package (for direct vite installations).
-* It constructs the path to the CLI binary within the resolved package.
-*/
-async function vite() {
-	const vitePackagePath = dirname(resolve$1("@voidzero-dev/vite-plus-core"));
+function resolveViteRoot({ cwd, args }) {
+	const cli = cac();
+	const command = cli.command("[root]").allowUnknownOptions();
+	for (const flag of [
+		"--clearScreen",
+		"--cors",
+		"--strictPort",
+		"--force",
+		"--experimentalBundle",
+		"--emptyOutDir",
+		"-w, --watch",
+		"--app",
+		"-h, --help",
+		"-v, --version"
+	]) command.option(flag, "");
+	const parsed = cli.parse([
+		"node",
+		"vite",
+		...args
+	], { run: false });
+	return resolve(cwd, parsed.args[0] ?? ".");
+}
+/** Resolve the bundled CLI for dev, build, and preview from the selected project root. */
+async function vite(err, context) {
+	if (err) throw err;
+	const vitePackagePath = dirname(resolveCore("", resolveViteRoot(context)));
+	const binPath = join(vitePackagePath, "cli.js");
+	if (!existsSync(binPath)) throw new Error(`Could not find the bundled Vite CLI at ${binPath}. Run \`vp install\`.`);
+	const envs = { ...DEFAULT_ENVS };
+	if (process.env.DEBUG_DISABLE_SOURCE_MAP) envs.DEBUG_DISABLE_SOURCE_MAP = process.env.DEBUG_DISABLE_SOURCE_MAP;
 	return {
-		binPath: join(vitePackagePath, "cli.js"),
-		envs: process.env.DEBUG_DISABLE_SOURCE_MAP ? {
-			...DEFAULT_ENVS,
-			DEBUG_DISABLE_SOURCE_MAP: process.env.DEBUG_DISABLE_SOURCE_MAP
-		} : { ...DEFAULT_ENVS }
+		binPath,
+		envs
 	};
 }
 //#endregion
@@ -1718,7 +1752,7 @@ async function vite() {
 /**
 * Unified entry point for both the local CLI (via bin/vp) and the global CLI (via Rust vp binary).
 *
-* Global commands (create, migrate, config, hooks, staged, --version) are handled by tsdown-bundled modules.
+* Global commands (create, migrate, sync-versions, config, hooks, staged, --version) are handled by tsdown-bundled modules.
 * All other commands are delegated to the Rust core through NAPI bindings, which
 * uses JavaScript tool resolver functions to locate tool binaries.
 *
@@ -1735,7 +1769,11 @@ function getErrorMessage(err) {
 	return String(err);
 }
 let args = process.argv.slice(2);
+const explicitChdirMarker = process.env.VP_EXPLICIT_CHDIR;
+let explicitChdir = explicitChdirMarker === "1";
+if (explicitChdirMarker !== void 0) delete process.env.VP_EXPLICIT_CHDIR;
 if (args[0]?.startsWith("-C")) {
+	explicitChdir = true;
 	const inline = args[0].length > 2;
 	const dir = inline ? args[0].slice(args[0][2] === "=" ? 3 : 2) : args[1];
 	if (!dir) {
@@ -1773,11 +1811,13 @@ const cliDistDir = path.dirname(fileURLToPath(import.meta.url));
 const vitePlusPackagePath = path.dirname(cliDistDir);
 if (maybePrintCommandHelp(args)) {} else if (command === "create") await import("./create/bin.js");
 else if (command === "migrate") await import("./migration/bin.js");
+else if (command === "sync-versions") await import("./sync-versions/bin.js");
 else if (command === "config") await import("./config/bin.js");
 else if (command === "hooks") await import("./hooks/bin.js");
 else if (command === "--version" || command === "-V") await import("./version.js");
 else if (command === "staged") await import("./staged/bin.js");
 else try {
+	const { resolveUniversalViteConfig } = await import("./resolve-vite-config-Dnmc-lBc.js");
 	const initInspection = inspectInitCommand(command, args.slice(1));
 	if (initInspection.handled && initInspection.configKey && initInspection.hasExistingConfigKey && initInspection.existingViteConfigPath) {
 		log(`Skipped initialization: '${accent(initInspection.configKey)}' already exists in '${accent(path.basename(initInspection.existingViteConfigPath))}'.`);
@@ -1793,6 +1833,7 @@ else try {
 		toolchainManifestPath: path.join(cliDistDir, "toolchain.json"),
 		vitePlusPackagePath,
 		resolveUniversalViteConfig,
+		explicitChdir,
 		args: rustCliArgs
 	});
 	let finalExitCode = exitCode;

package/dist/cli-parse-DHE8NrBU.js

@@ -0,0 +1,13 @@
+import { n as errorMsg, o as printHeader } from "./terminal-MKGAuy-p.js";
+//#region src/utils/cli-parse.ts
+function unwrapCliParseOutcome(outcome) {
+	if (outcome.status === "exit") process.exit(outcome.code);
+	if (outcome.status === "error") {
+		printHeader();
+		errorMsg(outcome.error.message.replace(/^error:\s*/, ""));
+		process.exit(1);
+	}
+	return outcome.value;
+}
+//#endregion
+export { unwrapCliParseOutcome as t };

package/dist/client/bundledDevClient.mjs

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