vitest 4.0.17 → 4.1.0-beta.1

package/dist/chunks/{vi.2VT5v0um.js → test.prxIahgM.js}

@@ -1,16 +1,18 @@
-import { chai, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
-import { getCurrentTest } from '@vitest/runner';
-import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.DvEY5TfP.js';
+import { getCurrentTest, updateTask, createTaskCollector, getCurrentSuite, getHooks, getFn } from '@vitest/runner';
+import { assertTypes, createSimpleStackTrace, createDefer } from '@vitest/utils/helpers';
 import { getSafeTimers, delay } from '@vitest/utils/timers';
-import { getNames } from '@vitest/runner/utils';
+import { a as getBenchOptions, g as getBenchFn } from './benchmark.B3N2zMcH.js';
+import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.DvEY5TfP.js';
+import { chai, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, ChaiStyleAssertions, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
+import { getNames, getTests, getTestName, createChainable } from '@vitest/runner/utils';
+import { processError } from '@vitest/utils/error';
+import { normalize } from 'pathe';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
-import '@vitest/utils/error';
-import { assertTypes, createSimpleStackTrace } from '@vitest/utils/helpers';
 import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunction } from '@vitest/spy';
 import '@vitest/utils/offset';
 import { parseSingleStack } from '@vitest/utils/source-map';
 import { c as commonjsGlobal } from './_commonjsHelpers.D26ty3Ew.js';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.Bq6ZW5rf.js';
+import { R as RealDate, b as resetDate, m as mockDate, r as rpc } from './rpc.HLmECnw_.js';
 
 // these matchers are not supported because they don't make sense with poll
 const unsupported = [
@@ -295,6 +297,7 @@ const SnapshotPlugin = (chai, utils) => {
 
 chai.use(JestExtend);
 chai.use(JestChaiExpect);
+chai.use(ChaiStyleAssertions);
 chai.use(SnapshotPlugin);
 chai.use(JestAsymmetricMatchers);
 
@@ -1326,6 +1329,30 @@ function requireFakeTimersSrc () {
 	    }
 	}
 
+	/**
+	 * @typedef {"nextAsync" | "manual" | "interval"} TickMode
+	 */
+
+	/**
+	 * @typedef {object} NextAsyncTickMode
+	 * @property {"nextAsync"} mode
+	 */
+
+	/**
+	 * @typedef {object} ManualTickMode
+	 * @property {"manual"} mode
+	 */
+
+	/**
+	 * @typedef {object} IntervalTickMode
+	 * @property {"interval"} mode
+	 * @property {number} [delta]
+	 */
+
+	/**
+	 * @typedef {IntervalTickMode | NextAsyncTickMode | ManualTickMode} TimerTickMode
+	 */
+
 	/**
 	 * @typedef {object} IdleDeadline
 	 * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout
@@ -1411,6 +1438,7 @@ function requireFakeTimersSrc () {
 	 * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods
 	 * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods
 	 * @property {Map<function(): void, AbortSignal>} abortListenerMap
+	 * @property {function(TimerTickMode): void} setTickMode
 	 */
 	/* eslint-enable jsdoc/require-property-description */
 
@@ -2208,10 +2236,9 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * @param {Clock} clock
-	     * @param {Config} config
 	     * @returns {Timer[]}
 	     */
-	    function uninstall(clock, config) {
+	    function uninstall(clock) {
 	        let method, i, l;
 	        const installedHrTime = "_hrtime";
 	        const installedNextTick = "_nextTick";
@@ -2269,9 +2296,7 @@ function requireFakeTimersSrc () {
 	            }
 	        }
 
-	        if (config.shouldAdvanceTime === true) {
-	            _global.clearInterval(clock.attachedInterval);
-	        }
+	        clock.setTickMode("manual");
 
 	        // Prevent multiple executions which will completely remove these props
 	        clock.methods = [];
@@ -2427,6 +2452,8 @@ function requireFakeTimersSrc () {
 	    }
 
 	    const originalSetTimeout = _global.setImmediate || _global.setTimeout;
+	    const originalClearInterval = _global.clearInterval;
+	    const originalSetInterval = _global.setInterval;
 
 	    /**
 	     * @param {Date|number} [start] the system time - non-integer values are floored
@@ -2445,6 +2472,7 @@ function requireFakeTimersSrc () {
 	            now: start,
 	            Date: createDate(),
 	            loopLimit: loopLimit,
+	            tickMode: { mode: "manual", counter: 0, delta: undefined },
 	        };
 
 	        clock.Date.clock = clock;
@@ -2511,6 +2539,74 @@ function requireFakeTimersSrc () {
 	            clock.Intl.clock = clock;
 	        }
 
+	        /**
+	         * @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.
+	         */
+	        clock.setTickMode = function (tickModeConfig) {
+	            const { mode: newMode, delta: newDelta } = tickModeConfig;
+	            const { mode: oldMode, delta: oldDelta } = clock.tickMode;
+	            if (newMode === oldMode && newDelta === oldDelta) {
+	                return;
+	            }
+
+	            if (oldMode === "interval") {
+	                originalClearInterval(clock.attachedInterval);
+	            }
+
+	            clock.tickMode = {
+	                counter: clock.tickMode.counter + 1,
+	                mode: newMode,
+	                delta: newDelta,
+	            };
+
+	            if (newMode === "nextAsync") {
+	                advanceUntilModeChanges();
+	            } else if (newMode === "interval") {
+	                createIntervalTick(clock, newDelta || 20);
+	            }
+	        };
+
+	        async function advanceUntilModeChanges() {
+	            async function newMacrotask() {
+	                // MessageChannel ensures that setTimeout is not throttled to 4ms.
+	                // https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#reasons_for_delays_longer_than_specified
+	                // https://stackblitz.com/edit/stackblitz-starters-qtlpcc
+	                const channel = new MessageChannel();
+	                await new Promise((resolve) => {
+	                    channel.port1.onmessage = () => {
+	                        resolve();
+	                        channel.port1.close();
+	                    };
+	                    channel.port2.postMessage(undefined);
+	                });
+	                channel.port1.close();
+	                channel.port2.close();
+	                // setTimeout ensures microtask queue is emptied
+	                await new Promise((resolve) => {
+	                    originalSetTimeout(resolve);
+	                });
+	            }
+
+	            const { counter } = clock.tickMode;
+	            while (clock.tickMode.counter === counter) {
+	                await newMacrotask();
+	                if (clock.tickMode.counter !== counter) {
+	                    return;
+	                }
+	                clock.next();
+	            }
+	        }
+
+	        function pauseAutoTickUntilFinished(promise) {
+	            if (clock.tickMode.mode !== "nextAsync") {
+	                return promise;
+	            }
+	            clock.setTickMode({ mode: "manual" });
+	            return promise.finally(() => {
+	                clock.setTickMode({ mode: "nextAsync" });
+	            });
+	        }
+
 	        clock.requestIdleCallback = function requestIdleCallback(
 	            func,
 	            timeout,
@@ -2809,15 +2905,17 @@ function requireFakeTimersSrc () {
 	             * @returns {Promise}
 	             */
 	            clock.tickAsync = function tickAsync(tickValue) {
-	                return new _global.Promise(function (resolve, reject) {
-	                    originalSetTimeout(function () {
-	                        try {
-	                            doTick(tickValue, true, resolve, reject);
-	                        } catch (e) {
-	                            reject(e);
-	                        }
-	                    });
-	                });
+	                return pauseAutoTickUntilFinished(
+	                    new _global.Promise(function (resolve, reject) {
+	                        originalSetTimeout(function () {
+	                            try {
+	                                doTick(tickValue, true, resolve, reject);
+	                            } catch (e) {
+	                                reject(e);
+	                            }
+	                        });
+	                    }),
+	                );
 	            };
 	        }
 
@@ -2841,37 +2939,39 @@ function requireFakeTimersSrc () {
 
 	        if (typeof _global.Promise !== "undefined") {
 	            clock.nextAsync = function nextAsync() {
-	                return new _global.Promise(function (resolve, reject) {
-	                    originalSetTimeout(function () {
-	                        try {
-	                            const timer = firstTimer(clock);
-	                            if (!timer) {
-	                                resolve(clock.now);
-	                                return;
-	                            }
-
-	                            let err;
-	                            clock.duringTick = true;
-	                            clock.now = timer.callAt;
+	                return pauseAutoTickUntilFinished(
+	                    new _global.Promise(function (resolve, reject) {
+	                        originalSetTimeout(function () {
 	                            try {
-	                                callTimer(clock, timer);
-	                            } catch (e) {
-	                                err = e;
-	                            }
-	                            clock.duringTick = false;
-
-	                            originalSetTimeout(function () {
-	                                if (err) {
-	                                    reject(err);
-	                                } else {
+	                                const timer = firstTimer(clock);
+	                                if (!timer) {
 	                                    resolve(clock.now);
+	                                    return;
 	                                }
-	                            });
-	                        } catch (e) {
-	                            reject(e);
-	                        }
-	                    });
-	                });
+
+	                                let err;
+	                                clock.duringTick = true;
+	                                clock.now = timer.callAt;
+	                                try {
+	                                    callTimer(clock, timer);
+	                                } catch (e) {
+	                                    err = e;
+	                                }
+	                                clock.duringTick = false;
+
+	                                originalSetTimeout(function () {
+	                                    if (err) {
+	                                        reject(err);
+	                                    } else {
+	                                        resolve(clock.now);
+	                                    }
+	                                });
+	                            } catch (e) {
+	                                reject(e);
+	                            }
+	                        });
+	                    }),
+	                );
 	            };
 	        }
 
@@ -2904,51 +3004,55 @@ function requireFakeTimersSrc () {
 
 	        if (typeof _global.Promise !== "undefined") {
 	            clock.runAllAsync = function runAllAsync() {
-	                return new _global.Promise(function (resolve, reject) {
-	                    let i = 0;
-	                    /**
-	                     *
-	                     */
-	                    function doRun() {
-	                        originalSetTimeout(function () {
-	                            try {
-	                                runJobs(clock);
-
-	                                let numTimers;
-	                                if (i < clock.loopLimit) {
-	                                    if (!clock.timers) {
-	                                        resetIsNearInfiniteLimit();
-	                                        resolve(clock.now);
-	                                        return;
-	                                    }
-
-	                                    numTimers = Object.keys(
-	                                        clock.timers,
-	                                    ).length;
-	                                    if (numTimers === 0) {
-	                                        resetIsNearInfiniteLimit();
-	                                        resolve(clock.now);
+	                return pauseAutoTickUntilFinished(
+	                    new _global.Promise(function (resolve, reject) {
+	                        let i = 0;
+	                        /**
+	                         *
+	                         */
+	                        function doRun() {
+	                            originalSetTimeout(function () {
+	                                try {
+	                                    runJobs(clock);
+
+	                                    let numTimers;
+	                                    if (i < clock.loopLimit) {
+	                                        if (!clock.timers) {
+	                                            resetIsNearInfiniteLimit();
+	                                            resolve(clock.now);
+	                                            return;
+	                                        }
+
+	                                        numTimers = Object.keys(
+	                                            clock.timers,
+	                                        ).length;
+	                                        if (numTimers === 0) {
+	                                            resetIsNearInfiniteLimit();
+	                                            resolve(clock.now);
+	                                            return;
+	                                        }
+
+	                                        clock.next();
+
+	                                        i++;
+
+	                                        doRun();
+	                                        checkIsNearInfiniteLimit(clock, i);
 	                                        return;
 	                                    }
 
-	                                    clock.next();
-
-	                                    i++;
-
-	                                    doRun();
-	                                    checkIsNearInfiniteLimit(clock, i);
-	                                    return;
+	                                    const excessJob = firstTimer(clock);
+	                                    reject(
+	                                        getInfiniteLoopError(clock, excessJob),
+	                                    );
+	                                } catch (e) {
+	                                    reject(e);
 	                                }
-
-	                                const excessJob = firstTimer(clock);
-	                                reject(getInfiniteLoopError(clock, excessJob));
-	                            } catch (e) {
-	                                reject(e);
-	                            }
-	                        });
-	                    }
-	                    doRun();
-	                });
+	                            });
+	                        }
+	                        doRun();
+	                    }),
+	                );
 	            };
 	        }
 
@@ -2964,21 +3068,25 @@ function requireFakeTimersSrc () {
 
 	        if (typeof _global.Promise !== "undefined") {
 	            clock.runToLastAsync = function runToLastAsync() {
-	                return new _global.Promise(function (resolve, reject) {
-	                    originalSetTimeout(function () {
-	                        try {
-	                            const timer = lastTimer(clock);
-	                            if (!timer) {
-	                                runJobs(clock);
-	                                resolve(clock.now);
-	                            }
+	                return pauseAutoTickUntilFinished(
+	                    new _global.Promise(function (resolve, reject) {
+	                        originalSetTimeout(function () {
+	                            try {
+	                                const timer = lastTimer(clock);
+	                                if (!timer) {
+	                                    runJobs(clock);
+	                                    resolve(clock.now);
+	                                }
 
-	                            resolve(clock.tickAsync(timer.callAt - clock.now));
-	                        } catch (e) {
-	                            reject(e);
-	                        }
-	                    });
-	                });
+	                                resolve(
+	                                    clock.tickAsync(timer.callAt - clock.now),
+	                                );
+	                            } catch (e) {
+	                                reject(e);
+	                            }
+	                        });
+	                    }),
+	                );
 	            };
 	        }
 
@@ -3042,6 +3150,12 @@ function requireFakeTimersSrc () {
 	        return clock;
 	    }
 
+	    function createIntervalTick(clock, delta) {
+	        const intervalTick = doIntervalTick.bind(null, clock, delta);
+	        const intervalId = originalSetInterval(intervalTick, delta);
+	        clock.attachedInterval = intervalId;
+	    }
+
 	    /* eslint-disable complexity */
 
 	    /**
@@ -3102,7 +3216,7 @@ function requireFakeTimersSrc () {
 	        clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
 
 	        clock.uninstall = function () {
-	            return uninstall(clock, config);
+	            return uninstall(clock);
 	        };
 
 	        clock.abortListenerMap = new Map();
@@ -3114,16 +3228,10 @@ function requireFakeTimersSrc () {
 	        }
 
 	        if (config.shouldAdvanceTime === true) {
-	            const intervalTick = doIntervalTick.bind(
-	                null,
-	                clock,
-	                config.advanceTimeDelta,
-	            );
-	            const intervalId = _global.setInterval(
-	                intervalTick,
-	                config.advanceTimeDelta,
-	            );
-	            clock.attachedInterval = intervalId;
+	            clock.setTickMode({
+	                mode: "interval",
+	                delta: config.advanceTimeDelta,
+	            });
 	        }
 
 	        if (clock.methods.includes("performance")) {
@@ -3535,9 +3643,7 @@ class FakeTimers {
 		if (this._checkFakeTimers()) this._clock.runToFrame();
 	}
 	runAllTicks() {
-		if (this._checkFakeTimers())
- // @ts-expect-error method not exposed
-		this._clock.runMicrotasks();
+		if (this._checkFakeTimers()) this._clock.runMicrotasks();
 	}
 	useRealTimers() {
 		if (this._fakingDate) {
@@ -3591,6 +3697,15 @@ class FakeTimers {
 		if (this._checkFakeTimers()) return this._clock.countTimers();
 		return 0;
 	}
+	setTimerTickMode(mode, interval) {
+		if (this._checkFakeTimers()) if (mode === "manual") this._clock.setTickMode({ mode: "manual" });
+		else if (mode === "nextTimerAsync") this._clock.setTickMode({ mode: "nextAsync" });
+		else if (mode === "interval") this._clock.setTickMode({
+			mode: "interval",
+			delta: interval
+		});
+		else throw new Error(`Invalid tick mode: ${mode}`);
+	}
 	configure(config) {
 		this._userConfig = config;
 	}
@@ -3793,6 +3908,10 @@ function createVitest() {
 			timers().clearAllTimers();
 			return utils;
 		},
+		setTimerTickMode(mode, interval) {
+			timers().setTimerTickMode(mode, interval);
+			return utils;
+		},
 		spyOn,
 		fn,
 		waitFor,
@@ -3814,6 +3933,11 @@ function createVitest() {
 			if (typeof path !== "string") throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
 			const importer = getImporter("doMock");
 			_mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
+			const rv = {};
+			if (Symbol.dispose) rv[Symbol.dispose] = () => {
+				_mocker().queueUnmock(path, importer);
+			};
+			return rv;
 		},
 		doUnmock(path) {
 			if (typeof path !== "string") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
@@ -3916,4 +4040,261 @@ function getImporter(name) {
 	}) + 1])?.file || "";
 }
 
-export { getSnapshotClient as a, assert as b, createExpect as c, vitest as d, globalExpect as g, inject as i, should as s, vi as v };
+function createBenchmarkResult(name) {
+	return {
+		name,
+		rank: 0,
+		rme: 0,
+		samples: []
+	};
+}
+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);
+	}
+	// run sub suites sequentially
+	for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
+	if (benchmarkGroup.length) {
+		const defer = createDefer();
+		suite.result = {
+			state: "run",
+			startTime: start,
+			benchmark: createBenchmarkResult(suite.name)
+		};
+		updateTask$1("suite-prepare", suite);
+		const addBenchTaskListener = (task, benchmark) => {
+			task.addEventListener("complete", (e) => {
+				const taskRes = e.task.result;
+				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;
+				updateTask$1("test-finished", benchmark);
+			}, { once: true });
+			task.addEventListener("error", (e) => {
+				const task = e.task;
+				defer.reject(benchmark ? task.result.error : e);
+			}, { once: true });
+		};
+		benchmarkGroup.forEach((benchmark) => {
+			const benchmarkInstance = new Bench(getBenchOptions(benchmark));
+			const benchmarkFn = getBenchFn(benchmark);
+			benchmark.result = {
+				state: "run",
+				startTime: start,
+				benchmark: createBenchmarkResult(benchmark.name)
+			};
+			const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
+			benchmarkTasks.set(benchmark, task);
+			addBenchTaskListener(task, benchmark);
+		});
+		const { setTimeout } = getSafeTimers();
+		const tasks = [];
+		for (const benchmark of benchmarkGroup) {
+			const task = benchmarkTasks.get(benchmark);
+			updateTask$1("test-prepare", benchmark);
+			await task.warmup();
+			tasks.push([await new Promise((resolve) => setTimeout(async () => {
+				resolve(await task.run());
+			})), benchmark]);
+		}
+		suite.result.duration = performance.now() - start;
+		suite.result.state = "pass";
+		updateTask$1("suite-finished", suite);
+		defer.resolve(null);
+		await defer;
+	}
+	function updateTask$1(event, task) {
+		updateTask(event, task, runner);
+	}
+}
+class NodeBenchmarkRunner {
+	moduleRunner;
+	constructor(config) {
+		this.config = config;
+	}
+	async importTinybench() {
+		return await import('tinybench');
+	}
+	importFile(filepath, source) {
+		if (source === "setup") {
+			const moduleNode = getWorkerState().evaluatedModules.getModuleById(filepath);
+			if (moduleNode) getWorkerState().evaluatedModules.invalidateModule(moduleNode);
+		}
+		return this.moduleRunner.import(filepath);
+	}
+	async runSuite(suite) {
+		await runBenchmarkSuite(suite, this);
+	}
+	async runTask() {
+		throw new Error("`test()` and `it()` is only available in test mode.");
+	}
+}
+
+// worker context is shared between all tests
+const workerContext = Object.create(null);
+class TestRunner {
+	snapshotClient = getSnapshotClient();
+	workerState = getWorkerState();
+	moduleRunner;
+	cancelRun = false;
+	assertionsErrors = /* @__PURE__ */ new WeakMap();
+	pool = this.workerState.ctx.pool;
+	_otel;
+	viteEnvironment;
+	constructor(config) {
+		this.config = config;
+		const environment = this.workerState.environment;
+		this.viteEnvironment = environment.viteEnvironment || environment.name;
+	}
+	importFile(filepath, source) {
+		if (source === "setup") {
+			const moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);
+			if (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);
+		}
+		return this._otel.$(`vitest.module.import_${source === "setup" ? "setup" : "spec"}`, { attributes: { "code.file.path": filepath } }, () => this.moduleRunner.import(filepath));
+	}
+	onCollectStart(file) {
+		this.workerState.current = file;
+	}
+	onCleanupWorkerContext(listener) {
+		this.workerState.onCleanup(listener);
+	}
+	onAfterRunFiles() {
+		this.snapshotClient.clear();
+		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 (suite.mode !== "skip" && "filepath" in suite) {
+			// 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);
+			if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
+				let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
+				for (const key of result.uncheckedKeys) message += `· ${key}\n`;
+				suite.result.errors ??= [];
+				suite.result.errors.push(processError(new Error(message)));
+				suite.result.state = "fail";
+			}
+			await rpc().snapshotSaved(result);
+		}
+		this.workerState.current = suite.suite || suite.file;
+	}
+	onAfterRunTask(test) {
+		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;
+		this.workerState.current = test;
+	}
+	async onBeforeRunSuite(suite) {
+		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) {
+		clearModuleMocks(this.config);
+		this.snapshotClient.clearTest(test.file.filepath, test.id);
+		setState({
+			assertionCalls: 0,
+			isExpectingAssertions: false,
+			isExpectingAssertionsError: null,
+			expectedAssertionsNumber: null,
+			expectedAssertionsNumberErrorGen: null,
+			currentTestName: getTestName(test),
+			snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
+		}, globalThis[GLOBAL_EXPECT]);
+	}
+	onAfterTryTask(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) {
+		// create error during the test initialization so we have a nice stack trace
+		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
+		let _expect;
+		Object.defineProperty(context, "expect", { get() {
+			if (!_expect) _expect = createExpect(context.task);
+			return _expect;
+		} });
+		Object.defineProperty(context, "_local", { get() {
+			return _expect != null;
+		} });
+		return context;
+	}
+	getImportDurations() {
+		const importDurations = {};
+		const entries = this.workerState.moduleExecutionInfo?.entries() || [];
+		for (const [filepath, { duration, selfTime, external, importer }] of entries) importDurations[normalize(filepath)] = {
+			selfTime,
+			totalTime: duration,
+			external,
+			importer
+		};
+		return importDurations;
+	}
+	trace = (name, attributes, cb) => {
+		const options = typeof attributes === "object" ? { attributes } : {};
+		return this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);
+	};
+	__setTraces(traces) {
+		this._otel = traces;
+	}
+	static createTaskCollector = createTaskCollector;
+	static getCurrentSuite = getCurrentSuite;
+	static getCurrentTest = getCurrentTest;
+	static createChainable = createChainable;
+	static getSuiteHooks = getHooks;
+	static getTestFn = getFn;
+	static setSuiteHooks = getHooks;
+	static setTestFn = getFn;
+	/**
+	* @deprecated
+	*/
+	static getBenchFn = getBenchFn;
+	/**
+	* @deprecated
+	*/
+	static getBenchOptions = getBenchOptions;
+}
+function clearModuleMocks(config) {
+	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+	if (restoreMocks) vi.restoreAllMocks();
+	if (mockReset) vi.resetAllMocks();
+	if (clearMocks) vi.clearAllMocks();
+	if (unstubEnvs) vi.unstubAllEnvs();
+	if (unstubGlobals) vi.unstubAllGlobals();
+}
+
+export { NodeBenchmarkRunner as N, TestRunner as T, assert as a, vitest as b, createExpect as c, globalExpect as g, inject as i, should as s, vi as v };