vitest 5.0.0-beta.3 → 5.0.0-beta.4

package/dist/chunks/{index.ukHtlBbI.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;
@@ -5649,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;
 }
@@ -5670,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 = () => {
@@ -5711,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) => {
@@ -5850,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;
 			};
 		},
@@ -5979,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 = [
@@ -7473,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();
@@ -7492,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
 		};
-		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 });
+	};
+	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
 		};
-		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);
+		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
+			}]
+		};
+		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);
+			}
+		};
+		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 {
@@ -7634,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;
@@ -7660,7 +7860,7 @@ class TestRunner {
 	onCleanupWorkerContext(listener) {
 		this.workerState.onCleanup(listener);
 	}
-	onAfterRunFiles() {
+	onAfterRunFiles(_files) {
 		this.snapshotClient.clear();
 		this.workerState.current = void 0;
 	}
@@ -7707,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({
@@ -7721,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;
@@ -7737,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() {
@@ -7771,13 +7982,13 @@ class TestRunner {
 	static setTestFn = getFn;
 	static matchesTags = matchesTags;
 	/**
-	* @deprecated
+	* @experimental
+	* A function that runs tinybench tasks.
+	* Can be overriden to run tasks in a special environment.
 	*/
-	static getBenchFn = getBenchFn;
-	/**
-	* @deprecated
-	*/
-	static getBenchOptions = getBenchOptions;
+	static async runBenchmarks(tinybench) {
+		return await tinybench.run();
+	}
 }
 function clearModuleMocks(config) {
 	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
@@ -7792,7 +8003,6 @@ const assertType = function assertType() {};
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  BenchmarkRunner: NodeBenchmarkRunner,
   EvaluatedModules: VitestEvaluatedModules,
   Snapshots: Snapshots,
   TestRunner: TestRunner,
@@ -7804,7 +8014,6 @@ var index = /*#__PURE__*/Object.freeze({
   assertType: assertType,
   beforeAll: beforeAll,
   beforeEach: beforeEach,
-  bench: bench,
   chai: chai,
   createExpect: createExpect,
   describe: describe,
@@ -7822,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 };