@vitest/runner 4.1.0-beta.2 → 4.1.0-beta.3

package/dist/chunk-tasks.js

@@ -578,4 +578,4 @@ function createTaskName(names, separator = " > ") {
 	return names.filter((name) => name !== undefined).join(separator);
 }
 
-export { calculateSuiteHash as a, createFileTask as b, createChainable as c, generateHash as d, createTagsFilter as e, findTestFileStackTrace as f, generateFileHash as g, createTaskName as h, interpretTaskModes as i, getFullName as j, getNames as k, limitConcurrency as l, getSuites as m, getTasks as n, getTestName as o, partitionSuiteChildren as p, getTests as q, hasFailed as r, someTasksAreOnly as s, hasTests as t, isTestCase as u, validateTags as v, createNoTagsError as w };
+export { createChainable as a, createFileTask as b, calculateSuiteHash as c, createTagsFilter as d, createTaskName as e, findTestFileStackTrace as f, generateFileHash as g, generateHash as h, getFullName as i, getNames as j, getSuites as k, getTasks as l, getTestName as m, getTests as n, hasFailed as o, hasTests as p, interpretTaskModes as q, isTestCase as r, limitConcurrency as s, partitionSuiteChildren as t, someTasksAreOnly as u, validateTags as v, createNoTagsError as w };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { T as TestArtifact, a as Test, S as Suite, b as SuiteHooks, F as FileSpecification, V as VitestRunner, c as File, d as TaskUpdateEvent, e as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-CLPU8HE4.js';
-export { A as AfterAllListener, s as AfterEachListener, B as BeforeAllListener, t as BeforeEachListener, C as CancelReason, u as Fixture, v as FixtureFn, w as FixtureOptions, x as Fixtures, I as ImportDuration, y as InferFixturesTypes, O as OnTestFailedHandler, z as OnTestFinishedHandler, R as Retry, D as RunMode, E as RuntimeContext, G as SequenceHooks, H as SequenceSetupFiles, J as SerializableRetry, K as SuiteFactory, L as TaskBase, M as TaskCustomOptions, N as TaskEventPack, P as TaskHook, Q as TaskMeta, U as TaskPopulated, W as TaskResult, X as TaskResultPack, Y as TaskState, Z as TestAnnotation, _ as TestAnnotationArtifact, $ as TestAnnotationLocation, a0 as TestArtifactBase, a1 as TestArtifactLocation, a2 as TestArtifactRegistry, a3 as TestAttachment, a4 as TestContext, a5 as TestFunction, a6 as TestOptions, n as TestTagDefinition, a7 as TestTags, a8 as Use, a9 as VisualRegressionArtifact, p as VitestRunnerConfig, q as VitestRunnerConstructor, r as VitestRunnerImportSource, i as afterAll, j as afterEach, k as beforeAll, l as beforeEach, o as onTestFailed, m as onTestFinished } from './tasks.d-CLPU8HE4.js';
+import { T as TestArtifact, a as Test, S as Suite, b as SuiteHooks, F as FileSpecification, V as VitestRunner, c as File, d as TaskUpdateEvent, e as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-WWG4yDf6.js';
+export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, I as ImportDuration, q as InferFixturesTypes, O as OnTestFailedHandler, r as OnTestFinishedHandler, R as Retry, s as RunMode, t as RuntimeContext, u as SequenceHooks, v as SequenceSetupFiles, w as SerializableRetry, x as SuiteFactory, y as SuiteOptions, z as TaskBase, D as TaskCustomOptions, E as TaskEventPack, G as TaskHook, H as TaskMeta, J as TaskPopulated, K as TaskResult, L as TaskResultPack, M as TaskState, N as TestAnnotation, P as TestAnnotationArtifact, Q as TestAnnotationLocation, U as TestArtifactBase, W as TestArtifactLocation, X as TestArtifactRegistry, Y as TestAttachment, Z as TestContext, _ as TestFunction, $ as TestOptions, a0 as TestTagDefinition, a1 as TestTags, a2 as Use, a3 as VisualRegressionArtifact, a4 as VitestRunnerConfig, a5 as VitestRunnerConstructor, a6 as VitestRunnerImportSource, a7 as afterAll, a8 as afterEach, a9 as aroundAll, aa as aroundEach, ab as beforeAll, ac as beforeEach, ad as onTestFailed, ae as onTestFinished } from './tasks.d-WWG4yDf6.js';
 import { Awaitable } from '@vitest/utils';
 import '@vitest/utils/diff';
 

package/dist/index.js

@@ -2,7 +2,7 @@ import { processError } from '@vitest/utils/error';
 import { isObject, filterOutComments, createDefer, assertTypes, toArray, isNegativeNaN, unique, objectAttr, shuffle } from '@vitest/utils/helpers';
 import { getSafeTimers } from '@vitest/utils/timers';
 import { format, formatRegExp, objDisplay } from '@vitest/utils/display';
-import { c as createChainable, v as validateTags, h as createTaskName, w as createNoTagsError, f as findTestFileStackTrace, e as createTagsFilter, b as createFileTask, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, l as limitConcurrency, p as partitionSuiteChildren, t as hasTests, r as hasFailed } from './chunk-tasks.js';
+import { a as createChainable, v as validateTags, e as createTaskName, w as createNoTagsError, f as findTestFileStackTrace, d as createTagsFilter, b as createFileTask, c as calculateSuiteHash, u as someTasksAreOnly, q as interpretTaskModes, s as limitConcurrency, t as partitionSuiteChildren, p as hasTests, o as hasFailed } from './chunk-tasks.js';
 import '@vitest/utils/source-map';
 import 'pathe';
 
@@ -24,6 +24,15 @@ class TestRunAbortError extends Error {
 		this.reason = reason;
 	}
 }
+class AroundHookSetupError extends Error {
+	name = "AroundHookSetupError";
+}
+class AroundHookTeardownError extends Error {
+	name = "AroundHookTeardownError";
+}
+class AroundHookMultipleCallsError extends Error {
+	name = "AroundHookMultipleCallsError";
+}
 
 // use WeakMap here to make the Test and Suite object serializable
 const fnMap = new WeakMap();
@@ -134,6 +143,33 @@ async function callFixtureCleanup(context) {
 	}
 	cleanupFnArrayMap.delete(context);
 }
+/**
+* Returns the current number of cleanup functions registered for the context.
+* This can be used as a checkpoint to later clean up only fixtures added after this point.
+*/
+function getFixtureCleanupCount(context) {
+	var _cleanupFnArrayMap$ge;
+	return ((_cleanupFnArrayMap$ge = cleanupFnArrayMap.get(context)) === null || _cleanupFnArrayMap$ge === void 0 ? void 0 : _cleanupFnArrayMap$ge.length) ?? 0;
+}
+/**
+* Cleans up only fixtures that were added after the given checkpoint index.
+* This is used by aroundEach to clean up fixtures created inside runTest()
+* while preserving fixtures that were created for aroundEach itself.
+*/
+async function callFixtureCleanupFrom(context, fromIndex) {
+	const cleanupFnArray = cleanupFnArrayMap.get(context);
+	if (!cleanupFnArray || cleanupFnArray.length <= fromIndex) {
+		return;
+	}
+	// Get items added after the checkpoint
+	const toCleanup = cleanupFnArray.slice(fromIndex);
+	// Clean up in reverse order
+	for (const cleanup of toCleanup.reverse()) {
+		await cleanup();
+	}
+	// Remove cleaned up items from the array, keeping items before checkpoint
+	cleanupFnArray.length = fromIndex;
+}
 function withFixtures(runner, fn, testContext) {
 	return (hookContext) => {
 		const context = hookContext || testContext;
@@ -358,6 +394,8 @@ function getDefaultHookTimeout() {
 }
 const CLEANUP_TIMEOUT_KEY = Symbol.for("VITEST_CLEANUP_TIMEOUT");
 const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
+const AROUND_TIMEOUT_KEY = Symbol.for("VITEST_AROUND_TIMEOUT");
+const AROUND_STACK_TRACE_KEY = Symbol.for("VITEST_AROUND_STACK_TRACE");
 function getBeforeHookCleanupCallback(hook, result, context) {
 	if (typeof result === "function") {
 		const timeout = CLEANUP_TIMEOUT_KEY in hook && typeof hook[CLEANUP_TIMEOUT_KEY] === "number" ? hook[CLEANUP_TIMEOUT_KEY] : getDefaultHookTimeout();
@@ -512,6 +550,113 @@ const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout)
 	test.onFinished || (test.onFinished = []);
 	test.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
 });
+/**
+* Registers a callback function that wraps around all tests within the current suite.
+* The callback receives a `runSuite` function that must be called to run the suite's tests.
+* This hook is useful for scenarios where you need to wrap an entire suite in a context
+* (e.g., starting a server, opening a database connection that all tests share).
+*
+* **Note:** When multiple `aroundAll` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* **Note:** Unlike `aroundEach`, the `aroundAll` hook does not receive test context or support fixtures,
+* as it runs at the suite level before any individual test context is created.
+*
+* @param {Function} fn - The callback function that wraps the suite. Must call `runSuite()` to run the tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using aroundAll to wrap suite in a tracing span
+* aroundAll(async (runSuite) => {
+*   await tracer.trace('test-suite', runSuite);
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundAll with AsyncLocalStorage context
+* aroundAll(async (runSuite) => {
+*   await asyncLocalStorage.run({ suiteId: 'my-suite' }, runSuite);
+* });
+* ```
+*/
+function aroundAll(fn, timeout) {
+	assertTypes(fn, "\"aroundAll\" callback", ["function"]);
+	const stackTraceError = new Error("STACK_TRACE_ERROR");
+	const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+	return getCurrentSuite().on("aroundAll", Object.assign(fn, {
+		[AROUND_TIMEOUT_KEY]: resolvedTimeout,
+		[AROUND_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Registers a callback function that wraps around each test within the current suite.
+* The callback receives a `runTest` function that must be called to run the test.
+* This hook is useful for scenarios where you need to wrap tests in a context (e.g., database transactions).
+*
+* **Note:** When multiple `aroundEach` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* @param {Function} fn - The callback function that wraps the test. Must call `runTest()` to run the test.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using aroundEach to wrap tests in a database transaction
+* aroundEach(async (runTest) => {
+*   await database.transaction(() => runTest());
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundEach with fixtures
+* aroundEach(async (runTest, { db }) => {
+*   await db.transaction(() => runTest());
+* });
+* ```
+*/
+function aroundEach(fn, timeout) {
+	assertTypes(fn, "\"aroundEach\" callback", ["function"]);
+	const stackTraceError = new Error("STACK_TRACE_ERROR");
+	const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+	const runner = getRunner();
+	// Create a wrapper function that supports fixtures in the second argument (context)
+	// withFixtures resolves fixtures into context, then we call fn with all 3 args
+	const wrappedFn = withAroundEachFixtures(runner, fn);
+	// Store timeout and stack trace on the function for use in callAroundEachHooks
+	// Setup and teardown phases will each have their own timeout
+	return getCurrentSuite().on("aroundEach", Object.assign(wrappedFn, {
+		[AROUND_TIMEOUT_KEY]: resolvedTimeout,
+		[AROUND_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Wraps an aroundEach listener to support fixtures.
+* Similar to withFixtures, but handles the aroundEach signature where:
+* - First arg is runTest function
+* - Second arg is context (where fixtures are destructured from)
+* - Third arg is suite
+*/
+function withAroundEachFixtures(runner, fn) {
+	// Create the wrapper that will be returned
+	const wrapper = (runTest, context, suite) => {
+		// Create inner function that will be passed to withFixtures
+		// This function receives context (with fixtures resolved) and calls original fn
+		const innerFn = (ctx) => fn(runTest, ctx, suite);
+		innerFn.__VITEST_FIXTURE_INDEX__ = 1;
+		innerFn.toString = () => fn.toString();
+		// Use withFixtures to resolve fixtures, passing context as the hook context
+		const fixtureResolver = withFixtures(runner, innerFn);
+		return fixtureResolver(context);
+	};
+	return wrapper;
+}
+function getAroundHookTimeout(hook) {
+	return AROUND_TIMEOUT_KEY in hook && typeof hook[AROUND_TIMEOUT_KEY] === "number" ? hook[AROUND_TIMEOUT_KEY] : getDefaultHookTimeout();
+}
+function getAroundHookStackTrace(hook) {
+	return AROUND_STACK_TRACE_KEY in hook && hook[AROUND_STACK_TRACE_KEY] instanceof Error ? hook[AROUND_STACK_TRACE_KEY] : undefined;
+}
 function createTestHook(name, handler) {
 	return (fn, timeout) => {
 		assertTypes(fn, `"${name}" callback`, ["function"]);
@@ -698,7 +843,9 @@ function createSuiteHooks() {
 		beforeAll: [],
 		afterAll: [],
 		beforeEach: [],
-		afterEach: []
+		afterEach: [],
+		aroundEach: [],
+		aroundAll: []
 	};
 }
 const POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
@@ -746,15 +893,31 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 			}
 			return tagDefinition;
 		}).filter((r) => r != null).sort((tag1, tag2) => (tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag) => {
-			const { name, description, priority, ...options } = tag;
+			const { name, description, priority, meta, ...options } = tag;
 			Object.assign(acc, options);
+			if (meta) {
+				acc.meta = Object.assign(acc.meta ?? Object.create(null), meta);
+			}
 			return acc;
 		}, {});
+		const testOwnMeta = options.meta;
 		options = {
 			...tagsOptions,
 			...options
 		};
 		const timeout = options.timeout ?? runner.config.testTimeout;
+		const parentMeta = currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.meta;
+		const tagMeta = tagsOptions.meta;
+		const testMeta = Object.create(null);
+		if (tagMeta) {
+			Object.assign(testMeta, tagMeta);
+		}
+		if (parentMeta) {
+			Object.assign(testMeta, parentMeta);
+		}
+		if (testOwnMeta) {
+			Object.assign(testMeta, testOwnMeta);
+		}
 		const task = {
 			id: "",
 			name,
@@ -770,7 +933,7 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 			retry: options.retry ?? runner.config.retry,
 			repeats: options.repeats,
 			mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
-			meta: options.meta ?? Object.create(null),
+			meta: testMeta,
 			annotations: [],
 			artifacts: [],
 			tags: testTags
@@ -880,7 +1043,7 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 			file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur8 = collectorContext.currentSuite) === null || _collectorContext$cur8 === void 0 ? void 0 : _collectorContext$cur8.file),
 			shuffle: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle,
 			tasks: [],
-			meta: Object.create(null),
+			meta: (suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.meta) ?? Object.create(null),
 			concurrent: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.concurrent,
 			tags: unique([...(parentTask === null || parentTask === void 0 ? void 0 : parentTask.tags) || [], ...suiteTags])
 		};
@@ -944,9 +1107,10 @@ function createSuite() {
 		let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
 		const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
 		const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
+		const { meta: parentMeta, ...parentOptions } = (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.options) || {};
 		// inherit options from current suite
 		options = {
-			...currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.options,
+			...parentOptions,
 			...options
 		};
 		const shuffle = this.shuffle ?? options.shuffle ?? (currentSuite === null || currentSuite === void 0 || (_currentSuite$options = currentSuite.options) === null || _currentSuite$options === void 0 ? void 0 : _currentSuite$options.shuffle) ?? (runner === null || runner === void 0 ? void 0 : runner.config.sequence.shuffle);
@@ -967,6 +1131,9 @@ function createSuite() {
 		if (isSequential != null) {
 			options.sequential = isSequential && !isConcurrent;
 		}
+		if (parentMeta) {
+			options.meta = Object.assign(Object.create(null), parentMeta, options.meta);
+		}
 		return createSuiteCollector(formatName(name), factory, mode, this.each, options, currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fixtures());
 	}
 	suiteFn.each = function(cases, ...args) {
@@ -1096,10 +1263,13 @@ function createTaskCollector(fn, context) {
 			originalWrapper.call(context, formatName(name), optionsOrFn, optionsOrTest);
 		}, _context);
 	};
+	taskFn.describe = suite;
 	taskFn.beforeEach = beforeEach;
 	taskFn.afterEach = afterEach;
 	taskFn.beforeAll = beforeAll;
 	taskFn.afterAll = afterAll;
+	taskFn.aroundEach = aroundEach;
+	taskFn.aroundAll = aroundAll;
 	const _test = createChainable([
 		"concurrent",
 		"sequential",
@@ -1586,6 +1756,157 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
 	}
 	return callbacks;
 }
+function getAroundEachHooks(suite) {
+	const hooks = [];
+	const parentSuite = "filepath" in suite ? null : suite.suite || suite.file;
+	if (parentSuite) {
+		hooks.push(...getAroundEachHooks(parentSuite));
+	}
+	hooks.push(...getHooks(suite).aroundEach);
+	return hooks;
+}
+function getAroundAllHooks(suite) {
+	return getHooks(suite).aroundAll;
+}
+function makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError) {
+	const message = `The ${phase} phase of "${hookName}" hook timed out after ${timeout}ms.`;
+	const ErrorClass = phase === "setup" ? AroundHookSetupError : AroundHookTeardownError;
+	const error = new ErrorClass(message);
+	if (stackTraceError === null || stackTraceError === void 0 ? void 0 : stackTraceError.stack) {
+		error.stack = stackTraceError.stack.replace(stackTraceError.message, error.message);
+	}
+	return error;
+}
+async function callAroundHooks(runInner, options) {
+	const { hooks, hookName, callbackName, onTimeout, invokeHook } = options;
+	if (!hooks.length) {
+		await runInner();
+		return;
+	}
+	const createTimeoutPromise = (timeout, phase, stackTraceError) => {
+		let timer;
+		const promise = new Promise((_, reject) => {
+			if (timeout > 0 && timeout !== Number.POSITIVE_INFINITY) {
+				var _timer$unref;
+				timer = setTimeout(() => {
+					const error = makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError);
+					onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(error);
+					reject(error);
+				}, timeout);
+				(_timer$unref = timer.unref) === null || _timer$unref === void 0 ? void 0 : _timer$unref.call(timer);
+			}
+		});
+		const clear = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = undefined;
+			}
+		};
+		return {
+			promise,
+			clear
+		};
+	};
+	const runNextHook = async (index) => {
+		if (index >= hooks.length) {
+			return runInner();
+		}
+		const hook = hooks[index];
+		const timeout = getAroundHookTimeout(hook);
+		const stackTraceError = getAroundHookStackTrace(hook);
+		let useCalled = false;
+		let setupTimeout;
+		let teardownTimeout;
+		// Promise that resolves when use() is called (setup phase complete)
+		let resolveUseCalled;
+		const useCalledPromise = new Promise((resolve) => {
+			resolveUseCalled = resolve;
+		});
+		// Promise that resolves when use() returns (inner hooks complete, teardown phase starts)
+		let resolveUseReturned;
+		const useReturnedPromise = new Promise((resolve) => {
+			resolveUseReturned = resolve;
+		});
+		// Promise that resolves when hook completes
+		let resolveHookComplete;
+		let rejectHookComplete;
+		const hookCompletePromise = new Promise((resolve, reject) => {
+			resolveHookComplete = resolve;
+			rejectHookComplete = reject;
+		});
+		const use = async () => {
+			if (useCalled) {
+				throw new AroundHookMultipleCallsError(`The \`${callbackName}\` callback was called multiple times in the \`${hookName}\` hook. ` + `The callback can only be called once per hook.`);
+			}
+			useCalled = true;
+			resolveUseCalled();
+			// Setup phase completed - clear setup timer
+			setupTimeout.clear();
+			// Run inner hooks - don't time this against our teardown timeout
+			await runNextHook(index + 1);
+			// Start teardown timer after inner hooks complete - only times this hook's teardown code
+			teardownTimeout = createTimeoutPromise(timeout, "teardown", stackTraceError);
+			// Signal that use() is returning (teardown phase starting)
+			resolveUseReturned();
+		};
+		// Start setup timeout
+		setupTimeout = createTimeoutPromise(timeout, "setup", stackTraceError);
+		(async () => {
+			try {
+				await invokeHook(hook, use);
+				if (!useCalled) {
+					throw new AroundHookSetupError(`The \`${callbackName}\` callback was not called in the \`${hookName}\` hook. ` + `Make sure to call \`${callbackName}\` to run the ${hookName === "aroundEach" ? "test" : "suite"}.`);
+				}
+				resolveHookComplete();
+			} catch (error) {
+				rejectHookComplete(error);
+			}
+		})();
+		// Wait for either: use() to be called OR hook to complete (error) OR setup timeout
+		try {
+			await Promise.race([
+				useCalledPromise,
+				hookCompletePromise,
+				setupTimeout.promise
+			]);
+		} finally {
+			setupTimeout.clear();
+		}
+		// Wait for use() to return (inner hooks complete) OR hook to complete (error during inner hooks)
+		await Promise.race([useReturnedPromise, hookCompletePromise]);
+		// Now teardownTimeout is guaranteed to be set
+		// Wait for hook to complete (teardown) OR teardown timeout
+		try {
+			await Promise.race([hookCompletePromise, teardownTimeout.promise]);
+		} finally {
+			teardownTimeout.clear();
+		}
+	};
+	await runNextHook(0);
+}
+async function callAroundAllHooks(suite, runSuiteInner) {
+	await callAroundHooks(runSuiteInner, {
+		hooks: getAroundAllHooks(suite),
+		hookName: "aroundAll",
+		callbackName: "runSuite()",
+		invokeHook: (hook, use) => hook(use, suite)
+	});
+}
+async function callAroundEachHooks(suite, test, runTest) {
+	await callAroundHooks(
+		// Take checkpoint right before runTest - at this point all aroundEach fixtures
+		// have been resolved, so we can correctly identify which fixtures belong to
+		// aroundEach (before checkpoint) vs inside runTest (after checkpoint)
+		() => runTest(getFixtureCleanupCount(test.context)),
+		{
+			hooks: getAroundEachHooks(suite),
+			hookName: "aroundEach",
+			callbackName: "runTest()",
+			onTimeout: (error) => abortContextSignal(test.context, error),
+			invokeHook: (hook, use) => hook(use, test.context, suite)
+		}
+	);
+}
 const packs = new Map();
 const eventsPacks = [];
 const pendingTasksUpdates = [];
@@ -1710,66 +2031,84 @@ async function runTest(test, runner) {
 	for (let repeatCount = 0; repeatCount <= repeats; repeatCount++) {
 		const retry = getRetryCount(test.retry);
 		for (let retryCount = 0; retryCount <= retry; retryCount++) {
-			var _test$onFinished, _test$onFailed, _runner$onAfterRetryT, _test$result2, _test$result3;
+			var _test$result2, _test$result3;
 			let beforeEachCleanups = [];
-			try {
-				var _runner$onBeforeTryTa, _runner$onAfterTryTas;
-				await ((_runner$onBeforeTryTa = runner.onBeforeTryTask) === null || _runner$onBeforeTryTa === void 0 ? void 0 : _runner$onBeforeTryTa.call(runner, test, {
-					retry: retryCount,
-					repeats: repeatCount
-				}));
-				test.result.repeatCount = repeatCount;
-				beforeEachCleanups = await $("test.beforeEach", () => callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]));
-				if (runner.runTask) {
-					await $("test.callback", () => runner.runTask(test));
-				} else {
-					const fn = getFn(test);
-					if (!fn) {
-						throw new Error("Test function is not found. Did you add it using `setFn`?");
+			// fixtureCheckpoint is passed by callAroundEachHooks - it represents the count
+			// of fixture cleanup functions AFTER all aroundEach fixtures have been resolved
+			// but BEFORE the test runs. This allows us to clean up only fixtures created
+			// inside runTest while preserving aroundEach fixtures for teardown.
+			await callAroundEachHooks(suite, test, async (fixtureCheckpoint) => {
+				var _test$onFinished, _test$onFailed, _runner$onAfterRetryT;
+				try {
+					var _runner$onBeforeTryTa, _runner$onAfterTryTas;
+					await ((_runner$onBeforeTryTa = runner.onBeforeTryTask) === null || _runner$onBeforeTryTa === void 0 ? void 0 : _runner$onBeforeTryTa.call(runner, test, {
+						retry: retryCount,
+						repeats: repeatCount
+					}));
+					test.result.repeatCount = repeatCount;
+					beforeEachCleanups = await $("test.beforeEach", () => callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]));
+					if (runner.runTask) {
+						await $("test.callback", () => runner.runTask(test));
+					} else {
+						const fn = getFn(test);
+						if (!fn) {
+							throw new Error("Test function is not found. Did you add it using `setFn`?");
+						}
+						await $("test.callback", () => fn());
+					}
+					await ((_runner$onAfterTryTas = runner.onAfterTryTask) === null || _runner$onAfterTryTas === void 0 ? void 0 : _runner$onAfterTryTas.call(runner, test, {
+						retry: retryCount,
+						repeats: repeatCount
+					}));
+					if (test.result.state !== "fail") {
+						if (!test.repeats) {
+							test.result.state = "pass";
+						} else if (test.repeats && retry === retryCount) {
+							test.result.state = "pass";
+						}
+					}
+				} catch (e) {
+					failTask(test.result, e, runner.config.diffOptions);
+				}
+				try {
+					var _runner$onTaskFinishe;
+					await ((_runner$onTaskFinishe = runner.onTaskFinished) === null || _runner$onTaskFinishe === void 0 ? void 0 : _runner$onTaskFinishe.call(runner, test));
+				} catch (e) {
+					failTask(test.result, e, runner.config.diffOptions);
+				}
+				try {
+					await $("test.afterEach", () => callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]));
+					if (beforeEachCleanups.length) {
+						await $("test.cleanup", () => callCleanupHooks(runner, beforeEachCleanups));
 					}
-					await $("test.callback", () => fn());
+					// Only clean up fixtures created inside runTest (after the checkpoint)
+					// Fixtures created for aroundEach will be cleaned up after aroundEach teardown
+					await callFixtureCleanupFrom(test.context, fixtureCheckpoint);
+				} catch (e) {
+					failTask(test.result, e, runner.config.diffOptions);
+				}
+				if ((_test$onFinished = test.onFinished) === null || _test$onFinished === void 0 ? void 0 : _test$onFinished.length) {
+					await $("test.onFinished", () => callTestHooks(runner, test, test.onFinished, "stack"));
 				}
-				await ((_runner$onAfterTryTas = runner.onAfterTryTask) === null || _runner$onAfterTryTas === void 0 ? void 0 : _runner$onAfterTryTas.call(runner, test, {
+				if (test.result.state === "fail" && ((_test$onFailed = test.onFailed) === null || _test$onFailed === void 0 ? void 0 : _test$onFailed.length)) {
+					await $("test.onFailed", () => callTestHooks(runner, test, test.onFailed, runner.config.sequence.hooks));
+				}
+				test.onFailed = undefined;
+				test.onFinished = undefined;
+				await ((_runner$onAfterRetryT = runner.onAfterRetryTask) === null || _runner$onAfterRetryT === void 0 ? void 0 : _runner$onAfterRetryT.call(runner, test, {
 					retry: retryCount,
 					repeats: repeatCount
 				}));
-				if (test.result.state !== "fail") {
-					if (!test.repeats) {
-						test.result.state = "pass";
-					} else if (test.repeats && retry === retryCount) {
-						test.result.state = "pass";
-					}
-				}
-			} catch (e) {
-				failTask(test.result, e, runner.config.diffOptions);
-			}
-			try {
-				var _runner$onTaskFinishe;
-				await ((_runner$onTaskFinishe = runner.onTaskFinished) === null || _runner$onTaskFinishe === void 0 ? void 0 : _runner$onTaskFinishe.call(runner, test));
-			} catch (e) {
-				failTask(test.result, e, runner.config.diffOptions);
-			}
+			}).catch((error) => {
+				failTask(test.result, error, runner.config.diffOptions);
+			});
+			// Clean up fixtures that were created for aroundEach (before the checkpoint)
+			// This runs after aroundEach teardown has completed
 			try {
-				await $("test.afterEach", () => callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]));
-				if (beforeEachCleanups.length) {
-					await $("test.cleanup", () => callCleanupHooks(runner, beforeEachCleanups));
-				}
 				await callFixtureCleanup(test.context);
 			} catch (e) {
 				failTask(test.result, e, runner.config.diffOptions);
 			}
-			if ((_test$onFinished = test.onFinished) === null || _test$onFinished === void 0 ? void 0 : _test$onFinished.length) {
-				await $("test.onFinished", () => callTestHooks(runner, test, test.onFinished, "stack"));
-			}
-			if (test.result.state === "fail" && ((_test$onFailed = test.onFailed) === null || _test$onFailed === void 0 ? void 0 : _test$onFailed.length)) {
-				await $("test.onFailed", () => callTestHooks(runner, test, test.onFailed, runner.config.sequence.hooks));
-			}
-			test.onFailed = undefined;
-			test.onFinished = undefined;
-			await ((_runner$onAfterRetryT = runner.onAfterRetryTask) === null || _runner$onAfterRetryT === void 0 ? void 0 : _runner$onAfterRetryT.call(runner, test, {
-				retry: retryCount,
-				repeats: repeatCount
-			}));
 			// skipped with new PendingError
 			if (((_test$result2 = test.result) === null || _test$result2 === void 0 ? void 0 : _test$result2.pending) || ((_test$result3 = test.result) === null || _test$result3 === void 0 ? void 0 : _test$result3.state) === "skip") {
 				var _test$result4;
@@ -1875,47 +2214,62 @@ async function runSuite(suite, runner) {
 		updateTask("suite-finished", suite, runner);
 	} else {
 		var _runner$onAfterRunSui;
+		let suiteRan = false;
 		try {
-			try {
-				beforeAllCleanups = await $("suite.beforeAll", () => callSuiteHook(suite, suite, "beforeAll", runner, [suite]));
-			} catch (e) {
-				markTasksAsSkipped(suite, runner);
-				throw e;
-			}
-			if (runner.runSuite) {
-				await runner.runSuite(suite);
-			} else {
-				for (let tasksGroup of partitionSuiteChildren(suite)) {
-					if (tasksGroup[0].concurrent === true) {
-						await Promise.all(tasksGroup.map((c) => runSuiteChild(c, runner)));
+			await callAroundAllHooks(suite, async () => {
+				suiteRan = true;
+				try {
+					// beforeAll
+					try {
+						beforeAllCleanups = await $("suite.beforeAll", () => callSuiteHook(suite, suite, "beforeAll", runner, [suite]));
+					} catch (e) {
+						failTask(suite.result, e, runner.config.diffOptions);
+						markTasksAsSkipped(suite, runner);
+						return;
+					}
+					// run suite children
+					if (runner.runSuite) {
+						await runner.runSuite(suite);
 					} else {
-						const { sequence } = runner.config;
-						if (suite.shuffle) {
-							// run describe block independently from tests
-							const suites = tasksGroup.filter((group) => group.type === "suite");
-							const tests = tasksGroup.filter((group) => group.type === "test");
-							const groups = shuffle([suites, tests], sequence.seed);
-							tasksGroup = groups.flatMap((group) => shuffle(group, sequence.seed));
+						for (let tasksGroup of partitionSuiteChildren(suite)) {
+							if (tasksGroup[0].concurrent === true) {
+								await Promise.all(tasksGroup.map((c) => runSuiteChild(c, runner)));
+							} else {
+								const { sequence } = runner.config;
+								if (suite.shuffle) {
+									// run describe block independently from tests
+									const suites = tasksGroup.filter((group) => group.type === "suite");
+									const tests = tasksGroup.filter((group) => group.type === "test");
+									const groups = shuffle([suites, tests], sequence.seed);
+									tasksGroup = groups.flatMap((group) => shuffle(group, sequence.seed));
+								}
+								for (const c of tasksGroup) {
+									await runSuiteChild(c, runner);
+								}
+							}
+						}
+					}
+				} finally {
+					// afterAll runs even if beforeAll or suite children fail
+					try {
+						await $("suite.afterAll", () => callSuiteHook(suite, suite, "afterAll", runner, [suite]));
+						if (beforeAllCleanups.length) {
+							await $("suite.cleanup", () => callCleanupHooks(runner, beforeAllCleanups));
 						}
-						for (const c of tasksGroup) {
-							await runSuiteChild(c, runner);
+						if (suite.file === suite) {
+							const context = getFileContext(suite);
+							await callFixtureCleanup(context);
 						}
+					} catch (e) {
+						failTask(suite.result, e, runner.config.diffOptions);
 					}
 				}
-			}
+			});
 		} catch (e) {
-			failTask(suite.result, e, runner.config.diffOptions);
-		}
-		try {
-			await $("suite.afterAll", () => callSuiteHook(suite, suite, "afterAll", runner, [suite]));
-			if (beforeAllCleanups.length) {
-				await $("suite.cleanup", () => callCleanupHooks(runner, beforeAllCleanups));
-			}
-			if (suite.file === suite) {
-				const context = getFileContext(suite);
-				await callFixtureCleanup(context);
+			// mark tasks as skipped if aroundAll failed before the suite callback was executed
+			if (!suiteRan) {
+				markTasksAsSkipped(suite, runner);
 			}
-		} catch (e) {
 			failTask(suite.result, e, runner.config.diffOptions);
 		}
 		if (suite.mode === "run" || suite.mode === "queued") {
@@ -2195,4 +2549,4 @@ function manageArtifactAttachment(attachment) {
 	}
 }
 
-export { afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, recordArtifact, setFn, setHooks, startTests, suite, test, updateTask };
+export { afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, recordArtifact, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/{tasks.d-CLPU8HE4.d.ts → tasks.d-WWG4yDf6.d.ts}

@@ -109,7 +109,7 @@ interface VitestRunner {
 		repeats: number;
 	}) => unknown;
 	/**
-	* Called after the retry resolution happend. Unlike `onAfterTryTask`, the test now has a new state.
+	* Called after the retry resolution happened. Unlike `onAfterTryTask`, the test now has a new state.
 	* All `after` hooks were also called by this point.
 	*/
 	onAfterRetryTask?: (test: Test, options: {
@@ -329,6 +329,64 @@ declare const onTestFailed: TaskHook<OnTestFailedHandler>;
 * ```
 */
 declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
+/**
+* Registers a callback function that wraps around all tests within the current suite.
+* The callback receives a `runSuite` function that must be called to run the suite's tests.
+* This hook is useful for scenarios where you need to wrap an entire suite in a context
+* (e.g., starting a server, opening a database connection that all tests share).
+*
+* **Note:** When multiple `aroundAll` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* **Note:** Unlike `aroundEach`, the `aroundAll` hook does not receive test context or support fixtures,
+* as it runs at the suite level before any individual test context is created.
+*
+* @param {Function} fn - The callback function that wraps the suite. Must call `runSuite()` to run the tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using aroundAll to wrap suite in a tracing span
+* aroundAll(async (runSuite) => {
+*   await tracer.trace('test-suite', runSuite);
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundAll with AsyncLocalStorage context
+* aroundAll(async (runSuite) => {
+*   await asyncLocalStorage.run({ suiteId: 'my-suite' }, runSuite);
+* });
+* ```
+*/
+declare function aroundAll(fn: AroundAllListener, timeout?: number): void;
+/**
+* Registers a callback function that wraps around each test within the current suite.
+* The callback receives a `runTest` function that must be called to run the test.
+* This hook is useful for scenarios where you need to wrap tests in a context (e.g., database transactions).
+*
+* **Note:** When multiple `aroundEach` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* @param {Function} fn - The callback function that wraps the test. Must call `runTest()` to run the test.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using aroundEach to wrap tests in a database transaction
+* aroundEach(async (runTest) => {
+*   await database.transaction(() => runTest());
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundEach with fixtures
+* aroundEach(async (runTest, { db }) => {
+*   await db.transaction(() => runTest());
+* });
+* ```
+*/
+declare function aroundEach<ExtraContext = object>(fn: AroundEachListener<ExtraContext>, timeout?: number): void;
 
 type ChainableFunction<
 	T extends string,
@@ -753,6 +811,10 @@ interface TestOptions {
 	* Custom tags of the test. Useful for filtering tests.
 	*/
 	tags?: keyof TestTags extends never ? string[] | string : TestTags[keyof TestTags] | TestTags[keyof TestTags][];
+	/**
+	* Custom test metadata available to reporters.
+	*/
+	meta?: Partial<TaskMeta>;
 }
 interface TestTags {}
 interface SuiteOptions extends TestOptions {
@@ -770,10 +832,13 @@ interface Hooks<ExtraContext> {
 	afterAll: typeof afterAll;
 	beforeEach: typeof beforeEach<ExtraContext>;
 	afterEach: typeof afterEach<ExtraContext>;
+	aroundEach: typeof aroundEach<ExtraContext>;
+	aroundAll: typeof aroundAll;
 }
 type TestAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & Hooks<ExtraContext> & {
 	extend: <T extends Record<string, any> = object>(fixtures: Fixtures<T, ExtraContext>) => TestAPI<{ [K in keyof T | keyof ExtraContext] : K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never }>;
 	scoped: (fixtures: Partial<Fixtures<ExtraContext>>) => void;
+	describe: SuiteAPI<ExtraContext>;
 };
 interface FixtureOptions {
 	/**
@@ -836,11 +901,19 @@ interface BeforeEachListener<ExtraContext = object> {
 interface AfterEachListener<ExtraContext = object> {
 	(context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
 }
+interface AroundEachListener<ExtraContext = object> {
+	(runTest: () => Promise<void>, context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+}
+interface AroundAllListener {
+	(runSuite: () => Promise<void>, suite: Readonly<Suite | File>): Awaitable<unknown>;
+}
 interface SuiteHooks<ExtraContext = object> {
 	beforeAll: BeforeAllListener[];
 	afterAll: AfterAllListener[];
 	beforeEach: BeforeEachListener<ExtraContext>[];
 	afterEach: AfterEachListener<ExtraContext>[];
+	aroundEach: AroundEachListener<ExtraContext>[];
+	aroundAll: AroundAllListener[];
 }
 interface TaskCustomOptions extends TestOptions {
 	/**
@@ -848,10 +921,6 @@ interface TaskCustomOptions extends TestOptions {
 	*/
 	each?: boolean;
 	/**
-	* Custom metadata for the task that will be assigned to `task.meta`.
-	*/
-	meta?: Record<string, unknown>;
-	/**
 	* Task fixtures.
 	*/
 	fixtures?: FixtureItem[];
@@ -1093,5 +1162,5 @@ interface TestArtifactRegistry {}
 */
 type TestArtifact = TestAnnotationArtifact | VisualRegressionArtifact | TestArtifactRegistry[keyof TestArtifactRegistry];
 
-export { createChainable as ab, afterAll as i, afterEach as j, beforeAll as k, beforeEach as l, onTestFinished as m, onTestFailed as o };
-export type { TestAnnotationLocation as $, AfterAllListener as A, BeforeAllListener as B, CancelReason as C, RunMode as D, RuntimeContext as E, FileSpecification as F, SequenceHooks as G, SequenceSetupFiles as H, ImportDuration as I, SerializableRetry as J, SuiteFactory as K, TaskBase as L, TaskCustomOptions as M, TaskEventPack as N, OnTestFailedHandler as O, TaskHook as P, TaskMeta as Q, Retry as R, Suite as S, TestArtifact as T, TaskPopulated as U, VitestRunner as V, TaskResult as W, TaskResultPack as X, TaskState as Y, TestAnnotation as Z, TestAnnotationArtifact as _, Test as a, TestArtifactBase as a0, TestArtifactLocation as a1, TestArtifactRegistry as a2, TestAttachment as a3, TestContext as a4, TestFunction as a5, TestOptions as a6, TestTags as a7, Use as a8, VisualRegressionArtifact as a9, ChainableFunction as aa, SuiteHooks as b, File as c, TaskUpdateEvent as d, Task as e, TestAPI as f, SuiteAPI as g, SuiteCollector as h, TestTagDefinition as n, VitestRunnerConfig as p, VitestRunnerConstructor as q, VitestRunnerImportSource as r, AfterEachListener as s, BeforeEachListener as t, Fixture as u, FixtureFn as v, FixtureOptions as w, Fixtures as x, InferFixturesTypes as y, OnTestFinishedHandler as z };
+export { afterAll as a7, afterEach as a8, aroundAll as a9, aroundEach as aa, beforeAll as ab, beforeEach as ac, onTestFailed as ad, onTestFinished as ae, createChainable as ag };
+export type { TestOptions as $, AfterAllListener as A, BeforeAllListener as B, CancelReason as C, TaskCustomOptions as D, TaskEventPack as E, FileSpecification as F, TaskHook as G, TaskMeta as H, ImportDuration as I, TaskPopulated as J, TaskResult as K, TaskResultPack as L, TaskState as M, TestAnnotation as N, OnTestFailedHandler as O, TestAnnotationArtifact as P, TestAnnotationLocation as Q, Retry as R, Suite as S, TestArtifact as T, TestArtifactBase as U, VitestRunner as V, TestArtifactLocation as W, TestArtifactRegistry as X, TestAttachment as Y, TestContext as Z, TestFunction as _, Test as a, TestTagDefinition as a0, TestTags as a1, Use as a2, VisualRegressionArtifact as a3, VitestRunnerConfig as a4, VitestRunnerConstructor as a5, VitestRunnerImportSource as a6, ChainableFunction as af, SuiteHooks as b, File as c, TaskUpdateEvent as d, Task as e, TestAPI as f, SuiteAPI as g, SuiteCollector as h, AfterEachListener as i, AroundAllListener as j, AroundEachListener as k, BeforeEachListener as l, Fixture as m, FixtureFn as n, FixtureOptions as o, Fixtures as p, InferFixturesTypes as q, OnTestFinishedHandler as r, RunMode as s, RuntimeContext as t, SequenceHooks as u, SequenceSetupFiles as v, SerializableRetry as w, SuiteFactory as x, SuiteOptions as y, TaskBase as z };

package/dist/types.d.ts

@@ -1,3 +1,3 @@
-export { A as AfterAllListener, s as AfterEachListener, B as BeforeAllListener, t as BeforeEachListener, C as CancelReason, c as File, F as FileSpecification, u as Fixture, v as FixtureFn, w as FixtureOptions, x as Fixtures, I as ImportDuration, y as InferFixturesTypes, O as OnTestFailedHandler, z as OnTestFinishedHandler, R as Retry, D as RunMode, E as RuntimeContext, G as SequenceHooks, H as SequenceSetupFiles, J as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, K as SuiteFactory, b as SuiteHooks, e as Task, L as TaskBase, M as TaskCustomOptions, N as TaskEventPack, P as TaskHook, Q as TaskMeta, U as TaskPopulated, W as TaskResult, X as TaskResultPack, Y as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, Z as TestAnnotation, _ as TestAnnotationArtifact, $ as TestAnnotationLocation, T as TestArtifact, a0 as TestArtifactBase, a1 as TestArtifactLocation, a2 as TestArtifactRegistry, a3 as TestAttachment, a4 as TestContext, a5 as TestFunction, a6 as TestOptions, n as TestTagDefinition, a7 as TestTags, a8 as Use, a9 as VisualRegressionArtifact, V as VitestRunner, p as VitestRunnerConfig, q as VitestRunnerConstructor, r as VitestRunnerImportSource } from './tasks.d-CLPU8HE4.js';
+export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, c as File, F as FileSpecification, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, I as ImportDuration, q as InferFixturesTypes, O as OnTestFailedHandler, r as OnTestFinishedHandler, R as Retry, s as RunMode, t as RuntimeContext, u as SequenceHooks, v as SequenceSetupFiles, w as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, x as SuiteFactory, b as SuiteHooks, y as SuiteOptions, e as Task, z as TaskBase, D as TaskCustomOptions, E as TaskEventPack, G as TaskHook, H as TaskMeta, J as TaskPopulated, K as TaskResult, L as TaskResultPack, M as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, N as TestAnnotation, P as TestAnnotationArtifact, Q as TestAnnotationLocation, T as TestArtifact, U as TestArtifactBase, W as TestArtifactLocation, X as TestArtifactRegistry, Y as TestAttachment, Z as TestContext, _ as TestFunction, $ as TestOptions, a0 as TestTagDefinition, a1 as TestTags, a2 as Use, a3 as VisualRegressionArtifact, V as VitestRunner, a4 as VitestRunnerConfig, a5 as VitestRunnerConstructor, a6 as VitestRunnerImportSource } from './tasks.d-WWG4yDf6.js';
 import '@vitest/utils/diff';
 import '@vitest/utils';

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, c as File, e as Task, n as TestTagDefinition, p as VitestRunnerConfig, a as Test } from './tasks.d-CLPU8HE4.js';
-export { aa as ChainableFunction, ab as createChainable } from './tasks.d-CLPU8HE4.js';
+import { S as Suite, c as File, e as Task, a0 as TestTagDefinition, a4 as VitestRunnerConfig, a as Test } from './tasks.d-WWG4yDf6.js';
+export { af as ChainableFunction, ag as createChainable } from './tasks.d-WWG4yDf6.js';
 import { ParsedStack, Arrayable } from '@vitest/utils';
 import '@vitest/utils/diff';
 

package/dist/utils.js

@@ -1,4 +1,4 @@
-export { a as calculateSuiteHash, c as createChainable, b as createFileTask, e as createTagsFilter, h as createTaskName, f as findTestFileStackTrace, g as generateFileHash, d as generateHash, j as getFullName, k as getNames, m as getSuites, n as getTasks, o as getTestName, q as getTests, r as hasFailed, t as hasTests, i as interpretTaskModes, u as isTestCase, l as limitConcurrency, p as partitionSuiteChildren, s as someTasksAreOnly, v as validateTags } from './chunk-tasks.js';
+export { c as calculateSuiteHash, a as createChainable, b as createFileTask, d as createTagsFilter, e as createTaskName, f as findTestFileStackTrace, g as generateFileHash, h as generateHash, i as getFullName, j as getNames, k as getSuites, l as getTasks, m as getTestName, n as getTests, o as hasFailed, p as hasTests, q as interpretTaskModes, r as isTestCase, s as limitConcurrency, t as partitionSuiteChildren, u as someTasksAreOnly, v as validateTags } from './chunk-tasks.js';
 import '@vitest/utils/error';
 import '@vitest/utils/source-map';
 import 'pathe';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "4.1.0-beta.2",
+  "version": "4.1.0-beta.3",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "pathe": "^2.0.3",
-    "@vitest/utils": "4.1.0-beta.2"
+    "@vitest/utils": "4.1.0-beta.3"
   },
   "scripts": {
     "build": "premove dist && rollup -c",