vite-plus 0.3.3 → 1.0.0-rc.1

package/dist/{define-config-D0mevyb3.cjs → define-config-CAeeMTvb.cjs}

@@ -34,19 +34,40 @@ var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["modu
 //#endregion
 let node_fs = require("node:fs");
 let node_module = require("node:module");
+let node_path = require("node:path");
 let node_url = require("node:url");
 let vitest_config = require("vitest/config");
 //#region package.json
-var version = "0.3.3", VITE_PLUS_VERSION, VITEST_VERSION, CONFIG_METADATA_ENV;
+var version = "1.0.0-rc.1", VITE_PLUS_VERSION, VITEST_VERSION, CONFIG_METADATA_ENV;
 var init_constants = __esmMin((() => {
 	VITE_PLUS_VERSION = process.env.VP_VERSION || version;
-	VITEST_VERSION = "4.1.11";
+	VITEST_VERSION = "5.0.1";
 	process.env.VP_OVERRIDE_PACKAGES ? JSON.parse(process.env.VP_OVERRIDE_PACKAGES) : `${VITE_PLUS_VERSION}`;
 	(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
 	process.versions.node, process.release.name;
 	CONFIG_METADATA_ENV = "VP_RESOLVING_CONFIG_METADATA";
 }));
 //#endregion
+//#region src/utils/vitest-ecosystem.ts
+var VITEST_EXACT_VERSION_PACKAGES, VITEST_RESOLVER_PACKAGES;
+var init_vitest_ecosystem = __esmMin((() => {
+	VITEST_EXACT_VERSION_PACKAGES = /* @__PURE__ */ new Set([
+		"@vitest/browser",
+		"@vitest/browser-playwright",
+		"@vitest/browser-preview",
+		"@vitest/coverage-v8",
+		"@vitest/coverage-istanbul",
+		"@vitest/mocker",
+		"@vitest/pretty-format",
+		"@vitest/snapshot",
+		"@vitest/spy",
+		"@vitest/ui",
+		"@vitest/utils",
+		"@vitest/web-worker"
+	]);
+	VITEST_RESOLVER_PACKAGES = /* @__PURE__ */ new Set(["vitest", ...VITEST_EXACT_VERSION_PACKAGES]);
+}));
+//#endregion
 //#region src/define-config.ts
 var define_config_exports = /* @__PURE__ */ __exportAll({
 	AUTO_INLINE_DEPS: () => AUTO_INLINE_DEPS,
@@ -69,6 +90,18 @@ function getVitestAnchor() {
 	}
 	return vitestAnchor;
 }
+function getVitestImportTarget(id) {
+	const anchor = getVitestAnchor();
+	if (!anchor) throw new Error("Cannot resolve the bundled Vitest package. Reinstall vite-plus.");
+	vitestExports ??= JSON.parse((0, node_fs.readFileSync)(anchor, "utf8")).exports;
+	let target = vitestExports[id === "vitest" ? "." : `.${id.slice(6)}`];
+	while (target && typeof target === "object") {
+		const conditions = target;
+		target = conditions.import ?? conditions.default;
+	}
+	if (typeof target !== "string" || !target.startsWith("./")) throw new Error(`The bundled Vitest has no ESM export for ${id}.`);
+	return (0, node_path.resolve)(anchor, "..", target);
+}
 /**
 * Match the `vitest` / `@vitest/*` family of bare specifiers — the imports a
 * browser-mode Vite dev server must resolve. Any query string is stripped
@@ -79,7 +112,9 @@ function getVitestAnchor() {
 function isVitestFamilySpecifier(id) {
 	const bare = id.split("?")[0];
 	if (bare.startsWith(".") || bare.startsWith("/") || bare.startsWith("\0")) return false;
-	return bare === "vitest" || bare.startsWith("vitest/") || bare === "@vitest/browser" || bare.startsWith("@vitest/");
+	const segments = bare.split("/");
+	const packageName = bare.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+	return VITEST_RESOLVER_PACKAGES.has(packageName);
 }
 /**
 * Rescue `vitest` / `@vitest/*` resolution for browser-mode tests.
@@ -88,10 +123,10 @@ function isVitestFamilySpecifier(id) {
 * and `@vitest/browser` are transitive deps. pnpm's isolated layout only
 * exposes a package's *direct* deps, so the browser-mode Vite dev server
 * (rooted at the consumer project) cannot resolve `vitest/internal/browser`,
-* `@vitest/expect`, etc. Non-browser tests are unaffected — vitest's own
+* `@vitest/mocker`, etc. Non-browser tests are unaffected — vitest's own
 * module runner handles resolution there.
 *
-* This plugin re-resolves the `vitest` / `@vitest/*` family through Vite's OWN
+* This plugin re-resolves the explicit Vitest runtime allowlist through Vite's OWN
 * resolver, but ROOTED at `vite-plus`'s location ([[vitePlusModuleFile]]) and
 * then the bundled `vitest`'s location ([[getVitestAnchor]]) BEFORE the
 * project. So every such import binds to the same physical (pinned) Vitest that
@@ -132,10 +167,61 @@ function isVitestFamilySpecifier(id) {
 *     [[vitePlusCoverageVersionGuardPlugin]] fails fast on a mismatch instead.
 */
 function vitePlusVitestResolverPlugin() {
+	let isVitestServer = false;
 	return {
 		name: "vite-plus:vitest-resolver",
 		enforce: "pre",
+		config: {
+			order: "post",
+			handler(config, { command }) {
+				isVitestServer = command === "serve" && !!config.environments?.["__vitest__"];
+				if (!isVitestServer || !config.test?.browser?.enabled) return;
+				const aliases = config.resolve?.alias;
+				const entries = Array.isArray(aliases) ? [...aliases] : Object.entries(aliases ?? {}).map(([find, replacement]) => ({
+					find,
+					replacement
+				}));
+				const runtimeRequire = (0, node_module.createRequire)(getVitestAnchor());
+				const targets = new Map([
+					"vitest",
+					"vitest/internal/browser",
+					"vitest/internal/traces",
+					"expect-type",
+					"magic-string",
+					"chai",
+					"vite/module-runner"
+				].map((id) => [id, id.startsWith("vitest") ? getVitestImportTarget(id) : runtimeRequire.resolve(id)]));
+				if (config.test.browser.provider?.name === "preview") {
+					const previewRequire = (0, node_module.createRequire)(vitePlusRequire.resolve("@vitest/browser-preview"));
+					for (const id of ["@testing-library/user-event", "@testing-library/dom"]) targets.set(id, previewRequire.resolve(id));
+				}
+				for (const [id, replacement] of targets) {
+					if (entries.some(({ find }) => typeof find === "string" ? id === find || id.startsWith(`${find}/`) : new RegExp(find).test(id))) continue;
+					entries.push({
+						find: new RegExp(`^${id}$`),
+						replacement
+					});
+				}
+				config.resolve ??= {};
+				config.resolve.alias = entries;
+			}
+		},
+		configResolved(config) {
+			const seen = /* @__PURE__ */ new Set();
+			const plugins = config.plugins;
+			const unique = plugins.filter((plugin) => {
+				if (!VITE_PLUS_TEST_PLUGIN_NAMES.has(plugin.name)) return true;
+				if (seen.has(plugin.name)) return false;
+				seen.add(plugin.name);
+				return true;
+			});
+			plugins.splice(0, plugins.length, ...unique);
+		},
 		async resolveId(id, importer, options) {
+			if (isVitestServer && id === "vite-plus/test") return this.resolve("vitest", importer, {
+				...options,
+				skipSelf: true
+			});
 			if (!isVitestFamilySpecifier(id)) return null;
 			if (id.includes("?")) return null;
 			const vitestAnchorPath = getVitestAnchor();
@@ -164,18 +250,26 @@ function vitePlusVitestResolverPlugin() {
 *
 * Exported for unit testing. The `_createRequire` parameter lets tests inject
 * a controlled resolver without needing to spy on Node's ESM module namespace.
+* Callers may share installation results for the same root within one config load.
 */
-function computeAutoInlineList(existingInline, projectRoot, _createRequire = node_module.createRequire) {
+function computeAutoInlineList(existingInline, projectRoot, _createRequire = node_module.createRequire, installedPackages = /* @__PURE__ */ new Map()) {
 	if (existingInline === true) return null;
-	const projectRequire = _createRequire(`${projectRoot}/package.json`);
+	let projectRequire;
 	const merged = Array.isArray(existingInline) ? [...existingInline] : [];
 	for (const pkg of AUTO_INLINE_DEPS) {
 		if (merged.some((entry) => entry === pkg || entry instanceof RegExp && entry.test(pkg))) continue;
-		try {
-			projectRequire.resolve(pkg);
-		} catch {
-			continue;
+		let installed = installedPackages.get(pkg);
+		if (installed === void 0) {
+			projectRequire ??= _createRequire(`${projectRoot}/package.json`);
+			try {
+				projectRequire.resolve(pkg);
+				installed = true;
+			} catch {
+				installed = false;
+			}
+			installedPackages.set(pkg, installed);
 		}
+		if (!installed) continue;
 		merged.push(pkg);
 	}
 	const hadEntries = Array.isArray(existingInline) ? existingInline.length : 0;
@@ -183,18 +277,47 @@ function computeAutoInlineList(existingInline, projectRoot, _createRequire = nod
 	return merged;
 }
 function vitePlusAutoInlineMatcherPlugin() {
+	let projectRoot = "";
+	let isVitestServer = false;
+	const installedByRoot = /* @__PURE__ */ new Map();
+	function inlineList(existing, root) {
+		root = (0, node_path.resolve)(root);
+		let installed = installedByRoot.get(root);
+		if (!installed) {
+			installed = /* @__PURE__ */ new Map();
+			installedByRoot.set(root, installed);
+		}
+		return computeAutoInlineList(existing, root, node_module.createRequire, installed);
+	}
 	return {
 		name: "vite-plus:auto-inline-matcher-deps",
 		enforce: "pre",
+		config: {
+			order: "post",
+			handler(config, { command }) {
+				isVitestServer = command === "serve" && !!config.environments?.["__vitest__"];
+				projectRoot = (0, node_path.resolve)(config.root ?? ".");
+				installedByRoot.clear();
+			}
+		},
+		configEnvironment(_name, config) {
+			if (!isVitestServer) return;
+			const existing = config.resolve?.noExternal;
+			const merged = inlineList(typeof existing === "string" || existing instanceof RegExp ? [existing] : existing, projectRoot);
+			if (merged !== null) {
+				config.resolve ??= {};
+				config.resolve.noExternal = merged;
+			}
+		},
 		configResolved(resolvedConfig) {
-			const testConfig = resolvedConfig.test;
-			const merged = computeAutoInlineList(testConfig?.server?.deps?.inline, resolvedConfig.root);
-			if (merged === null) return;
-			if (!testConfig) resolvedConfig.test = { server: { deps: { inline: merged } } };
-			else {
-				if (!testConfig.server) testConfig.server = {};
-				if (!testConfig.server.deps) testConfig.server.deps = {};
-				testConfig.server.deps.inline = merged;
+			if (!isVitestServer) return;
+			const config = resolvedConfig;
+			const merged = inlineList(config.test?.server?.deps?.inline, config.root);
+			if (merged !== null) {
+				config.test ??= {};
+				config.test.server ??= {};
+				config.test.server.deps ??= {};
+				config.test.server.deps.inline = merged;
 			}
 		}
 	};
@@ -299,15 +422,14 @@ function vitePlusCoverageVersionGuardPlugin() {
 		}
 	};
 }
-/**
-* Inject the vitest resolver plugin, the auto-inline matcher plugin, and the
-* coverage version guard into a single inline project config. Used both for
-* root configs and for object-shaped entries inside `test.projects`.
-*
-* The shapes overlap (both have an optional top-level `plugins` array and
-* an optional `test.server.deps.inline`), so a shared helper keeps the
-* wiring consistent.
-*/
+function withoutVitePlusTestPlugins(plugin) {
+	if (Array.isArray(plugin)) return plugin.filter(keepUserPlugin).map(withoutVitePlusTestPlugins);
+	if (plugin instanceof Promise) return plugin.then(withoutVitePlusTestPlugins);
+	return plugin && VITE_PLUS_TEST_PLUGIN_NAMES.has(plugin.name) ? false : plugin;
+}
+function keepUserPlugin(plugin) {
+	return !plugin || !("name" in plugin) || !VITE_PLUS_TEST_PLUGIN_NAMES.has(plugin.name);
+}
 function injectPluginIntoInlineConfig(config) {
 	return {
 		...config,
@@ -315,15 +437,13 @@ function injectPluginIntoInlineConfig(config) {
 			vitePlusVitestResolverPlugin(),
 			vitePlusAutoInlineMatcherPlugin(),
 			vitePlusCoverageVersionGuardPlugin(),
-			...config.plugins ?? []
+			...(config.plugins ?? []).filter(keepUserPlugin).map(withoutVitePlusTestPlugins)
 		]
 	};
 }
 /**
-* Walk `config.test?.projects` and inject the vite-plus plugins into each
-* project entry. Vitest spins up an independent Vite pipeline per project, so
-* root-level plugins do NOT propagate — without this, files matched by a
-* project's `include` glob never get the vitest resolver / auto-inline plugins.
+* Inline projects inherit root plugins by default in Vitest v5. Only projects
+* with inheritance disabled or an external base need their own injection.
 *
 * Entry shapes (from `TestProjectConfiguration`):
 *   - string  (glob path like `'./packages/*'`)  → passed through unchanged.
@@ -345,15 +465,18 @@ function injectPluginIntoProject(project) {
 	if (typeof project === "function") {
 		const wrapped = (env) => {
 			const result = project(env);
-			if (result instanceof Promise) return result.then(injectPluginIntoInlineConfig);
-			return injectPluginIntoInlineConfig(result);
+			if (result instanceof Promise) return result.then(injectIndependentProject);
+			return injectIndependentProject(result);
 		};
 		return wrapped;
 	}
-	if (project instanceof Promise) return project.then(injectPluginIntoInlineConfig);
-	if (typeof project === "object" && project !== null) return injectPluginIntoInlineConfig(project);
+	if (project instanceof Promise) return project.then(injectIndependentProject);
+	if (typeof project === "object" && project !== null) return injectIndependentProject(project);
 	return project;
 }
+function injectIndependentProject(config) {
+	return config.extends === false || typeof config.extends === "string" ? injectPlugin(config) : config;
+}
 function injectPlugin(config) {
 	const injected = injectPluginIntoInlineConfig(config);
 	const projects = injected.test?.projects;
@@ -375,22 +498,28 @@ function injectPluginIntoConfig(config) {
 	if (config instanceof Promise) return config.then(injectPlugin);
 	return injectPlugin(config);
 }
+/**
+* Keep a single generic signature so callback returns receive one contextual
+* config type. Separate sync and async overloads make TypeScript widen nested
+* literals in async callbacks before overload resolution (for example, an
+* Oxlint rule severity of `'warn'` becomes `string`).
+*/
 function defineConfig(config) {
 	return (0, vitest_config.defineConfig)(injectPluginIntoConfig(config));
 }
 /**
 * Inject the vite-plus plugins into a `defineProject` export. A project config
-* (`UserWorkspaceConfig`) cannot itself nest `test.projects`, so this only
-* touches the top-level `plugins` array (no project recursion like
-* [[injectPluginIntoConfig]] does).
+* (`UserWorkspaceConfig`) can itself declare nested projects in v5. Referenced
+* configs own a Vite server, so inject at their root and apply inheritance rules
+* to their inline children.
 */
 function injectPluginIntoProjectExport(config) {
 	if (typeof config === "function") return (env) => {
 		const result = config(env);
-		return result instanceof Promise ? result.then(injectPluginIntoInlineConfig) : injectPluginIntoInlineConfig(result);
+		return result instanceof Promise ? result.then(injectPlugin) : injectPlugin(result);
 	};
-	if (config instanceof Promise) return config.then(injectPluginIntoInlineConfig);
-	return injectPluginIntoInlineConfig(config);
+	if (config instanceof Promise) return config.then(injectPlugin);
+	return injectPlugin(config);
 }
 function defineProject(config) {
 	return (0, vitest_config.defineProject)(injectPluginIntoProjectExport(config));
@@ -432,9 +561,10 @@ function lazyPlugins(cb) {
 	if (result instanceof Promise) return [result];
 	return result;
 }
-var vitePlusRequire, vitePlusModuleFile, vitestAnchor, AUTO_INLINE_DEPS, KNOWN_COVERAGE_PROVIDERS, bundledVitestAnchorCache, coverageGuardedVitestInstances, configMetadataDepth, configMetadataSavedValue;
+var vitePlusRequire, vitePlusModuleFile, vitestAnchor, vitestExports, AUTO_INLINE_DEPS, KNOWN_COVERAGE_PROVIDERS, bundledVitestAnchorCache, coverageGuardedVitestInstances, VITE_PLUS_TEST_PLUGIN_NAMES, configMetadataDepth, configMetadataSavedValue;
 var init_define_config = __esmMin((() => {
 	init_constants();
+	init_vitest_ecosystem();
 	vitePlusRequire = (0, node_module.createRequire)(typeof __dirname !== "undefined" ? __dirname : require("url").pathToFileURL(__filename).href);
 	vitePlusModuleFile = (0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
 	AUTO_INLINE_DEPS = [
@@ -444,6 +574,11 @@ var init_define_config = __esmMin((() => {
 	];
 	KNOWN_COVERAGE_PROVIDERS = /* @__PURE__ */ new Set(["v8", "istanbul"]);
 	coverageGuardedVitestInstances = /* @__PURE__ */ new WeakSet();
+	VITE_PLUS_TEST_PLUGIN_NAMES = /* @__PURE__ */ new Set([
+		"vite-plus:vitest-resolver",
+		"vite-plus:auto-inline-matcher-deps",
+		"vite-plus:coverage-version-guard"
+	]);
 	configMetadataDepth = 0;
 }));
 //#endregion

package/dist/{define-config-DPNEJxPz.d.ts → define-config-Cf_5GHmY.d.ts}

@@ -57,11 +57,17 @@ type Task = {
    *   direct workspace dependency that defines a `build` task.
    */
   dependsOn?: Array<DependsOnEntry>;
-} & ({
   /**
-   * Whether to cache the task
+   * Whether and how to cache the task.
+   *
+   * - Omitted or `true`: caching enabled with default settings (same as `{}`)
+   * - `false`: caching disabled
+   * - Object: caching enabled with the given settings
    */
-  cache?: true;
+  cache?: TaskCache;
+};
+type TaskCache = boolean | TaskCacheConfig;
+type TaskCacheConfig = {
   /**
    * Environment variable names to be fingerprinted and passed to the task.
    */
@@ -92,12 +98,7 @@ type Task = {
    * - Negative patterns (e.g. `"!dist/cache/**"`) exclude matched files
    */
   output?: Array<string | GlobWithBase | AutoTracking>;
-} | {
-  /**
-   * Whether to cache the task
-   */
-  cache: false;
-});
+};
 type TaskDefinition = Task | Command;
 type UserGlobalCacheConfig = boolean | {
   /**
@@ -112,7 +113,8 @@ type UserGlobalCacheConfig = boolean | {
   /**
    * Global cache kill switch for task entries.
    *
-   * When `false`, overrides all tasks to disable caching, even tasks with `cache: true`.
+   * When `false`, overrides all tasks to disable caching, even tasks with `cache: true`
+   * or a `cache` object.
    * When `true`, respects each task's individual `cache` setting
    * (each task's `cache` defaults to `true` if omitted).
    *
@@ -155,15 +157,56 @@ type RunConfig = {
   enablePrePostScripts?: boolean;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.4.0/node_modules/lint-staged/lib/index.d.ts
-type SyncGenerateTask = (stagedFileNames: readonly string[]) => string | string[];
-type AsyncGenerateTask = (stagedFileNames: readonly string[]) => Promise<string | string[]>;
+//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/config.d.ts
+/**
+ * A single task that will be spawned
+ *
+ * @example "eslint --fix"
+ */
+type SpawnedTask = string;
+type SyncGenerateTask = (files: readonly string[]) => string | string[];
+type AsyncGenerateTask = (files: readonly string[]) => Promise<string | string[]>;
+/**
+ * A function that returns one or more tasks that will be spawned and run sequentially, in order.
+ * The function receives list of the matched staged files as its argument. Can be sync or async.
+ *
+ * @example <caption>Return a command after manipulating list of staged files</caption>
+ * (files: string) => `eslint --fix ${files.map((f) => `'${f}'`).join(' ')}`
+ *
+ * @example <caption>Ignore staged files and run "tsc" and "vitest" without any arguments</caption>
+ * () => ['tsc', 'vitest']
+ */
 type GenerateTask = SyncGenerateTask | AsyncGenerateTask;
+/**
+ * List of tasks that will be run in parallel
+ *
+ * @example ["prettier --write", "eslint --fix"]
+ */
+type ParallelTasks = (SpawnedTask | GenerateTask)[];
+/**
+ * List of tasks that will be run sequentially, in order
+ *
+ * @example ["prettier --write", "eslint --fix"]
+ */
+type SequentialTasks = (SpawnedTask | GenerateTask | ParallelTasks)[];
+/**
+ * A single Node.js/JavaScript task that defines its title and the function which will be
+ * run with the list of the matched staged files as its argument.
+ *
+ * @example
+ * {
+ *   title: 'Log staged files',
+ *   task: (files: readonly string[]) => {
+ *     console.log('Staged files:', files)
+ *   }
+ * }
+ */
 type TaskFunction = {
   title: string;
-  task: (stagedFileNames: readonly string[]) => void | Promise<void>;
+  task: (filepaths: readonly string[]) => void | Promise<void>;
 };
-type Configuration = Record<string, string | TaskFunction | GenerateTask | (string | GenerateTask)[]> | GenerateTask;
+/** An entire `lint-staged` configuration, or a function that returns one */
+type Configuration = Record<string, SpawnedTask | TaskFunction | GenerateTask | SequentialTasks> | GenerateTask;
 //#endregion
 //#region src/staged-config.d.ts
 type StagedConfig = Configuration;
@@ -246,6 +289,7 @@ type ViteUserConfigFnObject = (env: ConfigEnv) => UserConfig;
 type ViteUserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
 type ViteUserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
 type ViteUserConfigExport = UserConfig | Promise<UserConfig> | ViteUserConfigFnObject | ViteUserConfigFnPromise | ViteUserConfigFn;
+type DefinedViteUserConfig<T extends ViteUserConfigExport> = T extends ViteUserConfigFnPromise ? ViteUserConfigFnPromise : T extends ViteUserConfigFnObject ? ViteUserConfigFnObject : T extends ViteUserConfigFn ? ViteUserConfigFn : T extends Promise<UserConfig> ? Promise<UserConfig> : UserConfig;
 /**
  * Match the `vitest` / `@vitest/*` family of bare specifiers — the imports a
  * browser-mode Vite dev server must resolve. Any query string is stripped
@@ -266,10 +310,9 @@ declare function isVitestFamilySpecifier(id: string): boolean;
  * Absent packages are silently skipped so the server-deps optimizer never
  * tries to resolve a name that does not exist in the project's node_modules.
  *
- * The check is deferred to a `configResolved` plugin hook so that
- * `resolvedConfig.root` points at the actual project root (the value vite has
- * already normalised), rather than relying on `process.cwd()` at config-load
- * time (which can differ in workspace / monorepo setups).
+ * The environment hook adds installed packages to the module-runner options
+ * inherited by shared-server projects. The resolved-config hook also handles
+ * independent project servers, using each project's resolved root.
  *
  * Exported for unit testing.
  */
@@ -284,10 +327,11 @@ declare const AUTO_INLINE_DEPS: ReadonlyArray<string>;
  *
  * Exported for unit testing. The `_createRequire` parameter lets tests inject
  * a controlled resolver without needing to spy on Node's ESM module namespace.
+ * Callers may share installation results for the same root within one config load.
  */
 declare function computeAutoInlineList(existingInline: (string | RegExp)[] | true | undefined, projectRoot: string, _createRequire?: (from: string) => {
   resolve: (id: string) => string;
-}): (string | RegExp)[] | null;
+}, installedPackages?: Map<string, boolean>): (string | RegExp)[] | null;
 /**
  * Resolve the coverage provider package name that should be version-checked, or
  * `null` when no check applies (coverage off, or a `custom`/unknown provider
@@ -333,11 +377,13 @@ declare function checkCoverageProviderVersion(coverage: {
   };
   readFile?: (path: string) => string;
 }): void;
-declare function defineConfig$1(config: UserConfig): UserConfig;
-declare function defineConfig$1(config: Promise<UserConfig>): Promise<UserConfig>;
-declare function defineConfig$1(config: ViteUserConfigFnObject): ViteUserConfigFnObject;
-declare function defineConfig$1(config: ViteUserConfigFnPromise): ViteUserConfigFnPromise;
-declare function defineConfig$1(config: ViteUserConfigExport): ViteUserConfigExport;
+/**
+ * Keep a single generic signature so callback returns receive one contextual
+ * config type. Separate sync and async overloads make TypeScript widen nested
+ * literals in async callbacks before overload resolution (for example, an
+ * Oxlint rule severity of `'warn'` becomes `string`).
+ */
+declare function defineConfig$1<T extends ViteUserConfigExport>(config: T): DefinedViteUserConfig<T>;
 /**
  * `defineProject` counterpart of [[defineConfig]]. A migrated project config
  * that uses `defineProject({ test: { browser: ... } })` — e.g. a file named by

package/dist/define-config.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_define_config = require("./define-config-D0mevyb3.cjs");
+const require_define_config = require("./define-config-CAeeMTvb.cjs");
 require_define_config.init_define_config();
 exports.AUTO_INLINE_DEPS = require_define_config.AUTO_INLINE_DEPS;
 exports.assertCoverageProviderVersionMatch = require_define_config.assertCoverageProviderVersionMatch;

package/dist/define-config.d.ts

@@ -1,2 +1,2 @@
-import { a as defineConfig, c as lazyPlugins, i as computeAutoInlineList, l as resolveCoverageProviderToCheck, n as assertCoverageProviderVersionMatch, o as defineProject, r as checkCoverageProviderVersion, s as isVitestFamilySpecifier, t as AUTO_INLINE_DEPS, u as withConfigMetadataResolution } from "./define-config-DPNEJxPz.js";
+import { a as defineConfig, c as lazyPlugins, i as computeAutoInlineList, l as resolveCoverageProviderToCheck, n as assertCoverageProviderVersionMatch, o as defineProject, r as checkCoverageProviderVersion, s as isVitestFamilySpecifier, t as AUTO_INLINE_DEPS, u as withConfigMetadataResolution } from "./define-config-Cf_5GHmY.js";
 export { AUTO_INLINE_DEPS, assertCoverageProviderVersionMatch, checkCoverageProviderVersion, computeAutoInlineList, defineConfig, defineProject, isVitestFamilySpecifier, lazyPlugins, resolveCoverageProviderToCheck, withConfigMetadataResolution };

package/dist/define-config.js

@@ -1,2 +1,2 @@
-import { a as defineConfig, c as lazyPlugins, i as computeAutoInlineList, l as resolveCoverageProviderToCheck, n as assertCoverageProviderVersionMatch, o as defineProject, r as checkCoverageProviderVersion, s as isVitestFamilySpecifier, t as AUTO_INLINE_DEPS, u as withConfigMetadataResolution } from "./define-config-IgzmnvvV.js";
+import { a as defineConfig, c as lazyPlugins, i as computeAutoInlineList, l as resolveCoverageProviderToCheck, n as assertCoverageProviderVersionMatch, o as defineProject, r as checkCoverageProviderVersion, s as isVitestFamilySpecifier, t as AUTO_INLINE_DEPS, u as withConfigMetadataResolution } from "./define-config-Bz6dc3fm.js";
 export { AUTO_INLINE_DEPS, assertCoverageProviderVersionMatch, checkCoverageProviderVersion, computeAutoInlineList, defineConfig, defineProject, isVitestFamilySpecifier, lazyPlugins, resolveCoverageProviderToCheck, withConfigMetadataResolution };