vitest 5.0.0-beta.5 → 5.0.0-beta.7

package/dist/chunks/{index.CXzZ7KB8.js → index.CLtI1k_4.js}

@@ -1,22 +1,17 @@
-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.C0OHWdod.js';
+import { b as printDiffOrStringify, d as diff, a as processError, T as TestSyntaxError, g as getCurrentTest, c as createTaskCollector, e as getCurrentSuite, f as createChainable, h as getHooks, i as getFn, m as matchesTags, j as afterAll, k as afterEach, l as aroundAll, n as aroundEach, o as beforeAll, q as beforeEach, r as describe, t as it, u as onTestFailed, v as onTestFinished, w as recordArtifact, x as suite, y as test } from './artifact.DC5WoEgy.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.DZEh5xnQ.js';
+import { h as commonjsGlobal, a as getSafeTimers, f as parseSingleStack, i as delay, d as getDefaultExportFromCjs, j as parseErrorStacktrace } from './source-map.DZdIqpIJ.js';
+import { i as isMockFunction, f as fn, a as spyOn, r as restoreAllMocks, b as resetAllMocks, c as clearAllMocks } from './spy.B8mHA9qu.js';
+import { g as getType, v as isObject, p as noop, y as assertTypes, x as ordinal, D as createSimpleStackTrace, E as getCallLastIndex, i as isAbsolute, a as relative, n as normalize } from './pathe.M-eThtNZ.CbK_Vbae.js';
+import { R as RealDate, b as resetDate, m as mockDate, r as rpc, V as VitestEvaluatedModules } from './rpc.iNjF664v.js';
+import { s as stringify, i as inspect } from './display.CYwyMF4S.js';
+import { y } from './tinyrainbow.Ht9iggcq.js';
 import * as chai from 'chai';
 import { use, util } from 'chai';
 import { getNames, getTests, getTestName, createFileTask } from '../task-utils.js';
-import { processError } from '@vitest/utils/error';
-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 { g as getSerializers, a as addSerializer } from './plugins.CsoX-42X.js';
+import { p as positionToOffset, o as offsetToLineNumber, l as lineSplitRE } from './offset.Dy-5Fdfn.js';
+import { f as format } from './index.DzTmMrSM.js';
 import { Bench } from 'tinybench';
 import { expectTypeOf } from 'expect-type';
 
@@ -119,11 +114,11 @@ ${printReceived(actual)}`
 	}
 };
 
-const EXPECTED_COLOR = c.green;
-const RECEIVED_COLOR = c.red;
-const INVERTED_COLOR = c.inverse;
-const BOLD_WEIGHT = c.bold;
-const DIM_COLOR = c.dim;
+const EXPECTED_COLOR = y.green;
+const RECEIVED_COLOR = y.red;
+const INVERTED_COLOR = y.inverse;
+const BOLD_WEIGHT = y.bold;
+const DIM_COLOR = y.dim;
 function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
 	const { comment = "", isDirectExpectCall = false, isNot = false, promise = "", secondArgument = "", expectedColor = EXPECTED_COLOR, receivedColor = RECEIVED_COLOR, secondArgumentColor = EXPECTED_COLOR } = options;
 	let hint = "";
@@ -1449,25 +1444,25 @@ const JestChaiExpect = (chai, utils) => {
 	});
 };
 function formatCalls(spy, msg, showActualCall) {
-	if (spy.mock.calls.length) msg += c.gray(`\n\nReceived:\n\n${spy.mock.calls.map((callArg, i) => {
-		let methodCall = c.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call:\n\n`);
+	if (spy.mock.calls.length) msg += y.gray(`\n\nReceived:\n\n${spy.mock.calls.map((callArg, i) => {
+		let methodCall = y.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call:\n\n`);
 		if (showActualCall) methodCall += diff(showActualCall, callArg, { omitAnnotationLines: true });
 		else methodCall += stringify(callArg).split("\n").map((line) => `    ${line}`).join("\n");
 		methodCall += "\n";
 		return methodCall;
 	}).join("\n")}`);
-	msg += c.gray(`\n\nNumber of calls: ${c.bold(spy.mock.calls.length)}\n`);
+	msg += y.gray(`\n\nNumber of calls: ${y.bold(spy.mock.calls.length)}\n`);
 	return msg;
 }
 function formatReturns(spy, results, msg, showActualReturn) {
-	if (results.length) msg += c.gray(`\n\nReceived:\n\n${results.map((callReturn, i) => {
-		let methodCall = c.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call return:\n\n`);
+	if (results.length) msg += y.gray(`\n\nReceived:\n\n${results.map((callReturn, i) => {
+		let methodCall = y.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call return:\n\n`);
 		if (showActualReturn) methodCall += diff(showActualReturn, callReturn.value, { omitAnnotationLines: true });
 		else methodCall += stringify(callReturn).split("\n").map((line) => `    ${line}`).join("\n");
 		methodCall += "\n";
 		return methodCall;
 	}).join("\n")}`);
-	msg += c.gray(`\n\nNumber of calls: ${c.bold(spy.mock.calls.length)}\n`);
+	msg += y.gray(`\n\nNumber of calls: ${y.bold(spy.mock.calls.length)}\n`);
 	return msg;
 }
 
@@ -2729,15 +2724,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 +2798,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 +2832,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 +2857,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 +2889,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 +2901,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 +2947,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 +3014,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 +3130,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 +3147,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 +3265,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 +3275,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 +3501,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 +4185,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 +4201,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 +4303,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 +4325,7 @@ function requireFakeTimersSrc () {
 	        loopLimit = loopLimit || 1000;
 	        /** @type {number} */
 	        let nanos = 0;
+	        let uninstalled = false;
 	        /** @type {number[]} */
 	        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]
 
@@ -4389,6 +4403,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 +4485,9 @@ function requireFakeTimersSrc () {
 	            }
 	            clock.setTickMode({ mode: "manual" });
 	            return promise.finally(() => {
-	                clock.setTickMode({ mode: "nextAsync" });
+	                if (!uninstalled) {
+	                    clock.setTickMode({ mode: "nextAsync" });
+	                }
 	            });
 	        }
 
@@ -4623,15 +4643,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|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} tickValue milliseconds or a string parseable by parseTime
+	         * @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 +4841,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 +4897,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 +4978,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 +5104,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 +5133,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 +5312,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 +5825,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 +6250,8 @@ function createVitest() {
 		},
 		spyOn,
 		fn,
+		when,
+		isWhenChain,
 		waitFor,
 		waitUntil,
 		defineHelper: (fn) => {
@@ -5977,8 +6341,8 @@ function createVitest() {
 		stubEnv(name, value) {
 			const env = state().metaEnv;
 			if (!_stubsEnv.has(name)) _stubsEnv.set(name, env[name]);
-			if (_envBooleans.includes(name)) env[name] = value ? "1" : "";
-			else if (value === void 0) delete env[name];
+			if (value === void 0) delete env[name];
+			else if (_envBooleans.includes(name)) env[name] = value ? "1" : "";
 			else env[name] = String(value);
 			return utils;
 		},
@@ -6071,7 +6435,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) {
@@ -6229,6 +6593,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;
@@ -6888,7 +7261,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();
@@ -7481,6 +7854,7 @@ chai.use(JestChaiExpect);
 chai.use(ChaiStyleAssertions);
 chai.use(SnapshotPlugin);
 chai.use(JestAsymmetricMatchers);
+chai.use(MockPlugin);
 
 function createExpect(test) {
 	const expect = ((value, message) => {
@@ -7563,30 +7937,74 @@ function inject(key) {
 }
 
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+/**
+* The built-in benchmark provider, backed by tinybench. Selected when
+* `benchmark.provider` is not configured.
+*/
+function createDefaultBenchmarkProvider(config) {
+	let benchIdx = 0;
+	return { async run({ test, options, registrations }) {
+		const currentIndex = ++benchIdx;
+		const tinybench = new Bench({
+			signal: test.context.signal,
+			name: `${test.fullTestName} ${currentIndex}`,
+			retainSamples: config.benchmark.retainSamples,
+			...options,
+			now
+		});
+		for (const { name, fn, fnOpts } of registrations) tinybench.add(name, fn, fnOpts);
+		await tinybench.run();
+		const errors = tinybench.tasks.filter((task) => task.result.state === "errored").map((task) => task.result.error);
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Some benchmarks failed");
+		return tinybench.tasks.map(toBenchResult);
+	} };
+}
+function toBenchResult(task) {
+	const result = task.result;
+	if (result.state !== "completed") throw new Error(`task "${task.name}" did not complete: received "${result.state}"`);
+	return {
+		...result,
+		name: task.name
+	};
+}
+
 const kRegistration = Symbol("registration");
 const kFromSource = Symbol("fromSource");
 const kPerProject = Symbol("perProject");
 const kWriteResult = Symbol("writeResult");
 const kFinalize = Symbol("finalize");
+let cachedProvider;
+async function loadProviderModule(provider, moduleRunner) {
+	let mod;
+	try {
+		mod = await moduleRunner.import(provider);
+	} catch (error) {
+		throw new Error(`Failed to load benchmark provider from "${provider}".`, { cause: error });
+	}
+	if (mod.default == null) throw new Error(`Benchmark provider loaded from "${provider}" did not have a default export.`);
+	return mod.default;
+}
+/**
+* Resolves the benchmark provider for the current worker, importing a custom
+* provider module on first use. The result is cached for the lifetime of the
+* worker so a custom provider is imported at most once.
+*/
+function resolveBenchmarkProvider(config, moduleRunner) {
+	if (!cachedProvider) {
+		const provider = config.benchmark.provider;
+		cachedProvider = !provider ? Promise.resolve(createDefaultBenchmarkProvider(config)) : loadProviderModule(provider, moduleRunner);
+	}
+	return cachedProvider;
+}
 function isFromRegistration(reg) {
 	return kFromSource in reg;
 }
 function substitutePath(template, projectName) {
 	return template.replace(/\$\{projectName\}/g, projectName ?? "");
 }
-function createBench(test, config) {
-	let benchIdx = 0;
+function createBench(test, config, moduleRunner) {
 	const pending = /* @__PURE__ */ new Set();
-	const createTinybench = (options) => {
-		const currentIndex = ++benchIdx;
-		return new Bench({
-			signal: test.context.signal,
-			name: `${test.fullTestName} ${currentIndex}`,
-			retainSamples: config.benchmark.retainSamples,
-			...options,
-			now
-		});
-	};
 	const resolveTemplate = (template) => substitutePath(template, config.benchmark.projectName);
 	const resolveFromSource = async (source) => {
 		if (typeof source === "function") return source();
@@ -7604,42 +8022,37 @@ function createBench(test, config) {
 		rank: 0,
 		fromStore: true
 	});
-	const createCompareStorage = (bench, fromResults) => {
+	const createCompareStorage = (results, fromResults) => {
 		return { get(name) {
 			const stored = fromResults?.get(name);
 			if (stored) return stored;
-			const task = bench.getTask(name);
-			if (!task) throw new Error(`task "${name}" was not defined`);
-			return task.result;
+			const result = results.get(name);
+			if (!result) throw new Error(`task "${name}" was not defined`);
+			return result;
 		} };
 	};
-	const serializeBenchmark = (tinybenchTasks, name, taskMeta, fromTasks) => {
-		const tasks = tinybenchTasks.map((t) => {
-			const result = t.result;
-			if (result.state === "errored") throw result.error;
-			if (result.state !== "completed") throw new Error(`task "${t.name}" did not complete: received "${result.state}"`);
-			return {
-				name: t.name,
-				latency: result.latency,
-				throughput: result.throughput,
-				period: result.period,
-				totalTime: result.totalTime,
-				rank: 0,
-				...taskMeta?.get(t.name)
-			};
-		});
+	const serializeBenchmark = (results, name, taskMeta, fromTasks) => {
+		const tasks = results.map((result) => ({
+			name: result.name,
+			latency: result.latency,
+			throughput: result.throughput,
+			period: result.period,
+			totalTime: result.totalTime,
+			rank: 0,
+			...taskMeta?.get(result.name)
+		}));
 		if (fromTasks) tasks.push(...fromTasks);
 		tasks.sort((a, b) => a.latency.mean - b.latency.mean);
 		tasks.forEach((task, idx) => {
 			task.rank = idx + 1;
 		});
 		return {
-			name: name || test.fullTestName,
+			name,
 			tasks
 		};
 	};
-	const recordBenchmark = async (tinybenchTasks, name, taskMeta, fromTasks) => {
-		const serializedBenchmark = serializeBenchmark(tinybenchTasks, name, taskMeta, fromTasks);
+	const recordBenchmark = async (results, name, taskMeta, fromTasks) => {
+		const serializedBenchmark = serializeBenchmark(results, name, taskMeta, fromTasks);
 		test.benchmarks.push(serializedBenchmark);
 		await rpc().onTestBenchmark(test.id, serializedBenchmark);
 	};
@@ -7653,19 +8066,28 @@ function createBench(test, config) {
 		};
 		await rpc().writeBenchmarkResult(resolved, data);
 	};
-	const runBenchmarks = async (tinybench) => {
+	const groupName = (options) => options?.name ?? test.fullTestName;
+	const runGroup = async (registrations, options) => {
 		const workerState = getWorkerState();
 		const getterTracker = workerState.getterTracker;
 		getterTracker?.resetInvocations();
 		try {
-			return await TestRunner.runBenchmarks(tinybench);
+			const results = await (await resolveBenchmarkProvider(config, moduleRunner)).run({
+				test,
+				config: config.benchmark,
+				registrations,
+				options
+			});
+			const byName = /* @__PURE__ */ new Map();
+			for (const result of results) byName.set(result.name, result);
+			return byName;
 		} finally {
 			const excessiveInvocations = config.benchmark.suppressExportGetterWarnings ? void 0 : getterTracker?.getExcessiveInvocations();
 			if (excessiveInvocations?.length) {
 				const entries = excessiveInvocations.map(({ moduleId, exportName }) => `  - ${formatModuleId(moduleId, workerState.config.root)} > ${exportName}`).join("\n");
 				console.warn([
-					c.yellow(c.bold("Benchmark Warning")),
-					`Benchmark ${c.bold(`"${tinybench.name}"`)} accessed module export getters too many times.`,
+					y.yellow(y.bold("Benchmark Warning")),
+					`Benchmark ${y.bold(`"${groupName(options)}"`)} accessed module export getters too many times.`,
 					"",
 					"This can make results unreliable because export getters add overhead.",
 					"See https://vitest.dev/guide/benchmarking#module-runner-overhead",
@@ -7677,13 +8099,15 @@ function createBench(test, config) {
 		}
 	};
 	const runSingle = async (name, fn, fnOpts, options, meta, writeResult) => {
-		const tinybench = createTinybench(options).add(name, fn, fnOpts);
-		const tasks = await runBenchmarks(tinybench);
-		const task = tinybench.getTask(name);
-		if (task.result.state === "errored") throw task.result.error;
-		await recordBenchmark(tasks, tinybench.name, meta ? new Map([[name, meta]]) : void 0);
-		if (writeResult) await writeResultArtifact(writeResult, task.result);
-		return task.result;
+		const result = (await runGroup([{
+			name,
+			fn,
+			fnOpts
+		}], options)).get(name);
+		if (!result) throw new Error(`benchmark provider did not return a result for "${name}"`);
+		await recordBenchmark([result], groupName(options), meta ? new Map([[name, meta]]) : void 0);
+		if (writeResult) await writeResultArtifact(writeResult, result);
+		return result;
 	};
 	const runFrom = async (name, source) => {
 		const data = await resolveFromSource(source);
@@ -7737,8 +8161,8 @@ function createBench(test, config) {
 	};
 	bench.compare = async (...args) => {
 		validateBenchmarkProject(config);
-		// extract optional trailing BenchCompareOptions argument
-		const lastArg = args[args.length - 1];
+		// extract optional trailing BenchRunOptions argument
+		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
@@ -7767,33 +8191,29 @@ function createBench(test, config) {
 				fromTasks.push(taskFromBaseline(reg.name, data));
 			}
 		}
-		const tinybench = createTinybench(benchOptions);
-		runnable.forEach((reg) => {
-			tinybench.add(reg.name, reg.fn, reg.fnOpts);
-		});
-		let tasks = [];
-		if (runnable.length > 0) {
-			tasks = await runBenchmarks(tinybench);
-			const errors = tinybench.tasks.filter((task) => task.result.state === "errored").map((task) => task.result.error);
-			if (errors.length > 0) throw new AggregateError(errors, "Some benchmarks failed");
-		}
-		await recordBenchmark(tasks, tinybench.name, taskMeta, fromTasks);
+		let results = /* @__PURE__ */ new Map();
+		if (runnable.length > 0) results = await runGroup(runnable.map((reg) => ({
+			name: reg.name,
+			fn: reg.fn,
+			fnOpts: reg.fnOpts
+		})), benchOptions);
+		await recordBenchmark(Array.from(results.values()), groupName(benchOptions), taskMeta, fromTasks);
 		// write artifacts for every runnable registration that requested it. We
 		// do this after recording so a write failure can't be confused with a
 		// benchmark failure in the reporter output.
 		await Promise.all(runnable.filter((reg) => reg[kWriteResult] != null).map((reg) => {
-			const task = tinybench.getTask(reg.name);
-			return writeResultArtifact(reg[kWriteResult], task.result);
+			const result = results.get(reg.name);
+			return writeResultArtifact(reg[kWriteResult], result);
 		}));
-		return createCompareStorage(tinybench, fromResults);
+		return createCompareStorage(results, fromResults);
 	};
 	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")),
-			`Test ${c.bold(`"${test.fullTestName}"`)} registered benchmarks that never ran: ${names}.`,
+			y.yellow(y.bold("Benchmark Warning")),
+			`Test ${y.bold(`"${test.fullTestName}"`)} registered benchmarks that never ran: ${names}.`,
 			"",
 			"Call `.run()` on the registration, or pass it to `bench.compare()`.",
 			"See https://vitest.dev/guide/benchmarking#defining-a-benchmark"
@@ -7818,8 +8238,8 @@ function normalizeBenchArgs(a, b) {
 	if (typeof b !== "function") throw new TypeError("`bench()` expects a benchmark function. Call `bench(name, fn)` or `bench(name, options, fn)`.");
 	// Strip vitest-specific fields only when present so we don't allocate a new
 	// object — preserving referential identity matters: users inspect
-	// `registration.fnOpts` and tinybench's `add` sees the same object the
-	// caller passed in.
+	// `registration.fnOpts` and the provider sees the same object the caller
+	// passed in.
 	if (a.writeResult === void 0 && a.perProject === void 0) return {
 		fn: b,
 		fnOpts: a,
@@ -7955,9 +8375,10 @@ class TestRunner {
 		let _bench;
 		const runnerConfig = this.config;
 		const benchInstances = this.benchInstances;
+		const moduleRunner = this.moduleRunner;
 		Object.defineProperty(context, "bench", { get() {
 			if (!_bench) {
-				_bench = createBench(context.task, runnerConfig);
+				_bench = createBench(context.task, runnerConfig, moduleRunner);
 				benchInstances.set(context.task, _bench);
 			}
 			return _bench;
@@ -7996,14 +8417,6 @@ class TestRunner {
 	static setTestFn = getFn;
 	static matchesTags = matchesTags;
 	static createFileTask = createFileTask;
-	/**
-	* @experimental
-	* A function that runs tinybench tasks.
-	* Can be overriden to run tasks in a special environment.
-	*/
-	static async runBenchmarks(tinybench) {
-		return await tinybench.run();
-	}
 }
 function clearModuleMocks(config) {
 	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;