vitest 5.0.0-beta.4 → 5.0.0-beta.6

package/dist/chunks/{index.CE58PZNH.js → index.D6NDM5O1.js}

@@ -1,21 +1,21 @@
-import { TestSyntaxError, getCurrentTest, createTaskCollector, getCurrentSuite, getHooks, getFn, afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
-import { i as isChildProcess, w as waitForImportsToResolve, r as resetModules, g as getWorkerState } from './utils.BX5Fg8C4.js';
+import { T as TestSyntaxError, g as getCurrentTest, c as createTaskCollector, a as getCurrentSuite, b as createChainable, d as getHooks, e as getFn, m as matchesTags, f as afterAll, h as afterEach, i as aroundAll, j as aroundEach, k as beforeAll, l as beforeEach, n as describe, o as it, q as onTestFailed, r as onTestFinished, t as recordArtifact, u as suite, v as test } from './artifact.BNnEI1sJ.js';
+import { i as isChildProcess, r as resetModules, g as getWorkerState } from './utils.DYj33du9.js';
 import { getSafeTimers, delay } from '@vitest/utils/timers';
 import { isMockFunction, fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks } from '@vitest/spy';
 import { getType, isObject, noop, assertTypes, ordinal, createSimpleStackTrace, getCallLastIndex } from '@vitest/utils/helpers';
 import { positionToOffset, offsetToLineNumber, lineSplitRE } from '@vitest/utils/offset';
 import { parseSingleStack, parseErrorStacktrace } from '@vitest/utils/source-map';
 import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.D26ty3Ew.js';
-import { R as RealDate, b as resetDate, m as mockDate, r as rpc, V as VitestEvaluatedModules } from './rpc.DFRWVnRh.js';
+import { R as RealDate, b as resetDate, m as mockDate, r as rpc, V as VitestEvaluatedModules } from './rpc.DZEh5xnQ.js';
+import { stringify, inspect } from '@vitest/utils/display';
+import { printDiffOrStringify, diff } from '@vitest/utils/diff';
+import c from 'tinyrainbow';
 import * as chai from 'chai';
 import { use, util } from 'chai';
-import { getNames, getTests, getTestName, createChainable, matchesTags } from '@vitest/runner/utils';
 import { processError } from '@vitest/utils/error';
+import { getNames, getTests, getTestName, createFileTask } from '../task-utils.js';
 import { g as getSerializers, a as addSerializer } from './plugins.DrsmdUE2.js';
 import { format } from '@vitest/pretty-format';
-import { printDiffOrStringify, diff } from '@vitest/utils/diff';
-import { stringify, inspect } from '@vitest/utils/display';
-import c from 'tinyrainbow';
 import { isAbsolute, relative, normalize } from 'pathe';
 import { Bench } from 'tinybench';
 import { expectTypeOf } from 'expect-type';
@@ -342,7 +342,7 @@ function isA(typeName, value) {
 function isDomNode(obj) {
 	return obj !== null && typeof obj === "object" && "nodeType" in obj && typeof obj.nodeType === "number" && "nodeName" in obj && typeof obj.nodeName === "string" && "isEqualNode" in obj && typeof obj.isEqualNode === "function";
 }
-// SENTINEL constants are from https://github.com/facebook/immutable-js
+// SENTINEL constants are from https://github.com/immutable-js/immutable-js
 const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
 const IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
 const IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";
@@ -2729,15 +2729,35 @@ function requireFakeTimersSrc () {
 	 * @returns {void}
 	 */
 
+	/**
+	 * @typedef {object} TemporalDuration
+	 * @property {number} years - years component
+	 * @property {number} months - months component
+	 * @property {number} weeks - weeks component
+	 * @property {number} days - days component
+	 * @property {number} hours - hours component
+	 * @property {number} minutes - minutes component
+	 * @property {number} seconds - seconds component
+	 * @property {number} milliseconds - milliseconds component
+	 * @property {number} microseconds - microseconds component
+	 * @property {number} nanoseconds - nanoseconds component
+	 * @property {(options: {unit: string, relativeTo?: unknown}) => number} total - converts to a single unit
+	 */
+
+	/**
+	 * @typedef {object} TemporalTimelike
+	 * @property {number} epochMilliseconds - milliseconds since the Unix epoch (present on Temporal.Instant and Temporal.ZonedDateTime)
+	 */
+
 	/**
 	 * @callback Tick
-	 * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	 * @param {number|string|TemporalDuration} tickValue milliseconds, a string parseable by parseTime, or a Temporal.Duration
 	 * @returns {number} will return the new `now` value
 	 */
 
 	/**
 	 * @callback TickAsync
-	 * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	 * @param {number|string|TemporalDuration} tickValue milliseconds, a string parseable by parseTime, or a Temporal.Duration
 	 * @returns {Promise<number>}
 	 */
 
@@ -2783,13 +2803,13 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * @callback SetSystemTime
-	 * @param {number|Date} [now] initial mocked time, as milliseconds since epoch or a Date
+	 * @param {number|Date|TemporalTimelike} [now] initial mocked time, as milliseconds since epoch, a Date, a Temporal.Instant, or a Temporal.ZonedDateTime
 	 * @returns {void}
 	 */
 
 	/**
 	 * @callback Jump
-	 * @param {number|string} tickValue milliseconds or a human-readable value like "01:11:15"
+	 * @param {number|string|TemporalDuration} tickValue milliseconds, a human-readable value like "01:11:15", or a Temporal.Duration
 	 * @returns {number}
 	 */
 
@@ -2817,7 +2837,7 @@ function requireFakeTimersSrc () {
 	 */
 
 	/**
-	 * @typedef {"setTimeout" | "clearTimeout" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "Date" | "nextTick" | "hrtime" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "performance" | "queueMicrotask"} FakeMethod
+	 * @typedef {"setTimeout" | "clearTimeout" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "Date" | "nextTick" | "hrtime" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "performance" | "queueMicrotask" | "Intl" | "Temporal"} FakeMethod
 	 */
 
 	/**
@@ -2842,6 +2862,7 @@ function requireFakeTimersSrc () {
 	 *   performance?: any,
 	 *   Performance?: any,
 	 *   Intl?: any,
+	 *   Temporal?: any,
 	 *   Promise?: typeof Promise,
 	 *   Date: typeof Date & { isFake?: boolean, toSource?: () => string, clock?: any }
 	 * }} GlobalObject
@@ -2873,6 +2894,10 @@ function requireFakeTimersSrc () {
 	 * @typedef {Record<string, any> & { clock: Clock }} IntlWithClock
 	 */
 
+	/**
+	 * @typedef {Record<string, any> & { now: () => number }} PerformanceLike
+	 */
+
 	/**
 	 * @typedef {object} Timers
 	 * @property {SetTimeout} setTimeout - native `setTimeout`
@@ -2881,11 +2906,12 @@ function requireFakeTimersSrc () {
 	 * @property {ClearInterval} clearInterval - native `clearInterval`
 	 * @property {typeof Date} Date - native `Date`
 	 * @property {typeof Intl} [Intl] - native `Intl`
+	 * @property {any} [Temporal] - native `Temporal`
 	 * @property {SetImmediate} [setImmediate] - native `setImmediate`, if available
 	 * @property {ClearImmediate} [clearImmediate] - native `clearImmediate`, if available
 	 * @property {Hrtime} [hrtime] - native `process.hrtime`, if available
 	 * @property {NextTick} [nextTick] - native `process.nextTick`, if available
-	 * @property {Performance} [performance] - native `performance`, if available
+	 * @property {PerformanceLike} [performance] - native `performance`, if available
 	 * @property {RequestAnimationFrame} [requestAnimationFrame] - native `requestAnimationFrame`, if available
 	 * @property {QueueMicrotask} [queueMicrotask] - whether `queueMicrotask` exists
 	 * @property {CancelAnimationFrame} [cancelAnimationFrame] - native `cancelAnimationFrame`, if available
@@ -2926,7 +2952,7 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * @callback CreateClockCallback
-	 * @param {number|Date} [start] initial mocked time, as milliseconds since epoch or a Date
+	 * @param {number|Date|TemporalTimelike} [start] initial mocked time, as milliseconds since epoch, a Date, a Temporal.Instant, or a Temporal.ZonedDateTime
 	 * @param {number} [loopLimit] maximum number of timers run before aborting with an infinite-loop error
 	 * @returns {Clock}
 	 */
@@ -2993,13 +3019,14 @@ function requireFakeTimersSrc () {
 	 * @property {ClockTickMode} [tickMode] - internal flag
 	 * @property {Timer[]} [jobs] - internal flag
 	 * @property {IntlWithClock} [Intl] - fake Intl object
+	 * @property {any} [Temporal] - fake Temporal object
 	 */
 	/* eslint-enable jsdoc/reject-any-type */
 
 	/**
 	 * Configuration object for the `install` method.
 	 * @typedef {object} Config
-	 * @property {number|Date} [now] initial mocked time, as milliseconds since epoch or a Date
+	 * @property {number|Date|TemporalTimelike} [now] initial mocked time, as milliseconds since epoch, a Date, a Temporal.Instant, or a Temporal.ZonedDateTime
 	 * @property {FakeMethod[]} [toFake] method names that should be faked
 	 * @property {FakeMethod[]} [toNotFake] method names that should remain native
 	 * @property {number} [loopLimit] maximum number of timers run before aborting with an infinite-loop error
@@ -3108,6 +3135,11 @@ function requireFakeTimersSrc () {
 	    isPresent.clearImmediate =
 	        _global.clearImmediate && typeof _global.clearImmediate === "function";
 	    isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
+	    isPresent.Temporal =
+	        _global.Temporal !== null &&
+	        typeof _global.Temporal === "object" &&
+	        typeof _global.Temporal.Now !== "undefined" &&
+	        typeof _global.Temporal.Instant !== "undefined";
 
 	    if (_global.clearTimeout) {
 	        _global.clearTimeout(timeoutResult);
@@ -3120,6 +3152,7 @@ function requireFakeTimersSrc () {
 	              Object.getOwnPropertyDescriptors(_global.Intl),
 	          )
 	        : undefined;
+	    const NativeTemporal = isPresent.Temporal ? _global.Temporal : undefined;
 	    let uniqueTimerId = idCounterStart;
 	    /** @type {number} */
 	    let uniqueTimerOrder = 0;
@@ -3237,7 +3270,7 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Used to grok the `now` parameter to createClock.
-	     * @param {Date|number} epoch the system time
+	     * @param {Date|number|TemporalTimelike} epoch the system time
 	     * @returns {number}
 	     */
 	    function getEpoch(epoch) {
@@ -3247,8 +3280,16 @@ function requireFakeTimersSrc () {
 	        if (typeof epoch === "number") {
 	            return epoch;
 	        }
-	        if (typeof epoch.getTime === "function") {
-	            return epoch.getTime();
+	        if (typeof (/** @type {Date} */ (epoch).getTime) === "function") {
+	            return /** @type {Date} */ (epoch).getTime();
+	        }
+	        if (
+	            typeof (
+	                /** @type {TemporalTimelike} */ (epoch).epochMilliseconds
+	            ) === "number"
+	        ) {
+	            // Temporal.Instant and Temporal.ZonedDateTime both have epochMilliseconds
+	            return /** @type {TemporalTimelike} */ (epoch).epochMilliseconds;
 	        }
 	        throw new TypeError("now should be milliseconds since UNIX epoch");
 	    }
@@ -3465,6 +3506,56 @@ function requireFakeTimersSrc () {
 	        return IntlWithClock;
 	    }
 
+	    //eslint-disable-next-line jsdoc/require-jsdoc
+	    function createTemporal(clock, getNanos) {
+	        const fakeNow = {
+	            instant() {
+	                return NativeTemporal.Instant.fromEpochNanoseconds(
+	                    BigInt(clock.now) * 1_000_000n + BigInt(getNanos()),
+	                );
+	            },
+	            timeZoneId() {
+	                return NativeTemporal.Now.timeZoneId();
+	            },
+	            zonedDateTimeISO(timeZone) {
+	                const tz = timeZone ?? NativeTemporal.Now.timeZoneId();
+	                return fakeNow.instant().toZonedDateTimeISO(tz);
+	            },
+	            plainDateTimeISO(timeZone) {
+	                return fakeNow.zonedDateTimeISO(timeZone).toPlainDateTime();
+	            },
+	            plainDateISO(timeZone) {
+	                return fakeNow.zonedDateTimeISO(timeZone).toPlainDate();
+	            },
+	            plainTimeISO(timeZone) {
+	                return fakeNow.zonedDateTimeISO(timeZone).toPlainTime();
+	            },
+	        };
+
+	        const TemporalWithClock = Object.create(
+	            Object.getPrototypeOf(NativeTemporal),
+	        );
+	        [
+	            ...Object.getOwnPropertyNames(NativeTemporal),
+	            ...Object.getOwnPropertySymbols(NativeTemporal),
+	        ].forEach((prop) => {
+	            Object.defineProperty(
+	                TemporalWithClock,
+	                prop,
+	                Object.getOwnPropertyDescriptor(NativeTemporal, prop),
+	            );
+	        });
+	        // Temporal.Now is writable:false in the spec so we must use defineProperty
+	        Object.defineProperty(TemporalWithClock, "Now", {
+	            value: fakeNow,
+	            writable: true,
+	            enumerable: false,
+	            configurable: true,
+	        });
+
+	        return TemporalWithClock;
+	    }
+
 	    //eslint-disable-next-line jsdoc/require-jsdoc
 	    function enqueueJob(clock, job) {
 	        // enqueues a microtick-deferred task - ecma262/#sec-enqueuejob
@@ -4099,85 +4190,6 @@ function requireFakeTimersSrc () {
 	        }
 	    }
 
-	    /**
-	     * @param {Clock} clock
-	     * @returns {Timer[]}
-	     */
-	    function uninstall(clock) {
-	        let method, i, l;
-	        const installedHrTime = "_hrtime";
-	        const installedNextTick = "_nextTick";
-
-	        for (i = 0, l = clock.methods.length; i < l; i++) {
-	            method = clock.methods[i];
-	            if (method === "hrtime" && _global.process) {
-	                _global.process.hrtime = clock[installedHrTime];
-	            } else if (method === "nextTick" && _global.process) {
-	                _global.process.nextTick = clock[installedNextTick];
-	            } else if (method === "performance") {
-	                const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
-	                    clock,
-	                    `_${method}`,
-	                );
-	                if (
-	                    originalPerfDescriptor &&
-	                    originalPerfDescriptor.get &&
-	                    !originalPerfDescriptor.set
-	                ) {
-	                    Object.defineProperty(
-	                        _global,
-	                        method,
-	                        originalPerfDescriptor,
-	                    );
-	                } else if (originalPerfDescriptor.configurable) {
-	                    _global[method] = clock[`_${method}`];
-	                }
-	            } else {
-	                if (clock[method] && clock[method].hasOwnProperty) {
-	                    _global[method] = clock[`_${method}`];
-	                } else {
-	                    try {
-	                        delete _global[method];
-	                    } catch {
-	                        /* eslint no-empty: "off" */
-	                    }
-	                }
-	            }
-	            if (clock.timersModuleMethods !== undefined) {
-	                for (let j = 0; j < clock.timersModuleMethods.length; j++) {
-	                    const entry = clock.timersModuleMethods[j];
-	                    timersModule[entry.methodName] = entry.original;
-	                }
-	            }
-	            if (clock.timersPromisesModuleMethods !== undefined) {
-	                for (
-	                    let j = 0;
-	                    j < clock.timersPromisesModuleMethods.length;
-	                    j++
-	                ) {
-	                    const entry = clock.timersPromisesModuleMethods[j];
-	                    timersPromisesModule[entry.methodName] = entry.original;
-	                }
-	            }
-	        }
-
-	        clock.setTickMode({ mode: "manual" });
-
-	        // Prevent multiple executions which will completely remove these props
-	        clock.methods = [];
-
-	        for (const [listener, signal] of clock.abortListenerMap.entries()) {
-	            signal.removeEventListener("abort", listener);
-	            clock.abortListenerMap.delete(listener);
-	        }
-
-	        // return pending timers, to enable checking what timers remained on uninstall
-	        if (!clock.timerHeap) {
-	            return [];
-	        }
-	        return clock.timerHeap.timers.slice();
-	    }
-
 	    /**
 	     * @param {object} target the target containing the method to replace
 	     * @param {string} method the keyname of the method on the target
@@ -4194,6 +4206,8 @@ function requireFakeTimersSrc () {
 	            target[method] = clock[method];
 	        } else if (method === "Intl") {
 	            target[method] = clock[method];
+	        } else if (method === "Temporal") {
+	            target[method] = clock[method];
 	        } else if (method === "performance") {
 	            const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
 	                target,
@@ -4294,12 +4308,16 @@ function requireFakeTimersSrc () {
 	        timers.Intl = NativeIntl;
 	    }
 
+	    if (isPresent.Temporal) {
+	        timers.Temporal = NativeTemporal;
+	    }
+
 	    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
+	     * @param {Date|number|TemporalTimelike} [start] the system time - non-integer values are floored
 	     * @param {number} [loopLimit] maximum number of timers that will be run when calling runAll()
 	     * @returns {Clock}
 	     */
@@ -4312,6 +4330,7 @@ function requireFakeTimersSrc () {
 	        loopLimit = loopLimit || 1000;
 	        /** @type {number} */
 	        let nanos = 0;
+	        let uninstalled = false;
 	        /** @type {number[]} */
 	        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]
 
@@ -4389,6 +4408,10 @@ function requireFakeTimersSrc () {
 	            clock.Intl.clock = clock;
 	        }
 
+	        if (isPresent.Temporal) {
+	            clock.Temporal = createTemporal(clock, () => nanos);
+	        }
+
 	        /**
 	         * @param {SetTickModeConfig} tickModeConfig - The new configuration for how the clock should tick.
 	         */
@@ -4467,7 +4490,9 @@ function requireFakeTimersSrc () {
 	            }
 	            clock.setTickMode({ mode: "manual" });
 	            return promise.finally(() => {
-	                clock.setTickMode({ mode: "nextAsync" });
+	                if (!uninstalled) {
+	                    clock.setTickMode({ mode: "nextAsync" });
+	                }
 	            });
 	        }
 
@@ -4623,15 +4648,44 @@ function requireFakeTimersSrc () {
 	            runJobs(clock);
 	        };
 
+	        //eslint-disable-next-line jsdoc/require-jsdoc
+	        function durationToMs(duration) {
+	            // relativeTo uses the real system timezone — fake-timers fakes time, not place.
+	            // Calendar-unit durations (months, years) will resolve DST/length using the host tz.
+	            const relativeTo = NativeTemporal.Instant.fromEpochMilliseconds(
+	                clock.now,
+	            ).toZonedDateTimeISO(NativeTemporal.Now.timeZoneId());
+	            return duration.total({ unit: "millisecond", relativeTo });
+	        }
+
 	        /**
-	         * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	         * @param {number|string|TemporalDuration} tickValue
+	         * @returns {number} milliseconds as a float
+	         */
+	        function tickValueToMs(tickValue) {
+	            if (typeof tickValue === "number") {
+	                return tickValue;
+	            }
+	            if (
+	                isPresent.Temporal &&
+	                tickValue !== null &&
+	                typeof tickValue === "object" &&
+	                typeof (/** @type {TemporalDuration} */ (tickValue).total) ===
+	                    "function"
+	            ) {
+	                return durationToMs(
+	                    /** @type {TemporalDuration} */ (tickValue),
+	                );
+	            }
+	            return parseTime(/** @type {string} */ (tickValue));
+	        }
+
+	        /**
+	         * @param {number|string|TemporalDuration} tickValue milliseconds, a string parseable by parseTime, or a Temporal.Duration
 	         * @returns {ClockState} a mutable state object for the tick execution
 	         */
 	        function createTickState(tickValue) {
-	            const msFloat =
-	                typeof tickValue === "number"
-	                    ? tickValue
-	                    : parseTime(tickValue);
+	            const msFloat = tickValueToMs(tickValue);
 	            const ms = Math.floor(msFloat);
 	            const remainder = nanoRemainder(msFloat);
 	            let nanosTotal = nanos + remainder;
@@ -4792,7 +4846,7 @@ function requireFakeTimersSrc () {
 	        }
 
 	        /**
-	         * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	         * @param {number|string|TemporalDuration} tickValue milliseconds or a string parseable by parseTime
 	         * @param {boolean} isAsync whether this is an async tick
 	         * @param {FakeTimersFunction} [resolve] promise resolve function
 	         * @param {FakeTimersFunction} [reject] promise reject function
@@ -4848,7 +4902,7 @@ function requireFakeTimersSrc () {
 	        }
 
 	        /**
-	         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+	         * @param {string|number|TemporalDuration} tickValue number of milliseconds, a human-readable value like "01:11:15", or a Temporal.Duration
 	         * @returns {number} will return the new `now` value
 	         */
 	        clock.tick = function tick(tickValue) {
@@ -4929,7 +4983,7 @@ function requireFakeTimersSrc () {
 
 	        if (typeof _global.Promise !== "undefined") {
 	            /**
-	             * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+	             * @param {string|number|TemporalDuration} tickValue number of milliseconds, a human-readable value like "01:11:15", or a Temporal.Duration
 	             * @returns {Promise}
 	             */
 	            clock.tickAsync = function tickAsync(tickValue) {
@@ -5055,14 +5109,11 @@ function requireFakeTimersSrc () {
 	        };
 
 	        /**
-	         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+	         * @param {string|number|TemporalDuration} tickValue number of milliseconds, a human-readable value like "01:11:15", or a Temporal.Duration
 	         * @returns {number} the new `now` value
 	         */
 	        clock.jump = function jump(tickValue) {
-	            const msFloat =
-	                typeof tickValue === "number"
-	                    ? tickValue
-	                    : parseTime(tickValue);
+	            const msFloat = tickValueToMs(tickValue);
 	            const ms = Math.floor(msFloat);
 
 	            forEachActiveTimer(clock, (timer) => {
@@ -5087,6 +5138,97 @@ function requireFakeTimersSrc () {
 	            clock.hrtime = hrtime;
 	        }
 
+	        /**
+	         * @returns {Timer[]}
+	         */
+	        clock.uninstall = function () {
+	            uninstalled = true;
+	            clock.setTickMode({ mode: "manual" });
+
+	            if (clock.methods) {
+	                const installedHrTime = "_hrtime";
+	                const installedNextTick = "_nextTick";
+	                let method, i, l;
+	                for (i = 0, l = clock.methods.length; i < l; i++) {
+	                    method = clock.methods[i];
+	                    if (method === "hrtime" && _global.process) {
+	                        _global.process.hrtime = clock[installedHrTime];
+	                    } else if (method === "nextTick" && _global.process) {
+	                        _global.process.nextTick = clock[installedNextTick];
+	                    } else if (method === "performance") {
+	                        const originalPerfDescriptor =
+	                            Object.getOwnPropertyDescriptor(
+	                                clock,
+	                                `_${method}`,
+	                            );
+	                        if (
+	                            originalPerfDescriptor &&
+	                            originalPerfDescriptor.get &&
+	                            !originalPerfDescriptor.set
+	                        ) {
+	                            Object.defineProperty(
+	                                _global,
+	                                method,
+	                                originalPerfDescriptor,
+	                            );
+	                        } else if (originalPerfDescriptor.configurable) {
+	                            _global[method] = clock[`_${method}`];
+	                        }
+	                    } else {
+	                        if (clock[method] && clock[method].hasOwnProperty) {
+	                            _global[method] = clock[`_${method}`];
+	                        } else {
+	                            try {
+	                                delete _global[method];
+	                            } catch {
+	                                /* eslint no-empty: "off" */
+	                            }
+	                        }
+	                    }
+	                    if (clock.timersModuleMethods !== undefined) {
+	                        for (
+	                            let j = 0;
+	                            j < clock.timersModuleMethods.length;
+	                            j++
+	                        ) {
+	                            const entry = clock.timersModuleMethods[j];
+	                            timersModule[entry.methodName] = entry.original;
+	                        }
+	                    }
+	                    if (clock.timersPromisesModuleMethods !== undefined) {
+	                        for (
+	                            let j = 0;
+	                            j < clock.timersPromisesModuleMethods.length;
+	                            j++
+	                        ) {
+	                            const entry = clock.timersPromisesModuleMethods[j];
+	                            timersPromisesModule[entry.methodName] =
+	                                entry.original;
+	                        }
+	                    }
+	                }
+
+	                // Prevent multiple executions which will completely remove these props
+	                clock.methods = [];
+	            }
+
+	            if (clock.abortListenerMap) {
+	                for (const [
+	                    listener,
+	                    signal,
+	                ] of clock.abortListenerMap.entries()) {
+	                    signal.removeEventListener("abort", listener);
+	                    clock.abortListenerMap.delete(listener);
+	                }
+	            }
+
+	            // return pending timers, to enable checking what timers remained on uninstall
+	            if (!clock.timerHeap) {
+	                return [];
+	            }
+	            return clock.timerHeap.timers.slice();
+	        };
+
 	        return clock;
 	    }
 
@@ -5175,10 +5317,6 @@ function requireFakeTimersSrc () {
 	        const clock = createClock(config.now, config.loopLimit);
 	        clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
 
-	        clock.uninstall = function () {
-	            return uninstall(clock);
-	        };
-
 	        clock.abortListenerMap = new Map();
 
 	        if (hasToFake) {
@@ -5692,6 +5830,235 @@ class FakeTimers {
 	}
 }
 
+const whenSymbol = Symbol.for("$$vitest:when");
+/**
+* Returns `true` if the given value is a {@linkcode When} chain created by {@linkcode when|vi.when}.
+*
+* @param input - The value to check.
+* @returns `true` if `input` is a {@linkcode When} instance, `false` otherwise.
+*
+* @example
+* const spy = vi.fn()
+* const w = vi.when(spy).calledWith(1).thenReturn(0)
+*
+* expect(isWhenChain(w)).toBe(true)
+* expect(isWhenChain(spy)).toBe(false)
+*/
+function isWhenChain(input) {
+	try {
+		return Reflect.has(input, whenSymbol);
+	} catch {
+		return false;
+	}
+}
+/**
+* Defines conditional behaviors on a Vitest spy based on the arguments it is called with.
+*
+* Behaviors are matched using deep equality, last-registered first within each argument set.
+*
+* It automatically restores the spy's original implementation when the enclosing block exits if used with the `using` keyword.
+*
+* @param spy - A Vitest mock function to attach behaviors to.
+* @param options - Optional configuration.
+* @returns A {@linkcode When} instance for registering behaviors.
+*
+* @throws {TypeError} If `spy` is not a Vitest mock function.
+* @throws {Error} If chaining a non-existent method after `calledWith`.
+* @throws {RangeError} If setting the `times` option on a `then*` method as a negative value or `0`.
+*
+* @since 5.0.0
+* @see {@link https://vitest.dev/api/vi#vi-when}
+* @see {@link https://vitest.dev/guide/recipes/conditional-mocking}
+*
+* @example
+* // Basic usage
+* const spy = vi.fn(() => Number.NEGATIVE_INFINITY)
+* vi.when(spy).calledWith(1).thenReturn(0)
+*
+* expect(spy(1)).toBe(0)
+* expect(spy(2)).toBe(Number.NEGATIVE_INFINITY) // falls through to original implementation
+*
+* @example
+* // Async
+* const spy = vi.fn()
+* vi.when(spy).calledWith('user').thenResolve({ id: 1 })
+*
+* await expect(spy('user')).resolves.toEqual({ id: 1 })
+*
+* @example
+* // Scoped with `using`
+* const spy = vi.fn()
+*
+* {
+*   using w = vi.when(spy)
+*     .calledWith('darkMode')
+*     .thenReturn(true)
+*
+*   expect(spy('darkMode')).toBe(true)
+* }
+*
+* // spy's original implementation is restored here
+* expect(spy('darkMode')).toBe(undefined)
+*
+* @example
+* // Throw on unmatched calls
+* vi.when(spy, { onUnmatched: 'throw' })
+*   .calledWith(1)
+*   .thenReturn({ id: 1, name: 'Alice' })
+*
+* expect(spy(1)).toEqual({ id: 1, name: 'Alice' })
+* expect(() => spy(2)).toThrow()
+*/
+function when(spy, options) {
+	if (!isMockFunction(spy)) throw new TypeError("vi.when: the argument must be a mock function created with `vi.fn()` or `vi.spyOn()`");
+	const behaviors = [];
+	const originalImplementation = spy.getMockImplementation();
+	function findAction(args) {
+		const testers = [...getCustomEqualityTesters(), iterableEquality];
+		for (const behavior of behaviors) if (equals(args, behavior.arguments, testers)) return behavior.actions.findLast((action) => !(action.remaining === 0 && action.called)) ?? null;
+		return null;
+	}
+	spy.mockImplementation(
+		// @ts-expect-error cannot resolve generic args
+		(...args) => {
+			const action = findAction(args);
+			if (action === null) return (typeof options?.onUnmatched === "function" ? options.onUnmatched : options?.onUnmatched === "throw" ? () => {
+				throw new Error(`vi.when: no behavior defined when called with [${args.map((arg) => stringify(arg)).join(", ")}]`);
+			} : originalImplementation)?.(...args);
+			action.remaining -= 1;
+			action.called = true;
+			switch (action.type) {
+				case "return": return action.value;
+				case "throw": throw action.value;
+				case "resolve": return Promise.resolve(action.value);
+				case "reject": return Promise.reject(action.value);
+			}
+		}
+	);
+	function getOrCreateBehavior(args) {
+		const testers = [...getCustomEqualityTesters(), iterableEquality];
+		let behavior = behaviors.find((behavior) => equals(args, behavior.arguments, testers));
+		if (behavior === void 0) {
+			behavior = {
+				arguments: args,
+				actions: []
+			};
+			behaviors.push(behavior);
+		}
+		return behavior;
+	}
+	// @ts-expect-error `Symbol.dispose` has to be assigned conditionally since it's only supported in Node >= 24
+	const output = markWhenChain({
+		calledWith: (...args) => {
+			const behavior = getOrCreateBehavior(args);
+			function appendAction(behavior, type, value, times) {
+				behavior.actions.push({
+					type,
+					value,
+					times,
+					remaining: times,
+					called: false
+				});
+			}
+			const calledWithInstance = markWhenChain({
+				...output,
+				thenThrow: (value, options) => {
+					validateOptions(options);
+					appendAction(behavior, "throw", value, options?.times ?? Number.POSITIVE_INFINITY);
+					return calledWithInstance;
+				},
+				thenThrowOnce: (value) => {
+					appendAction(behavior, "throw", value, 1);
+					return calledWithInstance;
+				},
+				thenReturn: (value, options) => {
+					validateOptions(options);
+					appendAction(behavior, "return", value, options?.times ?? Number.POSITIVE_INFINITY);
+					return calledWithInstance;
+				},
+				thenReturnOnce: (value) => {
+					appendAction(behavior, "return", value, 1);
+					return calledWithInstance;
+				},
+				thenResolve: (value, options) => {
+					validateOptions(options);
+					appendAction(behavior, "resolve", value, options?.times ?? Number.POSITIVE_INFINITY);
+					return calledWithInstance;
+				},
+				thenResolveOnce: (value) => {
+					appendAction(behavior, "resolve", value, 1);
+					return calledWithInstance;
+				},
+				thenReject: (value, options) => {
+					validateOptions(options);
+					appendAction(behavior, "reject", value, options?.times ?? Number.POSITIVE_INFINITY);
+					return calledWithInstance;
+				},
+				thenRejectOnce: (value) => {
+					appendAction(behavior, "reject", value, 1);
+					return calledWithInstance;
+				}
+			});
+			return calledWithInstance;
+		},
+		_getDiagnostics: () => {
+			const pendingBehaviors = behaviors.filter((behavior) => behavior.actions.length === 0 || behavior.actions.some((action) => !hasBeenConsumed(action)));
+			return {
+				isExhausted: behaviors.length !== 0 && pendingBehaviors.length === 0,
+				pendingBehaviors: pendingBehaviors.map((behavior) => `calledWith(${behavior.arguments.map((argument) => stringify(argument)).join(", ")})${behavior.actions.length === 0 ? "  → no actions" : `\n${formatActions(behavior.actions)}`}`).join("\n\n")
+			};
+		}
+	});
+	if (Symbol.dispose) output[Symbol.dispose] = () => {
+		spy.mockImplementation(
+			// @ts-expect-error without an original implementation we should fall back to an undefined-returning function as that's what the mocking functions do
+			originalImplementation ?? noop
+		);
+	};
+	return output;
+}
+const whenChainMarkerOptions = {};
+function markWhenChain(input) {
+	Reflect.defineProperty(input, whenSymbol, whenChainMarkerOptions);
+	return input;
+}
+function formatActions(actions) {
+	const lines = actions.map((action, index) => {
+		const method = getMethodName(action.type);
+		const left = `  ${getSymbol(action)} ${method}(${stringify(action.value)}${action.times === Number.POSITIVE_INFINITY ? "" : `, { times: ${action.times} }`})`;
+		const unreachable = !hasBeenConsumed(action) && actions.slice(index + 1).some((later) => later.times === Number.POSITIVE_INFINITY);
+		return {
+			left,
+			remaining: getRemainingLabel(action) + (unreachable ? "  → unreachable action" : "")
+		};
+	});
+	const maxLeft = Math.max(...lines.map((line) => line.left.length));
+	return lines.map(({ left, remaining }) => `${left.padEnd(maxLeft + 2)}${remaining}`).join("\n");
+}
+function getMethodName(type) {
+	switch (type) {
+		case "return": return "thenReturn";
+		case "resolve": return "thenResolve";
+		case "throw": return "thenThrow";
+		case "reject": return "thenReject";
+		default: throw new Error(`vi.when: "${type}" is not a known method`);
+	}
+}
+function hasBeenConsumed(action) {
+	return action.remaining === 0 || action.remaining === Number.POSITIVE_INFINITY && action.called;
+}
+function getRemainingLabel(action) {
+	if (hasBeenConsumed(action)) return action.remaining === Number.POSITIVE_INFINITY ? "exhausted" : `exhausted (${action.times} of ${action.times})`;
+	return action.remaining === Number.POSITIVE_INFINITY ? "never called" : `${action.remaining} remaining (out of ${action.times})`;
+}
+function getSymbol(action) {
+	if (hasBeenConsumed(action)) return "✓";
+	return "✗";
+}
+function validateOptions(options) {
+	if (typeof options?.times === "number" && options.times <= 0) throw new RangeError("vi.when: `times` option must be greater than 0");
+}
+
 function copyStackTrace$2(target, source) {
 	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
 	return target;
@@ -5888,6 +6255,8 @@ function createVitest() {
 		},
 		spyOn,
 		fn,
+		when,
+		isWhenChain,
 		waitFor,
 		waitUntil,
 		defineHelper: (fn) => {
@@ -6034,6 +6403,20 @@ function copyStackTrace$1(target, source) {
 	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
 	return target;
 }
+function waitNextTick() {
+	const { setTimeout } = getSafeTimers();
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
+async function waitForImportsToResolve() {
+	await waitNextTick();
+	const state = getWorkerState();
+	const promises = [];
+	const resolvingCount = state.resolvingModules.size;
+	for (const [_, mod] of state.evaluatedModules.idToModuleMap) if (mod.promise && !mod.evaluated) promises.push(mod.promise);
+	if (!promises.length && !resolvingCount) return;
+	await Promise.allSettled(promises);
+	await waitForImportsToResolve();
+}
 
 // these matchers are not supported because they don't make sense with poll
 const unsupported = [
@@ -6057,7 +6440,7 @@ const unsupported = [
 * @throws Always throws the provided error with an amended stack trace
 */
 function throwWithCause(error, source) {
-	if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
+	error.cause ??= /* @__PURE__ */ new Error("Matcher did not succeed in time.");
 	throw copyStackTrace(error, source);
 }
 function createExpectPoll(expect) {
@@ -6215,6 +6598,15 @@ function raceWith$1(promise, other) {
 	}))]);
 }
 
+const MockPlugin = (chai, utils) => {
+	utils.addMethod(chai.Assertion.prototype, "toHaveBeenExhausted", wrapAssertion(utils, "toHaveBeenExhausted", function() {
+		const chain = utils.flag(this, "object");
+		if (!isWhenChain(chain)) throw new TypeError(`${utils.inspect(chain)} is not a \`vi.when\` instance`);
+		const diagnostics = chain._getDiagnostics();
+		this.assert(diagnostics.isExhausted, `expected all behaviors to have been exhausted, but some remain:\n\n  ${diagnostics.pendingBehaviors.replaceAll(/\n(?!\n)/g, "\n  ")}`, "expected at least one behavior to remain un-exhausted, but all were");
+	}));
+};
+
 var naturalCompare$1 = {exports: {}};
 
 var hasRequiredNaturalCompare;
@@ -6874,7 +7266,7 @@ class SnapshotState {
 		if (!rawSnapshot) receivedSerialized = addExtraLineBreaks(receivedSerialized);
 		if (rawSnapshot) {
 			// normalize EOL when snapshot contains CRLF but received is LF
-			if (rawSnapshot.content && rawSnapshot.content.match(/\r\n/) && !receivedSerialized.match(/\r\n/)) rawSnapshot.content = normalizeNewlines(rawSnapshot.content);
+			if (rawSnapshot.content && /\r\n/.test(rawSnapshot.content) && !/\r\n/.test(receivedSerialized)) rawSnapshot.content = normalizeNewlines(rawSnapshot.content);
 		}
 		const expected = isInline ? inlineSnapshot : rawSnapshot ? rawSnapshot.content : this._snapshotData[key];
 		const expectedTrimmed = rawSnapshot ? expected : expected?.trim();
@@ -7467,6 +7859,7 @@ chai.use(JestChaiExpect);
 chai.use(ChaiStyleAssertions);
 chai.use(SnapshotPlugin);
 chai.use(JestAsymmetricMatchers);
+chai.use(MockPlugin);
 
 function createExpect(test) {
 	const expect = ((value, message) => {
@@ -7724,7 +8117,7 @@ function createBench(test, config) {
 	bench.compare = async (...args) => {
 		validateBenchmarkProject(config);
 		// extract optional trailing BenchCompareOptions argument
-		const lastArg = args[args.length - 1];
+		const lastArg = args.at(-1);
 		const benchOptions = lastArg != null && typeof lastArg === "object" && !(kRegistration in lastArg) ? args.pop() : void 0;
 		const registrations = args;
 		// Mark every passed-in registration as consumed before validation so a
@@ -7775,7 +8168,7 @@ function createBench(test, config) {
 	};
 	bench[kFinalize] = () => {
 		if (pending.size === 0) return;
-		const names = [...pending].map((reg) => `"${reg.name}"`).join(", ");
+		const names = Array.from(pending, (reg) => `"${reg.name}"`).join(", ");
 		pending.clear();
 		console.warn([
 			c.yellow(c.bold("Benchmark Warning")),
@@ -7981,6 +8374,7 @@ class TestRunner {
 	static setSuiteHooks = getHooks;
 	static setTestFn = getFn;
 	static matchesTags = matchesTags;
+	static createFileTask = createFileTask;
 	/**
 	* @experimental
 	* A function that runs tinybench tasks.