vitest 4.0.6 → 4.0.8

package/dist/chunks/{index.CpdwpN7L.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.BL8Hg4Uk.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.CSGFj9zN.js → init-forks.2hx7cf78.js}

@@ -1,9 +1,13 @@
 import v8 from 'node:v8';
-import { i as init } from './init.DUeOfNO9.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) {
@@ -16,7 +20,8 @@ function workerInit(options) {
 		serialize: v8.serialize,
 		deserialize: (v) => v8.deserialize(Buffer.from(v)),
 		runTests: (state) => executeTests("run", state),
-		collectTests: (state) => executeTests("collect", state)
+		collectTests: (state) => executeTests("collect", state),
+		setup: options.setup
 	});
 	async function executeTests(method, state) {
 		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
@@ -36,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;
@@ -47,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.CIJLeFO8.js → init-threads.Cm4OCIWA.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.DUeOfNO9.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) {
@@ -10,7 +10,8 @@ function workerInit(options) {
 		off: (callback) => parentPort.off("message", callback),
 		teardown: () => parentPort.removeAllListeners("message"),
 		runTests: async (state) => runTests("run", state),
-		collectTests: async (state) => runTests("collect", state)
+		collectTests: async (state) => runTests("collect", state),
+		setup: options.setup
 	});
 }
 

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

@@ -1,20 +1,21 @@
-import { serializeError } from '@vitest/utils/error';
-import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { readFileSync } from 'node:fs';
 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.Di-EZqh0.js';
-import { e as environments } from './index.DV0mQLEO.js';
-import { s as setupInspect } from './inspector.DLZxSeU3.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.BUV7uWKJ.js';
+import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
+import { s as setupInspect } from './inspector.CvyFGlXm.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
-import { c as createRuntimeRpc, a as rpcDone } from './rpc.Dv1Jt3i2.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,32 +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(ctx, rpc) {
-	const name = ctx.environment.name;
+async function loadEnvironment(name, root, rpc) {
 	if (isBuiltinEnvironment(name)) return { environment: environments[name] };
-	const root = ctx.config.root, 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)];
-	let environmentLoader;
+	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, onCancel } = createRuntimeRpc(worker);
+	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 () => {
@@ -73,32 +79,32 @@ async function execute(method, ctx, worker) {
 				reject(/* @__PURE__ */ new Error(`[vitest-worker]: Closing rpc while "${method}" was pending`));
 			}));
 		});
-		const beforeEnvironmentTime = performance.now(), { environment, loader } = await loadEnvironment(ctx, rpc);
-		environmentLoader = loader;
 		const state = {
 			ctx,
 			evaluatedModules: new VitestEvaluatedModules(),
 			resolvingModules,
 			moduleExecutionInfo: /* @__PURE__ */ new Map(),
 			config: ctx.config,
-			onCancel,
-			environment,
+			environment: null,
 			durations: {
-				environment: beforeEnvironmentTime,
+				environment: 0,
 				prepare: prepareStart
 			},
 			rpc,
+			onCancel,
 			onCleanup: (listener) => globalListeners.add(listener),
 			providedContext: ctx.providedContext,
 			onFilterStackTrace(stack) {
 				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 environmentLoader?.close();
+		await rpcDone().catch(() => {});
+		await Promise.all(cleanups.map((fn) => fn())).catch(() => {});
 	}
 }
 function run(ctx, worker) {
@@ -110,6 +116,7 @@ function collect(ctx, worker) {
 async function teardown() {
 	await Promise.all([...globalListeners].map((l) => l()));
 }
+const env = process.env;
 function createImportMetaEnvProxy() {
 	// packages/vitest/src/node/plugins/index.ts:146
 	const booleanKeys = [
@@ -117,9 +124,11 @@ function createImportMetaEnvProxy() {
 		"PROD",
 		"SSR"
 	];
-	return new Proxy(process.env, {
+	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;
@@ -130,24 +139,48 @@ 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;
+	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) {
-			case "start":
-				reportMemory = message.options.reportMemory, send({
-					type: "started",
-					__vitest_worker_response__
-				});
+		if (message?.__vitest_worker_request__ !== true) return;
+		switch (message.type) {
+			case "start": {
+				reportMemory = message.options.reportMemory;
+				const { environment, config, pool } = message.context;
+				try {
+					setupContext = {
+						environment,
+						config,
+						pool,
+						rpc: createRuntimeRpc(worker),
+						projectName: config.name || ""
+					};
+					workerTeardown = await worker.setup?.(setupContext);
+					send({
+						type: "started",
+						__vitest_worker_response__
+					});
+				} catch (error) {
+					send({
+						type: "started",
+						__vitest_worker_response__,
+						error: serializeError(error)
+					});
+				}
 				break;
+			}
 			case "run":
 				// Prevent concurrent execution if worker is already running
 				if (isRunning) {
@@ -158,18 +191,32 @@ function init(worker) {
 					});
 					return;
 				}
-				isRunning = true, process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
 				try {
-					runPromise = run(message.context, worker).catch((error) => serializeError(error));
-					const error = await runPromise;
+					process.env.VITEST_POOL_ID = String(message.poolId);
+					process.env.VITEST_WORKER_ID = String(message.context.workerId);
+				} catch (error) {
+					return send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error: serializeError(error),
+						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+					});
+				}
+				isRunning = true;
+				try {
+					runPromise = run({
+						...setupContext,
+						...message.context
+					}, worker).catch((error) => serializeError(error));
 					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":
@@ -182,32 +229,55 @@ function init(worker) {
 					});
 					return;
 				}
-				isRunning = true, process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
 				try {
-					runPromise = collect(message.context, worker).catch((error) => serializeError(error));
-					const error = await runPromise;
+					process.env.VITEST_POOL_ID = String(message.poolId);
+					process.env.VITEST_WORKER_ID = String(message.context.workerId);
+				} catch (error) {
+					return send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error: serializeError(error),
+						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+					});
+				}
+				isRunning = true;
+				try {
+					runPromise = collect({
+						...setupContext,
+						...message.context
+					}, worker).catch((error) => serializeError(error));
 					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": {
+			case "stop":
 				await runPromise;
-				const error = await teardown().catch((error) => serializeError(error));
-				send({
-					type: "stopped",
-					error,
-					__vitest_worker_response__
-				}), worker.teardown?.();
+				try {
+					const error = await teardown().catch((error) => serializeError(error));
+					await workerTeardown?.();
+					send({
+						type: "stopped",
+						error,
+						__vitest_worker_response__
+					});
+				} catch (error) {
+					send({
+						type: "stopped",
+						error: serializeError(error),
+						__vitest_worker_response__
+					});
+				}
+				worker.teardown?.();
 				break;
-			}
 		}
 	}
 }
 
-export { init as i };
+export { init as i, loadEnvironment as l };

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.TP-w6tIQ.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, d as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.B4Hthdvt.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.lctzD3Wk.d.ts → plugin.d.D4RrtywJ.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.PEs0tXod.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.PEs0tXod.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, C as ContextRPC, L as LabelColor } from './worker.d.B4Hthdvt.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.ScGeWTou.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';
@@ -1445,6 +1445,7 @@ interface BrowserConfigOptions {
 	* Isolate test environment after each test
 	*
 	* @default true
+	* @deprecated use top-level `isolate` instead
 	*/
 	isolate?: boolean;
 	/**
@@ -1452,6 +1453,7 @@ interface BrowserConfigOptions {
 	* This option only has effect in headless mode (enabled in CI by default)
 	*
 	* @default // Same as "test.fileParallelism"
+	* @deprecated use top-level `fileParallelism` instead
 	*/
 	fileParallelism?: boolean;
 	/**
@@ -1533,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>>;
 	/**
@@ -1694,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;
@@ -1866,7 +1868,7 @@ interface PoolOptions {
 	project: TestProject;
 	method: "run" | "collect";
 	cacheFs?: boolean;
-	environment: string;
+	environment: ContextTestEnvironment;
 	execArgv: string[];
 	env: Partial<NodeJS.ProcessEnv>;
 }
@@ -1901,7 +1903,8 @@ interface PoolTask {
 	* so modifying it once will modify it for every task.
 	*/
 	execArgv: string[];
-	context: ContextRPC;
+	context: WorkerExecuteContext;
+	environment: ContextTestEnvironment;
 	memoryLimit: number | null;
 }
 type WorkerRequest = {
@@ -1911,15 +1914,20 @@ type WorkerRequest = {
 	options: {
 		reportMemory: boolean;
 	};
+	context: {
+		environment: WorkerTestEnvironment;
+		config: SerializedConfig;
+		pool: string;
+	};
 } | {
 	type: "stop";
 } | {
 	type: "run";
-	context: ContextRPC;
+	context: WorkerExecuteContext;
 	poolId: number;
 } | {
 	type: "collect";
-	context: ContextRPC;
+	context: WorkerExecuteContext;
 	poolId: number;
 } | {
 	type: "cancel";
@@ -1928,6 +1936,7 @@ type WorkerResponse = {
 	__vitest_worker_response__: true;
 } & ({
 	type: "started";
+	error?: unknown;
 } | {
 	type: "stopped";
 	error?: unknown;
@@ -2443,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[];
 	/**