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

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 { w as getChainableContext, a as createChainable, v as validateTags, e as createTaskName, x 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,18 @@ class TestRunAbortError extends Error {
 		this.reason = reason;
 	}
 }
+class FixtureDependencyError extends Error {
+	name = "FixtureDependencyError";
+}
+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();
@@ -38,7 +50,7 @@ function getFn(key) {
 function setTestFixture(key, fixture) {
 	testFixtureMap.set(key, fixture);
 }
-function getTestFixture(key) {
+function getTestFixtures(key) {
 	return testFixtureMap.get(key);
 }
 function setHooks(key, hooks) {
@@ -48,85 +60,182 @@ function getHooks(key) {
 	return hooksMap.get(key);
 }
 
-function mergeScopedFixtures(testFixtures, scopedFixtures) {
-	const scopedFixturesMap = scopedFixtures.reduce((map, fixture) => {
-		map[fixture.prop] = fixture;
-		return map;
-	}, {});
-	const newFixtures = {};
-	testFixtures.forEach((fixture) => {
-		const useFixture = scopedFixturesMap[fixture.prop] || { ...fixture };
-		newFixtures[useFixture.prop] = useFixture;
-	});
-	for (const fixtureKep in newFixtures) {
-		var _fixture$deps;
-		const fixture = newFixtures[fixtureKep];
-		// if the fixture was define before the scope, then its dep
-		// will reference the original fixture instead of the scope
-		fixture.deps = (_fixture$deps = fixture.deps) === null || _fixture$deps === void 0 ? void 0 : _fixture$deps.map((dep) => newFixtures[dep.prop]);
-	}
-	return Object.values(newFixtures);
-}
-function mergeContextFixtures(fixtures, context, runner) {
-	const fixtureOptionKeys = [
+class TestFixtures {
+	_suiteContexts;
+	_overrides = new WeakMap();
+	_registrations;
+	static _definitions = [];
+	static _builtinFixtures = [
+		"task",
+		"signal",
+		"onTestFailed",
+		"onTestFinished",
+		"skip",
+		"annotate"
+	];
+	static _fixtureOptionKeys = [
 		"auto",
 		"injected",
 		"scope"
 	];
-	const fixtureArray = Object.entries(fixtures).map(([prop, value]) => {
-		const fixtureItem = { value };
-		if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key) => fixtureOptionKeys.includes(key))) {
-			var _runner$injectValue;
-			// fixture with options
-			Object.assign(fixtureItem, value[1]);
-			const userValue = value[0];
-			fixtureItem.value = fixtureItem.injected ? ((_runner$injectValue = runner.injectValue) === null || _runner$injectValue === void 0 ? void 0 : _runner$injectValue.call(runner, prop)) ?? userValue : userValue;
-		}
-		fixtureItem.scope = fixtureItem.scope || "test";
-		if (fixtureItem.scope === "worker" && !runner.getWorkerContext) {
-			fixtureItem.scope = "file";
-		}
-		fixtureItem.prop = prop;
-		fixtureItem.isFn = typeof fixtureItem.value === "function";
-		return fixtureItem;
-	});
-	if (Array.isArray(context.fixtures)) {
-		context.fixtures = context.fixtures.concat(fixtureArray);
-	} else {
-		context.fixtures = fixtureArray;
-	}
-	// Update dependencies of fixture functions
-	fixtureArray.forEach((fixture) => {
-		if (fixture.isFn) {
-			const usedProps = getUsedProps(fixture.value);
-			if (usedProps.length) {
-				fixture.deps = context.fixtures.filter(({ prop }) => prop !== fixture.prop && usedProps.includes(prop));
+	static _fixtureScopes = [
+		"test",
+		"file",
+		"worker"
+	];
+	static _workerContextSymbol = Symbol("workerContext");
+	static clearDefinitions() {
+		TestFixtures._definitions.length = 0;
+	}
+	static getWorkerContexts() {
+		return TestFixtures._definitions.map((f) => f.getWorkerContext());
+	}
+	static getFileContexts(file) {
+		return TestFixtures._definitions.map((f) => f.getFileContext(file));
+	}
+	constructor(registrations) {
+		this._registrations = registrations ?? new Map();
+		this._suiteContexts = new WeakMap();
+		TestFixtures._definitions.push(this);
+	}
+	extend(runner, userFixtures) {
+		const { suite } = getCurrentSuite();
+		const isTopLevel = !suite || suite.file === suite;
+		const registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel);
+		return new TestFixtures(registrations);
+	}
+	get(suite) {
+		let currentSuite = suite;
+		while (currentSuite) {
+			const overrides = this._overrides.get(currentSuite);
+			// return the closest override
+			if (overrides) {
+				return overrides;
 			}
-			// test can access anything, so we ignore it
-			if (fixture.scope !== "test") {
-				var _fixture$deps2;
-				(_fixture$deps2 = fixture.deps) === null || _fixture$deps2 === void 0 ? void 0 : _fixture$deps2.forEach((dep) => {
-					if (!dep.isFn) {
-						// non fn fixtures are always resolved and available to anyone
-						return;
-					}
-					// worker scope can only import from worker scope
-					if (fixture.scope === "worker" && dep.scope === "worker") {
-						return;
-					}
-					// file scope an import from file and worker scopes
-					if (fixture.scope === "file" && dep.scope !== "test") {
-						return;
-					}
-					throw new SyntaxError(`cannot use the ${dep.scope} fixture "${dep.prop}" inside the ${fixture.scope} fixture "${fixture.prop}"`);
-				});
+			if (currentSuite === currentSuite.file) {
+				break;
 			}
+			currentSuite = currentSuite.suite || currentSuite.file;
+		}
+		return this._registrations;
+	}
+	override(runner, userFixtures) {
+		const { suite: currentSuite, file } = getCurrentSuite();
+		const suite = currentSuite || file;
+		const isTopLevel = !currentSuite || currentSuite.file === currentSuite;
+		// Create a copy of the closest parent's registrations to avoid modifying them
+		// For chained calls, this.get(suite) returns this suite's overrides; for first call, returns parent's
+		const suiteRegistrations = new Map(this.get(suite));
+		const registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel, suiteRegistrations);
+		// If defined in top-level, just override all registrations
+		// We don't support overriding suite-level fixtures anyway (it will throw an error)
+		if (isTopLevel) {
+			this._registrations = registrations;
+		} else {
+			this._overrides.set(suite, registrations);
 		}
-	});
-	return context;
+	}
+	getFileContext(file) {
+		if (!this._suiteContexts.has(file)) {
+			this._suiteContexts.set(file, Object.create(null));
+		}
+		return this._suiteContexts.get(file);
+	}
+	getWorkerContext() {
+		if (!this._suiteContexts.has(TestFixtures._workerContextSymbol)) {
+			this._suiteContexts.set(TestFixtures._workerContextSymbol, Object.create(null));
+		}
+		return this._suiteContexts.get(TestFixtures._workerContextSymbol);
+	}
+	parseUserFixtures(runner, userFixtures, supportNonTest, registrations = new Map(this._registrations)) {
+		const errors = [];
+		Object.entries(userFixtures).forEach(([name, fn]) => {
+			let options;
+			let value;
+			let _options;
+			if (Array.isArray(fn) && fn.length >= 2 && isObject(fn[1]) && Object.keys(fn[1]).some((key) => TestFixtures._fixtureOptionKeys.includes(key))) {
+				_options = fn[1];
+				options = {
+					auto: _options.auto ?? false,
+					scope: _options.scope ?? "test",
+					injected: _options.injected ?? false
+				};
+				value = options.injected ? runner.injectValue?.(name) ?? fn[0] : fn[0];
+			} else {
+				value = fn;
+			}
+			const parent = registrations.get(name);
+			if (parent && options) {
+				if (parent.scope !== options.scope) {
+					errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered with a "${options.scope}" scope.`));
+				}
+				if (parent.auto !== options.auto) {
+					errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered as { auto: ${options.auto} }.`));
+				}
+			} else if (parent) {
+				options = {
+					auto: parent.auto,
+					scope: parent.scope,
+					injected: parent.injected
+				};
+			} else if (!options) {
+				options = {
+					auto: false,
+					injected: false,
+					scope: "test"
+				};
+			}
+			if (options.scope && !TestFixtures._fixtureScopes.includes(options.scope)) {
+				errors.push(new FixtureDependencyError(`The "${name}" fixture has unknown scope "${options.scope}".`));
+			}
+			if (!supportNonTest && options.scope !== "test") {
+				errors.push(new FixtureDependencyError(`The "${name}" fixture cannot be defined with a ${options.scope} scope${!_options?.scope && parent?.scope ? " (inherited from the base fixture)" : ""} inside the describe block. Define it at the top level of the file instead.`));
+			}
+			const deps = isFixtureFunction(value) ? getUsedProps(value) : new Set();
+			const item = {
+				name,
+				value,
+				auto: options.auto ?? false,
+				injected: options.injected ?? false,
+				scope: options.scope ?? "test",
+				deps,
+				parent
+			};
+			registrations.set(name, item);
+			if (item.scope === "worker" && (runner.pool === "vmThreads" || runner.pool === "vmForks")) {
+				item.scope = "file";
+			}
+		});
+		// validate fixture dependency scopes
+		for (const fixture of registrations.values()) {
+			for (const depName of fixture.deps) {
+				if (TestFixtures._builtinFixtures.includes(depName)) {
+					continue;
+				}
+				const dep = registrations.get(depName);
+				if (!dep) {
+					errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on unknown fixture "${depName}".`));
+					continue;
+				}
+				if (depName === fixture.name && !fixture.parent) {
+					errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on itself, but does not have a base implementation.`));
+					continue;
+				}
+				if (TestFixtures._fixtureScopes.indexOf(fixture.scope) > TestFixtures._fixtureScopes.indexOf(dep.scope)) {
+					errors.push(new FixtureDependencyError(`The ${fixture.scope} "${fixture.name}" fixture cannot depend on a ${dep.scope} fixture "${dep.name}".`));
+					continue;
+				}
+			}
+		}
+		if (errors.length === 1) {
+			throw errors[0];
+		} else if (errors.length > 1) {
+			throw new AggregateError(errors, "Cannot resolve user fixtures. See errors for more information.");
+		}
+		return registrations;
+	}
 }
-const fixtureValueMaps = new Map();
-const cleanupFnArrayMap = new Map();
+const cleanupFnArrayMap = new WeakMap();
 async function callFixtureCleanup(context) {
 	const cleanupFnArray = cleanupFnArrayMap.get(context) ?? [];
 	for (const cleanup of cleanupFnArray.reverse()) {
@@ -134,96 +243,152 @@ async function callFixtureCleanup(context) {
 	}
 	cleanupFnArrayMap.delete(context);
 }
-function withFixtures(runner, fn, testContext) {
-	return (hookContext) => {
-		const context = hookContext || testContext;
+/**
+* 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) {
+	return cleanupFnArrayMap.get(context)?.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;
+}
+const contextHasFixturesCache = new WeakMap();
+function withFixtures(fn, options) {
+	const collector = getCurrentSuite();
+	const suite = collector.suite || collector.file;
+	return async (hookContext) => {
+		const context = hookContext || options?.context;
 		if (!context) {
+			if (options?.suiteHook) {
+				validateSuiteHook(fn, options.suiteHook, options.stackTraceError);
+			}
 			return fn({});
 		}
-		const fixtures = getTestFixture(context);
-		if (!(fixtures === null || fixtures === void 0 ? void 0 : fixtures.length)) {
+		const fixtures = options?.fixtures || getTestFixtures(context);
+		if (!fixtures) {
 			return fn(context);
 		}
-		const usedProps = getUsedProps(fn);
-		const hasAutoFixture = fixtures.some(({ auto }) => auto);
-		if (!usedProps.length && !hasAutoFixture) {
+		const registrations = fixtures.get(suite);
+		if (!registrations.size) {
 			return fn(context);
 		}
-		if (!fixtureValueMaps.get(context)) {
-			fixtureValueMaps.set(context, new Map());
+		const usedFixtures = [];
+		const usedProps = getUsedProps(fn);
+		for (const fixture of registrations.values()) {
+			if (fixture.auto || usedProps.has(fixture.name)) {
+				usedFixtures.push(fixture);
+			}
+		}
+		if (!usedFixtures.length) {
+			return fn(context);
 		}
-		const fixtureValueMap = fixtureValueMaps.get(context);
 		if (!cleanupFnArrayMap.has(context)) {
 			cleanupFnArrayMap.set(context, []);
 		}
 		const cleanupFnArray = cleanupFnArrayMap.get(context);
-		const usedFixtures = fixtures.filter(({ prop, auto }) => auto || usedProps.includes(prop));
-		const pendingFixtures = resolveDeps(usedFixtures);
+		const pendingFixtures = resolveDeps(usedFixtures, registrations);
 		if (!pendingFixtures.length) {
 			return fn(context);
 		}
-		async function resolveFixtures() {
-			for (const fixture of pendingFixtures) {
+		// Check if suite-level hook is trying to access test-scoped fixtures
+		// Suite hooks (beforeAll/afterAll/aroundAll) can only access file/worker scoped fixtures
+		if (options?.suiteHook) {
+			const testScopedFixtures = pendingFixtures.filter((f) => f.scope === "test");
+			if (testScopedFixtures.length > 0) {
+				const fixtureNames = testScopedFixtures.map((f) => `"${f.name}"`).join(", ");
+				const alternativeHook = {
+					aroundAll: "aroundEach",
+					beforeAll: "beforeEach",
+					afterAll: "afterEach"
+				};
+				const error = new FixtureDependencyError(`Test-scoped fixtures cannot be used inside ${options.suiteHook} hook. ` + `The following fixtures are test-scoped: ${fixtureNames}. ` + `Use { scope: 'file' } or { scope: 'worker' } fixtures instead, or move the logic to ${alternativeHook[options.suiteHook]} hook.`);
+				// Use stack trace from hook registration for better error location
+				if (options.stackTraceError?.stack) {
+					error.stack = error.message + options.stackTraceError.stack.replace(options.stackTraceError.message, "");
+				}
+				throw error;
+			}
+		}
+		if (!contextHasFixturesCache.has(context)) {
+			contextHasFixturesCache.set(context, new WeakSet());
+		}
+		const cachedFixtures = contextHasFixturesCache.get(context);
+		for (const fixture of pendingFixtures) {
+			if (fixture.scope === "test") {
 				// fixture could be already initialized during "before" hook
-				if (fixtureValueMap.has(fixture)) {
+				// we can't check "fixture.name" in context because context may
+				// access the parent fixture ({ a: ({ a }) => {} })
+				if (cachedFixtures.has(fixture)) {
 					continue;
 				}
-				const resolvedValue = await resolveFixtureValue(runner, fixture, context, cleanupFnArray);
-				context[fixture.prop] = resolvedValue;
-				fixtureValueMap.set(fixture, resolvedValue);
-				if (fixture.scope === "test") {
-					cleanupFnArray.unshift(() => {
-						fixtureValueMap.delete(fixture);
-					});
-				}
+				cachedFixtures.add(fixture);
+				const resolvedValue = await resolveTestFixtureValue(fixture, context, cleanupFnArray);
+				context[fixture.name] = resolvedValue;
+				cleanupFnArray.push(() => {
+					cachedFixtures.delete(fixture);
+				});
+			} else {
+				const resolvedValue = await resolveScopeFixtureValue(fixtures, suite, fixture);
+				context[fixture.name] = resolvedValue;
 			}
 		}
-		return resolveFixtures().then(() => fn(context));
+		return fn(context);
 	};
 }
-const globalFixturePromise = new WeakMap();
-function resolveFixtureValue(runner, fixture, context, cleanupFnArray) {
-	var _runner$getWorkerCont;
-	const fileContext = getFileContext(context.task.file);
-	const workerContext = (_runner$getWorkerCont = runner.getWorkerContext) === null || _runner$getWorkerCont === void 0 ? void 0 : _runner$getWorkerCont.call(runner);
-	if (!fixture.isFn) {
-		var _fixture$prop;
-		fileContext[_fixture$prop = fixture.prop] ?? (fileContext[_fixture$prop] = fixture.value);
-		if (workerContext) {
-			var _fixture$prop2;
-			workerContext[_fixture$prop2 = fixture.prop] ?? (workerContext[_fixture$prop2] = fixture.value);
-		}
+function isFixtureFunction(value) {
+	return typeof value === "function";
+}
+function resolveTestFixtureValue(fixture, context, cleanupFnArray) {
+	if (!isFixtureFunction(fixture.value)) {
 		return fixture.value;
 	}
-	if (fixture.scope === "test") {
-		return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
-	}
-	// in case the test runs in parallel
-	if (globalFixturePromise.has(fixture)) {
-		return globalFixturePromise.get(fixture);
+	return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
+}
+const scopedFixturePromiseCache = new WeakMap();
+async function resolveScopeFixtureValue(fixtures, suite, fixture) {
+	const workerContext = fixtures.getWorkerContext();
+	const fileContext = fixtures.getFileContext(suite.file);
+	const fixtureContext = fixture.scope === "worker" ? workerContext : fileContext;
+	if (!isFixtureFunction(fixture.value)) {
+		fixtureContext[fixture.name] = fixture.value;
+		return fixture.value;
 	}
-	let fixtureContext;
-	if (fixture.scope === "worker") {
-		if (!workerContext) {
-			throw new TypeError("[@vitest/runner] The worker context is not available in the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.");
-		}
-		fixtureContext = workerContext;
-	} else {
-		fixtureContext = fileContext;
+	if (fixture.name in fixtureContext) {
+		return fixtureContext[fixture.name];
 	}
-	if (fixture.prop in fixtureContext) {
-		return fixtureContext[fixture.prop];
+	if (scopedFixturePromiseCache.has(fixture)) {
+		return scopedFixturePromiseCache.get(fixture);
 	}
 	if (!cleanupFnArrayMap.has(fixtureContext)) {
 		cleanupFnArrayMap.set(fixtureContext, []);
 	}
 	const cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext);
-	const promise = resolveFixtureFunction(fixture.value, fixtureContext, cleanupFnFileArray).then((value) => {
-		fixtureContext[fixture.prop] = value;
-		globalFixturePromise.delete(fixture);
+	const promise = resolveFixtureFunction(fixture.value, fixture.scope === "file" ? {
+		...workerContext,
+		...fileContext
+	} : fixtureContext, cleanupFnFileArray).then((value) => {
+		fixtureContext[fixture.name] = value;
+		scopedFixturePromiseCache.delete(fixture);
 		return value;
 	});
-	globalFixturePromise.set(fixture, promise);
+	scopedFixturePromiseCache.set(fixture, promise);
 	return promise;
 }
 async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
@@ -254,27 +419,50 @@ async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
 	});
 	return useFnArgPromise;
 }
-function resolveDeps(fixtures, depSet = new Set(), pendingFixtures = []) {
-	fixtures.forEach((fixture) => {
+function resolveDeps(usedFixtures, registrations, depSet = new Set(), pendingFixtures = []) {
+	usedFixtures.forEach((fixture) => {
 		if (pendingFixtures.includes(fixture)) {
 			return;
 		}
-		if (!fixture.isFn || !fixture.deps) {
+		if (!isFixtureFunction(fixture.value) || !fixture.deps) {
 			pendingFixtures.push(fixture);
 			return;
 		}
 		if (depSet.has(fixture)) {
-			throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`);
+			if (fixture.parent) {
+				fixture = fixture.parent;
+			} else {
+				throw new Error(`Circular fixture dependency detected: ${fixture.name} <- ${[...depSet].reverse().map((d) => d.name).join(" <- ")}`);
+			}
 		}
 		depSet.add(fixture);
-		resolveDeps(fixture.deps, depSet, pendingFixtures);
+		resolveDeps([...fixture.deps].map((n) => n === fixture.name ? fixture.parent : registrations.get(n)).filter((n) => !!n), registrations, depSet, pendingFixtures);
 		pendingFixtures.push(fixture);
 		depSet.clear();
 	});
 	return pendingFixtures;
 }
+function validateSuiteHook(fn, hook, error) {
+	const usedProps = getUsedProps(fn);
+	if (usedProps.size) {
+		console.warn(`The ${hook} hook uses fixtures "${[...usedProps].join("\", \"")}", but has no access to context. Did you forget to call it as "test.${hook}()" instead of "${hook}()"? This will throw an error in a future major. See https://vitest.dev/guide/test-context#suite-level-hooks`);
+		if (error) {
+			const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
+			const stack = processor(error.stack || "");
+			console.warn(stack);
+		}
+	}
+}
+const kPropsSymbol = Symbol("$vitest:fixture-props");
+function configureProps(fn, options) {
+	Object.defineProperty(fn, kPropsSymbol, {
+		value: options,
+		enumerable: false
+	});
+}
 function getUsedProps(fn) {
-	let fnString = filterOutComments(fn.toString());
+	const { index: fixturesIndex = 0, original: implementation = fn } = kPropsSymbol in fn ? fn[kPropsSymbol] : {};
+	let fnString = filterOutComments(implementation.toString());
 	// match lowered async function and strip it off
 	// example code on esbuild-try https://esbuild.github.io/try/#YgAwLjI0LjAALS1zdXBwb3J0ZWQ6YXN5bmMtYXdhaXQ9ZmFsc2UAZQBlbnRyeS50cwBjb25zdCBvID0gewogIGYxOiBhc3luYyAoKSA9PiB7fSwKICBmMjogYXN5bmMgKGEpID0+IHt9LAogIGYzOiBhc3luYyAoYSwgYikgPT4ge30sCiAgZjQ6IGFzeW5jIGZ1bmN0aW9uKGEpIHt9LAogIGY1OiBhc3luYyBmdW5jdGlvbiBmZihhKSB7fSwKICBhc3luYyBmNihhKSB7fSwKCiAgZzE6IGFzeW5jICgpID0+IHt9LAogIGcyOiBhc3luYyAoeyBhIH0pID0+IHt9LAogIGczOiBhc3luYyAoeyBhIH0sIGIpID0+IHt9LAogIGc0OiBhc3luYyBmdW5jdGlvbiAoeyBhIH0pIHt9LAogIGc1OiBhc3luYyBmdW5jdGlvbiBnZyh7IGEgfSkge30sCiAgYXN5bmMgZzYoeyBhIH0pIHt9LAoKICBoMTogYXN5bmMgKCkgPT4ge30sCiAgLy8gY29tbWVudCBiZXR3ZWVuCiAgaDI6IGFzeW5jIChhKSA9PiB7fSwKfQ
 	//   __async(this, null, function*
@@ -285,23 +473,20 @@ function getUsedProps(fn) {
 	}
 	const match = fnString.match(/[^(]*\(([^)]*)/);
 	if (!match) {
-		return [];
+		return new Set();
 	}
 	const args = splitByComma(match[1]);
 	if (!args.length) {
-		return [];
+		return new Set();
 	}
-	let first = args[0];
-	if ("__VITEST_FIXTURE_INDEX__" in fn) {
-		first = args[fn.__VITEST_FIXTURE_INDEX__];
-		if (!first) {
-			return [];
-		}
+	const fixturesArgument = args[fixturesIndex];
+	if (!fixturesArgument) {
+		return new Set();
 	}
-	if (!(first[0] === "{" && first.endsWith("}"))) {
-		throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`);
+	if (!(fixturesArgument[0] === "{" && fixturesArgument.endsWith("}"))) {
+		throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${fixturesArgument}".`);
 	}
-	const _first = first.slice(1, -1).replace(/\s/g, "");
+	const _first = fixturesArgument.slice(1, -1).replace(/\s/g, "");
 	const props = splitByComma(_first).map((prop) => {
 		return prop.replace(/:.*|=.*/g, "");
 	});
@@ -309,7 +494,7 @@ function getUsedProps(fn) {
 	if (last && last.startsWith("...")) {
 		throw new Error(`Rest parameters are not supported in fixtures, received "${last}".`);
 	}
-	return props;
+	return new Set(props);
 }
 function splitByComma(s) {
 	const result = [];
@@ -358,6 +543,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();
@@ -389,7 +576,8 @@ function getBeforeHookCleanupCallback(hook, result, context) {
 function beforeAll(fn, timeout = getDefaultHookTimeout()) {
 	assertTypes(fn, "\"beforeAll\" callback", ["function"]);
 	const stackTraceError = new Error("STACK_TRACE_ERROR");
-	return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(fn, timeout, true, stackTraceError), {
+	const context = getChainableContext(this);
+	return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(withSuiteFixtures("beforeAll", fn, context, stackTraceError), timeout, true, stackTraceError), {
 		[CLEANUP_TIMEOUT_KEY]: timeout,
 		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
 	}));
@@ -413,7 +601,9 @@ function beforeAll(fn, timeout = getDefaultHookTimeout()) {
 */
 function afterAll(fn, timeout) {
 	assertTypes(fn, "\"afterAll\" callback", ["function"]);
-	return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR")));
+	const context = getChainableContext(this);
+	const stackTraceError = new Error("STACK_TRACE_ERROR");
+	return getCurrentSuite().on("afterAll", withTimeout(withSuiteFixtures("afterAll", fn, context, stackTraceError), timeout ?? getDefaultHookTimeout(), true, stackTraceError));
 }
 /**
 * Registers a callback function to be executed before each test within the current suite.
@@ -435,8 +625,7 @@ function afterAll(fn, timeout) {
 function beforeEach(fn, timeout = getDefaultHookTimeout()) {
 	assertTypes(fn, "\"beforeEach\" callback", ["function"]);
 	const stackTraceError = new Error("STACK_TRACE_ERROR");
-	const runner = getRunner();
-	return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(withFixtures(runner, fn), timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
+	return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
 		[CLEANUP_TIMEOUT_KEY]: timeout,
 		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
 	}));
@@ -460,8 +649,7 @@ function beforeEach(fn, timeout = getDefaultHookTimeout()) {
 */
 function afterEach(fn, timeout) {
 	assertTypes(fn, "\"afterEach\" callback", ["function"]);
-	const runner = getRunner();
-	return getCurrentSuite().on("afterEach", withTimeout(withFixtures(runner, fn), timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+	return getCurrentSuite().on("afterEach", withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
 }
 /**
 * Registers a callback function to be executed when a test fails within the current suite.
@@ -482,7 +670,7 @@ function afterEach(fn, timeout) {
 * ```
 */
 const onTestFailed = createTestHook("onTestFailed", (test, handler, timeout) => {
-	test.onFailed || (test.onFailed = []);
+	test.onFailed ||= [];
 	test.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
 });
 /**
@@ -509,9 +697,116 @@ const onTestFailed = createTestHook("onTestFailed", (test, handler, timeout) =>
 * ```
 */
 const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout) => {
-	test.onFinished || (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.
+*
+* @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 fixtures
+* aroundAll(async (runSuite, { db }) => {
+*   await db.transaction(() => runSuite());
+* });
+* ```
+*/
+function aroundAll(fn, timeout) {
+	assertTypes(fn, "\"aroundAll\" callback", ["function"]);
+	const stackTraceError = new Error("STACK_TRACE_ERROR");
+	const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+	const context = getChainableContext(this);
+	return getCurrentSuite().on("aroundAll", Object.assign(withSuiteFixtures("aroundAll", fn, context, stackTraceError, 1), {
+		[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 wrapper = (runTest, context, suite) => {
+		const innerFn = (ctx) => fn(runTest, ctx, suite);
+		configureProps(innerFn, {
+			index: 1,
+			original: fn
+		});
+		const fixtureResolver = withFixtures(innerFn);
+		return fixtureResolver(context);
+	};
+	return getCurrentSuite().on("aroundEach", Object.assign(wrapper, {
+		[AROUND_TIMEOUT_KEY]: resolvedTimeout,
+		[AROUND_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+function withSuiteFixtures(suiteHook, fn, context, stackTraceError, contextIndex = 0) {
+	return (...args) => {
+		const suite = args.at(-1);
+		const prefix = args.slice(0, -1);
+		const wrapper = (ctx) => fn(...prefix, ctx, suite);
+		configureProps(wrapper, {
+			index: contextIndex,
+			original: fn
+		});
+		const fixtures = context?.getFixtures();
+		const fileContext = fixtures?.getFileContext(suite.file);
+		const fixtured = withFixtures(wrapper, {
+			suiteHook,
+			fixtures,
+			context: fileContext,
+			stackTraceError
+		});
+		return fixtured();
+	};
+}
+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 +993,9 @@ function createSuiteHooks() {
 		beforeAll: [],
 		afterAll: [],
 		beforeEach: [],
-		afterEach: []
+		afterEach: [],
+		aroundEach: [],
+		aroundAll: []
 	};
 }
 const POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
@@ -728,49 +1025,63 @@ function parseArguments(optionsOrFn, timeoutOrTest) {
 	};
 }
 // implementations
-function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions, parentCollectorFixtures) {
+function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions) {
 	const tasks = [];
 	let suite;
 	initSuite(true);
 	const task = function(name = "", options = {}) {
-		var _collectorContext$cur, _collectorContext$cur2, _collectorContext$cur3, _collectorContext$cur4;
-		const currentSuite = (_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.suite;
-		const parentTask = currentSuite ?? ((_collectorContext$cur2 = collectorContext.currentSuite) === null || _collectorContext$cur2 === void 0 ? void 0 : _collectorContext$cur2.file);
-		const parentTags = (parentTask === null || parentTask === void 0 ? void 0 : parentTask.tags) || [];
+		const currentSuite = collectorContext.currentSuite?.suite;
+		const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+		const parentTags = parentTask?.tags || [];
 		const testTags = unique([...parentTags, ...toArray(options.tags)]);
 		const tagsOptions = testTags.map((tag) => {
-			var _runner$config$tags;
-			const tagDefinition = (_runner$config$tags = runner.config.tags) === null || _runner$config$tags === void 0 ? void 0 : _runner$config$tags.find((t) => t.name === tag);
+			const tagDefinition = runner.config.tags?.find((t) => t.name === tag);
 			if (!tagDefinition && runner.config.strictTags) {
 				throw createNoTagsError(runner.config.tags, tag);
 			}
 			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?.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,
-			fullName: createTaskName([(currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur3 = collectorContext.currentSuite) === null || _collectorContext$cur3 === void 0 || (_collectorContext$cur3 = _collectorContext$cur3.file) === null || _collectorContext$cur3 === void 0 ? void 0 : _collectorContext$cur3.fullName), name]),
-			fullTestName: createTaskName([currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName, name]),
+			fullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),
+			fullTestName: createTaskName([currentSuite?.fullTestName, name]),
 			suite: currentSuite,
 			each: options.each,
 			fails: options.fails,
 			context: undefined,
 			type: "test",
-			file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur4 = collectorContext.currentSuite) === null || _collectorContext$cur4 === void 0 ? void 0 : _collectorContext$cur4.file),
+			file: currentSuite?.file ?? collectorContext.currentSuite?.file,
 			timeout,
 			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
@@ -782,21 +1093,20 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
 			task.concurrent = true;
 		}
-		task.shuffle = suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle;
+		task.shuffle = suiteOptions?.shuffle;
 		const context = createTestContext(task, runner);
 		// create test context
 		Object.defineProperty(task, "context", {
 			value: context,
 			enumerable: false
 		});
-		setTestFixture(context, options.fixtures);
-		// custom can be called from any place, let's assume the limit is 15 stacks
+		setTestFixture(context, options.fixtures ?? new TestFixtures());
 		const limit = Error.stackTraceLimit;
-		Error.stackTraceLimit = 15;
+		Error.stackTraceLimit = 10;
 		const stackTraceError = new Error("STACK_TRACE_ERROR");
 		Error.stackTraceLimit = limit;
 		if (handler) {
-			setFn(task, withTimeout(withAwaitAsyncAssertions(withFixtures(runner, handler, context), task), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
+			setFn(task, withTimeout(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
 		}
 		if (runner.config.includeTaskLocation) {
 			const error = stackTraceError.stack;
@@ -818,11 +1128,11 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 			options = Object.assign({}, suiteOptions, options);
 		}
 		// inherit concurrent / sequential from suite
-		const concurrent = this.concurrent ?? (!this.sequential && (options === null || options === void 0 ? void 0 : options.concurrent));
+		const concurrent = this.concurrent ?? (!this.sequential && options?.concurrent);
 		if (options.concurrent != null && concurrent != null) {
 			options.concurrent = concurrent;
 		}
-		const sequential = this.sequential ?? (!this.concurrent && (options === null || options === void 0 ? void 0 : options.sequential));
+		const sequential = this.sequential ?? (!this.concurrent && options?.sequential);
 		if (options.sequential != null && sequential != null) {
 			options.sequential = sequential;
 		}
@@ -833,7 +1143,6 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		});
 		test.type = "test";
 	});
-	let collectorFixtures = parentCollectorFixtures;
 	const collector = {
 		type: "collector",
 		name,
@@ -841,48 +1150,39 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		suite,
 		options: suiteOptions,
 		test,
+		file: suite.file,
 		tasks,
 		collect,
 		task,
 		clear,
-		on: addHook,
-		fixtures() {
-			return collectorFixtures;
-		},
-		scoped(fixtures) {
-			const parsed = mergeContextFixtures(fixtures, { fixtures: collectorFixtures }, runner);
-			if (parsed.fixtures) {
-				collectorFixtures = parsed.fixtures;
-			}
-		}
+		on: addHook
 	};
 	function addHook(name, ...fn) {
 		getHooks(suite)[name].push(...fn);
 	}
 	function initSuite(includeLocation) {
-		var _collectorContext$cur5, _collectorContext$cur6, _collectorContext$cur7, _collectorContext$cur8;
 		if (typeof suiteOptions === "number") {
 			suiteOptions = { timeout: suiteOptions };
 		}
-		const currentSuite = (_collectorContext$cur5 = collectorContext.currentSuite) === null || _collectorContext$cur5 === void 0 ? void 0 : _collectorContext$cur5.suite;
-		const parentTask = currentSuite ?? ((_collectorContext$cur6 = collectorContext.currentSuite) === null || _collectorContext$cur6 === void 0 ? void 0 : _collectorContext$cur6.file);
-		const suiteTags = toArray(suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.tags);
+		const currentSuite = collectorContext.currentSuite?.suite;
+		const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+		const suiteTags = toArray(suiteOptions?.tags);
 		validateTags(runner.config, suiteTags);
 		suite = {
 			id: "",
 			type: "suite",
 			name,
-			fullName: createTaskName([(currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur7 = collectorContext.currentSuite) === null || _collectorContext$cur7 === void 0 || (_collectorContext$cur7 = _collectorContext$cur7.file) === null || _collectorContext$cur7 === void 0 ? void 0 : _collectorContext$cur7.fullName), name]),
-			fullTestName: createTaskName([currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName, name]),
+			fullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),
+			fullTestName: createTaskName([currentSuite?.fullTestName, name]),
 			suite: currentSuite,
 			mode,
 			each,
-			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,
+			file: currentSuite?.file ?? collectorContext.currentSuite?.file,
+			shuffle: suiteOptions?.shuffle,
 			tasks: [],
-			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])
+			meta: suiteOptions?.meta ?? Object.create(null),
+			concurrent: suiteOptions?.concurrent,
+			tags: unique([...parentTask?.tags || [], ...suiteTags])
 		};
 		if (runner && includeLocation && runner.config.includeTaskLocation) {
 			const limit = Error.stackTraceLimit;
@@ -936,7 +1236,6 @@ function withAwaitAsyncAssertions(fn, task) {
 }
 function createSuite() {
 	function suiteFn(name, factoryOrOptions, optionsOrFactory) {
-		var _currentSuite$options;
 		if (getCurrentTest()) {
 			throw new Error("Calling the suite function inside test function is not allowed. It can be only called at the top level or inside another suite function.");
 		}
@@ -944,12 +1243,13 @@ 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?.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);
+		const shuffle = this.shuffle ?? options.shuffle ?? currentSuite?.options?.shuffle ?? runner?.config.sequence.shuffle;
 		if (shuffle != null) {
 			options.shuffle = shuffle;
 		}
@@ -967,11 +1267,15 @@ function createSuite() {
 		if (isSequential != null) {
 			options.sequential = isSequential && !isConcurrent;
 		}
-		return createSuiteCollector(formatName(name), factory, mode, this.each, options, currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fixtures());
+		if (parentMeta) {
+			options.meta = Object.assign(Object.create(null), parentMeta, options.meta);
+		}
+		return createSuiteCollector(formatName(name), factory, mode, this.each, options);
 	}
 	suiteFn.each = function(cases, ...args) {
-		const suite = this.withContext();
-		this.setContext("each", true);
+		const context = getChainableContext(this);
+		const suite = context.withContext();
+		context.setContext("each", true);
 		if (Array.isArray(cases) && args.length) {
 			cases = formatTemplateString(cases, args);
 		}
@@ -996,7 +1300,7 @@ function createSuite() {
 					}
 				}
 			});
-			this.setContext("each", undefined);
+			context.setContext("each", undefined);
 		};
 	};
 	suiteFn.for = function(cases, ...args) {
@@ -1022,11 +1326,12 @@ function createSuite() {
 		"todo"
 	], suiteFn);
 }
-function createTaskCollector(fn, context) {
+function createTaskCollector(fn) {
 	const taskFn = fn;
 	taskFn.each = function(cases, ...args) {
-		const test = this.withContext();
-		this.setContext("each", true);
+		const context = getChainableContext(this);
+		const test = context.withContext();
+		context.setContext("each", true);
 		if (Array.isArray(cases) && args.length) {
 			cases = formatTemplateString(cases, args);
 		}
@@ -1051,11 +1356,12 @@ function createTaskCollector(fn, context) {
 					}
 				}
 			});
-			this.setContext("each", undefined);
+			context.setContext("each", undefined);
 		};
 	};
 	taskFn.for = function(cases, ...args) {
-		const test = this.withContext();
+		const context = getChainableContext(this);
+		const test = context.withContext();
 		if (Array.isArray(cases) && args.length) {
 			cases = formatTemplateString(cases, args);
 		}
@@ -1066,8 +1372,10 @@ function createTaskCollector(fn, context) {
 				// monkey-patch handler to allow parsing fixture
 				const handlerWrapper = handler ? (ctx) => handler(item, ctx) : undefined;
 				if (handlerWrapper) {
-					handlerWrapper.__VITEST_FIXTURE_INDEX__ = 1;
-					handlerWrapper.toString = () => handler.toString();
+					configureProps(handlerWrapper, {
+						index: 1,
+						original: handler
+					});
 				}
 				test(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
 			});
@@ -1079,27 +1387,91 @@ function createTaskCollector(fn, context) {
 	taskFn.runIf = function(condition) {
 		return condition ? this : this.skip;
 	};
+	/**
+	* Parse builder pattern arguments into a fixtures object.
+	* Handles both builder pattern (name, options?, value) and object syntax.
+	*/
+	function parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn) {
+		// Object syntax: just return as-is
+		if (typeof fixturesOrName !== "string") {
+			return fixturesOrName;
+		}
+		const fixtureName = fixturesOrName;
+		let fixtureOptions;
+		let fixtureValue;
+		if (maybeFn !== undefined) {
+			// (name, options, value) or (name, options, fn)
+			fixtureOptions = optionsOrFn;
+			fixtureValue = maybeFn;
+		} else {
+			// (name, value) or (name, fn)
+			// Check if optionsOrFn looks like fixture options (has scope or auto)
+			if (optionsOrFn !== null && typeof optionsOrFn === "object" && !Array.isArray(optionsOrFn) && ("scope" in optionsOrFn || "auto" in optionsOrFn)) {
+				// (name, options) with no value - treat as empty object fixture
+				fixtureOptions = optionsOrFn;
+				fixtureValue = {};
+			} else {
+				// (name, value) or (name, fn)
+				fixtureOptions = undefined;
+				fixtureValue = optionsOrFn;
+			}
+		}
+		// Function value: wrap with onCleanup pattern
+		if (typeof fixtureValue === "function") {
+			const builderFn = fixtureValue;
+			// Wrap builder pattern function (returns value) to use() pattern
+			const fixture = async (ctx, use) => {
+				let cleanup;
+				const onCleanup = (fn) => {
+					if (cleanup !== undefined) {
+						throw new Error(`onCleanup can only be called once per fixture. ` + `Define separate fixtures if you need multiple cleanup functions.`);
+					}
+					cleanup = fn;
+				};
+				const value = await builderFn(ctx, { onCleanup });
+				await use(value);
+				if (cleanup) {
+					await cleanup();
+				}
+			};
+			configureProps(fixture, { original: builderFn });
+			if (fixtureOptions) {
+				return { [fixtureName]: [fixture, fixtureOptions] };
+			}
+			return { [fixtureName]: fixture };
+		}
+		// Non-function value: use directly
+		if (fixtureOptions) {
+			return { [fixtureName]: [fixtureValue, fixtureOptions] };
+		}
+		return { [fixtureName]: fixtureValue };
+	}
+	taskFn.override = function(fixturesOrName, optionsOrFn, maybeFn) {
+		const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+		getChainableContext(this).getFixtures().override(runner, userFixtures);
+		return this;
+	};
 	taskFn.scoped = function(fixtures) {
-		const collector = getCurrentSuite();
-		collector.scoped(fixtures);
+		console.warn(`test.scoped() is deprecated and will be removed in future versions. Please use test.override() instead.`);
+		return this.override(fixtures);
 	};
-	taskFn.extend = function(fixtures) {
-		const _context = mergeContextFixtures(fixtures, context || {}, runner);
-		const originalWrapper = fn;
-		return createTest(function(name, optionsOrFn, optionsOrTest) {
-			const collector = getCurrentSuite();
-			const scopedFixtures = collector.fixtures();
-			const context = { ...this };
-			if (scopedFixtures) {
-				context.fixtures = mergeScopedFixtures(context.fixtures || [], scopedFixtures);
-			}
-			originalWrapper.call(context, formatName(name), optionsOrFn, optionsOrTest);
-		}, _context);
+	taskFn.extend = function(fixturesOrName, optionsOrFn, maybeFn) {
+		const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+		const fixtures = getChainableContext(this).getFixtures().extend(runner, userFixtures);
+		const _test = createTest(function(name, optionsOrFn, optionsOrTest) {
+			fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+		});
+		getChainableContext(_test).mergeContext({ fixtures });
+		return _test;
 	};
+	taskFn.describe = suite;
+	taskFn.suite = suite;
 	taskFn.beforeEach = beforeEach;
 	taskFn.afterEach = afterEach;
 	taskFn.beforeAll = beforeAll;
 	taskFn.afterAll = afterAll;
+	taskFn.aroundEach = aroundEach;
+	taskFn.aroundAll = aroundAll;
 	const _test = createChainable([
 		"concurrent",
 		"sequential",
@@ -1107,14 +1479,11 @@ function createTaskCollector(fn, context) {
 		"only",
 		"todo",
 		"fails"
-	], taskFn);
-	if (context) {
-		_test.mergeContext(context);
-	}
+	], taskFn, { fixtures: new TestFixtures() });
 	return _test;
 }
-function createTest(fn, context) {
-	return createTaskCollector(fn, context);
+function createTest(fn) {
+	return createTaskCollector(fn);
 }
 function formatName(name) {
 	return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
@@ -1141,14 +1510,13 @@ function formatTitle(template, items, idx) {
 	const isObjectItem = isObject(items[0]);
 	function formatAttribute(s) {
 		return s.replace(/\$([$\w.]+)/g, (_, key) => {
-			var _runner$config;
 			const isArrayKey = /^\d+$/.test(key);
 			if (!isObjectItem && !isArrayKey) {
 				return `$${key}`;
 			}
 			const arrayElement = isArrayKey ? objectAttr(items, key) : undefined;
 			const value = isObjectItem ? objectAttr(items[0], key, arrayElement) : arrayElement;
-			return objDisplay(value, { truncate: runner === null || runner === void 0 || (_runner$config = runner.config) === null || _runner$config === void 0 || (_runner$config = _runner$config.chaiConfig) === null || _runner$config === void 0 ? void 0 : _runner$config.truncateThreshold });
+			return objDisplay(value, { truncate: runner?.config?.chaiConfig?.truncateThreshold });
 		});
 	}
 	let output = "";
@@ -1204,8 +1572,7 @@ const collectorContext = {
 	currentSuite: null
 };
 function collectTask(task) {
-	var _collectorContext$cur;
-	(_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.tasks.push(task);
+	collectorContext.currentSuite?.tasks.push(task);
 }
 async function runWithSuite(suite, fn) {
 	const prev = collectorContext.currentSuite;
@@ -1225,16 +1592,15 @@ function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
 		runner._currentTaskStartTime = startTime;
 		runner._currentTaskTimeout = timeout;
 		return new Promise((resolve_, reject_) => {
-			var _timer$unref;
 			const timer = setTimeout(() => {
 				clearTimeout(timer);
 				rejectTimeoutError();
 			}, timeout);
 			// `unref` might not exist in browser
-			(_timer$unref = timer.unref) === null || _timer$unref === void 0 ? void 0 : _timer$unref.call(timer);
+			timer.unref?.();
 			function rejectTimeoutError() {
 				const error = makeTimeoutError(isHook, timeout, stackTraceError);
-				onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(args, error);
+				onTimeout?.(args, error);
 				reject_(error);
 			}
 			function resolve(result) {
@@ -1282,10 +1648,9 @@ function abortIfTimeout([context], error) {
 }
 function abortContextSignal(context, error) {
 	const abortController = abortControllers.get(context);
-	abortController === null || abortController === void 0 ? void 0 : abortController.abort(error);
+	abortController?.abort(error);
 }
 function createTestContext(test, runner) {
-	var _runner$extendTaskCon;
 	const context = function() {
 		throw new Error("done() callback is deprecated, use promise instead");
 	};
@@ -1301,7 +1666,7 @@ function createTestContext(test, runner) {
 			// do nothing
 			return undefined;
 		}
-		test.result ?? (test.result = { state: "skip" });
+		test.result ??= { state: "skip" };
 		test.result.pending = true;
 		throw new PendingError("test is skipped; abort execution", test, typeof condition === "string" ? condition : note);
 	};
@@ -1332,34 +1697,23 @@ function createTestContext(test, runner) {
 		}));
 	});
 	context.onTestFailed = (handler, timeout) => {
-		test.onFailed || (test.onFailed = []);
+		test.onFailed ||= [];
 		test.onFailed.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
 	};
 	context.onTestFinished = (handler, timeout) => {
-		test.onFinished || (test.onFinished = []);
+		test.onFinished ||= [];
 		test.onFinished.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
 	};
-	return ((_runner$extendTaskCon = runner.extendTaskContext) === null || _runner$extendTaskCon === void 0 ? void 0 : _runner$extendTaskCon.call(runner, context)) || context;
+	return runner.extendTaskContext?.(context) || context;
 }
 function makeTimeoutError(isHook, timeout, stackTraceError) {
 	const message = `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.\nIf this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
 	const error = new Error(message);
-	if (stackTraceError === null || stackTraceError === void 0 ? void 0 : stackTraceError.stack) {
+	if (stackTraceError?.stack) {
 		error.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);
 	}
 	return error;
 }
-const fileContexts = new WeakMap();
-function getFileContext(file) {
-	const context = fileContexts.get(file);
-	if (!context) {
-		throw new Error(`Cannot find file context for ${file.name}`);
-	}
-	return context;
-}
-function setFileContext(file, context) {
-	fileContexts.set(file, context);
-}
 
 async function runSetupFiles(config, files, runner) {
 	if (config.sequence.setupFiles === "parallel") {
@@ -1388,13 +1742,11 @@ async function collectTests(specs, runner) {
 			const testTagsFilter = typeof spec === "object" && spec.testTagsFilter ? createTagsFilter(spec.testTagsFilter, config.tags) : undefined;
 			const fileTags = typeof spec === "string" ? [] : spec.fileTags || [];
 			const file = createFileTask(filepath, config.root, config.name, runner.pool, runner.viteEnvironment);
-			setFileContext(file, Object.create(null));
 			file.tags = fileTags;
 			file.shuffle = config.sequence.shuffle;
 			try {
-				var _runner$onCollectStar, _runner$getImportDura;
 				validateTags(runner.config, fileTags);
-				(_runner$onCollectStar = runner.onCollectStart) === null || _runner$onCollectStar === void 0 ? void 0 : _runner$onCollectStar.call(runner, file);
+				runner.onCollectStart?.(file);
 				clearCollectorContext(file, runner);
 				const setupFiles = toArray(config.setupFiles);
 				if (setupFiles.length) {
@@ -1407,7 +1759,7 @@ async function collectTests(specs, runner) {
 				}
 				const collectStart = now$1();
 				await runner.importFile(filepath, "collect");
-				const durations = (_runner$getImportDura = runner.getImportDurations) === null || _runner$getImportDura === void 0 ? void 0 : _runner$getImportDura.call(runner);
+				const durations = runner.getImportDurations?.();
 				if (durations) {
 					file.importDurations = durations;
 				}
@@ -1431,13 +1783,12 @@ async function collectTests(specs, runner) {
 				setHooks(file, fileHooks);
 				file.collectDuration = now$1() - collectStart;
 			} catch (e) {
-				var _runner$getImportDura2;
-				const error = processError(e);
+				const errors = e instanceof AggregateError ? e.errors.map((e) => processError(e, runner.config.diffOptions)) : [processError(e, runner.config.diffOptions)];
 				file.result = {
 					state: "fail",
-					errors: [error]
+					errors
 				};
-				const durations = (_runner$getImportDura2 = runner.getImportDurations) === null || _runner$getImportDura2 === void 0 ? void 0 : _runner$getImportDura2.call(runner);
+				const durations = runner.getImportDurations?.();
 				if (durations) {
 					file.importDurations = durations;
 				}
@@ -1586,12 +1937,179 @@ 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?.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;
+		let timedout = false;
+		const promise = new Promise((_, reject) => {
+			if (timeout > 0 && timeout !== Number.POSITIVE_INFINITY) {
+				timer = setTimeout(() => {
+					timedout = true;
+					const error = makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError);
+					onTimeout?.(error);
+					reject(error);
+				}, timeout);
+				timer.unref?.();
+			}
+		});
+		const clear = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = undefined;
+			}
+		};
+		return {
+			promise,
+			clear,
+			isTimedOut: () => timedout
+		};
+	};
+	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 () => {
+			// shouldn't continue to next (runTest/Suite or inner aroundEach/All) when aroundEach/All setup timed out.
+			if (setupTimeout.isTimedOut()) {
+				// we can throw any error to bail out.
+				// this error is not seen by end users since `runNextHook` already rejected with timeout error
+				// and this error is caught by `rejectHookComplete`.
+				throw new Error("__VITEST_INTERNAL_AROUND_HOOK_ABORT__");
+			}
+			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
+			let nextError;
+			try {
+				await runNextHook(index + 1);
+			} catch (value) {
+				nextError = { value };
+			}
+			// 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();
+			if (nextError) {
+				throw nextError.value;
+			}
+		};
+		// 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 = [];
 function sendTasksUpdate(runner) {
 	if (packs.size) {
-		var _runner$onTaskUpdate;
 		const taskPacks = Array.from(packs).map(([id, task]) => {
 			return [
 				id,
@@ -1599,7 +2117,7 @@ function sendTasksUpdate(runner) {
 				task[1]
 			];
 		});
-		const p = (_runner$onTaskUpdate = runner.onTaskUpdate) === null || _runner$onTaskUpdate === void 0 ? void 0 : _runner$onTaskUpdate.call(runner, taskPacks, eventsPacks);
+		const p = runner.onTaskUpdate?.(taskPacks, eventsPacks);
 		if (p) {
 			pendingTasksUpdates.push(p);
 			// remove successful promise to not grow array indefnitely,
@@ -1626,7 +2144,7 @@ function throttle(fn, ms) {
 			return fn.apply(this, args);
 		}
 		// Make sure fn is still called even if there are no further calls
-		pendingCall ?? (pendingCall = setTimeout(() => call.bind(this)(...args), ms));
+		pendingCall ??= setTimeout(() => call.bind(this)(...args), ms);
 	};
 }
 // throttle based on summary reporter's DURATION_UPDATE_INTERVAL_MS
@@ -1681,14 +2199,13 @@ function passesRetryCondition(test, errors) {
 	return false;
 }
 async function runTest(test, runner) {
-	var _runner$onBeforeRunTa, _test$result, _runner$onAfterRunTas;
-	await ((_runner$onBeforeRunTa = runner.onBeforeRunTask) === null || _runner$onBeforeRunTa === void 0 ? void 0 : _runner$onBeforeRunTa.call(runner, test));
+	await runner.onBeforeRunTask?.(test);
 	if (test.mode !== "run" && test.mode !== "queued") {
 		updateTask("test-prepare", test, runner);
 		updateTask("test-finished", test, runner);
 		return;
 	}
-	if (((_test$result = test.result) === null || _test$result === void 0 ? void 0 : _test$result.state) === "fail") {
+	if (test.result?.state === "fail") {
 		// should not be possible to get here, I think this is just copy pasted from suite
 		// TODO: maybe someone fails tests in `beforeAll` hooks?
 		// https://github.com/vitest-dev/vitest/pull/7069
@@ -1710,73 +2227,86 @@ 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;
 			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) => {
+				try {
+					await runner.onBeforeTryTask?.(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.onAfterTryTask?.(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";
+						}
 					}
-					await $("test.callback", () => fn());
+				} catch (e) {
+					failTask(test.result, e, runner.config.diffOptions);
 				}
-				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";
+				try {
+					await runner.onTaskFinished?.(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));
 					}
+					// 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);
 				}
-			} 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));
+				if (test.onFinished?.length) {
+					await $("test.onFinished", () => callTestHooks(runner, test, test.onFinished, "stack"));
 				}
+				if (test.result.state === "fail" && test.onFailed?.length) {
+					await $("test.onFailed", () => callTestHooks(runner, test, test.onFailed, runner.config.sequence.hooks));
+				}
+				test.onFailed = undefined;
+				test.onFinished = undefined;
+				await runner.onAfterRetryTask?.(test, {
+					retry: retryCount,
+					repeats: repeatCount
+				});
+			}).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 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;
+			if (test.result?.pending || test.result?.state === "skip") {
 				test.mode = "skip";
 				test.result = {
 					state: "skip",
-					note: (_test$result4 = test.result) === null || _test$result4 === void 0 ? void 0 : _test$result4.note,
+					note: test.result?.note,
 					pending: true,
 					duration: now() - start
 				};
@@ -1818,7 +2348,7 @@ async function runTest(test, runner) {
 	cleanupRunningTest();
 	setCurrentTest(undefined);
 	test.result.duration = now() - start;
-	await ((_runner$onAfterRunTas = runner.onAfterRunTask) === null || _runner$onAfterRunTas === void 0 ? void 0 : _runner$onAfterRunTas.call(runner, test));
+	await runner.onAfterRunTask?.(test);
 	updateTask("test-finished", test, runner);
 }
 function failTask(result, err, diffOptions) {
@@ -1831,9 +2361,9 @@ function failTask(result, err, diffOptions) {
 	result.state = "fail";
 	const errors = Array.isArray(err) ? err : [err];
 	for (const e of errors) {
-		const error = processError(e, diffOptions);
-		result.errors ?? (result.errors = []);
-		result.errors.push(error);
+		const errors = e instanceof AggregateError ? e.errors.map((e) => processError(e, diffOptions)) : [processError(e, diffOptions)];
+		result.errors ??= [];
+		result.errors.push(...errors);
 	}
 }
 function markTasksAsSkipped(suite, runner) {
@@ -1850,9 +2380,8 @@ function markTasksAsSkipped(suite, runner) {
 	});
 }
 async function runSuite(suite, runner) {
-	var _runner$onBeforeRunSu, _suite$result;
-	await ((_runner$onBeforeRunSu = runner.onBeforeRunSuite) === null || _runner$onBeforeRunSu === void 0 ? void 0 : _runner$onBeforeRunSu.call(runner, suite));
-	if (((_suite$result = suite.result) === null || _suite$result === void 0 ? void 0 : _suite$result.state) === "fail") {
+	await runner.onBeforeRunSuite?.(suite);
+	if (suite.result?.state === "fail") {
 		markTasksAsSkipped(suite, runner);
 		// failed during collection
 		updateTask("suite-failed-early", suite, runner);
@@ -1874,55 +2403,68 @@ async function runSuite(suite, runner) {
 		suite.result.state = "todo";
 		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 contexts = TestFixtures.getFileContexts(suite.file);
+							await Promise.all(contexts.map((context) => 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") {
 			if (!runner.config.passWithNoTests && !hasTests(suite)) {
-				var _suite$result$errors;
 				suite.result.state = "fail";
-				if (!((_suite$result$errors = suite.result.errors) === null || _suite$result$errors === void 0 ? void 0 : _suite$result$errors.length)) {
+				if (!suite.result.errors?.length) {
 					const error = processError(new Error(`No test found in suite ${suite.name}`));
 					suite.result.errors = [error];
 				}
@@ -1933,7 +2475,7 @@ async function runSuite(suite, runner) {
 			}
 		}
 		suite.result.duration = now() - start;
-		await ((_runner$onAfterRunSui = runner.onAfterRunSuite) === null || _runner$onAfterRunSui === void 0 ? void 0 : _runner$onAfterRunSui.call(runner, suite));
+		await runner.onAfterRunSuite?.(suite);
 		updateTask("suite-finished", suite, runner);
 	}
 }
@@ -1941,36 +2483,31 @@ let limitMaxConcurrency;
 async function runSuiteChild(c, runner) {
 	const $ = runner.trace;
 	if (c.type === "test") {
-		return limitMaxConcurrency(() => {
-			var _c$location, _c$location2;
-			return $("run.test", {
-				"vitest.test.id": c.id,
-				"vitest.test.name": c.name,
-				"vitest.test.mode": c.mode,
-				"vitest.test.timeout": c.timeout,
-				"code.file.path": c.file.filepath,
-				"code.line.number": (_c$location = c.location) === null || _c$location === void 0 ? void 0 : _c$location.line,
-				"code.column.number": (_c$location2 = c.location) === null || _c$location2 === void 0 ? void 0 : _c$location2.column
-			}, () => runTest(c, runner));
-		});
+		return limitMaxConcurrency(() => $("run.test", {
+			"vitest.test.id": c.id,
+			"vitest.test.name": c.name,
+			"vitest.test.mode": c.mode,
+			"vitest.test.timeout": c.timeout,
+			"code.file.path": c.file.filepath,
+			"code.line.number": c.location?.line,
+			"code.column.number": c.location?.column
+		}, () => runTest(c, runner)));
 	} else if (c.type === "suite") {
-		var _c$location3, _c$location4;
 		return $("run.suite", {
 			"vitest.suite.id": c.id,
 			"vitest.suite.name": c.name,
 			"vitest.suite.mode": c.mode,
 			"code.file.path": c.file.filepath,
-			"code.line.number": (_c$location3 = c.location) === null || _c$location3 === void 0 ? void 0 : _c$location3.line,
-			"code.column.number": (_c$location4 = c.location) === null || _c$location4 === void 0 ? void 0 : _c$location4.column
+			"code.line.number": c.location?.line,
+			"code.column.number": c.location?.column
 		}, () => runSuite(c, runner));
 	}
 }
 async function runFiles(files, runner) {
-	limitMaxConcurrency ?? (limitMaxConcurrency = limitConcurrency(runner.config.maxConcurrency));
+	limitMaxConcurrency ??= limitConcurrency(runner.config.maxConcurrency);
 	for (const file of files) {
 		if (!file.tasks.length && !runner.config.passWithNoTests) {
-			var _file$result;
-			if (!((_file$result = file.result) === null || _file$result === void 0 || (_file$result = _file$result.errors) === null || _file$result === void 0 ? void 0 : _file$result.length)) {
+			if (!file.result?.errors?.length) {
 				const error = processError(new Error(`No test suite found in file ${file.filepath}`));
 				file.result = {
 					state: "fail",
@@ -1992,37 +2529,32 @@ function defaultTrace(_, attributes, cb) {
 	return cb();
 }
 async function startTests(specs, runner) {
-	var _runner$cancel;
-	runner.trace ?? (runner.trace = defaultTrace);
-	const cancel = (_runner$cancel = runner.cancel) === null || _runner$cancel === void 0 ? void 0 : _runner$cancel.bind(runner);
+	runner.trace ??= defaultTrace;
+	const cancel = runner.cancel?.bind(runner);
 	// Ideally, we need to have an event listener for this, but only have a runner here.
 	// Adding another onCancel felt wrong (maybe it needs to be refactored)
 	runner.cancel = (reason) => {
 		// We intentionally create only one error since there is only one test run that can be cancelled
 		const error = new TestRunAbortError("The test run was aborted by the user.", reason);
 		getRunningTests().forEach((test) => abortContextSignal(test.context, error));
-		return cancel === null || cancel === void 0 ? void 0 : cancel(reason);
+		return cancel?.(reason);
 	};
 	if (!workerRunners.has(runner)) {
-		var _runner$onCleanupWork;
-		(_runner$onCleanupWork = runner.onCleanupWorkerContext) === null || _runner$onCleanupWork === void 0 ? void 0 : _runner$onCleanupWork.call(runner, async () => {
-			var _runner$getWorkerCont;
-			const context = (_runner$getWorkerCont = runner.getWorkerContext) === null || _runner$getWorkerCont === void 0 ? void 0 : _runner$getWorkerCont.call(runner);
-			if (context) {
-				await callFixtureCleanup(context);
-			}
+		runner.onCleanupWorkerContext?.(async () => {
+			await Promise.all([...TestFixtures.getWorkerContexts()].map((context) => callFixtureCleanup(context))).finally(() => {
+				TestFixtures.clearDefinitions();
+			});
 		});
 		workerRunners.add(runner);
 	}
 	try {
-		var _runner$onBeforeColle, _runner$onCollected, _runner$onBeforeRunFi, _runner$onAfterRunFil;
 		const paths = specs.map((f) => typeof f === "string" ? f : f.filepath);
-		await ((_runner$onBeforeColle = runner.onBeforeCollect) === null || _runner$onBeforeColle === void 0 ? void 0 : _runner$onBeforeColle.call(runner, paths));
+		await runner.onBeforeCollect?.(paths);
 		const files = await collectTests(specs, runner);
-		await ((_runner$onCollected = runner.onCollected) === null || _runner$onCollected === void 0 ? void 0 : _runner$onCollected.call(runner, files));
-		await ((_runner$onBeforeRunFi = runner.onBeforeRunFiles) === null || _runner$onBeforeRunFi === void 0 ? void 0 : _runner$onBeforeRunFi.call(runner, files));
+		await runner.onCollected?.(files);
+		await runner.onBeforeRunFiles?.(files);
 		await runFiles(files, runner);
-		await ((_runner$onAfterRunFil = runner.onAfterRunFiles) === null || _runner$onAfterRunFil === void 0 ? void 0 : _runner$onAfterRunFil.call(runner, files));
+		await runner.onAfterRunFiles?.(files);
 		await finishSendTasksUpdate(runner);
 		return files;
 	} finally {
@@ -2030,12 +2562,11 @@ async function startTests(specs, runner) {
 	}
 }
 async function publicCollect(specs, runner) {
-	var _runner$onBeforeColle2, _runner$onCollected2;
-	runner.trace ?? (runner.trace = defaultTrace);
+	runner.trace ??= defaultTrace;
 	const paths = specs.map((f) => typeof f === "string" ? f : f.filepath);
-	await ((_runner$onBeforeColle2 = runner.onBeforeCollect) === null || _runner$onBeforeColle2 === void 0 ? void 0 : _runner$onBeforeColle2.call(runner, paths));
+	await runner.onBeforeCollect?.(paths);
 	const files = await collectTests(specs, runner);
-	await ((_runner$onCollected2 = runner.onCollected) === null || _runner$onCollected2 === void 0 ? void 0 : _runner$onCollected2.call(runner, files));
+	await runner.onCollected?.(files);
 	return files;
 }
 
@@ -2049,12 +2580,13 @@ async function publicCollect(specs, runner) {
 *
 * Vitest automatically injects the source location where the artifact was created and manages any attachments you include.
 *
+* **Note:** artifacts must be recorded before the task is reported. Any artifacts recorded after that will not be included in the task.
+*
 * @param task - The test task context, typically accessed via `this.task` in custom matchers or `context.task` in tests
 * @param artifact - The artifact to record. Must extend {@linkcode TestArtifactBase}
 *
 * @returns A promise that resolves to the recorded artifact with location injected
 *
-* @throws {Error} If called after the test has finished running
 * @throws {Error} If the test runner doesn't support artifacts
 *
 * @example
@@ -2075,9 +2607,6 @@ async function publicCollect(specs, runner) {
 */
 async function recordArtifact(task, artifact) {
 	const runner = getRunner();
-	if (task.result && task.result.state !== "run") {
-		throw new Error(`Cannot record a test artifact outside of the test run. The test "${task.name}" finished running with the "${task.result.state}" state already.`);
-	}
 	const stack = findTestFileStackTrace(task.file.filepath, new Error("STACK_TRACE").stack);
 	if (stack) {
 		artifact.location = {
@@ -2195,4 +2724,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 };