vitest 3.2.0-beta.2 → 3.2.0

package/dist/runners.d.ts

@@ -1,7 +1,7 @@
 import * as tinybench from 'tinybench';
-import { VitestRunner, VitestRunnerImportSource, Suite, File, Task, CancelReason, TestContext } from '@vitest/runner';
+import { VitestRunner, VitestRunnerImportSource, Suite, File, Task, CancelReason, Test, TestContext, ImportDuration } from '@vitest/runner';
 export { VitestRunner } from '@vitest/runner';
-import { a as SerializedConfig } from './chunks/config.d.UqE-KR0o.js';
+import { a as SerializedConfig } from './chunks/config.d.D2ROskhv.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
@@ -28,7 +28,9 @@ declare class VitestTestRunner implements VitestRunner {
 	constructor(config: SerializedConfig);
 	importFile(filepath: string, source: VitestRunnerImportSource): unknown;
 	onCollectStart(file: File): void;
+	onCleanupWorkerContext(listener: () => unknown): void;
 	onAfterRunFiles(): void;
+	getWorkerContext(): Record<string, unknown>;
 	onAfterRunSuite(suite: Suite): Promise<void>;
 	onAfterRunTask(test: Task): void;
 	cancel(_reason: CancelReason): void;
@@ -36,8 +38,9 @@ declare class VitestTestRunner implements VitestRunner {
 	onBeforeRunTask(test: Task): Promise<void>;
 	onBeforeRunSuite(suite: Suite): Promise<void>;
 	onBeforeTryTask(test: Task): void;
-	onAfterTryTask(test: Task): void;
+	onAfterTryTask(test: Test): void;
 	extendTaskContext(context: TestContext): TestContext;
+	getImportDurations(): Record<string, ImportDuration>;
 }
 
 export { NodeBenchmarkRunner, VitestTestRunner };

package/dist/runners.js

@@ -1,18 +1,19 @@
 import { updateTask } from '@vitest/runner';
 import { createDefer, getSafeTimers } from '@vitest/utils';
-import { a as getBenchOptions, g as getBenchFn } from './chunks/benchmark.BoF7jW0Q.js';
-import { g as getWorkerState } from './chunks/utils.CgTj3MsC.js';
+import { a as getBenchOptions, g as getBenchFn } from './chunks/benchmark.CYdenmiT.js';
+import { g as getWorkerState } from './chunks/utils.XdZDrNZV.js';
 import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
 import { getTests, getNames, getTestName } from '@vitest/runner/utils';
-import { g as getSnapshotClient, i as inject, c as createExpect, v as vi } from './chunks/vi.BFR5YIgu.js';
-import { r as rpc } from './chunks/rpc.D9_013TY.js';
+import { normalize } from 'pathe';
+import { g as getSnapshotClient, i as inject, c as createExpect, v as vi } from './chunks/vi.bdSIJ99Y.js';
+import { r as rpc } from './chunks/rpc.Iovn4oWe.js';
 import 'chai';
 import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
-import './chunks/date.CDOsz-HY.js';
+import './chunks/date.Bq6ZW5rf.js';
 import './chunks/index.CJ0plNrh.js';
 
 function createBenchmarkResult(name) {
@@ -23,25 +24,19 @@ function createBenchmarkResult(name) {
 		samples: []
 	};
 }
-const benchmarkTasks = new WeakMap();
+const benchmarkTasks = /* @__PURE__ */ new WeakMap();
 async function runBenchmarkSuite(suite, runner) {
 	const { Task, Bench } = await runner.importTinybench();
 	const start = performance.now();
 	const benchmarkGroup = [];
 	const benchmarkSuiteGroup = [];
 	for (const task of suite.tasks) {
-		if (task.mode !== "run" && task.mode !== "queued") {
-			continue;
-		}
-		if (task.meta?.benchmark) {
-			benchmarkGroup.push(task);
-		} else if (task.type === "suite") {
-			benchmarkSuiteGroup.push(task);
-		}
-	}
-	for (const subSuite of benchmarkSuiteGroup) {
-		await runBenchmarkSuite(subSuite, runner);
+		if (task.mode !== "run" && task.mode !== "queued") continue;
+		if (task.meta?.benchmark) benchmarkGroup.push(task);
+		else if (task.type === "suite") benchmarkSuiteGroup.push(task);
 	}
+	// run sub suites sequentially
+	for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
 	if (benchmarkGroup.length) {
 		const defer = createDefer();
 		suite.result = {
@@ -57,12 +52,11 @@ async function runBenchmarkSuite(suite, runner) {
 				const result = benchmark.result.benchmark;
 				benchmark.result.state = "pass";
 				Object.assign(result, taskRes);
+				// compute extra stats and free raw samples as early as possible
 				const samples = result.samples;
 				result.sampleCount = samples.length;
 				result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
-				if (!runner.config.benchmark?.includeSamples) {
-					result.samples.length = 0;
-				}
+				if (!runner.config.benchmark?.includeSamples) result.samples.length = 0;
 				updateTask$1("test-finished", benchmark);
 			}, { once: true });
 			task.addEventListener("error", (e) => {
@@ -112,9 +106,7 @@ class NodeBenchmarkRunner {
 		return await import('tinybench');
 	}
 	importFile(filepath, source) {
-		if (source === "setup") {
-			getWorkerState().moduleCache.delete(filepath);
-		}
+		if (source === "setup") getWorkerState().moduleCache.delete(filepath);
 		return this.__vitest_executor.executeId(filepath);
 	}
 	async runSuite(suite) {
@@ -125,39 +117,42 @@ class NodeBenchmarkRunner {
 	}
 }
 
+// worker context is shared between all tests
+const workerContext = Object.create(null);
 class VitestTestRunner {
 	snapshotClient = getSnapshotClient();
 	workerState = getWorkerState();
 	__vitest_executor;
 	cancelRun = false;
-	assertionsErrors = new WeakMap();
+	assertionsErrors = /* @__PURE__ */ new WeakMap();
 	pool = this.workerState.ctx.pool;
 	constructor(config) {
 		this.config = config;
 	}
 	importFile(filepath, source) {
-		if (source === "setup") {
-			this.workerState.moduleCache.delete(filepath);
-		}
+		if (source === "setup") this.workerState.moduleCache.delete(filepath);
 		return this.__vitest_executor.executeId(filepath);
 	}
 	onCollectStart(file) {
 		this.workerState.current = file;
 	}
+	onCleanupWorkerContext(listener) {
+		this.workerState.onCleanup(listener);
+	}
 	onAfterRunFiles() {
 		this.snapshotClient.clear();
-		this.workerState.current = undefined;
+		this.workerState.current = void 0;
+	}
+	getWorkerContext() {
+		return workerContext;
 	}
 	async onAfterRunSuite(suite) {
-		if (this.config.logHeapUsage && typeof process !== "undefined") {
-			suite.result.heap = process.memoryUsage().heapUsed;
-		}
+		if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
 		if (suite.mode !== "skip" && "filepath" in suite) {
-			for (const test of getTests(suite)) {
-				if (test.mode === "skip") {
-					const name = getNames(test).slice(1).join(" > ");
-					this.snapshotClient.skipTest(suite.file.filepath, name);
-				}
+			// mark snapshots in skipped tests as not obsolete
+			for (const test of getTests(suite)) if (test.mode === "skip") {
+				const name = getNames(test).slice(1).join(" > ");
+				this.snapshotClient.skipTest(suite.file.filepath, name);
 			}
 			const result = await this.snapshotClient.finish(suite.file.filepath);
 			await rpc().snapshotSaved(result);
@@ -165,33 +160,26 @@ class VitestTestRunner {
 		this.workerState.current = suite.suite || suite.file;
 	}
 	onAfterRunTask(test) {
-		if (this.config.logHeapUsage && typeof process !== "undefined") {
-			test.result.heap = process.memoryUsage().heapUsed;
-		}
+		if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
 		this.workerState.current = test.suite || test.file;
 	}
 	cancel(_reason) {
 		this.cancelRun = true;
 	}
 	injectValue(key) {
+		// inject has a very limiting type controlled by ProvidedContext
+		// some tests override it which causes the build to fail
 		return inject(key);
 	}
 	async onBeforeRunTask(test) {
-		if (this.cancelRun) {
-			test.mode = "skip";
-		}
-		if (test.mode !== "run" && test.mode !== "queued") {
-			return;
-		}
+		if (this.cancelRun) test.mode = "skip";
+		if (test.mode !== "run" && test.mode !== "queued") return;
 		this.workerState.current = test;
 	}
 	async onBeforeRunSuite(suite) {
-		if (this.cancelRun) {
-			suite.mode = "skip";
-		}
-		if (suite.mode !== "skip" && "filepath" in suite) {
-			await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
-		}
+		if (this.cancelRun) suite.mode = "skip";
+		// initialize snapshot state before running file suite
+		if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
 		this.workerState.current = suite;
 	}
 	onBeforeTryTask(test) {
@@ -208,26 +196,17 @@ class VitestTestRunner {
 		}, globalThis[GLOBAL_EXPECT]);
 	}
 	onAfterTryTask(test) {
-		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = "context" in test && test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
-		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) {
-			throw expectedAssertionsNumberErrorGen();
-		}
-		if (isExpectingAssertions === true && assertionCalls === 0) {
-			throw isExpectingAssertionsError;
-		}
-		if (this.config.expect.requireAssertions && assertionCalls === 0) {
-			throw this.assertionsErrors.get(test);
-		}
+		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
+		if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
+		if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
 	}
 	extendTaskContext(context) {
-		if (this.config.expect.requireAssertions) {
-			this.assertionsErrors.set(context.task, new Error("expected any number of assertion, but got none"));
-		}
+		// create error during the test initialization so we have a nice stack trace
+		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, new Error("expected any number of assertion, but got none"));
 		let _expect;
 		Object.defineProperty(context, "expect", { get() {
-			if (!_expect) {
-				_expect = createExpect(context.task);
-			}
+			if (!_expect) _expect = createExpect(context.task);
 			return _expect;
 		} });
 		Object.defineProperty(context, "_local", { get() {
@@ -235,22 +214,22 @@ class VitestTestRunner {
 		} });
 		return context;
 	}
+	getImportDurations() {
+		const entries = [...this.workerState.moduleExecutionInfo?.entries() ?? []];
+		return Object.fromEntries(entries.map(([filepath, { duration, selfTime }]) => [normalize(filepath), {
+			selfTime,
+			totalTime: duration
+		}]));
+	}
 }
 function clearModuleMocks(config) {
 	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
-	if (restoreMocks) {
-		vi.restoreAllMocks();
-	} else if (mockReset) {
-		vi.resetAllMocks();
-	} else if (clearMocks) {
-		vi.clearAllMocks();
-	}
-	if (unstubEnvs) {
-		vi.unstubAllEnvs();
-	}
-	if (unstubGlobals) {
-		vi.unstubAllGlobals();
-	}
+	// since each function calls another, we can just call one
+	if (restoreMocks) vi.restoreAllMocks();
+	else if (mockReset) vi.resetAllMocks();
+	else if (clearMocks) vi.clearAllMocks();
+	if (unstubEnvs) vi.unstubAllEnvs();
+	if (unstubGlobals) vi.unstubAllGlobals();
 }
 
 export { NodeBenchmarkRunner, VitestTestRunner };

package/dist/snapshot.js

@@ -1,4 +1,4 @@
-export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment } from './chunks/node.3xsWotC9.js';
+export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment } from './chunks/node.fjCdwEIl.js';
 import '@vitest/snapshot/environment';
-import './chunks/utils.CgTj3MsC.js';
+import './chunks/utils.XdZDrNZV.js';
 import '@vitest/utils';

package/dist/suite.js

@@ -1,5 +1,5 @@
-export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.BoF7jW0Q.js';
+export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.CYdenmiT.js';
 export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
 export { createChainable } from '@vitest/runner/utils';
 import '@vitest/utils';
-import './chunks/utils.CgTj3MsC.js';
+import './chunks/utils.XdZDrNZV.js';

package/dist/worker.js

@@ -4,11 +4,11 @@ import { workerId } from 'tinypool';
 import { ViteNodeRunner, ModuleCacheMap } from 'vite-node/client';
 import { readFileSync } from 'node:fs';
 import { resolve, normalize } from 'pathe';
-import { e as environments } from './chunks/index.DFXFpH3w.js';
-import { s as setupInspect } from './chunks/inspector.DbDkSkFn.js';
-import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.D9_013TY.js';
-import { i as isChildProcess, s as setProcessTitle } from './chunks/utils.CgTj3MsC.js';
-import { d as disposeInternalListeners } from './chunks/utils.BfxieIyZ.js';
+import { e as environments } from './chunks/index.CmSc2RE5.js';
+import { s as setupInspect } from './chunks/inspector.C914Efll.js';
+import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.Iovn4oWe.js';
+import { i as isChildProcess, s as setProcessTitle } from './chunks/utils.XdZDrNZV.js';
+import { d as disposeInternalListeners } from './chunks/utils.CAioKnHs.js';
 import 'node:console';
 import 'node:module';
 import '@vitest/utils';
@@ -17,7 +17,7 @@ import './chunks/index.CJ0plNrh.js';
 function isBuiltinEnvironment(env) {
 	return env in environments;
 }
-const _loaders = new Map();
+const _loaders = /* @__PURE__ */ new Map();
 async function createEnvironmentLoader(options) {
 	if (!_loaders.has(options.root)) {
 		const loader = new ViteNodeRunner(options);
@@ -28,42 +28,44 @@ async function createEnvironmentLoader(options) {
 }
 async function loadEnvironment(ctx, rpc) {
 	const name = ctx.environment.name;
-	if (isBuiltinEnvironment(name)) {
-		return environments[name];
-	}
+	if (isBuiltinEnvironment(name)) return environments[name];
 	const loader = await createEnvironmentLoader({
 		root: ctx.config.root,
 		fetchModule: async (id) => {
 			const result = await rpc.fetch(id, "ssr");
-			if (result.id) {
-				return { code: readFileSync(result.id, "utf-8") };
-			}
+			if (result.id) return { code: readFileSync(result.id, "utf-8") };
 			return result;
 		},
 		resolveId: (id, importer) => rpc.resolveId(id, importer, "ssr")
 	});
 	const root = loader.root;
-	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolveId(`vitest-environment-${name}`, undefined, "ssr"))?.id ?? resolve(root, name);
+	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolveId(`vitest-environment-${name}`, void 0, "ssr"))?.id ?? resolve(root, name);
 	const pkg = await loader.executeId(normalize(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.`);
-	}
+	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 !== "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".`);
-	}
+	if (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".`);
 	return environment;
 }
 
+const listeners = /* @__PURE__ */ new Set();
+function addCleanupListener(listener) {
+	listeners.add(listener);
+}
+async function cleanup() {
+	const promises = [...listeners].map((l) => l());
+	await Promise.all(promises);
+}
+
 if (isChildProcess()) {
 	setProcessTitle(`vitest ${workerId}`);
 	const isProfiling = process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"));
-	if (isProfiling) {
-		process.on("SIGTERM", () => {
-			process.exit();
-		});
-	}
+	if (isProfiling)
+ // Work-around for nodejs/node#55094
+	process.on("SIGTERM", () => {
+		process.exit();
+	});
 }
+// this is what every pool executes when running tests
 async function execute(method, ctx) {
 	disposeInternalListeners();
 	const prepareStart = performance.now();
@@ -71,28 +73,22 @@ async function execute(method, ctx) {
 	process.env.VITEST_WORKER_ID = String(ctx.workerId);
 	process.env.VITEST_POOL_ID = String(workerId);
 	try {
-		if (ctx.worker[0] === ".") {
-			throw new Error(`Path to the test runner cannot be relative, received "${ctx.worker}"`);
-		}
+		// worker is a filepath or URL to a file that exposes a default export with "getRpcOptions" and "runTests" methods
+		if (ctx.worker[0] === ".") throw new Error(`Path to the test runner cannot be relative, received "${ctx.worker}"`);
 		const file = ctx.worker.startsWith("file:") ? ctx.worker : pathToFileURL(ctx.worker).toString();
 		const testRunnerModule = await import(file);
-		if (!testRunnerModule.default || typeof testRunnerModule.default !== "object") {
-			throw new TypeError(`Test worker object should be exposed as a default export. Received "${typeof testRunnerModule.default}"`);
-		}
+		if (!testRunnerModule.default || typeof testRunnerModule.default !== "object") throw new TypeError(`Test worker object should be exposed as a default export. Received "${typeof testRunnerModule.default}"`);
 		const worker = testRunnerModule.default;
-		if (!worker.getRpcOptions || typeof worker.getRpcOptions !== "function") {
-			throw new TypeError(`Test worker should expose "getRpcOptions" method. Received "${typeof worker.getRpcOptions}".`);
-		}
+		if (!worker.getRpcOptions || typeof worker.getRpcOptions !== "function") throw new TypeError(`Test worker should expose "getRpcOptions" method. Received "${typeof worker.getRpcOptions}".`);
+		// 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.getRpcOptions(ctx));
 		const beforeEnvironmentTime = performance.now();
 		const environment = await loadEnvironment(ctx, rpc);
-		if (ctx.environment.transformMode) {
-			environment.transformMode = ctx.environment.transformMode;
-		}
+		if (ctx.environment.transformMode) environment.transformMode = ctx.environment.transformMode;
 		const state = {
 			ctx,
 			moduleCache: new ModuleCacheMap(),
-			moduleExecutionInfo: new Map(),
+			moduleExecutionInfo: /* @__PURE__ */ new Map(),
 			config: ctx.config,
 			onCancel,
 			environment,
@@ -101,15 +97,14 @@ async function execute(method, ctx) {
 				prepare: prepareStart
 			},
 			rpc,
+			onCleanup: (listener) => addCleanupListener(listener),
 			providedContext: ctx.providedContext,
 			onFilterStackTrace(stack) {
 				return createStackString(parseStacktrace(stack));
 			}
 		};
 		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}".`);
-		}
+		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(() => {});
@@ -122,5 +117,8 @@ function run(ctx) {
 function collect(ctx) {
 	return execute("collect", ctx);
 }
+async function teardown() {
+	return cleanup();
+}
 
-export { collect, run };
+export { collect, run, teardown };

package/dist/workers/forks.js

@@ -1,8 +1,8 @@
 import v8 from 'node:v8';
-import { r as runBaseTests } from '../chunks/base.DwtwORaC.js';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.BfxieIyZ.js';
+import { r as runBaseTests } from '../chunks/base.Cg0miDlQ.js';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.CAioKnHs.js';
 import 'vite-node/client';
-import '../chunks/execute.JlGHLJZT.js';
+import '../chunks/execute.B7h3T_Hc.js';
 import 'node:fs';
 import 'node:url';
 import 'node:vm';
@@ -14,13 +14,15 @@ import 'node:path';
 import '@vitest/mocker';
 import 'node:module';
 import '@vitest/utils';
-import '../chunks/utils.CgTj3MsC.js';
+import '../chunks/utils.XdZDrNZV.js';
 
 class ForksBaseWorker {
 	getRpcOptions() {
 		return createForksRpcOptions(v8);
 	}
 	async executeTests(method, state) {
+		// TODO: don't rely on reassigning process.exit
+		// https://github.com/vitest-dev/vitest/pull/4441#discussion_r1443771486
 		const exit = process.exit;
 		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
 		try {

package/dist/workers/runVmTests.js

@@ -6,29 +6,29 @@ import util from 'node:util';
 import { startTests, collectTests } from '@vitest/runner';
 import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
 import { installSourcemapsSupport } from 'vite-node/source-map';
-import { s as setupChaiConfig, r as resolveTestRunner, a as resolveSnapshotEnvironment } from '../chunks/index.DswW_LEs.js';
-import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from '../chunks/setup-common.CYo3Y0dD.js';
-import { V as VitestIndex } from '../chunks/index.CfXMNXHg.js';
-import { c as closeInspector } from '../chunks/inspector.DbDkSkFn.js';
-import { g as getWorkerState } from '../chunks/utils.CgTj3MsC.js';
+import { s as setupChaiConfig, r as resolveTestRunner, a as resolveSnapshotEnvironment } from '../chunks/index.BbB8_kAK.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from '../chunks/setup-common.Dd054P77.js';
+import { V as VitestIndex } from '../chunks/index.CdQS2e2Q.js';
+import { c as closeInspector } from '../chunks/inspector.C914Efll.js';
+import { g as getWorkerState } from '../chunks/utils.XdZDrNZV.js';
 import 'chai';
 import 'node:path';
 import '../path.js';
 import 'node:url';
-import '../chunks/rpc.D9_013TY.js';
+import '../chunks/rpc.Iovn4oWe.js';
 import '@vitest/utils';
 import '../chunks/index.CJ0plNrh.js';
-import '../chunks/coverage.0iPg4Wrz.js';
+import '../chunks/coverage.DVF1vEu8.js';
 import '@vitest/snapshot';
-import '../chunks/vi.BFR5YIgu.js';
+import '../chunks/vi.bdSIJ99Y.js';
 import '@vitest/expect';
 import '@vitest/runner/utils';
 import '../chunks/_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
-import '../chunks/date.CDOsz-HY.js';
-import '../chunks/benchmark.BoF7jW0Q.js';
+import '../chunks/date.Bq6ZW5rf.js';
+import '../chunks/benchmark.CYdenmiT.js';
 import 'expect-type';
 
 async function run(method, files, config, executor) {
@@ -40,17 +40,18 @@ async function run(method, files, config, executor) {
 	});
 	if (workerState.environment.transformMode === "web") {
 		const _require = createRequire(import.meta.url);
+		// always mock "required" `css` files, because we cannot process them
 		_require.extensions[".css"] = resolveCss;
 		_require.extensions[".scss"] = resolveCss;
 		_require.extensions[".sass"] = resolveCss;
 		_require.extensions[".less"] = resolveCss;
+		// since we are using Vite, we can assume how these will be resolved
 		KNOWN_ASSET_TYPES.forEach((type) => {
 			_require.extensions[`.${type}`] = resolveAsset;
 		});
 		process.env.SSR = "";
-	} else {
-		process.env.SSR = "1";
-	}
+	} else process.env.SSR = "1";
+	// @ts-expect-error not typed global for patched timers
 	globalThis.__vitest_required__ = {
 		util,
 		timers,
@@ -58,11 +59,10 @@ async function run(method, files, config, executor) {
 	};
 	installSourcemapsSupport({ getSourceMap: (source) => workerState.moduleCache.getSourceMap(source) });
 	await startCoverageInsideWorker(config.coverage, executor, { isolate: false });
-	if (config.chaiConfig) {
-		setupChaiConfig(config.chaiConfig);
-	}
+	if (config.chaiConfig) setupChaiConfig(config.chaiConfig);
 	const [runner, snapshotEnvironment] = await Promise.all([resolveTestRunner(config, executor), resolveSnapshotEnvironment(config, executor)]);
 	config.snapshotOptions.snapshotEnvironment = snapshotEnvironment;
+	runner.getWorkerContext = void 0;
 	workerState.onCancel.then((reason) => {
 		closeInspector(config);
 		runner.cancel?.(reason);
@@ -71,12 +71,11 @@ async function run(method, files, config, executor) {
 	const { vi } = VitestIndex;
 	for (const file of files) {
 		workerState.filepath = file.filepath;
-		if (method === "run") {
-			await startTests([file], runner);
-		} else {
-			await collectTests([file], runner);
-		}
+		if (method === "run") await startTests([file], runner);
+		else await collectTests([file], runner);
+		// reset after tests, because user might call `vi.setConfig` in setupFile
 		vi.resetConfig();
+		// mocks should not affect different files
 		vi.restoreAllMocks();
 	}
 	await stopCoverageInsideWorker(config.coverage, executor, { isolate: false });

package/dist/workers/threads.js

@@ -1,7 +1,7 @@
-import { r as runBaseTests } from '../chunks/base.DwtwORaC.js';
-import { a as createThreadsRpcOptions } from '../chunks/utils.BfxieIyZ.js';
+import { r as runBaseTests } from '../chunks/base.Cg0miDlQ.js';
+import { a as createThreadsRpcOptions } from '../chunks/utils.CAioKnHs.js';
 import 'vite-node/client';
-import '../chunks/execute.JlGHLJZT.js';
+import '../chunks/execute.B7h3T_Hc.js';
 import 'node:fs';
 import 'node:url';
 import 'node:vm';
@@ -13,7 +13,7 @@ import 'node:path';
 import '@vitest/mocker';
 import 'node:module';
 import '@vitest/utils';
-import '../chunks/utils.CgTj3MsC.js';
+import '../chunks/utils.XdZDrNZV.js';
 
 class ThreadsBaseWorker {
 	getRpcOptions(ctx) {

package/dist/workers/vmForks.js

@@ -1,19 +1,19 @@
 import v8 from 'node:v8';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.BfxieIyZ.js';
-import { r as runVmTests } from '../chunks/vm.C1HHjtNS.js';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.CAioKnHs.js';
+import { r as runVmTests } from '../chunks/vm.BThCzidc.js';
 import '@vitest/utils';
 import 'node:url';
 import 'node:vm';
 import 'pathe';
 import '../path.js';
 import 'node:path';
-import '../chunks/console.K1NMVOSc.js';
+import '../chunks/console.CtFJOzRO.js';
 import 'node:console';
 import 'node:stream';
 import 'tinyrainbow';
-import '../chunks/date.CDOsz-HY.js';
-import '../chunks/utils.CgTj3MsC.js';
-import '../chunks/execute.JlGHLJZT.js';
+import '../chunks/date.Bq6ZW5rf.js';
+import '../chunks/utils.XdZDrNZV.js';
+import '../chunks/execute.B7h3T_Hc.js';
 import 'node:fs';
 import '@vitest/utils/error';
 import 'vite-node/client';

package/dist/workers/vmThreads.js

@@ -1,18 +1,18 @@
-import { a as createThreadsRpcOptions } from '../chunks/utils.BfxieIyZ.js';
-import { r as runVmTests } from '../chunks/vm.C1HHjtNS.js';
+import { a as createThreadsRpcOptions } from '../chunks/utils.CAioKnHs.js';
+import { r as runVmTests } from '../chunks/vm.BThCzidc.js';
 import '@vitest/utils';
 import 'node:url';
 import 'node:vm';
 import 'pathe';
 import '../path.js';
 import 'node:path';
-import '../chunks/console.K1NMVOSc.js';
+import '../chunks/console.CtFJOzRO.js';
 import 'node:console';
 import 'node:stream';
 import 'tinyrainbow';
-import '../chunks/date.CDOsz-HY.js';
-import '../chunks/utils.CgTj3MsC.js';
-import '../chunks/execute.JlGHLJZT.js';
+import '../chunks/date.Bq6ZW5rf.js';
+import '../chunks/utils.XdZDrNZV.js';
+import '../chunks/execute.B7h3T_Hc.js';
 import 'node:fs';
 import '@vitest/utils/error';
 import 'vite-node/client';