vitest 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/chunks/{index.D_7-4CaB.js → index.CE58PZNH.js}

@@ -1,22 +1,23 @@
-import { TestSyntaxError, getCurrentTest, getCurrentSuite, updateTask, createTaskCollector, getHooks, getFn, afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
+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 { getSafeTimers, delay } from '@vitest/utils/timers';
 import { isMockFunction, fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks } from '@vitest/spy';
-import { getType, isObject, noop, assertTypes, ordinal, createSimpleStackTrace, getCallLastIndex, createDefer } from '@vitest/utils/helpers';
+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 * as chai from 'chai';
 import { use, util } from 'chai';
-import { getNames, createChainable, getTests, getTestName, matchesTags } from '@vitest/runner/utils';
+import { getNames, getTests, getTestName, createChainable, matchesTags } from '@vitest/runner/utils';
 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 { normalize } from 'pathe';
+import { isAbsolute, relative, normalize } from 'pathe';
+import { Bench } from 'tinybench';
 import { expectTypeOf } from 'expect-type';
 
 const ChaiStyleAssertions = (chai, utils) => {
@@ -1590,6 +1591,48 @@ const JestExtend = (chai, utils) => {
 	});
 };
 
+function isBenchResult(value) {
+	return typeof value === "object" && value !== null && "latency" in value && typeof value.latency?.mean === "number";
+}
+function formatOps(ops) {
+	return ops.toLocaleString("en-US", {
+		minimumFractionDigits: 2,
+		maximumFractionDigits: 2
+	});
+}
+const benchMatchers = {
+	toBeFasterThan(actual, expected, options) {
+		const { matcherHint, RECEIVED_COLOR, EXPECTED_COLOR } = this.utils;
+		const delta = options?.delta ?? 0;
+		if (!isBenchResult(actual)) throw new TypeError(`${matcherHint(".toBeFasterThan")} expects the actual value to be a benchmark result.`);
+		if (!isBenchResult(expected)) throw new TypeError(`${matcherHint(".toBeFasterThan")} expects the expected value to be a benchmark result.`);
+		const threshold = expected.latency.mean * (1 - delta);
+		const pass = actual.latency.mean < threshold;
+		return {
+			pass,
+			message: () => {
+				const relation = ((actual.latency.mean - expected.latency.mean) / expected.latency.mean * 100).toFixed(2);
+				return pass ? `${matcherHint(".not.toBeFasterThan")}\n\nExpected to not be faster, but was ${Math.abs(Number(relation))}% faster.\n\nReceived: ${RECEIVED_COLOR(formatOps(actual.throughput.mean))} ops/sec\nExpected: ${EXPECTED_COLOR(formatOps(expected.throughput.mean))} ops/sec\n` : `${matcherHint(".toBeFasterThan")}\n\nExpected to be faster${delta > 0 ? ` by at least ${(delta * 100).toFixed(0)}%` : ""}, but was ${Number(relation) > 0 ? `${relation}% slower` : `only ${Math.abs(Number(relation))}% faster`}.\n\nReceived: ${RECEIVED_COLOR(formatOps(actual.throughput.mean))} ops/sec\nExpected: ${EXPECTED_COLOR(formatOps(expected.throughput.mean))} ops/sec\n`;
+			}
+		};
+	},
+	toBeSlowerThan(actual, expected, options) {
+		const { matcherHint, RECEIVED_COLOR, EXPECTED_COLOR } = this.utils;
+		const delta = options?.delta ?? 0;
+		if (!isBenchResult(actual)) throw new TypeError(`${matcherHint(".toBeSlowerThan")} expects the actual value to be a benchmark result.`);
+		if (!isBenchResult(expected)) throw new TypeError(`${matcherHint(".toBeSlowerThan")} expects the expected value to be a benchmark result.`);
+		const threshold = expected.latency.mean * (1 + delta);
+		const pass = actual.latency.mean > threshold;
+		return {
+			pass,
+			message: () => {
+				const relation = ((actual.latency.mean - expected.latency.mean) / expected.latency.mean * 100).toFixed(2);
+				return pass ? `${matcherHint(".not.toBeSlowerThan")}\n\nExpected to not be slower, but was ${relation}% slower.\n\nReceived: ${RECEIVED_COLOR(formatOps(actual.throughput.mean))} ops/sec\nExpected: ${EXPECTED_COLOR(formatOps(expected.throughput.mean))} ops/sec\n` : `${matcherHint(".toBeSlowerThan")}\n\nExpected to be slower${delta > 0 ? ` by at least ${(delta * 100).toFixed(0)}%` : ""}, but was ${Number(relation) < 0 ? `${Math.abs(Number(relation))}% faster` : `only ${relation}% slower`}.\n\nReceived: ${RECEIVED_COLOR(formatOps(actual.throughput.mean))} ops/sec\nExpected: ${EXPECTED_COLOR(formatOps(expected.throughput.mean))} ops/sec\n`;
+			}
+		};
+	}
+};
+
 var fakeTimersSrc = {};
 
 var global;
@@ -2529,12 +2572,12 @@ function requireFakeTimersSrc () {
 	if (typeof __vitest_required__ !== 'undefined') {
 	    try {
 	        timersModule = __vitest_required__.timers;
-	    } catch (e) {
+	    } catch {
 	        // ignored
 	    }
 	    try {
 	        timersPromisesModule = __vitest_required__.timersPromises;
-	    } catch (e) {
+	    } catch {
 	        // ignored
 	    }
 	}
@@ -2545,18 +2588,18 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * @typedef {object} NextAsyncTickMode
-	 * @property {"nextAsync"} mode
+	 * @property {"nextAsync"} mode - runs timers one macrotask at a time
 	 */
 
 	/**
 	 * @typedef {object} ManualTickMode
-	 * @property {"manual"} mode
+	 * @property {"manual"} mode - advances only when the caller explicitly ticks
 	 */
 
 	/**
 	 * @typedef {object} IntervalTickMode
-	 * @property {"interval"} mode
-	 * @property {number} [delta]
+	 * @property {"interval"} mode - advances automatically on a native interval
+	 * @property {number} [delta] - interval duration in milliseconds
 	 */
 
 	/**
@@ -2564,134 +2607,447 @@ function requireFakeTimersSrc () {
 	 */
 
 	/**
-	 * @typedef {object} IdleDeadline
-	 * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout
-	 * @property {function():number} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period
+	 * @callback FakeTimersFunction
+	 * @param {...unknown[]} args
+	 * @returns {unknown}
 	 */
 
 	/**
-	 * Queues a function to be called during a browser's idle periods
-	 * @callback RequestIdleCallback
-	 * @param {function(IdleDeadline)} callback
-	 * @param {{timeout: number}} options - an options object
-	 * @returns {number} the id
+	 * @callback VoidVarArgsFunc
+	 * @param {...unknown[]} args - optional arguments to call the callback with
+	 * @returns {void}
 	 */
 
 	/**
 	 * @callback NextTick
 	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} args - optional arguments to call the callback with
+	 * @param {...unknown[]} args - optional arguments to call the callback with
 	 * @returns {void}
 	 */
 
 	/**
 	 * @callback SetImmediate
 	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} args - optional arguments to call the callback with
+	 * @param {...unknown[]} args - optional arguments to call the callback with
 	 * @returns {NodeImmediate}
 	 */
 
 	/**
-	 * @callback VoidVarArgsFunc
-	 * @param {...*} callback - the callback to run
+	 * @callback SetTimeout
+	 * @param {VoidVarArgsFunc} callback - the callback to run
+	 * @param {number} [delay] - optional delay in milliseconds
+	 * @param {...unknown[]} args - optional arguments to call the callback with
+	 * @returns {TimerId} - the timeout identifier
+	 */
+
+	/**
+	 * @callback ClearTimeout
+	 * @param {TimerId} [id] - the timeout identifier to clear
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback SetInterval
+	 * @param {VoidVarArgsFunc} callback - the callback to run
+	 * @param {number} [delay] - optional delay in milliseconds
+	 * @param {...unknown[]} args - optional arguments to call the callback with
+	 * @returns {TimerId} - the interval identifier
+	 */
+
+	/**
+	 * @callback ClearInterval
+	 * @param {TimerId} [id] - the interval identifier to clear
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback QueueMicrotask
+	 * @param {VoidVarArgsFunc} callback - the callback to run
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback TimeRemaining
+	 * @returns {number}
+	 */
+
+	/**
+	 * @typedef {object} IdleDeadline
+	 * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout
+	 * @property {TimeRemaining} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period
+	 */
+
+	/**
+	 * @callback RequestIdleCallbackCallback
+	 * @param {IdleDeadline} deadline
+	 */
+
+	/**
+	 * Queues a function to be called during a browser's idle periods
+	 * @callback RequestIdleCallback
+	 * @param {RequestIdleCallbackCallback} callback
+	 * @param {{timeout?: number}} [options] - an options object
+	 * @returns {number} the id
+	 */
+
+	/**
+	 * @callback AnimationFrameCallback
+	 * @param {number} timestamp
+	 */
+
+	/**
+	 * @callback RequestAnimationFrame
+	 * @param {AnimationFrameCallback} callback
+	 * @returns {TimerId} - the request id
+	 */
+
+	/**
+	 * @callback CancelAnimationFrame
+	 * @param {TimerId} id - cancels a frame callback
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback CancelIdleCallback
+	 * @param {TimerId} id - cancels a scheduled idle callback
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback ClearImmediate
+	 * @param {NodeImmediate} id - faked `clearImmediate`
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback CountTimers
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback RunMicrotasks
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback Tick
+	 * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	 * @returns {number} will return the new `now` value
+	 */
+
+	/**
+	 * @callback TickAsync
+	 * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	 * @returns {Promise<number>}
+	 */
+
+	/**
+	 * @callback Next
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback NextAsync
+	 * @returns {Promise<number>}
+	 */
+
+	/**
+	 * @callback RunAll
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback RunToFrame
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback RunAllAsync
+	 * @returns {Promise<number>}
+	 */
+
+	/**
+	 * @callback RunToLast
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback RunToLastAsync
+	 * @returns {Promise<number>}
+	 */
+
+	/**
+	 * @callback Reset
 	 * @returns {void}
 	 */
 
 	/**
-	 * @typedef RequestAnimationFrame
-	 * @property {function(number):void} requestAnimationFrame
-	 * @returns {number} - the id
+	 * @callback SetSystemTime
+	 * @param {number|Date} [now] initial mocked time, as milliseconds since epoch or a Date
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback Jump
+	 * @param {number|string} tickValue milliseconds or a human-readable value like "01:11:15"
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback Uninstall
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback SetTickMode
+	 * @param {SetTickModeConfig} tickModeConfig - The new configuration for how the clock should tick.
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback Hrtime
+	 * @param {Array<number>} [prev]
+	 * @returns {Array<number>}
+	 */
+
+	/**
+	 * @callback WithGlobal
+	 * @param {object} _global Namespace to mock (e.g. `window`)
+	 * @returns {FakeTimers}
+	 */
+
+	/**
+	 * @typedef {"setTimeout" | "clearTimeout" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "Date" | "nextTick" | "hrtime" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "performance" | "queueMicrotask"} FakeMethod
+	 */
+
+	/**
+	 * @typedef {number | NodeImmediate | Timer} TimerId
+	 */
+
+	/* eslint-disable jsdoc/reject-any-type */
+	/**
+	 * @typedef {Record<string, any> & {
+	 *   setTimeout?: SetTimeout,
+	 *   clearTimeout?: ClearTimeout,
+	 *   setInterval?: SetInterval,
+	 *   clearInterval?: ClearInterval,
+	 *   setImmediate?: SetImmediate,
+	 *   clearImmediate?: ClearImmediate,
+	 *   queueMicrotask?: QueueMicrotask,
+	 *   requestAnimationFrame?: RequestAnimationFrame,
+	 *   cancelAnimationFrame?: CancelAnimationFrame,
+	 *   requestIdleCallback?: RequestIdleCallback,
+	 *   cancelIdleCallback?: CancelIdleCallback,
+	 *   process?: any,
+	 *   performance?: any,
+	 *   Performance?: any,
+	 *   Intl?: any,
+	 *   Promise?: typeof Promise,
+	 *   Date: typeof Date & { isFake?: boolean, toSource?: () => string, clock?: any }
+	 * }} GlobalObject
+	 */
+
+	/**
+	 * @typedef {object} TimerHeap
+	 * @property {Timer[]} timers - the heap-ordered timers
+	 * @property {() => Timer | undefined} peek - returns the next timer without removing it
+	 * @property {(timer: Timer) => void} push - adds a timer to the heap
+	 * @property {() => Timer | undefined} pop - removes and returns the next timer
+	 * @property {(timer: Timer) => void} remove - removes a specific timer
+	 */
+
+	/**
+	 * @typedef {object} ClockTickMode
+	 * @property {TickMode} mode - active tick mode
+	 * @property {number} counter - increments whenever the mode changes
+	 * @property {number} [delta] - interval length in milliseconds
+	 */
+
+	/**
+	 * @typedef {object} SetTickModeConfig
+	 * @property {TickMode} mode - desired tick mode
+	 * @property {number} [delta] - interval length in milliseconds
+	 */
+
+	/**
+	 * @typedef {Record<string, any> & { clock: Clock }} IntlWithClock
+	 */
+
+	/**
+	 * @typedef {object} Timers
+	 * @property {SetTimeout} setTimeout - native `setTimeout`
+	 * @property {ClearTimeout} clearTimeout - native `clearTimeout`
+	 * @property {SetInterval} setInterval - native `setInterval`
+	 * @property {ClearInterval} clearInterval - native `clearInterval`
+	 * @property {typeof Date} Date - native `Date`
+	 * @property {typeof Intl} [Intl] - native `Intl`
+	 * @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 {RequestAnimationFrame} [requestAnimationFrame] - native `requestAnimationFrame`, if available
+	 * @property {QueueMicrotask} [queueMicrotask] - whether `queueMicrotask` exists
+	 * @property {CancelAnimationFrame} [cancelAnimationFrame] - native `cancelAnimationFrame`, if available
+	 * @property {RequestIdleCallback} [requestIdleCallback] - native `requestIdleCallback`, if available
+	 * @property {CancelIdleCallback} [cancelIdleCallback] - native `cancelIdleCallback`, if available
+	 */
+
+	/**
+	 * @typedef {object} ClockState
+	 * @property {number} tickFrom - lower bound of the current tick range
+	 * @property {number} tickTo - upper bound of the current tick range
+	 * @property {number} [previous] - previous timer time used during ticking
+	 * @property {number | null} [oldNow] - previous value of `now`
+	 * @property {Timer} [timer] - timer currently being processed
+	 * @property {unknown} [firstException] - first exception raised while processing timers
+	 * @property {number} [nanosTotal] - accumulated nanoseconds from fractional ticks
+	 * @property {number} [msFloat] - accumulated fractional milliseconds
+	 * @property {number} [ms] - accumulated whole milliseconds
+	 */
+
+	/**
+	 * @typedef {object} TimerInitialProps
+	 * @property {VoidVarArgsFunc} func - callback or string to execute
+	 * @property {unknown[]} [args] - arguments passed to the callback
+	 * @property {'Timeout' | 'Interval' | 'Immediate' | 'AnimationFrame' | 'IdleCallback'} [type] - timer kind
+	 * @property {number} [delay] - requested delay in milliseconds
+	 * @property {number} [callAt] - scheduled execution time
+	 * @property {number} [createdAt] - time at which the timer was created
+	 * @property {boolean} [immediate] - whether this timer should run before non-immediate timers at the same time
+	 * @property {number} [id] - unique timer identifier
+	 * @property {Error} [error] - captured stack for loop diagnostics
+	 * @property {number} [interval] - interval for repeated timers
+	 * @property {boolean} [animation] - whether this is an animation frame timer
+	 * @property {boolean} [requestIdleCallback] - whether this is an idle callback timer
+	 * @property {number} [order] - execution order for timers at the same time
+	 * @property {number} [heapIndex] - index in the timer heap
+	 */
+
+	/**
+	 * @callback CreateClockCallback
+	 * @param {number|Date} [start] initial mocked time, as milliseconds since epoch or a Date
+	 * @param {number} [loopLimit] maximum number of timers run before aborting with an infinite-loop error
+	 * @returns {Clock}
+	 */
+
+	/**
+	 * @callback InstallCallback
+	 * @param {Config} [config] Optional config
+	 * @returns {Clock}
 	 */
 
 	/**
-	 * @typedef Performance
-	 * @property {function(): number} now
+	 * @typedef {object} FakeTimers
+	 * @property {Timers} timers - the native timer APIs saved for later restoration
+	 * @property {CreateClockCallback} createClock - creates a new fake clock
+	 * @property {InstallCallback} install - installs the fake timers onto the default global object
+	 * @property {WithGlobal} withGlobal - creates a fake-timers instance for a provided global object
 	 */
 
-	/* eslint-disable jsdoc/require-property-description */
 	/**
 	 * @typedef {object} Clock
-	 * @property {number} now - the current time
-	 * @property {Date} Date - the Date constructor
-	 * @property {number} loopLimit - the maximum number of timers before assuming an infinite loop
-	 * @property {RequestIdleCallback} requestIdleCallback
-	 * @property {function(number):void} cancelIdleCallback
-	 * @property {setTimeout} setTimeout
-	 * @property {clearTimeout} clearTimeout
-	 * @property {NextTick} nextTick
-	 * @property {queueMicrotask} queueMicrotask
-	 * @property {setInterval} setInterval
-	 * @property {clearInterval} clearInterval
-	 * @property {SetImmediate} setImmediate
-	 * @property {function(NodeImmediate):void} clearImmediate
-	 * @property {function():number} countTimers
-	 * @property {RequestAnimationFrame} requestAnimationFrame
-	 * @property {function(number):void} cancelAnimationFrame
-	 * @property {function():void} runMicrotasks
-	 * @property {function(string | number): number} tick
-	 * @property {function(string | number): Promise<number>} tickAsync
-	 * @property {function(): number} next
-	 * @property {function(): Promise<number>} nextAsync
-	 * @property {function(): number} runAll
-	 * @property {function(): number} runToFrame
-	 * @property {function(): Promise<number>} runAllAsync
-	 * @property {function(): number} runToLast
-	 * @property {function(): Promise<number>} runToLastAsync
-	 * @property {function(): void} reset
-	 * @property {function(number | Date): void} setSystemTime
-	 * @property {function(number): void} jump
-	 * @property {Performance} performance
-	 * @property {function(number[]): number[]} hrtime - process.hrtime (legacy)
-	 * @property {function(): void} uninstall Uninstall the clock.
-	 * @property {Function[]} methods - the methods that are faked
-	 * @property {boolean} [shouldClearNativeTimers] inherited from config
-	 * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods
-	 * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods
-	 * @property {Map<function(): void, AbortSignal>} abortListenerMap
-	 * @property {function(TimerTickMode): void} setTickMode
+	 * @property {number} now - current mocked time in milliseconds
+	 * @property {typeof Date & {clock?: Clock, isFake?: boolean, toSource?: () => string}} Date - fake Date constructor bound to this clock
+	 * @property {number} loopLimit - maximum number of timers before assuming an infinite loop
+	 * @property {RequestIdleCallback} requestIdleCallback - schedules an idle callback
+	 * @property {CancelIdleCallback} cancelIdleCallback - cancels a scheduled idle callback
+	 * @property {SetTimeout} setTimeout - faked `setTimeout`
+	 * @property {ClearTimeout} clearTimeout - faked `clearTimeout`
+	 * @property {NextTick} nextTick - faked `process.nextTick`
+	 * @property {QueueMicrotask} queueMicrotask - faked `queueMicrotask`
+	 * @property {SetInterval} setInterval - faked `setInterval`
+	 * @property {ClearInterval} clearInterval - faked `clearInterval`
+	 * @property {SetImmediate} setImmediate - faked `setImmediate`
+	 * @property {ClearImmediate} clearImmediate - faked `clearImmediate`
+	 * @property {CountTimers} countTimers - counts scheduled timers
+	 * @property {RequestAnimationFrame} requestAnimationFrame - schedules a frame callback
+	 * @property {CancelAnimationFrame} cancelAnimationFrame - cancels a frame callback
+	 * @property {RunMicrotasks} runMicrotasks - drains microtasks
+	 * @property {Tick} tick - advances fake time synchronously
+	 * @property {TickAsync} tickAsync - advances fake time asynchronously
+	 * @property {Next} next - runs the next scheduled timer
+	 * @property {NextAsync} nextAsync - runs the next scheduled timer asynchronously
+	 * @property {RunAll} runAll - runs all scheduled timers
+	 * @property {RunToFrame} runToFrame - runs timers up to the next animation frame
+	 * @property {RunAllAsync} runAllAsync - runs all scheduled timers asynchronously
+	 * @property {RunToLast} runToLast - runs timers up to the last scheduled timer
+	 * @property {RunToLastAsync} runToLastAsync - runs timers up to the last scheduled timer asynchronously
+	 * @property {Reset} reset - clears all timers and resets the clock
+	 * @property {SetSystemTime} setSystemTime - sets the clock to a specific wall-clock time
+	 * @property {Jump} jump - advances time and returns the new `now`
+	 * @property {any} performance - fake performance object
+	 * @property {Hrtime} hrtime - faked `process.hrtime`
+	 * @property {Uninstall} uninstall - restores native timers
+	 * @property {string[]} methods - names of faked methods
+	 * @property {boolean} [shouldClearNativeTimers] - inherited from config
+	 * @property {{methodName:string, original:unknown}[] | undefined} timersModuleMethods - saved Node timers module methods
+	 * @property {{methodName:string, original:unknown}[] | undefined} timersPromisesModuleMethods - saved Node timers/promises methods
+	 * @property {Map<VoidVarArgsFunc, AbortSignal>} abortListenerMap - active abort listeners
+	 * @property {SetTickMode} setTickMode - switches the auto-tick mode
+	 * @property {Map<number, Timer>} [timers] - internal timer storage
+	 * @property {TimerHeap} [timerHeap] - internal timer heap
+	 * @property {boolean} [duringTick] - internal flag
+	 * @property {boolean} isNearInfiniteLimit - internal flag indicating the loop limit is nearly reached
+	 * @property {TimerId} [attachedInterval] - internal flag
+	 * @property {ClockTickMode} [tickMode] - internal flag
+	 * @property {Timer[]} [jobs] - internal flag
+	 * @property {IntlWithClock} [Intl] - fake Intl object
 	 */
-	/* eslint-enable jsdoc/require-property-description */
+	/* eslint-enable jsdoc/reject-any-type */
 
 	/**
 	 * Configuration object for the `install` method.
 	 * @typedef {object} Config
-	 * @property {number|Date} [now] a number (in milliseconds) or a Date object (default epoch)
-	 * @property {string[]} [toFake] names of the methods that should be faked.
-	 * @property {number} [loopLimit] the maximum number of timers that will be run when calling runAll()
-	 * @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false)
-	 * @property {number} [advanceTimeDelta] increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)
-	 * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)
-	 * @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error
+	 * @property {number|Date} [now] initial mocked time, as milliseconds since epoch or a Date
+	 * @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
+	 * @property {boolean} [shouldAdvanceTime] automatically increments mocked time while the clock is installed
+	 * @property {number} [advanceTimeDelta] interval in milliseconds used when `shouldAdvanceTime` is enabled
+	 * @property {boolean} [shouldClearNativeTimers] forwards clear calls to native methods when the timer is not fake
+	 * @property {boolean} [ignoreMissingTimers] suppresses errors when a requested timer is missing from the global object
+	 * @property {GlobalObject} [target] global object to install onto
 	 */
 
-	/* eslint-disable jsdoc/require-property-description */
 	/**
 	 * The internal structure to describe a scheduled fake timer
-	 * @typedef {object} Timer
-	 * @property {Function} func
-	 * @property {*[]} args
-	 * @property {number} delay
-	 * @property {number} callAt
-	 * @property {number} createdAt
-	 * @property {boolean} immediate
-	 * @property {number} id
-	 * @property {Error} [error]
+	 * @typedef {TimerInitialProps} Timer
+	 * @property {unknown[]} args - arguments passed to the callback
+	 * @property {number} callAt - scheduled execution time
+	 * @property {number} createdAt - time at which the timer was created
+	 * @property {number} id - unique timer identifier
+	 * @property {'Timeout' | 'Interval' | 'Immediate' | 'AnimationFrame' | 'IdleCallback'} type - timer kind
+	 */
+
+	/**
+	 * @callback NodeImmediateHasRef
+	 * @returns {boolean}
+	 */
+
+	/**
+	 * @callback NodeImmediateRef
+	 * @returns {NodeImmediate}
+	 */
+
+	/**
+	 * @callback NodeImmediateUnref
+	 * @returns {NodeImmediate}
 	 */
 
 	/**
 	 * A Node timer
 	 * @typedef {object} NodeImmediate
-	 * @property {function(): boolean} hasRef
-	 * @property {function(): NodeImmediate} ref
-	 * @property {function(): NodeImmediate} unref
+	 * @property {NodeImmediateHasRef} hasRef - reports whether the timer keeps the event loop alive
+	 * @property {NodeImmediateRef} ref - marks the timer as referenced
+	 * @property {NodeImmediateUnref} unref - marks the timer as unreferenced
 	 */
-	/* eslint-enable jsdoc/require-property-description */
 
 	/* eslint-disable complexity */
 
 	/**
 	 * Mocks available features in the specified global namespace.
-	 * @param {*} _global Namespace to mock (e.g. `window`)
+	 * @param {GlobalObject} _global Namespace to mock (e.g. `window`)
 	 * @returns {FakeTimers}
 	 */
 	function withGlobal(_global) {
@@ -2731,7 +3087,10 @@ function requireFakeTimersSrc () {
 	        _global.performance &&
 	        _global.performance.constructor &&
 	        _global.performance.constructor.prototype;
-	    isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+	    isPresent.queueMicrotask = Object.prototype.hasOwnProperty.call(
+	        _global,
+	        "queueMicrotask",
+	    );
 	    isPresent.requestAnimationFrame =
 	        _global.requestAnimationFrame &&
 	        typeof _global.requestAnimationFrame === "function";
@@ -2741,7 +3100,7 @@ function requireFakeTimersSrc () {
 	    isPresent.requestIdleCallback =
 	        _global.requestIdleCallback &&
 	        typeof _global.requestIdleCallback === "function";
-	    isPresent.cancelIdleCallbackPresent =
+	    isPresent.cancelIdleCallback =
 	        _global.cancelIdleCallback &&
 	        typeof _global.cancelIdleCallback === "function";
 	    isPresent.setImmediate =
@@ -2762,6 +3121,8 @@ function requireFakeTimersSrc () {
 	          )
 	        : undefined;
 	    let uniqueTimerId = idCounterStart;
+	    /** @type {number} */
+	    let uniqueTimerOrder = 0;
 
 	    if (NativeDate === undefined) {
 	        throw new Error(
@@ -2802,23 +3163,23 @@ function requireFakeTimersSrc () {
 	        return isFinite(num);
 	    }
 
-	    let isNearInfiniteLimit = false;
-
 	    /**
 	     * @param {Clock} clock
 	     * @param {number} i
 	     */
 	    function checkIsNearInfiniteLimit(clock, i) {
 	        if (clock.loopLimit && i === clock.loopLimit - 1) {
-	            isNearInfiniteLimit = true;
+	            clock.isNearInfiniteLimit = true;
 	        }
 	    }
 
 	    /**
-	     *
+	     * @param {Clock} clock
 	     */
-	    function resetIsNearInfiniteLimit() {
-	        isNearInfiniteLimit = false;
+	    function resetIsNearInfiniteLimit(clock) {
+	        if (clock) {
+	            clock.isNearInfiniteLimit = false;
+	        }
 	    }
 
 	    /**
@@ -2883,12 +3244,12 @@ function requireFakeTimersSrc () {
 	        if (!epoch) {
 	            return 0;
 	        }
-	        if (typeof epoch.getTime === "function") {
-	            return epoch.getTime();
-	        }
 	        if (typeof epoch === "number") {
 	            return epoch;
 	        }
+	        if (typeof epoch.getTime === "function") {
+	            return epoch.getTime();
+	        }
 	        throw new TypeError("now should be milliseconds since UNIX epoch");
 	    }
 
@@ -2905,6 +3266,7 @@ function requireFakeTimersSrc () {
 	    /**
 	     * @param {Clock} clock
 	     * @param {Timer} job
+	     * @returns {Error}
 	     */
 	    function getInfiniteLoopError(clock, job) {
 	        const infiniteLoopError = new Error(
@@ -2964,34 +3326,29 @@ function requireFakeTimersSrc () {
 	            Object.defineProperty(infiniteLoopError, "stack", {
 	                value: stack,
 	            });
-	        } catch (e) {
+	        } catch {
 	            // noop
 	        }
 
 	        return infiniteLoopError;
 	    }
 
-	    //eslint-disable-next-line jsdoc/require-jsdoc
+	    /**
+	     * @returns {typeof Date & { clock: Clock }}
+	     */
 	    function createDate() {
 	        class ClockDate extends NativeDate {
-	            /**
-	             * @param {number} year
-	             * @param {number} month
-	             * @param {number} date
-	             * @param {number} hour
-	             * @param {number} minute
-	             * @param {number} second
-	             * @param {number} ms
-	             * @returns void
-	             */
-	            // eslint-disable-next-line no-unused-vars
-	            constructor(year, month, date, hour, minute, second, ms) {
-	                // Defensive and verbose to avoid potential harm in passing
-	                // explicit undefined when user does not pass argument
-	                if (arguments.length === 0) {
+	            /** @type {Clock} */
+	            static clock;
+
+	            constructor(...args) {
+	                // Preserve fake time when Date is called without arguments.
+	                if (args.length === 0) {
 	                    super(ClockDate.clock.now);
 	                } else {
-	                    super(...arguments);
+	                    // The subclass is intentionally thin for explicit args.
+	                    // @ts-expect-error Date constructor overloads are intentionally dynamic.
+	                    super(...args);
 	                }
 
 	                // ensures identity checks using the constructor prop still works
@@ -3015,21 +3372,26 @@ function requireFakeTimersSrc () {
 	            };
 	        }
 
-	        if (NativeDate.toSource) {
+	        const NativeDateWithToSource =
+	            /** @type {typeof Date & { toSource?: () => string }} */ (
+	                NativeDate
+	            );
+
+	        if (NativeDateWithToSource.toSource) {
 	            ClockDate.toSource = function toSource() {
-	                return NativeDate.toSource();
+	                return NativeDateWithToSource.toSource();
 	            };
 	        }
 
 	        ClockDate.toString = function toString() {
-	            return NativeDate.toString();
+	            return NativeDateWithToSource.toString();
 	        };
 
 	        // noinspection UnnecessaryLocalVariableJS
 	        /**
 	         * A normal Class constructor cannot be called without `new`, but Date can, so we need
 	         * to wrap it in a Proxy in order to ensure this functionality of Date is kept intact
-	         * @type {ClockDate}
+	         * @type {typeof ClockDate}
 	         */
 	        const ClockDateProxy = new Proxy(ClockDate, {
 	            // handler for [[Call]] invocations (i.e. not using `new`)
@@ -3046,7 +3408,9 @@ function requireFakeTimersSrc () {
 	            },
 	        });
 
-	        return ClockDateProxy;
+	        return /** @type {typeof Date & { clock: Clock }} */ (
+	            /** @type {unknown} */ (ClockDateProxy)
+	        );
 	    }
 
 	    /**
@@ -3055,19 +3419,21 @@ function requireFakeTimersSrc () {
 	     * Most of the properties are the original native ones,
 	     * but we need to take control of those that have a
 	     * dependency on the current clock.
-	     * @returns {object} the partly fake Intl implementation
+	     * @param {Clock} clock
+	     * @returns {IntlWithClock} the partly fake Intl implementation
 	     */
-	    function createIntl() {
-	        const ClockIntl = {};
+	    function createIntl(clock) {
+	        /** @type {IntlWithClock} */
+	        const IntlWithClock = { clock: clock };
 	        /*
 	         * All properties of Intl are non-enumerable, so we need
 	         * to do a bit of work to get them out.
 	         */
 	        Object.getOwnPropertyNames(NativeIntl).forEach(
-	            (property) => (ClockIntl[property] = NativeIntl[property]),
+	            (property) => (IntlWithClock[property] = NativeIntl[property]),
 	        );
 
-	        ClockIntl.DateTimeFormat = function (...args) {
+	        IntlWithClock.DateTimeFormat = function (...args) {
 	            const realFormatter = new NativeIntl.DateTimeFormat(...args);
 	            const formatter = {};
 
@@ -3080,21 +3446,23 @@ function requireFakeTimersSrc () {
 
 	            ["format", "formatToParts"].forEach((method) => {
 	                formatter[method] = function (date) {
-	                    return realFormatter[method](date || ClockIntl.clock.now);
+	                    return realFormatter[method](
+	                        date || IntlWithClock.clock.now,
+	                    );
 	                };
 	            });
 
 	            return formatter;
 	        };
 
-	        ClockIntl.DateTimeFormat.prototype = Object.create(
+	        IntlWithClock.DateTimeFormat.prototype = Object.create(
 	            NativeIntl.DateTimeFormat.prototype,
 	        );
 
-	        ClockIntl.DateTimeFormat.supportedLocalesOf =
+	        IntlWithClock.DateTimeFormat.supportedLocalesOf =
 	            NativeIntl.DateTimeFormat.supportedLocalesOf;
 
-	        return ClockIntl;
+	        return IntlWithClock;
 	    }
 
 	    //eslint-disable-next-line jsdoc/require-jsdoc
@@ -3112,6 +3480,7 @@ function requireFakeTimersSrc () {
 	        if (!clock.jobs) {
 	            return;
 	        }
+	        const wasNearLimit = clock.isNearInfiniteLimit;
 	        for (let i = 0; i < clock.jobs.length; i++) {
 	            const job = clock.jobs[i];
 	            job.func.apply(null, job.args);
@@ -3121,38 +3490,275 @@ function requireFakeTimersSrc () {
 	                throw getInfiniteLoopError(clock, job);
 	            }
 	        }
-	        resetIsNearInfiniteLimit();
+	        if (!wasNearLimit) {
+	            resetIsNearInfiniteLimit(clock);
+	        }
 	        clock.jobs = [];
 	    }
 
+	    /**
+	     * A compact "soonest timer first" container.
+	     *
+	     * Think of this as a waiting room for scheduled callbacks where the next
+	     * callback to run is always kept at the front of the list. The internal
+	     * array is arranged so we can find, add, remove, and reorder timers
+	     * efficiently without sorting the whole list every time something changes.
+	     *
+	     * The important idea is not the data structure name, but the behavior:
+	     * the timer that should run next stays near the front, and when one timer
+	     * moves, the rest are shifted just enough to keep that promise true.
+	     */
+	    class TimerHeap {
+	        constructor() {
+	            this.timers = [];
+	        }
+
+	        /**
+	         * Look at the next timer without removing it.
+	         * This is the timer the clock would run first if time advanced now.
+	         * @returns {Timer}
+	         */
+	        peek() {
+	            return this.timers[0];
+	        }
+
+	        /**
+	         * Add a timer to the waiting room, then move it upward until it is in
+	         * the right place relative to the timers it should run before and after.
+	         * @param {Timer} timer
+	         */
+	        push(timer) {
+	            this.timers.push(timer);
+	            this.bubbleUp(this.timers.length - 1);
+	        }
+
+	        /**
+	         * Remove and return the next timer to run.
+	         *
+	         * We pull the front timer out, move the last timer into the empty spot,
+	         * and then shift that replacement down until the ordering is correct
+	         * again. That avoids rebuilding the whole list from scratch.
+	         * @returns {Timer|undefined}
+	         */
+	        pop() {
+	            if (this.timers.length === 0) {
+	                return undefined;
+	            }
+	            const first = this.timers[0];
+	            const last = this.timers.pop();
+	            if (this.timers.length > 0) {
+	                this.timers[0] = last;
+	                last.heapIndex = 0;
+	                this.bubbleDown(0);
+	            }
+	            delete first.heapIndex;
+	            return first;
+	        }
+
+	        /**
+	         * Remove a specific timer from the waiting room.
+	         *
+	         * The heap stores timers in a shape that lets us jump directly to the
+	         * timer's current position, replace it with the last timer, and then
+	         * move that replacement up or down until the ordering is correct again.
+	         * @param {Timer} timer
+	         * @returns {boolean}
+	         */
+	        remove(timer) {
+	            const index = timer.heapIndex;
+	            if (index === undefined || this.timers[index] !== timer) {
+	                return false;
+	            }
+	            const last = this.timers.pop();
+	            if (timer !== last) {
+	                this.timers[index] = last;
+	                last.heapIndex = index;
+	                if (compareTimers(last, timer) < 0) {
+	                    this.bubbleUp(index);
+	                } else {
+	                    this.bubbleDown(index);
+	                }
+	            }
+	            delete timer.heapIndex;
+	            return true;
+	        }
+
+	        /**
+	         * Move a timer toward the front until it is no longer "earlier" than
+	         * the timer above it.
+	         *
+	         * Conceptually, this is what happens when something newly scheduled
+	         * turns out to belong ahead of its parent in the waiting room. We keep
+	         * swapping it upward until it is no longer out of place.
+	         * @param {number} index
+	         */
+	        bubbleUp(index) {
+	            const timer = this.timers[index];
+	            let currentIndex = index;
+	            while (currentIndex > 0) {
+	                const parentIndex = Math.floor((currentIndex - 1) / 2);
+	                const parent = this.timers[parentIndex];
+	                if (compareTimers(timer, parent) < 0) {
+	                    this.timers[currentIndex] = parent;
+	                    parent.heapIndex = currentIndex;
+	                    currentIndex = parentIndex;
+	                } else {
+	                    break;
+	                }
+	            }
+	            this.timers[currentIndex] = timer;
+	            timer.heapIndex = currentIndex;
+	        }
+
+	        /**
+	         * Move a timer away from the front until the timer below it is no
+	         * longer supposed to run after it.
+	         *
+	         * This is the opposite of `bubbleUp`: when a timer at the front is
+	         * removed or moved, the replacement may be too far ahead, so we
+	         * repeatedly swap it downward with the best child until the waiting
+	         * room is ordered again.
+	         * @param {number} index
+	         */
+	        bubbleDown(index) {
+	            const timer = this.timers[index];
+	            let currentIndex = index;
+	            const halfLength = Math.floor(this.timers.length / 2);
+	            while (currentIndex < halfLength) {
+	                const leftIndex = currentIndex * 2 + 1;
+	                const rightIndex = leftIndex + 1;
+	                let bestChildIndex = leftIndex;
+	                let bestChild = this.timers[leftIndex];
+
+	                if (
+	                    rightIndex < this.timers.length &&
+	                    compareTimers(this.timers[rightIndex], bestChild) < 0
+	                ) {
+	                    bestChildIndex = rightIndex;
+	                    bestChild = this.timers[rightIndex];
+	                }
+
+	                if (compareTimers(bestChild, timer) < 0) {
+	                    this.timers[currentIndex] = bestChild;
+	                    bestChild.heapIndex = currentIndex;
+	                    currentIndex = bestChildIndex;
+	                } else {
+	                    break;
+	                }
+	            }
+	            this.timers[currentIndex] = timer;
+	            timer.heapIndex = currentIndex;
+	        }
+	    }
+
+	    /**
+	     * Ensure timer storage and heap stay in sync even if a clear path touches
+	     * timer state before anything has been scheduled.
+	     *
+	     * Why do we need two data structures to keep tabs on timers?
+	     * 1. Fast ID Lookup (clock.timers): This is a Map from timer IDs to their respective timer objects. It allows clearTimeout(id) and
+	     * clearInterval(id) to be $O(1)$ operations. Without this map, finding a specific timer in the heap to remove it would require a linear
+	     * $O(n)$ search, which would significantly degrade performance as the number of active timers grows.
+	     * 2. Efficient Scheduling (clock.timerHeap): This is a priority queue (min-heap) that keeps timers ordered by their execution time (callAt). It
+	     * allows the library to instantly find the next timer to run (peek() in $O(1)$) and efficiently update the schedule when timers are added or
+	     * removed ($O(\log n)$).
+	     *
+	     * In short: clock.timers provides fast access by ID, while clock.timerHeap provides fast access by Time. Removing either one would make common
+	     * operations (like clearing or finding the next timer) much slower.
+	     * @param {Clock} clock
+	     */
+	    function ensureTimerState(clock) {
+	        if (!clock.timers) {
+	            clock.timers = new Map();
+	            clock.timerHeap = new TimerHeap();
+	        }
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {number} id
+	     * @returns {boolean}
+	     */
+	    function hasTimer(clock, id) {
+	        return clock.timers ? clock.timers.has(id) : false;
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {number} id
+	     * @returns {Timer}
+	     */
+	    function getTimer(clock, id) {
+	        return clock.timers ? clock.timers.get(id) : undefined;
+	    }
+
 	    /**
 	     * @param {Clock} clock
 	     * @param {Timer} timer
-	     * @returns {number} id of the created timer
+	     */
+	    function setTimer(clock, timer) {
+	        ensureTimerState(clock);
+	        clock.timers.set(timer.id, timer);
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {number} id
+	     * @returns {boolean}
+	     */
+	    function deleteTimer(clock, id) {
+	        return clock.timers ? clock.timers.delete(id) : false;
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {(timer: Timer) => void} callback
+	     */
+	    function forEachActiveTimer(clock, callback) {
+	        if (!clock.timers) {
+	            return;
+	        }
+
+	        for (const timer of clock.timers.values()) {
+	            callback(timer);
+	        }
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     */
+	    function rebuildTimerHeap(clock) {
+	        clock.timerHeap = new TimerHeap();
+	        forEachActiveTimer(clock, (timer) => {
+	            clock.timerHeap.push(timer);
+	        });
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {TimerInitialProps} timer
+	     * @returns {TimerId} id of the created timer
 	     */
 	    function addTimer(clock, timer) {
 	        if (timer.func === undefined) {
 	            throw new Error("Callback must be provided to timer calls");
 	        }
 
-	        if (addTimerReturnsObject) {
-	            // Node.js environment
-	            if (typeof timer.func !== "function") {
-	                throw new TypeError(
-	                    `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${
-	                        timer.func
-	                    } of type ${typeof timer.func}`,
-	                );
-	            }
+	        if (typeof timer.func !== "function") {
+	            throw new TypeError(
+	                `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${
+	                    timer.func
+	                } of type ${typeof timer.func}`,
+	            );
 	        }
 
-	        if (isNearInfiniteLimit) {
+	        if (clock.isNearInfiniteLimit) {
 	            timer.error = new Error();
 	        }
 
 	        timer.type = timer.immediate ? "Immediate" : "Timeout";
 
-	        if (timer.hasOwnProperty("delay")) {
+	        if (Object.prototype.hasOwnProperty.call(timer, "delay")) {
 	            if (typeof timer.delay !== "number") {
 	                timer.delay = parseInt(timer.delay, 10);
 	            }
@@ -3164,42 +3770,60 @@ function requireFakeTimersSrc () {
 	            timer.delay = Math.max(0, timer.delay);
 	        }
 
-	        if (timer.hasOwnProperty("interval")) {
+	        if (Object.prototype.hasOwnProperty.call(timer, "interval")) {
 	            timer.type = "Interval";
 	            timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
 	        }
 
-	        if (timer.hasOwnProperty("animation")) {
+	        if (Object.prototype.hasOwnProperty.call(timer, "animation")) {
 	            timer.type = "AnimationFrame";
 	            timer.animation = true;
 	        }
 
-	        if (timer.hasOwnProperty("idleCallback")) {
-	            timer.type = "IdleCallback";
-	            timer.idleCallback = true;
+	        if (
+	            Object.prototype.hasOwnProperty.call(timer, "requestIdleCallback")
+	        ) {
+	            // mark timer as IdleCallback type if it has no delay, otherwise it'd be of type timeout
+	            // this way we are able to sort such that the timer only gets called when there's truly no pending task to run
+	            if (!timer.delay) {
+	                timer.type = "IdleCallback";
+	            }
+	            timer.requestIdleCallback = true;
 	        }
 
-	        if (!clock.timers) {
-	            clock.timers = {};
+	        ensureTimerState(clock);
+
+	        while (hasTimer(clock, uniqueTimerId)) {
+	            uniqueTimerId++;
+	            if (uniqueTimerId >= Number.MAX_SAFE_INTEGER) {
+	                uniqueTimerId = idCounterStart;
+	            }
 	        }
 
 	        timer.id = uniqueTimerId++;
+	        if (uniqueTimerId >= Number.MAX_SAFE_INTEGER) {
+	            uniqueTimerId = idCounterStart;
+	        }
+
+	        timer.order = uniqueTimerOrder++;
 	        timer.createdAt = clock.now;
 	        timer.callAt =
-	            clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+	            clock.now +
+	            (parseInt(String(timer.delay)) || (clock.duringTick ? 1 : 0));
 
-	        clock.timers[timer.id] = timer;
+	        setTimer(clock, timer);
+	        clock.timerHeap.push(timer);
 
 	        if (addTimerReturnsObject) {
 	            const res = {
 	                refed: true,
 	                ref: function () {
 	                    this.refed = true;
-	                    return res;
+	                    return this;
 	                },
 	                unref: function () {
 	                    this.refed = false;
-	                    return res;
+	                    return this;
 	                },
 	                hasRef: function () {
 	                    return this.refed;
@@ -3207,12 +3831,15 @@ function requireFakeTimersSrc () {
 	                refresh: function () {
 	                    timer.callAt =
 	                        clock.now +
-	                        (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+	                        (parseInt(String(timer.delay)) ||
+	                            (clock.duringTick ? 1 : 0));
 
-	                    // it _might_ have been removed, but if not the assignment is perfectly fine
-	                    clock.timers[timer.id] = timer;
+	                    clock.timerHeap.remove(timer);
+	                    timer.order = uniqueTimerOrder++;
+	                    setTimer(clock, timer);
+	                    clock.timerHeap.push(timer);
 
-	                    return res;
+	                    return this;
 	                },
 	                [Symbol.toPrimitive]: function () {
 	                    return timer.id;
@@ -3226,12 +3853,20 @@ function requireFakeTimersSrc () {
 
 	    /* eslint consistent-return: "off" */
 	    /**
-	     * Timer comparitor
+	     * Timer comparator
 	     * @param {Timer} a
 	     * @param {Timer} b
 	     * @returns {number}
 	     */
 	    function compareTimers(a, b) {
+	        // Sort IdleCallback timers to the bottom when scheduled for the same time
+	        if (a.type === "IdleCallback" && b.type !== "IdleCallback") {
+	            return 1;
+	        }
+	        if (a.type !== "IdleCallback" && b.type === "IdleCallback") {
+	            return -1;
+	        }
+
 	        // Sort first by absolute timing
 	        if (a.callAt < b.callAt) {
 	            return -1;
@@ -3248,6 +3883,13 @@ function requireFakeTimersSrc () {
 	            return 1;
 	        }
 
+	        if (a.order < b.order) {
+	            return -1;
+	        }
+	        if (a.order > b.order) {
+	            return 1;
+	        }
+
 	        // Sort next by creation time, earlier-created timers take precedence
 	        if (a.createdAt < b.createdAt) {
 	            return -1;
@@ -3265,6 +3907,7 @@ function requireFakeTimersSrc () {
 	        }
 
 	        // As timer ids are unique, no fallback `0` is necessary
+	        return 0;
 	    }
 
 	    /**
@@ -3274,20 +3917,31 @@ function requireFakeTimersSrc () {
 	     * @returns {Timer}
 	     */
 	    function firstTimerInRange(clock, from, to) {
-	        const timers = clock.timers;
-	        let timer = null;
-	        let id, isInRange;
+	        if (!clock.timerHeap) {
+	            return null;
+	        }
 
-	        for (id in timers) {
-	            if (timers.hasOwnProperty(id)) {
-	                isInRange = inRange(from, to, timers[id]);
+	        const timers = clock.timerHeap.timers;
+	        if (timers.length === 1 && timers[0].requestIdleCallback) {
+	            return timers[0];
+	        }
 
-	                if (
-	                    isInRange &&
-	                    (!timer || compareTimers(timer, timers[id]) === 1)
-	                ) {
-	                    timer = timers[id];
-	                }
+	        const first = clock.timerHeap.peek();
+	        if (first && inRange(from, to, first)) {
+	            return first;
+	        }
+
+	        /**
+	         * @type {?Timer}
+	         */
+	        let timer = null;
+
+	        for (let i = 0; i < timers.length; i++) {
+	            if (
+	                inRange(from, to, timers[i]) &&
+	                (!timer || compareTimers(timer, timers[i]) === 1)
+	            ) {
+	                timer = timers[i];
 	            }
 	        }
 
@@ -3299,19 +3953,10 @@ function requireFakeTimersSrc () {
 	     * @returns {Timer}
 	     */
 	    function firstTimer(clock) {
-	        const timers = clock.timers;
-	        let timer = null;
-	        let id;
-
-	        for (id in timers) {
-	            if (timers.hasOwnProperty(id)) {
-	                if (!timer || compareTimers(timer, timers[id]) === 1) {
-	                    timer = timers[id];
-	                }
-	            }
+	        if (!clock.timerHeap) {
+	            return null;
 	        }
-
-	        return timer;
+	        return clock.timerHeap.peek() || null;
 	    }
 
 	    /**
@@ -3319,15 +3964,15 @@ function requireFakeTimersSrc () {
 	     * @returns {Timer}
 	     */
 	    function lastTimer(clock) {
-	        const timers = clock.timers;
+	        if (!clock.timerHeap) {
+	            return null;
+	        }
+	        const timers = clock.timerHeap.timers;
 	        let timer = null;
-	        let id;
 
-	        for (id in timers) {
-	            if (timers.hasOwnProperty(id)) {
-	                if (!timer || compareTimers(timer, timers[id]) === -1) {
-	                    timer = timers[id];
-	                }
+	        for (let i = 0; i < timers.length; i++) {
+	            if (!timer || compareTimers(timer, timers[i]) === -1) {
+	                timer = timers[i];
 	            }
 	        }
 
@@ -3340,25 +3985,27 @@ function requireFakeTimersSrc () {
 	     */
 	    function callTimer(clock, timer) {
 	        if (typeof timer.interval === "number") {
-	            clock.timers[timer.id].callAt += timer.interval;
+	            clock.timerHeap.remove(timer);
+	            timer.callAt += timer.interval;
+	            timer.order = uniqueTimerOrder++;
+	            if (clock.isNearInfiniteLimit) {
+	                timer.error = new Error();
+	            }
+	            clock.timerHeap.push(timer);
 	        } else {
-	            delete clock.timers[timer.id];
+	            deleteTimer(clock, timer.id);
+	            clock.timerHeap.remove(timer);
 	        }
 
 	        if (typeof timer.func === "function") {
 	            timer.func.apply(null, timer.args);
-	        } else {
-	            /* eslint no-eval: "off" */
-	            const eval2 = eval;
-	            (function () {
-	                eval2(timer.func);
-	            })();
 	        }
 	    }
 
 	    /**
 	     * Gets clear handler name for a given timer type
 	     * @param {string} ttype
+	     * @returns {string}
 	     */
 	    function getClearHandler(ttype) {
 	        if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
@@ -3370,6 +4017,7 @@ function requireFakeTimersSrc () {
 	    /**
 	     * Gets schedule handler name for a given timer type
 	     * @param {string} ttype
+	     * @returns {string}
 	     */
 	    function getScheduleHandler(ttype) {
 	        if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
@@ -3380,6 +4028,7 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Creates an anonymous function to warn only once
+	     * @returns {(msg: string) => void}
 	     */
 	    function createWarnOnce() {
 	        let calls = 0;
@@ -3392,8 +4041,9 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * @param {Clock} clock
-	     * @param {number} timerId
+	     * @param {TimerId} timerId
 	     * @param {string} ttype
+	     * @returns {void}
 	     */
 	    function clearTimer(clock, timerId, ttype) {
 	        if (!timerId) {
@@ -3402,10 +4052,6 @@ function requireFakeTimersSrc () {
 	            return;
 	        }
 
-	        if (!clock.timers) {
-	            clock.timers = {};
-	        }
-
 	        // in Node, the ID is stored as the primitive value for `Timeout` objects
 	        // for `Immediate` objects, no ID exists, so it gets coerced to NaN
 	        const id = Number(timerId);
@@ -3419,21 +4065,30 @@ function requireFakeTimersSrc () {
 	                    ? nativeHandler(timerId)
 	                    : undefined;
 	            }
+
+	            // Include the stacktrace, excluding the 'error' line
+	            const stackTrace = new Error().stack
+	                .split("\n")
+	                .slice(1)
+	                .join("\n");
+
 	            warnOnce(
 	                `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.` +
-	                    "\nTo automatically clean-up native timers, use `shouldClearNativeTimers`.",
+	                    "\nTo automatically clean-up native timers, use `shouldClearNativeTimers`." +
+	                    `\n${stackTrace}`,
 	            );
 	        }
 
-	        if (clock.timers.hasOwnProperty(id)) {
+	        if (hasTimer(clock, id)) {
 	            // check that the ID matches a timer of the correct type
-	            const timer = clock.timers[id];
+	            const timer = getTimer(clock, id);
 	            if (
 	                timer.type === ttype ||
 	                (timer.type === "Timeout" && ttype === "Interval") ||
 	                (timer.type === "Interval" && ttype === "Timeout")
 	            ) {
-	                delete clock.timers[id];
+	                deleteTimer(clock, id);
+	                clock.timerHeap.remove(timer);
 	            } else {
 	                const clear = getClearHandler(ttype);
 	                const schedule = getScheduleHandler(timer.type);
@@ -3478,12 +4133,12 @@ function requireFakeTimersSrc () {
 	                    _global[method] = clock[`_${method}`];
 	                }
 	            } else {
-	                if (_global[method] && _global[method].hadOwnProperty) {
+	                if (clock[method] && clock[method].hasOwnProperty) {
 	                    _global[method] = clock[`_${method}`];
 	                } else {
 	                    try {
 	                        delete _global[method];
-	                    } catch (ignore) {
+	                    } catch {
 	                        /* eslint no-empty: "off" */
 	                    }
 	                }
@@ -3506,7 +4161,7 @@ function requireFakeTimersSrc () {
 	            }
 	        }
 
-	        clock.setTickMode("manual");
+	        clock.setTickMode({ mode: "manual" });
 
 	        // Prevent multiple executions which will completely remove these props
 	        clock.methods = [];
@@ -3517,12 +4172,10 @@ function requireFakeTimersSrc () {
 	        }
 
 	        // return pending timers, to enable checking what timers remained on uninstall
-	        if (!clock.timers) {
+	        if (!clock.timerHeap) {
 	            return [];
 	        }
-	        return Object.keys(clock.timers).map(function mapper(key) {
-	            return clock.timers[key];
-	        });
+	        return clock.timerHeap.timers.slice();
 	    }
 
 	    /**
@@ -3531,7 +4184,7 @@ function requireFakeTimersSrc () {
 	     * @param {Clock} clock
 	     */
 	    function hijackMethod(target, method, clock) {
-	        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(
+	        clock[method].hasOwnProperty = Object.prototype.hasOwnProperty.call(
 	            target,
 	            method,
 	        );
@@ -3588,26 +4241,6 @@ function requireFakeTimersSrc () {
 	        clock.tick(advanceTimeDelta);
 	    }
 
-	    /**
-	     * @typedef {object} Timers
-	     * @property {setTimeout} setTimeout
-	     * @property {clearTimeout} clearTimeout
-	     * @property {setInterval} setInterval
-	     * @property {clearInterval} clearInterval
-	     * @property {Date} Date
-	     * @property {Intl} Intl
-	     * @property {SetImmediate=} setImmediate
-	     * @property {function(NodeImmediate): void=} clearImmediate
-	     * @property {function(number[]):number[]=} hrtime
-	     * @property {NextTick=} nextTick
-	     * @property {Performance=} performance
-	     * @property {RequestAnimationFrame=} requestAnimationFrame
-	     * @property {boolean=} queueMicrotask
-	     * @property {function(number): void=} cancelAnimationFrame
-	     * @property {RequestIdleCallback=} requestIdleCallback
-	     * @property {function(number): void=} cancelIdleCallback
-	     */
-
 	    /** @type {Timers} */
 	    const timers = {
 	        setTimeout: _global.setTimeout,
@@ -3671,30 +4304,37 @@ function requireFakeTimersSrc () {
 	     * @returns {Clock}
 	     */
 	    function createClock(start, loopLimit) {
+	        /** @type {number} */
 	        // eslint-disable-next-line no-param-reassign
 	        start = Math.floor(getEpoch(start));
+	        const startTimestamp = start;
 	        // eslint-disable-next-line no-param-reassign
 	        loopLimit = loopLimit || 1000;
+	        /** @type {number} */
 	        let nanos = 0;
+	        /** @type {number[]} */
 	        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]
 
-	        const clock = {
+	        /** @type {Clock} */
+	        const clock = /** @type {Clock} */ ({
 	            now: start,
 	            Date: createDate(),
 	            loopLimit: loopLimit,
+	            isNearInfiniteLimit: false,
 	            tickMode: { mode: "manual", counter: 0, delta: undefined },
-	        };
+	        });
 
 	        clock.Date.clock = clock;
 
 	        //eslint-disable-next-line jsdoc/require-jsdoc
 	        function getTimeToNextFrame() {
-	            return 16 - ((clock.now - start) % 16);
+	            return 16 - ((clock.now - startTimestamp) % 16);
 	        }
 
 	        //eslint-disable-next-line jsdoc/require-jsdoc
 	        function hrtime(prev) {
-	            const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
+	            const millisSinceStart =
+	                clock.now - adjustedSystemTime[0] - startTimestamp;
 	            const secsSinceStart = Math.floor(millisSinceStart / 1000);
 	            const remainderInNanos =
 	                (millisSinceStart - secsSinceStart * 1e3) * 1e6 +
@@ -3740,20 +4380,21 @@ function requireFakeTimersSrc () {
 	        if (isPresent.hrtimeBigint) {
 	            hrtime.bigint = function () {
 	                const parts = hrtime();
-	                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line
+	                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
 	            };
 	        }
 
 	        if (isPresent.Intl) {
-	            clock.Intl = createIntl();
+	            clock.Intl = createIntl(clock);
 	            clock.Intl.clock = clock;
 	        }
 
 	        /**
-	         * @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.
+	         * @param {SetTickModeConfig} tickModeConfig - The new configuration for how the clock should tick.
 	         */
 	        clock.setTickMode = function (tickModeConfig) {
-	            const { mode: newMode, delta: newDelta } = tickModeConfig;
+	            const { mode: newMode, delta: newDelta } =
+	                /** @type {SetTickModeConfig} */ (tickModeConfig);
 	            const { mode: oldMode, delta: oldDelta } = clock.tickMode;
 	            if (newMode === oldMode && newDelta === oldDelta) {
 	                return;
@@ -3776,7 +4417,15 @@ function requireFakeTimersSrc () {
 	            }
 	        };
 
+	        /**
+	         * Keeps advancing the native event loop until the tick mode changes.
+	         * @returns {Promise<void>}
+	         */
 	        async function advanceUntilModeChanges() {
+	            /**
+	             * Waits for one native macrotask and then one microtask turn.
+	             * @returns {Promise<void>}
+	             */
 	            async function newMacrotask() {
 	                // MessageChannel ensures that setTimeout is not throttled to 4ms.
 	                // https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#reasons_for_delays_longer_than_specified
@@ -3784,7 +4433,7 @@ function requireFakeTimersSrc () {
 	                const channel = new MessageChannel();
 	                await new Promise((resolve) => {
 	                    channel.port1.onmessage = () => {
-	                        resolve();
+	                        resolve(undefined);
 	                        channel.port1.close();
 	                    };
 	                    channel.port2.postMessage(undefined);
@@ -3807,6 +4456,11 @@ function requireFakeTimersSrc () {
 	            }
 	        }
 
+	        /**
+	         * Temporarily pauses nextAsync auto-ticking while an async operation runs.
+	         * @param {Promise<unknown>} promise
+	         * @returns {Promise<unknown>}
+	         */
 	        function pauseAutoTickUntilFinished(promise) {
 	            if (clock.tickMode.mode !== "nextAsync") {
 	                return promise;
@@ -3817,24 +4471,37 @@ function requireFakeTimersSrc () {
 	            });
 	        }
 
-	        clock.requestIdleCallback = function requestIdleCallback(
-	            func,
-	            timeout,
-	        ) {
+	        /**
+	         * Returns the remaining time in the current idle window.
+	         * @returns {number}
+	         */
+	        function getTimeToNextIdlePeriod() {
 	            let timeToNextIdlePeriod = 0;
 
 	            if (clock.countTimers() > 0) {
 	                timeToNextIdlePeriod = 50; // const for now
 	            }
 
+	            return timeToNextIdlePeriod;
+	        }
+
+	        clock.requestIdleCallback = function requestIdleCallback(
+	            func,
+	            { timeout } = /** @type {{ timeout?: number }} */ ({}),
+	        ) {
+	            /**
+	             * @type {IdleDeadline}
+	             */
+	            const idleDeadline = {
+	                didTimeout: true,
+	                timeRemaining: getTimeToNextIdlePeriod,
+	            };
+
 	            const result = addTimer(clock, {
 	                func: func,
-	                args: Array.prototype.slice.call(arguments, 2),
-	                delay:
-	                    typeof timeout === "undefined"
-	                        ? timeToNextIdlePeriod
-	                        : Math.min(timeout, timeToNextIdlePeriod),
-	                idleCallback: true,
+	                args: [idleDeadline],
+	                delay: timeout,
+	                requestIdleCallback: true,
 	            });
 
 	            return Number(result);
@@ -3874,7 +4541,7 @@ function requireFakeTimersSrc () {
 	            return enqueueJob(clock, {
 	                func: func,
 	                args: Array.prototype.slice.call(arguments, 1),
-	                error: isNearInfiniteLimit ? new Error() : null,
+	                error: clock.isNearInfiniteLimit ? new Error() : null,
 	            });
 	        };
 
@@ -3884,7 +4551,7 @@ function requireFakeTimersSrc () {
 
 	        clock.setInterval = function setInterval(func, timeout) {
 	            // eslint-disable-next-line no-param-reassign
-	            timeout = parseInt(timeout, 10);
+	            timeout = parseInt(String(timeout), 10);
 	            return addTimer(clock, {
 	                func: func,
 	                args: Array.prototype.slice.call(arguments, 2),
@@ -3898,13 +4565,15 @@ function requireFakeTimersSrc () {
 	        };
 
 	        if (isPresent.setImmediate) {
-	            clock.setImmediate = function setImmediate(func) {
-	                return addTimer(clock, {
-	                    func: func,
-	                    args: Array.prototype.slice.call(arguments, 1),
-	                    immediate: true,
-	                });
-	            };
+	            clock.setImmediate = /** @type {SetImmediate} */ (
+	                function setImmediate(func) {
+	                    return addTimer(clock, {
+	                        func: func,
+	                        args: Array.prototype.slice.call(arguments, 1),
+	                        immediate: true,
+	                    });
+	                }
+	            );
 
 	            if (typeof _global.Promise !== "undefined" && utilPromisify) {
 	                clock.setImmediate[utilPromisify.custom] =
@@ -3928,7 +4597,7 @@ function requireFakeTimersSrc () {
 
 	        clock.countTimers = function countTimers() {
 	            return (
-	                Object.keys(clock.timers || {}).length +
+	                (clock.timerHeap ? clock.timerHeap.timers.length : 0) +
 	                (clock.jobs || []).length
 	            );
 	        };
@@ -3956,12 +4625,9 @@ function requireFakeTimersSrc () {
 
 	        /**
 	         * @param {number|string} tickValue milliseconds or a string parseable by parseTime
-	         * @param {boolean} isAsync
-	         * @param {Function} resolve
-	         * @param {Function} reject
-	         * @returns {number|undefined} will return the new `now` value or nothing for async
+	         * @returns {ClockState} a mutable state object for the tick execution
 	         */
-	        function doTick(tickValue, isAsync, resolve, reject) {
+	        function createTickState(tickValue) {
 	            const msFloat =
 	                typeof tickValue === "number"
 	                    ? tickValue
@@ -3981,122 +4647,202 @@ function requireFakeTimersSrc () {
 	                nanosTotal -= 1e6;
 	            }
 
-	            nanos = nanosTotal;
-	            let tickFrom = clock.now;
-	            let previous = clock.now;
-	            // ESLint fails to detect this correctly
-	            /* eslint-disable prefer-const */
-	            let timer,
-	                firstException,
-	                oldNow,
-	                nextPromiseTick,
-	                compensationCheck,
-	                postTimerCall;
-	            /* eslint-enable prefer-const */
-
-	            clock.duringTick = true;
+	            return /** @type {ClockState} */ ({
+	                msFloat: msFloat,
+	                ms: ms,
+	                nanosTotal: nanosTotal,
+	                tickFrom: clock.now,
+	                tickTo: tickTo,
+	                previous: clock.now,
+	                timer: null,
+	                firstException: null,
+	                oldNow: null,
+	            });
+	        }
 
-	            // perform microtasks
-	            oldNow = clock.now;
-	            runJobs(clock);
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         * @param {number} oldNow the clock.now before some action
+	         * @param {object} [options] compensation options
+	         * @param {boolean} [options.includePrevious] whether to also update state.previous
+	         */
+	        function applyClockChangeCompensation(state, oldNow, options) {
 	            if (oldNow !== clock.now) {
-	                // compensate for any setSystemTime() call during microtask callback
-	                tickFrom += clock.now - oldNow;
-	                tickTo += clock.now - oldNow;
+	                const difference = clock.now - oldNow;
+	                state.tickFrom += difference;
+	                state.tickTo += difference;
+	                if (options && options.includePrevious) {
+	                    state.previous += difference;
+	                }
 	            }
+	        }
 
-	            //eslint-disable-next-line jsdoc/require-jsdoc
-	            function doTickInner() {
-	                // perform each timer in the requested range
-	                timer = firstTimerInRange(clock, tickFrom, tickTo);
-	                // eslint-disable-next-line no-unmodified-loop-condition
-	                while (timer && tickFrom <= tickTo) {
-	                    if (clock.timers[timer.id]) {
-	                        tickFrom = timer.callAt;
-	                        clock.now = timer.callAt;
-	                        oldNow = clock.now;
-	                        try {
-	                            runJobs(clock);
-	                            callTimer(clock, timer);
-	                        } catch (e) {
-	                            firstException = firstException || e;
-	                        }
-
-	                        if (isAsync) {
-	                            // finish up after native setImmediate callback to allow
-	                            // all native es6 promises to process their callbacks after
-	                            // each timer fires.
-	                            originalSetTimeout(nextPromiseTick);
-	                            return;
-	                        }
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         */
+	        function runInitialJobs(state) {
+	            state.oldNow = clock.now;
+	            runJobs(clock);
+	            applyClockChangeCompensation(state, state.oldNow);
+	        }
 
-	                        compensationCheck();
-	                    }
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         */
+	        function runPostLoopJobs(state) {
+	            state.oldNow = clock.now;
+	            runJobs(clock);
+	            applyClockChangeCompensation(state, state.oldNow);
+	        }
 
-	                    postTimerCall();
-	                }
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         */
+	        function selectNextTimerInRange(state) {
+	            state.timer = firstTimerInRange(
+	                clock,
+	                state.previous,
+	                state.tickTo,
+	            );
+	            state.previous = state.tickFrom;
+	        }
 
-	                // perform process.nextTick()s again
-	                oldNow = clock.now;
-	                runJobs(clock);
-	                if (oldNow !== clock.now) {
-	                    // compensate for any setSystemTime() call during process.nextTick() callback
-	                    tickFrom += clock.now - oldNow;
-	                    tickTo += clock.now - oldNow;
-	                }
-	                clock.duringTick = false;
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         * @param {boolean} isAsync whether this is an async tick
+	         * @param {FakeTimersFunction} nextPromiseTick callback for async promise settlement
+	         * @param {FakeTimersFunction} compensationCheck callback for clock change compensation
+	         * @returns {boolean} whether an early return was triggered (async mode)
+	         */
+	        function runTimersInRange(
+	            state,
+	            isAsync,
+	            nextPromiseTick,
+	            compensationCheck,
+	        ) {
+	            state.timer = firstTimerInRange(
+	                clock,
+	                state.tickFrom,
+	                state.tickTo,
+	            );
 
-	                // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo]
-	                timer = firstTimerInRange(clock, tickFrom, tickTo);
-	                if (timer) {
+	            while (state.timer && state.tickFrom <= state.tickTo) {
+	                if (hasTimer(clock, state.timer.id)) {
+	                    state.tickFrom = state.timer.callAt;
+	                    clock.now = state.timer.callAt;
+	                    state.oldNow = clock.now;
 	                    try {
-	                        clock.tick(tickTo - clock.now); // do it all again - for the remainder of the requested range
+	                        runJobs(clock);
+	                        callTimer(clock, state.timer);
 	                    } catch (e) {
-	                        firstException = firstException || e;
+	                        state.firstException = state.firstException || e;
+	                    }
+
+	                    if (isAsync) {
+	                        // finish up after native setImmediate callback to allow
+	                        // all native es6 promises to process their callbacks after
+	                        // each timer fires.
+	                        originalSetTimeout(nextPromiseTick);
+	                        return true;
 	                    }
-	                } else {
-	                    // no timers remaining in the requested range: move the clock all the way to the end
-	                    clock.now = tickTo;
 
-	                    // update nanos
-	                    nanos = nanosTotal;
-	                }
-	                if (firstException) {
-	                    throw firstException;
+	                    compensationCheck();
 	                }
 
-	                if (isAsync) {
-	                    resolve(clock.now);
-	                } else {
-	                    return clock.now;
+	                selectNextTimerInRange(state);
+	            }
+	            return false;
+	        }
+
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         * @param {boolean} isAsync whether this is an async tick
+	         * @param {FakeTimersFunction} resolve promise resolve function
+	         * @returns {number|undefined} the new clock.now or nothing for async
+	         */
+	        function finalizeTick(state, isAsync, resolve) {
+	            // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo]
+	            state.timer = firstTimerInRange(
+	                clock,
+	                state.tickFrom,
+	                state.tickTo,
+	            );
+	            if (state.timer) {
+	                try {
+	                    clock.tick(state.tickTo - clock.now); // do it all again - for the remainder of the requested range
+	                } catch (e) {
+	                    state.firstException = state.firstException || e;
 	                }
+	            } else {
+	                // no timers remaining in the requested range: move the clock all the way to the end
+	                clock.now = state.tickTo;
+
+	                // update nanos
+	                nanos = state.nanosTotal;
+	            }
+	            if (state.firstException) {
+	                throw state.firstException;
+	            }
+
+	            if (isAsync) {
+	                resolve(clock.now);
+	            } else {
+	                return clock.now;
 	            }
+	        }
+
+	        /**
+	         * @param {number|string} 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
+	         * @returns {number|undefined} the new clock.now or nothing for async
+	         */
+	        function doTick(tickValue, isAsync, resolve, reject) {
+	            /** @type {ClockState} */
+	            const state = createTickState(tickValue);
+
+	            nanos = state.nanosTotal;
+	            clock.duringTick = true;
+
+	            runInitialJobs(state);
+
+	            const compensationCheck = function () {
+	                applyClockChangeCompensation(state, state.oldNow, {
+	                    includePrevious: true,
+	                });
+	            };
 
-	            nextPromiseTick =
+	            const nextPromiseTick =
 	                isAsync &&
 	                function () {
 	                    try {
 	                        compensationCheck();
-	                        postTimerCall();
+	                        selectNextTimerInRange(state);
 	                        doTickInner();
 	                    } catch (e) {
 	                        reject(e);
 	                    }
 	                };
 
-	            compensationCheck = function () {
-	                // compensate for any setSystemTime() call during timer callback
-	                if (oldNow !== clock.now) {
-	                    tickFrom += clock.now - oldNow;
-	                    tickTo += clock.now - oldNow;
-	                    previous += clock.now - oldNow;
+	            //eslint-disable-next-line jsdoc/require-jsdoc
+	            function doTickInner() {
+	                if (
+	                    runTimersInRange(
+	                        state,
+	                        isAsync,
+	                        nextPromiseTick,
+	                        compensationCheck,
+	                    )
+	                ) {
+	                    return;
 	                }
-	            };
 
-	            postTimerCall = function () {
-	                timer = firstTimerInRange(clock, previous, tickTo);
-	                previous = tickFrom;
-	            };
+	                runPostLoopJobs(state);
+	                clock.duringTick = false;
+
+	                return finalizeTick(state, isAsync, resolve);
+	            }
 
 	            return doTickInner();
 	        }
@@ -4109,26 +4855,6 @@ function requireFakeTimersSrc () {
 	            return doTick(tickValue, false);
 	        };
 
-	        if (typeof _global.Promise !== "undefined") {
-	            /**
-	             * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
-	             * @returns {Promise}
-	             */
-	            clock.tickAsync = function tickAsync(tickValue) {
-	                return pauseAutoTickUntilFinished(
-	                    new _global.Promise(function (resolve, reject) {
-	                        originalSetTimeout(function () {
-	                            try {
-	                                doTick(tickValue, true, resolve, reject);
-	                            } catch (e) {
-	                                reject(e);
-	                            }
-	                        });
-	                    }),
-	                );
-	            };
-	        }
-
 	        clock.next = function next() {
 	            runJobs(clock);
 	            const timer = firstTimer(clock);
@@ -4147,61 +4873,40 @@ function requireFakeTimersSrc () {
 	            }
 	        };
 
-	        if (typeof _global.Promise !== "undefined") {
-	            clock.nextAsync = function nextAsync() {
-	                return pauseAutoTickUntilFinished(
-	                    new _global.Promise(function (resolve, reject) {
-	                        originalSetTimeout(function () {
-	                            try {
-	                                const timer = firstTimer(clock);
-	                                if (!timer) {
-	                                    resolve(clock.now);
-	                                    return;
-	                                }
-
-	                                let err;
-	                                clock.duringTick = true;
-	                                clock.now = timer.callAt;
-	                                try {
-	                                    callTimer(clock, timer);
-	                                } catch (e) {
-	                                    err = e;
-	                                }
-	                                clock.duringTick = false;
-
-	                                originalSetTimeout(function () {
-	                                    if (err) {
-	                                        reject(err);
-	                                    } else {
-	                                        resolve(clock.now);
-	                                    }
-	                                });
-	                            } catch (e) {
-	                                reject(e);
-	                            }
-	                        });
-	                    }),
-	                );
-	            };
+	        /**
+	         * @param {(resolve: (value: unknown) => void, reject: (reason?: unknown) => void) => void} callback function to run inside native setTimeout
+	         * @returns {Promise}
+	         */
+	        function runAsyncWithNativeTimeout(callback) {
+	            return pauseAutoTickUntilFinished(
+	                new _global.Promise(function (resolve, reject) {
+	                    originalSetTimeout(function () {
+	                        try {
+	                            callback(resolve, reject);
+	                        } catch (e) {
+	                            reject(e);
+	                        }
+	                    });
+	                }),
+	            );
 	        }
 
 	        clock.runAll = function runAll() {
-	            let numTimers, i;
 	            runJobs(clock);
-	            for (i = 0; i < clock.loopLimit; i++) {
+	            for (let i = 0; i < clock.loopLimit; i++) {
 	                if (!clock.timers) {
-	                    resetIsNearInfiniteLimit();
+	                    resetIsNearInfiniteLimit(clock);
 	                    return clock.now;
 	                }
 
-	                numTimers = Object.keys(clock.timers).length;
+	                const numTimers = clock.timerHeap.timers.length;
 	                if (numTimers === 0) {
-	                    resetIsNearInfiniteLimit();
+	                    resetIsNearInfiniteLimit(clock);
 	                    return clock.now;
 	                }
 
-	                clock.next();
 	                checkIsNearInfiniteLimit(clock, i);
+	                clock.next();
 	            }
 
 	            const excessJob = firstTimer(clock);
@@ -4212,60 +4917,6 @@ function requireFakeTimersSrc () {
 	            return clock.tick(getTimeToNextFrame());
 	        };
 
-	        if (typeof _global.Promise !== "undefined") {
-	            clock.runAllAsync = function runAllAsync() {
-	                return pauseAutoTickUntilFinished(
-	                    new _global.Promise(function (resolve, reject) {
-	                        let i = 0;
-	                        /**
-	                         *
-	                         */
-	                        function doRun() {
-	                            originalSetTimeout(function () {
-	                                try {
-	                                    runJobs(clock);
-
-	                                    let numTimers;
-	                                    if (i < clock.loopLimit) {
-	                                        if (!clock.timers) {
-	                                            resetIsNearInfiniteLimit();
-	                                            resolve(clock.now);
-	                                            return;
-	                                        }
-
-	                                        numTimers = Object.keys(
-	                                            clock.timers,
-	                                        ).length;
-	                                        if (numTimers === 0) {
-	                                            resetIsNearInfiniteLimit();
-	                                            resolve(clock.now);
-	                                            return;
-	                                        }
-
-	                                        clock.next();
-
-	                                        i++;
-
-	                                        doRun();
-	                                        checkIsNearInfiniteLimit(clock, i);
-	                                        return;
-	                                    }
-
-	                                    const excessJob = firstTimer(clock);
-	                                    reject(
-	                                        getInfiniteLoopError(clock, excessJob),
-	                                    );
-	                                } catch (e) {
-	                                    reject(e);
-	                                }
-	                            });
-	                        }
-	                        doRun();
-	                    }),
-	                );
-	            };
-	        }
-
 	        clock.runToLast = function runToLast() {
 	            const timer = lastTimer(clock);
 	            if (!timer) {
@@ -4277,32 +4928,110 @@ function requireFakeTimersSrc () {
 	        };
 
 	        if (typeof _global.Promise !== "undefined") {
-	            clock.runToLastAsync = function runToLastAsync() {
-	                return pauseAutoTickUntilFinished(
-	                    new _global.Promise(function (resolve, reject) {
-	                        originalSetTimeout(function () {
-	                            try {
-	                                const timer = lastTimer(clock);
-	                                if (!timer) {
-	                                    runJobs(clock);
-	                                    resolve(clock.now);
-	                                }
+	            /**
+	             * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+	             * @returns {Promise}
+	             */
+	            clock.tickAsync = function tickAsync(tickValue) {
+	                return runAsyncWithNativeTimeout(function (resolve, reject) {
+	                    doTick(tickValue, true, resolve, reject);
+	                });
+	            };
 
-	                                resolve(
-	                                    clock.tickAsync(timer.callAt - clock.now),
-	                                );
-	                            } catch (e) {
-	                                reject(e);
+	            clock.nextAsync = function nextAsync() {
+	                return runAsyncWithNativeTimeout(function (resolve, reject) {
+	                    const timer = firstTimer(clock);
+	                    if (!timer) {
+	                        resolve(clock.now);
+	                        return;
+	                    }
+
+	                    let err;
+	                    clock.duringTick = true;
+	                    clock.now = timer.callAt;
+	                    try {
+	                        callTimer(clock, timer);
+	                    } catch (e) {
+	                        err = e;
+	                    }
+	                    clock.duringTick = false;
+
+	                    originalSetTimeout(function () {
+	                        if (err) {
+	                            reject(err);
+	                        } else {
+	                            resolve(clock.now);
+	                        }
+	                    });
+	                });
+	            };
+
+	            clock.runAllAsync = function runAllAsync() {
+	                let i = 0;
+	                /**
+	                 * @param {(value: unknown) => void} resolve promise resolve function
+	                 * @param {(reason?: unknown) => void} reject promise reject function
+	                 */
+	                function doRun(resolve, reject) {
+	                    try {
+	                        runJobs(clock);
+
+	                        let numTimers;
+	                        if (i < clock.loopLimit) {
+	                            if (!clock.timerHeap) {
+	                                resetIsNearInfiniteLimit(clock);
+	                                resolve(clock.now);
+	                                return;
 	                            }
-	                        });
-	                    }),
-	                );
+
+	                            numTimers = clock.timerHeap.timers.length;
+	                            if (numTimers === 0) {
+	                                resetIsNearInfiniteLimit(clock);
+	                                resolve(clock.now);
+	                                return;
+	                            }
+
+	                            checkIsNearInfiniteLimit(clock, i);
+	                            clock.next();
+
+	                            i++;
+
+	                            originalSetTimeout(function () {
+	                                doRun(resolve, reject);
+	                            });
+	                            return;
+	                        }
+
+	                        const excessJob = firstTimer(clock);
+	                        reject(getInfiniteLoopError(clock, excessJob));
+	                    } catch (e) {
+	                        reject(e);
+	                    }
+	                }
+
+	                return runAsyncWithNativeTimeout(function (resolve, reject) {
+	                    doRun(resolve, reject);
+	                });
+	            };
+
+	            clock.runToLastAsync = function runToLastAsync() {
+	                return runAsyncWithNativeTimeout(function (resolve) {
+	                    const timer = lastTimer(clock);
+	                    if (!timer) {
+	                        runJobs(clock);
+	                        resolve(clock.now);
+	                        return;
+	                    }
+
+	                    resolve(clock.tickAsync(timer.callAt - clock.now));
+	                });
 	            };
 	        }
 
 	        clock.reset = function reset() {
 	            nanos = 0;
-	            clock.timers = {};
+	            clock.timers = new Map();
+	            clock.timerHeap = new TimerHeap();
 	            clock.jobs = [];
 	            clock.now = start;
 	        };
@@ -4311,7 +5040,6 @@ function requireFakeTimersSrc () {
 	            // determine time difference
 	            const newNow = getEpoch(systemTime);
 	            const difference = newNow - clock.now;
-	            let id, timer;
 
 	            adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
 	            adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
@@ -4320,18 +5048,15 @@ function requireFakeTimersSrc () {
 	            nanos = 0;
 
 	            // update timers and intervals to keep them stable
-	            for (id in clock.timers) {
-	                if (clock.timers.hasOwnProperty(id)) {
-	                    timer = clock.timers[id];
-	                    timer.createdAt += difference;
-	                    timer.callAt += difference;
-	                }
-	            }
+	            forEachActiveTimer(clock, (timer) => {
+	                timer.createdAt += difference;
+	                timer.callAt += difference;
+	            });
 	        };
 
 	        /**
 	         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
-	         * @returns {number} will return the new `now` value
+	         * @returns {number} the new `now` value
 	         */
 	        clock.jump = function jump(tickValue) {
 	            const msFloat =
@@ -4340,12 +5065,17 @@ function requireFakeTimersSrc () {
 	                    : parseTime(tickValue);
 	            const ms = Math.floor(msFloat);
 
-	            for (const timer of Object.values(clock.timers)) {
+	            forEachActiveTimer(clock, (timer) => {
 	                if (clock.now + ms > timer.callAt) {
 	                    timer.callAt = clock.now + ms;
 	                }
-	            }
+	            });
+
+	            // Rebuild heap as order might have changed
+	            rebuildTimerHeap(clock);
+
 	            clock.tick(ms);
+	            return clock.now;
 	        };
 
 	        if (isPresent.performance) {
@@ -4360,6 +5090,11 @@ function requireFakeTimersSrc () {
 	        return clock;
 	    }
 
+	    /**
+	     * Starts the interval used to advance the clock automatically.
+	     * @param {Clock} clock
+	     * @param {number} delta
+	     */
 	    function createIntervalTick(clock, delta) {
 	        const intervalTick = doIntervalTick.bind(null, clock, delta);
 	        const intervalId = originalSetInterval(intervalTick, delta);
@@ -4401,6 +5136,21 @@ function requireFakeTimersSrc () {
 	        config.shouldClearNativeTimers =
 	            config.shouldClearNativeTimers || false;
 
+	        const hasToFake = Object.prototype.hasOwnProperty.call(
+	            config,
+	            "toFake",
+	        );
+	        const hasToNotFake = Object.prototype.hasOwnProperty.call(
+	            config,
+	            "toNotFake",
+	        );
+
+	        if (hasToFake && hasToNotFake) {
+	            throw new TypeError(
+	                "config.toFake and config.toNotFake cannot be used together",
+	            );
+	        }
+
 	        if (config.target) {
 	            throw new TypeError(
 	                "config.target is no longer supported. Use `withGlobal(target)` instead.",
@@ -4408,8 +5158,8 @@ function requireFakeTimersSrc () {
 	        }
 
 	        /**
-	         * @param {string} timer/object the name of the thing that is not present
-	         * @param timer
+	         * Handles a missing timer or API name during installation.
+	         * @param {string} timer - the name of the missing timer or object
 	         */
 	        function handleMissingTimer(timer) {
 	            if (config.ignoreMissingTimers) {
@@ -4431,10 +5181,24 @@ function requireFakeTimersSrc () {
 
 	        clock.abortListenerMap = new Map();
 
-	        clock.methods = config.toFake || [];
-
-	        if (clock.methods.length === 0) {
-	            clock.methods = Object.keys(timers);
+	        if (hasToFake) {
+	            clock.methods = /** @type {FakeMethod[]} */ (config.toFake || []);
+	            if (clock.methods.length === 0) {
+	                clock.methods = /** @type {FakeMethod[]} */ (
+	                    Object.keys(timers)
+	                );
+	            }
+	        } else if (hasToNotFake) {
+	            const methodsToNotFake = /** @type {string[]} */ (
+	                config.toNotFake || []
+	            );
+	            clock.methods = /** @type {FakeMethod[]} */ (
+	                Object.keys(timers).filter(
+	                    (method) => !methodsToNotFake.includes(method),
+	                )
+	            );
+	        } else {
+	            clock.methods = /** @type {FakeMethod[]} */ (Object.keys(timers));
 	        }
 
 	        if (config.shouldAdvanceTime === true) {
@@ -4471,7 +5235,7 @@ function requireFakeTimersSrc () {
 	                // (or the Worker was installed)
 	                clock.performance.timeOrigin = getEpoch(config.now);
 	            } else if ((config.toFake || []).includes("performance")) {
-	                return handleMissingTimer("performance");
+	                handleMissingTimer("performance");
 	            }
 	        }
 	        if (_global === globalObject && timersModule) {
@@ -4635,10 +5399,13 @@ function requireFakeTimersSrc () {
 	                        [Symbol.asyncIterator]: () => {
 	                            const createResolvable = () => {
 	                                let resolve, reject;
-	                                const promise = new Promise((res, rej) => {
-	                                    resolve = res;
-	                                    reject = rej;
-	                                });
+	                                const promise =
+	                                    /** @type {Promise<unknown> & { resolve: (value: unknown) => void; reject: (reason: unknown) => void }} */ (
+	                                        new Promise((res, rej) => {
+	                                            resolve = res;
+	                                            reject = rej;
+	                                        })
+	                                    );
 	                                promise.resolve = resolve;
 	                                promise.reject = reject;
 	                                return promise;
@@ -4766,22 +5533,13 @@ function requireFakeTimersSrc () {
 	    };
 	}
 
-	/**
-	 * @typedef {object} FakeTimers
-	 * @property {Timers} timers
-	 * @property {createClock} createClock
-	 * @property {Function} install
-	 * @property {withGlobal} withGlobal
-	 */
-
-	/* eslint-enable complexity */
-
 	/** @type {FakeTimers} */
 	const defaultImplementation = withGlobal(globalObject);
 
 	fakeTimersSrc.timers = defaultImplementation.timers;
 	fakeTimersSrc.createClock = defaultImplementation.createClock;
 	fakeTimersSrc.install = defaultImplementation.install;
+	/** @type {WithGlobal} */
 	fakeTimersSrc.withGlobal = withGlobal;
 	return fakeTimersSrc;
 }
@@ -4872,12 +5630,18 @@ class FakeTimers {
 			this._fakingDate = null;
 		}
 		if (this._fakingTime) this._clock.uninstall();
-		const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
-		if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process");
+		let toFake = this._userConfig?.toFake;
+		if (isChildProcess() && toFake?.includes("nextTick")) throw new Error("process.nextTick cannot be mocked inside child_process");
+		let toNotFake = this._userConfig?.toNotFake;
+		if (toFake === void 0 && toNotFake === void 0)
+ // Do not mock timers internally used by node by default. It can still be mocked through userConfig.
+		toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
+		if (isChildProcess() && toNotFake && !toNotFake.includes("nextTick")) toNotFake = [...toNotFake, "nextTick"];
 		this._clock = this._fakeTimers.install({
 			now: fakeDate,
 			...this._userConfig,
-			toFake: this._userConfig?.toFake || toFake,
+			...toFake && { toFake },
+			...toNotFake && { toNotFake },
 			ignoreMissingTimers: true
 		});
 		this._fakingTime = true;
@@ -4928,7 +5692,7 @@ class FakeTimers {
 	}
 }
 
-function copyStackTrace$1(target, source) {
+function copyStackTrace$2(target, source) {
 	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
 	return target;
 }
@@ -4949,7 +5713,7 @@ function waitFor(callback, options = {}) {
 		const handleTimeout = () => {
 			if (intervalId) clearInterval(intervalId);
 			let error = lastError;
-			if (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
+			if (!error) error = copyStackTrace$2(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
 			reject(error);
 		};
 		const checkCallback = () => {
@@ -4990,7 +5754,7 @@ function waitUntil(callback, options = {}) {
 		let intervalId;
 		const onReject = (error) => {
 			if (intervalId) clearInterval(intervalId);
-			if (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
+			if (!error) error = copyStackTrace$2(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
 			reject(error);
 		};
 		const onResolve = (result) => {
@@ -5129,9 +5893,17 @@ function createVitest() {
 		defineHelper: (fn) => {
 			return function __VITEST_HELPER__(...args) {
 				const result = fn.apply(this, args);
-				if (result && typeof result === "object" && typeof result.then === "function") return (async function __VITEST_HELPER__() {
-					return await result;
-				})();
+				if (result && typeof result === "object" && typeof result.then === "function") {
+					const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+					return (async function __VITEST_HELPER__() {
+						try {
+							return await result;
+						} catch (error) {
+							if (error instanceof Error && !error.stack?.includes("__VITEST_HELPER__")) copyStackTrace$1(error, stackTraceError);
+							throw error;
+						}
+					})();
+				}
 				return result;
 			};
 		},
@@ -5258,6 +6030,10 @@ function getImporter(name) {
 		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`) || stack.includes(` at ${name} (`);
 	}) + 1])?.file || "";
 }
+function copyStackTrace$1(target, source) {
+	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
+	return target;
+}
 
 // these matchers are not supported because they don't make sense with poll
 const unsupported = [
@@ -5325,7 +6101,9 @@ function createExpectPoll(expect) {
 				const promise = async () => {
 					chai.util.flag(assertion, "_name", key);
 					chai.util.flag(assertion, "error", STACK_TRACE_ERROR);
+					const onStart = chai.util.flag(assertion, "_poll.onStart");
 					const onSettled = chai.util.flag(assertion, "_poll.onSettled");
+					await onStart?.({ assertion });
 					if (Object.getOwnPropertyDescriptor(assertionFunction, "__vitest_poll_takeover__")?.value) try {
 						const output = await assertionFunction.call(assertion, ...args);
 						await onSettled?.({
@@ -5341,41 +6119,53 @@ function createExpectPoll(expect) {
 						throwWithCause(err, STACK_TRACE_ERROR);
 					}
 					const { setTimeout, clearTimeout } = getSafeTimers();
-					let executionPhase = "fn";
-					let hasTimedOut = false;
-					const timerId = setTimeout(() => {
-						hasTimedOut = true;
-					}, timeout);
+					let timerId;
+					const timeoutController = new AbortController();
+					const timeoutPromise = new Promise((resolve) => {
+						timerId = setTimeout(() => {
+							timeoutController.abort();
+							resolve();
+						}, timeout);
+					});
+					let lastError;
 					try {
-						while (true) {
-							const isLastAttempt = hasTimedOut;
-							if (isLastAttempt) chai.util.flag(assertion, "_isLastPollAttempt", true);
-							try {
-								executionPhase = "fn";
-								const obj = await fn();
-								chai.util.flag(assertion, "object", obj);
-								executionPhase = "assertion";
-								const output = await assertionFunction.call(assertion, ...args);
-								await onSettled?.({
-									assertion,
-									status: "pass"
-								});
-								return output;
-							} catch (err) {
-								if (isLastAttempt || executionPhase === "assertion" && chai.util.flag(assertion, "_poll.assert_once")) {
-									await onSettled?.({
-										assertion,
-										status: "fail"
-									});
-									throwWithCause(err, STACK_TRACE_ERROR);
-								}
-								await delay(interval, setTimeout);
-								if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+						while (true) try {
+							const fnResult = await raceWith$1(Promise.resolve().then(() => fn({ signal: timeoutController.signal })), timeoutPromise);
+							if (!fnResult.ok) {
+								lastError ??= /* @__PURE__ */ new Error(`expect.poll() function didn't resolve in time.`);
+								break;
 							}
+							const obj = fnResult.value;
+							chai.util.flag(assertion, "object", obj);
+							const assertionResult = await raceWith$1(Promise.resolve().then(() => assertionFunction.apply(assertion, args)), timeoutPromise);
+							if (!assertionResult.ok) {
+								lastError ??= /* @__PURE__ */ new Error(`expect.poll() assertion didn't resolve in time.`);
+								break;
+							}
+							const output = assertionResult.value;
+							await onSettled?.({
+								assertion,
+								status: "pass"
+							});
+							return output;
+						} catch (err) {
+							lastError = err;
+							// no retry for toMatchScreenshot since
+							// it owns retry/stability after the first element resolution
+							if (key === "toMatchScreenshot") break;
+							if (!(await raceWith$1(delay(interval, setTimeout), timeoutPromise)).ok) break;
+							if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
 						}
 					} finally {
 						clearTimeout(timerId);
 					}
+					if (lastError) {
+						await onSettled?.({
+							assertion,
+							status: "fail"
+						});
+						throwWithCause(lastError, STACK_TRACE_ERROR);
+					}
 				};
 				let awaited = false;
 				test.onFinished ??= [];
@@ -5413,6 +6203,17 @@ function copyStackTrace(target, source) {
 	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
 	return target;
 }
+function raceWith$1(promise, other) {
+	const left = promise.then((value) => ({
+		ok: true,
+		value
+	}));
+	if (!other) return left;
+	return Promise.race([left, other.then((value) => ({
+		ok: false,
+		value
+	}))]);
+}
 
 var naturalCompare$1 = {exports: {}};
 
@@ -6303,11 +7104,15 @@ class SnapshotClient {
 			inlineSnapshot
 		});
 		const reference = expectedSnapshot.data !== void 0 && snapshotState.snapshotUpdateState !== "all" ? adapter.parseExpected(expectedSnapshot.data) : void 0;
+		const timeoutController = new AbortController();
 		const stableResult = await getStableSnapshot({
 			adapter,
-			poll,
+			poll: () => poll({ signal: timeoutController.signal }),
 			interval,
-			timedOut: timeout > 0 ? new Promise((r) => setTimeout(r, timeout)) : void 0,
+			timedOut: timeout > 0 ? new Promise((r) => setTimeout(() => {
+				timeoutController.abort();
+				r();
+			}, timeout)) : void 0,
 			match: reference ? (captured) => adapter.match(captured, reference).pass : void 0
 		});
 		expectedSnapshot.markAsChecked();
@@ -6723,6 +7528,7 @@ function createExpect(test) {
 	chai.util.addMethod(expect, "assertions", assertions);
 	chai.util.addMethod(expect, "hasAssertions", hasAssertions);
 	expect.extend(customMatchers);
+	expect.extend(benchMatchers);
 	return expect;
 }
 const globalExpect = createExpect();
@@ -6742,140 +7548,280 @@ function inject(key) {
 	return getWorkerState().providedContext[key];
 }
 
-const benchFns = /* @__PURE__ */ new WeakMap();
-const benchOptsMap = /* @__PURE__ */ new WeakMap();
-function getBenchOptions(key) {
-	return benchOptsMap.get(key);
-}
-function getBenchFn(key) {
-	return benchFns.get(key);
-}
-const bench = createBenchmark(function(name, fn = noop, options = {}) {
-	if (getWorkerState().config.mode !== "benchmark") throw new Error("`bench()` is only available in benchmark mode.");
-	const task = getCurrentSuite().task(formatName(name), {
-		...this,
-		meta: { benchmark: true }
-	});
-	benchFns.set(task, fn);
-	benchOptsMap.set(task, options);
-	// vitest runner sets mode to `todo` if handler is not passed down
-	// but we store handler separately
-	if (!this.todo && task.mode === "todo") task.mode = "run";
-});
-function createBenchmark(fn) {
-	const benchmark = createChainable([
-		"skip",
-		"only",
-		"todo"
-	], fn);
-	benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
-	benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
-	return benchmark;
-}
-function formatName(name) {
-	return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
-}
-
-function createBenchmarkResult(name) {
-	return {
+const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+const kRegistration = Symbol("registration");
+const kFromSource = Symbol("fromSource");
+const kPerProject = Symbol("perProject");
+const kWriteResult = Symbol("writeResult");
+const kFinalize = Symbol("finalize");
+function isFromRegistration(reg) {
+	return kFromSource in reg;
+}
+function substitutePath(template, projectName) {
+	return template.replace(/\$\{projectName\}/g, projectName ?? "");
+}
+function createBench(test, config) {
+	let benchIdx = 0;
+	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();
+		const resolved = resolveTemplate(source);
+		const data = await rpc().readBenchmarkResult(resolved);
+		if (data == null) throw new Error(`\`bench.from()\` could not find a result file at "${resolved}". Run the source benchmark first to create it.`);
+		return data;
+	};
+	const taskFromBaseline = (name, data) => ({
 		name,
+		latency: data.latency,
+		throughput: data.throughput,
+		period: data.period,
+		totalTime: data.totalTime,
 		rank: 0,
-		rme: 0,
-		samples: []
+		fromStore: true
+	});
+	const createCompareStorage = (bench, 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 benchmarkTasks = /* @__PURE__ */ new WeakMap();
-async function runBenchmarkSuite(suite, runner) {
-	const { Task, Bench } = await runner.importTinybench();
-	const start = performance.now();
-	const benchmarkGroup = [];
-	const benchmarkSuiteGroup = [];
-	for (const task of suite.tasks) {
-		if (task.mode !== "run" && task.mode !== "queued") continue;
-		if (task.meta?.benchmark) benchmarkGroup.push(task);
-		else if (task.type === "suite") benchmarkSuiteGroup.push(task);
-	}
-	// run sub suites sequentially
-	for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
-	if (benchmarkGroup.length) {
-		const defer = createDefer();
-		suite.result = {
-			state: "run",
-			startTime: start,
-			benchmark: createBenchmarkResult(suite.name)
+	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)
+			};
+		});
+		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,
+			tasks
+		};
+	};
+	const recordBenchmark = async (tinybenchTasks, name, taskMeta, fromTasks) => {
+		const serializedBenchmark = serializeBenchmark(tinybenchTasks, name, taskMeta, fromTasks);
+		test.benchmarks.push(serializedBenchmark);
+		await rpc().onTestBenchmark(test.id, serializedBenchmark);
+	};
+	const writeResultArtifact = async (template, result) => {
+		const resolved = resolveTemplate(template);
+		const data = {
+			latency: result.latency,
+			throughput: result.throughput,
+			period: result.period,
+			totalTime: result.totalTime
+		};
+		await rpc().writeBenchmarkResult(resolved, data);
+	};
+	const runBenchmarks = async (tinybench) => {
+		const workerState = getWorkerState();
+		const getterTracker = workerState.getterTracker;
+		getterTracker?.resetInvocations();
+		try {
+			return await TestRunner.runBenchmarks(tinybench);
+		} 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.`,
+					"",
+					"This can make results unreliable because export getters add overhead.",
+					"See https://vitest.dev/guide/benchmarking#module-runner-overhead",
+					"",
+					"Tracked exports:",
+					entries
+				].join("\n"));
+			}
+		}
+	};
+	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 runFrom = async (name, source) => {
+		const data = await resolveFromSource(source);
+		const benchmark = {
+			name: test.fullTestName,
+			tasks: [{
+				...taskFromBaseline(name, data),
+				rank: 1
+			}]
 		};
-		updateTask$1("suite-prepare", suite);
-		const addBenchTaskListener = (task, benchmark) => {
-			task.addEventListener("complete", (e) => {
-				const taskRes = e.task.result;
-				const result = benchmark.result.benchmark;
-				benchmark.result.state = "pass";
-				Object.assign(result, taskRes);
-				// compute extra stats and free raw samples as early as possible
-				const samples = result.samples;
-				result.sampleCount = samples.length;
-				result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
-				if (!runner.config.benchmark?.includeSamples) result.samples.length = 0;
-				updateTask$1("test-finished", benchmark);
-			}, { once: true });
-			task.addEventListener("error", (e) => {
-				const task = e.task;
-				defer.reject(benchmark ? task.result.error : e);
-			}, { once: true });
+		test.benchmarks.push(benchmark);
+		await rpc().onTestBenchmark(test.id, benchmark);
+		return data;
+	};
+	const bench = (nameOrFunction, a, b) => {
+		validateBenchmarkProject(config);
+		const { fn, fnOpts, writeResult, perProject } = normalizeBenchArgs(a, b);
+		const name = typeof nameOrFunction === "function" ? nameOrFunction.name || "<anonymous>" : nameOrFunction;
+		const meta = perProject ? { perProject: true } : void 0;
+		const registration = {
+			[kRegistration]: true,
+			name,
+			fn,
+			fnOpts,
+			run: (options) => {
+				pending.delete(registration);
+				return runSingle(name, fn, fnOpts, options, meta, writeResult);
+			}
 		};
-		benchmarkGroup.forEach((benchmark) => {
-			const benchmarkInstance = new Bench(getBenchOptions(benchmark));
-			const benchmarkFn = getBenchFn(benchmark);
-			benchmark.result = {
-				state: "run",
-				startTime: start,
-				benchmark: createBenchmarkResult(benchmark.name)
-			};
-			const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
-			benchmarkTasks.set(benchmark, task);
-			addBenchTaskListener(task, benchmark);
+		if (perProject) registration[kPerProject] = true;
+		if (writeResult) registration[kWriteResult] = writeResult;
+		pending.add(registration);
+		return registration;
+	};
+	bench.from = (nameOrFunction, source) => {
+		validateBenchmarkProject(config);
+		if (typeof nameOrFunction !== "string" && typeof nameOrFunction !== "function") throw new TypeError("`bench.from()` requires a name (string or named function) as its first argument.");
+		if (typeof source !== "string" && typeof source !== "function") throw new TypeError("`bench.from()` expects a string path or a function returning the result data as its second argument.");
+		const name = typeof nameOrFunction === "function" ? nameOrFunction.name || "<anonymous>" : nameOrFunction;
+		const registration = {
+			[kRegistration]: true,
+			[kFromSource]: source,
+			name,
+			run: () => {
+				pending.delete(registration);
+				return runFrom(name, source);
+			}
+		};
+		pending.add(registration);
+		return registration;
+	};
+	bench.compare = async (...args) => {
+		validateBenchmarkProject(config);
+		// extract optional trailing BenchCompareOptions argument
+		const lastArg = args[args.length - 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
+		// throwing `bench.compare()` (wrong arity, wrong shape) doesn't also
+		// trigger the unrun-bench warning — the user's intent was to consume them.
+		for (const reg of registrations) if (reg != null && typeof reg === "object" && kRegistration in reg) pending.delete(reg);
+		if (registrations.length < 2) throw new SyntaxError(`\`bench.compare()\` requires at least 2 benchmarks, received ${registrations.length} instead. ${registrations.length === 1 ? "Consider calling `bench().run()`. " : "Define benchmarks by calling `bench()`. "}See https://vitest.dev/guide/benchmarking#comparing-benchmarks`);
+		for (const reg of registrations) if (reg == null || typeof reg !== "object" || !(kRegistration in reg)) throw new SyntaxError("`bench.compare()` expects every argument to be the return value of `bench` or `bench.from`.");
+		const runnable = [];
+		const fromEntries = [];
+		for (const reg of registrations) if (isFromRegistration(reg)) fromEntries.push(reg);
+		else runnable.push(reg);
+		const taskMeta = /* @__PURE__ */ new Map();
+		for (const reg of runnable) if (reg[kPerProject]) taskMeta.set(reg.name, { perProject: true });
+		const fromResults = /* @__PURE__ */ new Map();
+		const fromTasks = [];
+		if (fromEntries.length > 0) {
+			const resolved = await Promise.all(fromEntries.map(async (reg) => {
+				return {
+					reg,
+					data: await resolveFromSource(reg[kFromSource])
+				};
+			}));
+			for (const { reg, data } of resolved) {
+				fromResults.set(reg.name, data);
+				fromTasks.push(taskFromBaseline(reg.name, data));
+			}
+		}
+		const tinybench = createTinybench(benchOptions);
+		runnable.forEach((reg) => {
+			tinybench.add(reg.name, reg.fn, reg.fnOpts);
 		});
-		const { setTimeout } = getSafeTimers();
-		const tasks = [];
-		for (const benchmark of benchmarkGroup) {
-			const task = benchmarkTasks.get(benchmark);
-			updateTask$1("test-prepare", benchmark);
-			await task.warmup();
-			tasks.push([await new Promise((resolve) => setTimeout(async () => {
-				resolve(await task.run());
-			})), benchmark]);
+		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");
 		}
-		suite.result.duration = performance.now() - start;
-		suite.result.state = "pass";
-		updateTask$1("suite-finished", suite);
-		defer.resolve(null);
-		await defer;
-	}
-	function updateTask$1(event, task) {
-		updateTask(event, task, runner);
-	}
+		await recordBenchmark(tasks, tinybench.name, 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);
+		}));
+		return createCompareStorage(tinybench, fromResults);
+	};
+	bench[kFinalize] = () => {
+		if (pending.size === 0) return;
+		const names = [...pending].map((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}.`,
+			"",
+			"Call `.run()` on the registration, or pass it to `bench.compare()`.",
+			"See https://vitest.dev/guide/benchmarking#defining-a-benchmark"
+		].join("\n"));
+	};
+	return bench;
 }
-class NodeBenchmarkRunner {
-	moduleRunner;
-	constructor(config) {
-		this.config = config;
-	}
-	async importTinybench() {
-		return await import('tinybench');
-	}
-	importFile(filepath, source) {
-		if (source === "setup") {
-			const moduleNode = getWorkerState().evaluatedModules.getModuleById(filepath);
-			if (moduleNode) getWorkerState().evaluatedModules.invalidateModule(moduleNode);
-		}
-		return this.moduleRunner.import(filepath);
-	}
-	async runSuite(suite) {
-		await runBenchmarkSuite(suite, this);
-	}
-	async runTask() {
-		throw new Error("`test()` and `it()` is only available in test mode.");
+function formatModuleId(moduleId, root) {
+	if (!root || !isAbsolute(moduleId)) return moduleId;
+	return relative(root, moduleId);
+}
+function normalizeBenchArgs(a, b) {
+	if (typeof a === "function") {
+		if (b !== void 0) throw new TypeError("`bench()` does not accept options as the third argument. Pass options as the second argument instead: `bench(name, options, fn)`.");
+		return {
+			fn: a,
+			fnOpts: void 0,
+			writeResult: void 0,
+			perProject: false
+		};
 	}
+	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.
+	if (a.writeResult === void 0 && a.perProject === void 0) return {
+		fn: b,
+		fnOpts: a,
+		writeResult: void 0,
+		perProject: false
+	};
+	const { writeResult, perProject, ...fnOpts } = a;
+	return {
+		fn: b,
+		fnOpts: Object.keys(fnOpts).length > 0 ? fnOpts : void 0,
+		writeResult,
+		perProject: perProject ?? false
+	};
+}
+function validateBenchmarkProject(config) {
+	if (!config.benchmark.enabled) throw new Error("Cannot use the `bench` test-context fixture within a regular test run. Benchmarks are inherently flaky, so Vitest runs them in a dedicated project based on the `benchmark.include` pattern (default `**/*.{bench,benchmark}.?(c|m)[jt]s?(x)`). Move this code to a file matched by `benchmark.include`, and make sure `bench` is destructured from the test context (`test('...', async ({ bench }) => { ... })`) — it is not a top-level export of `vitest`. See https://vitest.dev/guide/benchmarking#stability");
 }
 
 class TestRunner {
@@ -6884,7 +7830,11 @@ class TestRunner {
 	moduleRunner;
 	cancelRun = false;
 	assertionsErrors = /* @__PURE__ */ new WeakMap();
+	benchInstances = /* @__PURE__ */ new WeakMap();
 	pool = this.workerState.ctx.pool;
+	/**
+	* @internal
+	*/
 	_otel;
 	viteEnvironment;
 	viteModuleRunner;
@@ -6910,7 +7860,7 @@ class TestRunner {
 	onCleanupWorkerContext(listener) {
 		this.workerState.onCleanup(listener);
 	}
-	onAfterRunFiles() {
+	onAfterRunFiles(_files) {
 		this.snapshotClient.clear();
 		this.workerState.current = void 0;
 	}
@@ -6957,7 +7907,7 @@ class TestRunner {
 		if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
 		this.workerState.current = suite;
 	}
-	onBeforeTryTask(test) {
+	onBeforeTryTask(test, _options) {
 		clearModuleMocks(this.config);
 		this.snapshotClient.clearTest(test.file.filepath, test.id);
 		setState({
@@ -6971,6 +7921,7 @@ class TestRunner {
 		}, globalThis[GLOBAL_EXPECT]);
 	}
 	onAfterTryTask(test) {
+		this.benchInstances.get(test)?.[kFinalize]();
 		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
 		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
 		if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
@@ -6987,6 +7938,16 @@ class TestRunner {
 		Object.defineProperty(context, "_local", { get() {
 			return _expect != null;
 		} });
+		let _bench;
+		const runnerConfig = this.config;
+		const benchInstances = this.benchInstances;
+		Object.defineProperty(context, "bench", { get() {
+			if (!_bench) {
+				_bench = createBench(context.task, runnerConfig);
+				benchInstances.set(context.task, _bench);
+			}
+			return _bench;
+		} });
 		return context;
 	}
 	getImportDurations() {
@@ -7021,13 +7982,13 @@ class TestRunner {
 	static setTestFn = getFn;
 	static matchesTags = matchesTags;
 	/**
-	* @deprecated
-	*/
-	static getBenchFn = getBenchFn;
-	/**
-	* @deprecated
+	* @experimental
+	* A function that runs tinybench tasks.
+	* Can be overriden to run tasks in a special environment.
 	*/
-	static getBenchOptions = getBenchOptions;
+	static async runBenchmarks(tinybench) {
+		return await tinybench.run();
+	}
 }
 function clearModuleMocks(config) {
 	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
@@ -7042,7 +8003,6 @@ const assertType = function assertType() {};
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  BenchmarkRunner: NodeBenchmarkRunner,
   EvaluatedModules: VitestEvaluatedModules,
   Snapshots: Snapshots,
   TestRunner: TestRunner,
@@ -7054,7 +8014,6 @@ var index = /*#__PURE__*/Object.freeze({
   assertType: assertType,
   beforeAll: beforeAll,
   beforeEach: beforeEach,
-  bench: bench,
   chai: chai,
   createExpect: createExpect,
   describe: describe,
@@ -7072,4 +8031,4 @@ var index = /*#__PURE__*/Object.freeze({
   vitest: vitest
 });
 
-export { NodeBenchmarkRunner as N, Snapshots as S, TestRunner as T, assert as a, assertType as b, bench as c, createExpect as d, inject as e, vitest as f, globalExpect as g, index as i, should as s, vi as v };
+export { Snapshots as S, TestRunner as T, assert as a, assertType as b, createExpect as c, inject as d, vitest as e, globalExpect as g, index as i, should as s, vi as v };