vitest 4.0.7 → 4.0.8

package/dist/chunks/{index.jMQYiEWE.js → index.op2Re5rn.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.CVpyv-Zg.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.kotH7DY7.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils/helpers';
 
@@ -98,16 +98,19 @@ function renderBenchmark(result, widths) {
 	].join("  ");
 }
 function renderTable(options) {
-	const output = [], benchMap = {};
+	const output = [];
+	const benchMap = {};
 	for (const task of options.tasks) if (task.meta.benchmark && task.result?.benchmark) benchMap[task.id] = {
 		current: task.result.benchmark,
 		baseline: options.compare?.[task.id]
 	};
-	const benchCount = Object.entries(benchMap).length, columnWidths = computeColumnWidths(Object.values(benchMap).flatMap((v) => [v.current, v.baseline]).filter(notNullish));
+	const benchCount = Object.entries(benchMap).length;
+	const columnWidths = computeColumnWidths(Object.values(benchMap).flatMap((v) => [v.current, v.baseline]).filter(notNullish));
 	let idx = 0;
 	const padding = "  ".repeat(1 );
 	for (const task of options.tasks) {
-		const duration = task.result?.duration, bench = benchMap[task.id];
+		const duration = task.result?.duration;
+		const bench = benchMap[task.id];
 		let prefix = "";
 		if (idx === 0 && task.meta?.benchmark) prefix += `${renderTableHead(columnWidths)}\n${padding}`;
 		prefix += ` ${getStateSymbol(task)} `;
@@ -123,7 +126,8 @@ function renderTable(options) {
 			let body = renderBenchmark(bench.current, columnWidths);
 			if (options.compare && bench.baseline) {
 				if (bench.current.hz) {
-					const diff = bench.current.hz / bench.baseline.hz, diffFixed = diff.toFixed(2);
+					const diff = bench.current.hz / bench.baseline.hz;
+					const diffFixed = diff.toFixed(2);
 					if (diffFixed === "1.0.0") body += c.gray(`  [${diffFixed}x]`);
 					if (diff > 1) body += c.blue(`  [${diffFixed}x] ⇑`);
 					else body += c.red(`  [${diffFixed}x] ⇓`);
@@ -140,7 +144,8 @@ function renderTable(options) {
 		if (task.result?.state !== "pass" && outputMap.get(task) != null) {
 			let data = outputMap.get(task);
 			if (typeof data === "string") {
-				if (data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop()), data === "") data = void 0;
+				data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop());
+				if (data === "") data = void 0;
 			}
 			if (data != null) {
 				const out = `   ${"  ".repeat(options.level)}${F_RIGHT} ${data}`;
@@ -155,7 +160,8 @@ function renderTable(options) {
 class BenchmarkReporter extends DefaultReporter {
 	compare;
 	async onInit(ctx) {
-		if (super.onInit(ctx), this.ctx.config.benchmark?.compare) {
+		super.onInit(ctx);
+		if (this.ctx.config.benchmark?.compare) {
 			const compareFile = pathe.resolve(this.ctx.config.root, this.ctx.config.benchmark?.compare);
 			try {
 				this.compare = flattenFormattedBenchmarkReport(JSON.parse(await fs.promises.readFile(compareFile, "utf-8")));
@@ -173,7 +179,8 @@ class BenchmarkReporter extends DefaultReporter {
 		}
 	}
 	onTestSuiteResult(testSuite) {
-		super.onTestSuiteResult(testSuite), this.printSuiteTable(testSuite);
+		super.onTestSuiteResult(testSuite);
+		this.printSuiteTable(testSuite);
 	}
 	printTestModule(testModule) {
 		this.printSuiteTable(testModule);
@@ -181,11 +188,13 @@ class BenchmarkReporter extends DefaultReporter {
 	printSuiteTable(testTask) {
 		const state = testTask.state();
 		if (state === "pending" || state === "queued") return;
-		const benches = testTask.task.tasks.filter((t) => t.meta.benchmark), duration = testTask.task.result?.duration || 0;
+		const benches = testTask.task.tasks.filter((t) => t.meta.benchmark);
+		const duration = testTask.task.result?.duration || 0;
 		if (benches.length > 0 && benches.every((t) => t.result?.state !== "run" && t.result?.state !== "queued")) {
 			let title = `\n ${getStateSymbol(testTask.task)} ${formatProjectName(testTask.project)}${getFullName(testTask.task, separator)}`;
 			if (duration != null && duration > this.ctx.config.slowTestThreshold) title += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
-			this.log(title), this.log(renderTable({
+			this.log(title);
+			this.log(renderTable({
 				tasks: benches,
 				level: 1,
 				columns: this.ctx.logger.getColumns(),
@@ -203,8 +212,9 @@ class BenchmarkReporter extends DefaultReporter {
 			outputFile = pathe.resolve(this.ctx.config.root, outputFile);
 			const outputDirectory = pathe.dirname(outputFile);
 			if (!fs.existsSync(outputDirectory)) await fs.promises.mkdir(outputDirectory, { recursive: true });
-			const files = testModules.map((t) => t.task.file), output = createBenchmarkJsonReport(files);
-			await fs.promises.writeFile(outputFile, JSON.stringify(output, null, 2)), this.log(`Benchmark report written to ${outputFile}`);
+			const output = createBenchmarkJsonReport(testModules.map((t) => t.task.file));
+			await fs.promises.writeFile(outputFile, JSON.stringify(output, null, 2));
+			this.log(`Benchmark report written to ${outputFile}`);
 		}
 	}
 }

package/dist/chunks/{init-forks.IU-xQ2_X.js → init-forks.2hx7cf78.js}

@@ -1,9 +1,13 @@
 import v8 from 'node:v8';
-import { i as init } from './init.fmH9J833.js';
+import { i as init } from './init.DMDG-idf.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them
-const processExit = process.exit.bind(process), processSend = process.send.bind(process), processOn = process.on.bind(process), processOff = process.off.bind(process), processRemoveAllListeners = process.removeAllListeners.bind(process);
+const processExit = process.exit.bind(process);
+const processSend = process.send.bind(process);
+const processOn = process.on.bind(process);
+const processOff = process.off.bind(process);
+const processRemoveAllListeners = process.removeAllListeners.bind(process);
 // Work-around for nodejs/node#55094
 if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"))) processOn("SIGTERM", () => processExit());
 function workerInit(options) {
@@ -37,7 +41,8 @@ function unwrapSerializableConfig(config) {
 		if (testNamePattern.startsWith("$$vitest:")) config.testNamePattern = parseRegexp(testNamePattern.slice(9));
 	}
 	if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
-		const { keys, original } = config.defines, defines = {};
+		const { keys, original } = config.defines;
+		const defines = {};
 		// Apply all keys from the original. Entries which had undefined value are missing from original now
 		for (const key of keys) defines[key] = original[key];
 		config.defines = defines;
@@ -48,8 +53,13 @@ function parseRegexp(input) {
 	// Parse input
 	// eslint-disable-next-line regexp/no-misleading-capturing-group
 	const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
+	// match nothing
+	if (!m) return /$^/;
+	// Invalid flags
+	// eslint-disable-next-line regexp/optimal-quantifier-concatenation
+	if (m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3])) return new RegExp(input);
 	// Create the regular expression
-	return m ? m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3]) ? new RegExp(input) : new RegExp(m[2], m[3]) : /$^/;
+	return new RegExp(m[2], m[3]);
 }
 
 export { workerInit as w };

package/dist/chunks/{init-threads.C_NWvZkU.js → init-threads.Cm4OCIWA.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.fmH9J833.js';
+import { i as init } from './init.DMDG-idf.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {

package/dist/chunks/{init.fmH9J833.js → init.DMDG-idf.js}

@@ -3,18 +3,19 @@ import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
 import { ModuleRunner } from 'vite/module-runner';
-import { b as VitestTransport } from './startModuleRunner.Cn7hCL7D.js';
-import { e as environments } from './index.CWIFvlX5.js';
+import { b as VitestTransport } from './startModuleRunner.BOmUtLIO.js';
+import { e as environments } from './index.DfKyPFVi.js';
 import { serializeError } from '@vitest/utils/error';
-import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.D38ahn14.js';
+import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BUV7uWKJ.js';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
-import { s as setupInspect } from './inspector.DLZxSeU3.js';
+import { s as setupInspect } from './inspector.CvyFGlXm.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 
 function isBuiltinEnvironment(env) {
 	return env in environments;
 }
-const isWindows = process.platform === "win32", _loaders = /* @__PURE__ */ new Map();
+const isWindows = process.platform === "win32";
+const _loaders = /* @__PURE__ */ new Map();
 async function createEnvironmentLoader(root, rpc) {
 	const cachedLoader = _loaders.get(root);
 	if (!cachedLoader || cachedLoader.isClosed()) {
@@ -40,28 +41,37 @@ async function createEnvironmentLoader(root, rpc) {
 				}
 			})
 		});
-		_loaders.set(root, moduleRunner), await moduleRunner.import("/@vite/env");
+		_loaders.set(root, moduleRunner);
+		await moduleRunner.import("/@vite/env");
 	}
 	return _loaders.get(root);
 }
 async function loadEnvironment(name, root, rpc) {
 	if (isBuiltinEnvironment(name)) return { environment: environments[name] };
-	const loader = await createEnvironmentLoader(root, rpc), packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__"))?.id ?? resolve(root, name), pkg = await loader.import(packageId);
+	const loader = await createEnvironmentLoader(root, rpc);
+	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__"))?.id ?? resolve(root, name);
+	const pkg = await loader.import(packageId);
 	if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
 	const environment = pkg.default;
 	if (environment.transformMode != null && environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web", received "${environment.transformMode}".`);
-	if (environment.transformMode)
- // keep for backwards compat
-	console.warn(`The Vitest environment ${environment.name} defines the "transformMode". This options was deprecated in Vitest 4 and will be removed in the next major version. Please, use "viteEnvironment" instead.`), environment.viteEnvironment ??= environment.transformMode === "ssr" ? "ssr" : "client";
+	if (environment.transformMode) {
+		console.warn(`The Vitest environment ${environment.name} defines the "transformMode". This options was deprecated in Vitest 4 and will be removed in the next major version. Please, use "viteEnvironment" instead.`);
+		// keep for backwards compat
+		environment.viteEnvironment ??= environment.transformMode === "ssr" ? "ssr" : "client";
+	}
 	return {
 		environment,
 		loader
 	};
 }
 
-const resolvingModules = /* @__PURE__ */ new Set(), globalListeners = /* @__PURE__ */ new Set();
+const resolvingModules = /* @__PURE__ */ new Set();
+const globalListeners = /* @__PURE__ */ new Set();
 async function execute(method, ctx, worker) {
-	const prepareStart = performance.now(), cleanups = [setupInspect(ctx)], rpc = ctx.rpc;
+	const prepareStart = performance.now();
+	const cleanups = [setupInspect(ctx)];
+	// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
+	const rpc = ctx.rpc;
 	try {
 		// do not close the RPC channel so that we can get the error messages sent to the main thread
 		cleanups.push(async () => {
@@ -88,11 +98,13 @@ async function execute(method, ctx, worker) {
 				return createStackString(parseStacktrace(stack));
 			},
 			metaEnv: createImportMetaEnvProxy()
-		}, methodName = method === "collect" ? "collectTests" : "runTests";
+		};
+		const methodName = method === "collect" ? "collectTests" : "runTests";
 		if (!worker[methodName] || typeof worker[methodName] !== "function") throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
 		await worker[methodName](state);
 	} finally {
-		await rpcDone().catch(() => {}), await Promise.all(cleanups.map((fn) => fn())).catch(() => {});
+		await rpcDone().catch(() => {});
+		await Promise.all(cleanups.map((fn) => fn())).catch(() => {});
 	}
 }
 function run(ctx, worker) {
@@ -114,7 +126,9 @@ function createImportMetaEnvProxy() {
 	];
 	return new Proxy(env, {
 		get(_, key) {
-			if (typeof key === "string") return booleanKeys.includes(key) ? !!process.env[key] : process.env[key];
+			if (typeof key !== "string") return;
+			if (booleanKeys.includes(key)) return !!process.env[key];
+			return process.env[key];
 		},
 		set(_, key, value) {
 			if (typeof key !== "string") return true;
@@ -125,30 +139,36 @@ function createImportMetaEnvProxy() {
 	});
 }
 
-const __vitest_worker_response__ = true, memoryUsage = process.memoryUsage.bind(process);
+const __vitest_worker_response__ = true;
+const memoryUsage = process.memoryUsage.bind(process);
 let reportMemory = false;
 /** @experimental */
 function init(worker) {
 	worker.on(onMessage);
-	let runPromise, isRunning = false, workerTeardown, setupContext;
+	let runPromise;
+	let isRunning = false;
+	let workerTeardown;
+	let setupContext;
 	function send(response) {
 		worker.post(worker.serialize ? worker.serialize(response) : response);
 	}
 	async function onMessage(rawMessage) {
 		const message = worker.deserialize ? worker.deserialize(rawMessage) : rawMessage;
-		if (message?.__vitest_worker_request__ === true) switch (message.type) {
+		if (message?.__vitest_worker_request__ !== true) return;
+		switch (message.type) {
 			case "start": {
 				reportMemory = message.options.reportMemory;
 				const { environment, config, pool } = message.context;
 				try {
-					const rpc = createRuntimeRpc(worker);
 					setupContext = {
 						environment,
 						config,
 						pool,
-						rpc,
+						rpc: createRuntimeRpc(worker),
 						projectName: config.name || ""
-					}, workerTeardown = await worker.setup?.(setupContext), send({
+					};
+					workerTeardown = await worker.setup?.(setupContext);
+					send({
 						type: "started",
 						__vitest_worker_response__
 					});
@@ -172,7 +192,8 @@ function init(worker) {
 					return;
 				}
 				try {
-					process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
+					process.env.VITEST_POOL_ID = String(message.poolId);
+					process.env.VITEST_WORKER_ID = String(message.context.workerId);
 				} catch (error) {
 					return send({
 						type: "testfileFinished",
@@ -187,15 +208,15 @@ function init(worker) {
 						...setupContext,
 						...message.context
 					}, worker).catch((error) => serializeError(error));
-					const error = await runPromise;
 					send({
 						type: "testfileFinished",
 						__vitest_worker_response__,
-						error,
+						error: await runPromise,
 						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
 					});
 				} finally {
-					runPromise = void 0, isRunning = false;
+					runPromise = void 0;
+					isRunning = false;
 				}
 				break;
 			case "collect":
@@ -209,7 +230,8 @@ function init(worker) {
 					return;
 				}
 				try {
-					process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
+					process.env.VITEST_POOL_ID = String(message.poolId);
+					process.env.VITEST_WORKER_ID = String(message.context.workerId);
 				} catch (error) {
 					return send({
 						type: "testfileFinished",
@@ -224,22 +246,23 @@ function init(worker) {
 						...setupContext,
 						...message.context
 					}, worker).catch((error) => serializeError(error));
-					const error = await runPromise;
 					send({
 						type: "testfileFinished",
 						__vitest_worker_response__,
-						error,
+						error: await runPromise,
 						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
 					});
 				} finally {
-					runPromise = void 0, isRunning = false;
+					runPromise = void 0;
+					isRunning = false;
 				}
 				break;
 			case "stop":
 				await runPromise;
 				try {
 					const error = await teardown().catch((error) => serializeError(error));
-					await workerTeardown?.(), send({
+					await workerTeardown?.();
+					send({
 						type: "stopped",
 						error,
 						__vitest_worker_response__

package/dist/chunks/{inspector.DLZxSeU3.js → inspector.CvyFGlXm.js}

@@ -2,33 +2,48 @@ import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 
 const __require = createRequire(import.meta.url);
-let inspector, session;
+let inspector;
+let session;
 /**
 * Enables debugging inside `worker_threads` and `child_process`.
 * Should be called as early as possible when worker/process has been set up.
 */
 function setupInspect(ctx) {
-	const config = ctx.config, isEnabled = config.inspector.enabled;
+	const config = ctx.config;
+	const isEnabled = config.inspector.enabled;
 	if (isEnabled) {
-		if (inspector = __require("node:inspector"), !(inspector.url() !== void 0)) {
-			if (inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger), config.inspectBrk) {
+		inspector = __require("node:inspector");
+		if (!(inspector.url() !== void 0)) {
+			inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger);
+			if (config.inspectBrk) {
 				const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
 				// Stop at first test file
-				if (firstTestFile) session = new inspector.Session(), session.connect(), session.post("Debugger.enable"), session.post("Debugger.setBreakpointByUrl", {
-					lineNumber: 0,
-					url: pathToFileURL(firstTestFile)
-				});
+				if (firstTestFile) {
+					session = new inspector.Session();
+					session.connect();
+					session.post("Debugger.enable");
+					session.post("Debugger.setBreakpointByUrl", {
+						lineNumber: 0,
+						url: pathToFileURL(firstTestFile)
+					});
+				}
 			}
 		}
 	}
 	const keepOpen = shouldKeepOpen(config);
 	return function cleanup() {
-		if (isEnabled && !keepOpen && inspector) inspector.close(), session?.disconnect();
+		if (isEnabled && !keepOpen && inspector) {
+			inspector.close();
+			session?.disconnect();
+		}
 	};
 }
 function closeInspector(config) {
 	const keepOpen = shouldKeepOpen(config);
-	if (inspector && !keepOpen) inspector.close(), session?.disconnect();
+	if (inspector && !keepOpen) {
+		inspector.close();
+		session?.disconnect();
+	}
 }
 function shouldKeepOpen(config) {
 	// In watch mode the inspector can persist re-runs if isolation is disabled and a single worker is used

package/dist/chunks/{moduleRunner.d.DEkTotCv.d.ts → moduleRunner.d.CzOZ_4wC.d.ts}

@@ -2,7 +2,7 @@ import * as _vitest_spy from '@vitest/spy';
 import vm from 'node:vm';
 import * as viteModuleRunner from 'vite/module-runner';
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, EvaluatedModules } from 'vite/module-runner';
-import { R as RuntimeRPC, e as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.D25zYZ7N.js';
+import { R as RuntimeRPC, e as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.DadbA89M.js';
 import { MockedModule, MockedModuleType } from '@vitest/mocker';
 import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './mocker.d.BE_2ls6u.js';
 

package/dist/chunks/{node.BwAWWjHZ.js → node.Ce0vMQM7.js}

@@ -1,5 +1,5 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.CG9h5ccR.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
 import '@vitest/utils/timers';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {

package/dist/chunks/{plugin.d.Cpes8Bt6.d.ts → plugin.d.D4RrtywJ.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.CSNcMDxF.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.Da1D1VbQ.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;

package/dist/chunks/{reporters.d.CSNcMDxF.d.ts → reporters.d.Da1D1VbQ.d.ts}

@@ -1,13 +1,13 @@
 import { TaskMeta, Suite, File, TestAnnotation, ImportDuration, Test, Task, TaskResultPack, FileSpecification, CancelReason, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
 import { TestError, SerializedError, Arrayable, ParsedStack, Awaitable } from '@vitest/utils';
-import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, d as ContextTestEnvironment, f as WorkerTestEnvironment, g as WorkerExecuteContext, L as LabelColor } from './worker.d.D25zYZ7N.js';
+import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, d as ContextTestEnvironment, f as WorkerTestEnvironment, g as WorkerExecuteContext, L as LabelColor } from './worker.d.DadbA89M.js';
 import { Writable } from 'node:stream';
 import { TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { BrowserCommands } from 'vitest/browser';
 import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.BTfZNUu9.js';
-import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.-LKfRopd.js';
+import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.DTTM2PTh.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -1535,7 +1535,7 @@ interface BrowserConfigOptions {
 	/**
 	* Commands that will be executed on the server
 	* via the browser `import("vitest/browser").commands` API.
-	* @see {@link https://vitest.dev/guide/browser/commands}
+	* @see {@link https://vitest.dev/api/browser/commands}
 	*/
 	commands?: Record<string, BrowserCommand<any>>;
 	/**
@@ -1696,7 +1696,7 @@ type ToMatchScreenshotResolvePath = (data: {
 	platform: NodeJS.Platform;
 	/**
 	* The value provided to
-	* {@linkcode https://vitest.dev/guide/browser/config#browser-screenshotdirectory|browser.screenshotDirectory},
+	* {@linkcode https://vitest.dev/config/browser/screenshotdirectory|browser.screenshotDirectory},
 	* if none is provided, its default value.
 	*/
 	screenshotDirectory: string;
@@ -2452,9 +2452,10 @@ interface InlineConfig {
 	*/
 	benchmark?: BenchmarkUserOptions;
 	/**
-	* Include globs for test files
+	* A list of [glob patterns](https://superchupu.dev/tinyglobby/comparison) that match your test files.
 	*
 	* @default ['**\/*.{test,spec}.?(c|m)[jt]s?(x)']
+	* @see {@link https://vitest.dev/config/include}
 	*/
 	include?: string[];
 	/**

package/dist/chunks/{rpc.D38ahn14.js → rpc.BUV7uWKJ.js}

@@ -1,17 +1,28 @@
 import { getSafeTimers } from '@vitest/utils/timers';
-import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { g as getWorkerState } from './utils.CG9h5ccR.js';
+import { c as createBirpc } from './index.DAL392Ss.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {
-	const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers(), currentSetTimeout = globalThis.setTimeout, currentClearTimeout = globalThis.clearTimeout, currentSetImmediate = globalThis.setImmediate, currentClearImmediate = globalThis.clearImmediate, currentNextTick = globalThis.process?.nextTick;
+	const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
+	const currentSetTimeout = globalThis.setTimeout;
+	const currentClearTimeout = globalThis.clearTimeout;
+	const currentSetImmediate = globalThis.setImmediate;
+	const currentClearImmediate = globalThis.clearImmediate;
+	const currentNextTick = globalThis.process?.nextTick;
 	try {
-		if (globalThis.setTimeout = setTimeout, globalThis.clearTimeout = clearTimeout, setImmediate) globalThis.setImmediate = setImmediate;
+		globalThis.setTimeout = setTimeout;
+		globalThis.clearTimeout = clearTimeout;
+		if (setImmediate) globalThis.setImmediate = setImmediate;
 		if (clearImmediate) globalThis.clearImmediate = clearImmediate;
 		if (globalThis.process && nextTick) globalThis.process.nextTick = nextTick;
 		return fn();
 	} finally {
-		if (globalThis.setTimeout = currentSetTimeout, globalThis.clearTimeout = currentClearTimeout, globalThis.setImmediate = currentSetImmediate, globalThis.clearImmediate = currentClearImmediate, globalThis.process && nextTick) nextTick(() => {
+		globalThis.setTimeout = currentSetTimeout;
+		globalThis.clearTimeout = currentClearTimeout;
+		globalThis.setImmediate = currentSetImmediate;
+		globalThis.clearImmediate = currentClearImmediate;
+		if (globalThis.process && nextTick) nextTick(() => {
 			globalThis.process.nextTick = currentNextTick;
 		});
 	}
@@ -43,7 +54,8 @@ function createSafeRpc(rpc) {
 	return new Proxy(rpc, { get(target, p, handler) {
 		// keep $rejectPendingCalls as sync function
 		if (p === "$rejectPendingCalls") return rpc.$rejectPendingCalls;
-		const sendCall = get(target, p, handler), safeSendCall = (...args) => withSafeTimers(async () => {
+		const sendCall = get(target, p, handler);
+		const safeSendCall = (...args) => withSafeTimers(async () => {
 			const result = sendCall(...args);
 			promises.add(result);
 			try {
@@ -52,7 +64,8 @@ function createSafeRpc(rpc) {
 				promises.delete(result);
 			}
 		});
-		return safeSendCall.asEvent = sendCall.asEvent, safeSendCall;
+		safeSendCall.asEvent = sendCall.asEvent;
+		return safeSendCall;
 	} });
 }
 function rpc() {

package/dist/chunks/{setup-common.DR1sucx6.js → setup-common.LGjNSzXp.js}

@@ -1,38 +1,50 @@
 import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 import { addSerializer } from '@vitest/snapshot';
 import { setSafeTimers } from '@vitest/utils/timers';
-import { g as getWorkerState } from './utils.CG9h5ccR.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
 
 async function startCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
-	return coverageModule ? coverageModule.startCoverage?.(runtimeOptions) : null;
+	if (coverageModule) return coverageModule.startCoverage?.(runtimeOptions);
+	return null;
 }
 async function takeCoverageInsideWorker(options, loader) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
-	return coverageModule ? coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo }) : null;
+	if (coverageModule) return coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo });
+	return null;
 }
 async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
-	return coverageModule ? coverageModule.stopCoverage?.(runtimeOptions) : null;
+	if (coverageModule) return coverageModule.stopCoverage?.(runtimeOptions);
+	return null;
 }
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
-	if (setupDefines(config), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.BGT_RUsD.js')).registerApiGlobally();
+	setupDefines(config);
+	setupEnv(config.env);
+	if (globalSetup) return;
+	globalSetup = true;
+	setSafeTimers();
+	if (config.globals) (await import('./globals.DOh96BiR.js')).registerApiGlobally();
 }
 function setupDefines(config) {
 	for (const key in config.defines) globalThis[key] = config.defines[key];
 }
 function setupEnv(env) {
-	const state = getWorkerState(), { PROD, DEV,...restEnvs } = env;
-	for (const key in state.metaEnv.PROD = PROD, state.metaEnv.DEV = DEV, restEnvs) state.metaEnv[key] = env[key];
+	const state = getWorkerState();
+	// same boolean-to-string assignment as VitestPlugin.configResolved
+	const { PROD, DEV,...restEnvs } = env;
+	state.metaEnv.PROD = PROD;
+	state.metaEnv.DEV = DEV;
+	for (const key in restEnvs) state.metaEnv[key] = env[key];
 }
 async function loadDiffConfig(config, moduleRunner) {
 	if (typeof config.diff === "object") return config.diff;
 	if (typeof config.diff !== "string") return;
 	const diffModule = await moduleRunner.import(config.diff);
 	if (diffModule && typeof diffModule.default === "object" && diffModule.default != null) return diffModule.default;
-	throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
+	else throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
 }
 async function loadSnapshotSerializers(config, moduleRunner) {
 	const files = config.snapshotSerializers;