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

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 { 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 { 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,9 @@ class TestRunAbortError extends Error {
 		this.reason = reason;
 	}
 }
+class FixtureDependencyError extends Error {
+	name = "FixtureDependencyError";
+}
 class AroundHookSetupError extends Error {
 	name = "AroundHookSetupError";
 }
@@ -47,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) {
@@ -57,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 _workerContextSuite = { type: "worker" };
+	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._workerContextSuite)) {
+			this._suiteContexts.set(TestFixtures._workerContextSuite, Object.create(null));
+		}
+		return this._suiteContexts.get(TestFixtures._workerContextSuite);
+	}
+	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()) {
@@ -148,8 +248,7 @@ async function callFixtureCleanup(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;
+	return cleanupFnArrayMap.get(context)?.length ?? 0;
 }
 /**
 * Cleans up only fixtures that were added after the given checkpoint index.
@@ -170,96 +269,126 @@ async function callFixtureCleanupFrom(context, fromIndex) {
 	// 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;
+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) {
@@ -290,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*
@@ -321,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, "");
 	});
@@ -345,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 = [];
@@ -427,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
 	}));
@@ -451,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.
@@ -473,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
 	}));
@@ -498,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.
@@ -520,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));
 });
 /**
@@ -547,7 +697,7 @@ 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));
 });
 /**
@@ -559,9 +709,6 @@ const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout)
 * **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}
@@ -574,9 +721,9 @@ const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout)
 * ```
 * @example
 * ```ts
-* // Example of using aroundAll with AsyncLocalStorage context
-* aroundAll(async (runSuite) => {
-*   await asyncLocalStorage.run({ suiteId: 'my-suite' }, runSuite);
+* // Example of using aroundAll with fixtures
+* aroundAll(async (runSuite, { db }) => {
+*   await db.transaction(() => runSuite());
 * });
 * ```
 */
@@ -584,7 +731,8 @@ 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, {
+	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
 	}));
@@ -619,37 +767,39 @@ 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, {
+	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
 	}));
 }
-/**
-* 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);
+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();
 	};
-	return wrapper;
 }
 function getAroundHookTimeout(hook) {
 	return AROUND_TIMEOUT_KEY in hook && typeof hook[AROUND_TIMEOUT_KEY] === "number" ? hook[AROUND_TIMEOUT_KEY] : getDefaultHookTimeout();
@@ -875,19 +1025,17 @@ 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);
 			}
@@ -906,7 +1054,7 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 			...options
 		};
 		const timeout = options.timeout ?? runner.config.testTimeout;
-		const parentMeta = currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.meta;
+		const parentMeta = currentSuite?.meta;
 		const tagMeta = tagsOptions.meta;
 		const testMeta = Object.create(null);
 		if (tagMeta) {
@@ -921,14 +1069,14 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		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,
@@ -945,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(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), task.context.signal), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
 		}
 		if (runner.config.includeTaskLocation) {
 			const error = stackTraceError.stack;
@@ -981,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;
 		}
@@ -996,7 +1143,6 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		});
 		test.type = "test";
 	});
-	let collectorFixtures = parentCollectorFixtures;
 	const collector = {
 		type: "collector",
 		name,
@@ -1004,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: (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])
+			meta: suiteOptions?.meta ?? Object.create(null),
+			concurrent: suiteOptions?.concurrent,
+			tags: unique([...parentTask?.tags || [], ...suiteTags])
 		};
 		if (runner && includeLocation && runner.config.includeTaskLocation) {
 			const limit = Error.stackTraceLimit;
@@ -1099,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.");
 		}
@@ -1107,13 +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 === null || currentSuite === void 0 ? void 0 : currentSuite.options) || {};
+		const { meta: parentMeta, ...parentOptions } = currentSuite?.options || {};
 		// inherit options from current suite
 		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;
 		}
@@ -1134,11 +1270,12 @@ function createSuite() {
 		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());
+		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);
 		}
@@ -1163,7 +1300,7 @@ function createSuite() {
 					}
 				}
 			});
-			this.setContext("each", undefined);
+			context.setContext("each", undefined);
 		};
 	};
 	suiteFn.for = function(cases, ...args) {
@@ -1189,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);
 		}
@@ -1218,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);
 		}
@@ -1233,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);
 			});
@@ -1246,24 +1387,85 @@ 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;
@@ -1277,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);
@@ -1311,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 = "";
@@ -1374,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;
@@ -1395,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) {
@@ -1444,6 +1640,23 @@ catch (error) {
 		});
 	});
 }
+function withCancel(fn, signal) {
+	return (function runWithCancel(...args) {
+		return new Promise((resolve, reject) => {
+			signal.addEventListener("abort", () => reject(signal.reason));
+			try {
+				const result = fn(...args);
+				if (typeof result === "object" && result != null && typeof result.then === "function") {
+					result.then(resolve, reject);
+				} else {
+					resolve(result);
+				}
+			} catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
 const abortControllers = new WeakMap();
 function abortIfTimeout([context], error) {
 	if (context) {
@@ -1452,10 +1665,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");
 	};
@@ -1471,7 +1683,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);
 	};
@@ -1502,34 +1714,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") {
@@ -1558,13 +1759,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) {
@@ -1577,7 +1776,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;
 				}
@@ -1601,13 +1800,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;
 				}
@@ -1637,6 +1835,7 @@ function mergeHooks(baseHooks, hooks) {
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const unixNow = Date.now;
 const { clearTimeout, setTimeout } = getSafeTimers();
+let limitMaxConcurrency;
 /**
 * Normalizes retry configuration to extract individual values.
 * Handles both number and object forms.
@@ -1710,14 +1909,14 @@ async function callTestHooks(runner, test, hooks, sequence) {
 	};
 	if (sequence === "parallel") {
 		try {
-			await Promise.all(hooks.map((fn) => fn(test.context)));
+			await Promise.all(hooks.map((fn) => limitMaxConcurrency(() => fn(test.context))));
 		} catch (e) {
 			failTask(test.result, e, runner.config.diffOptions);
 		}
 	} else {
 		for (const fn of hooks) {
 			try {
-				await fn(test.context);
+				await limitMaxConcurrency(() => fn(test.context));
 			} catch (e) {
 				failTask(test.result, e, runner.config.diffOptions);
 			}
@@ -1739,7 +1938,9 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
 		updateSuiteHookState(currentTask, name, "run", runner);
 	}
 	async function runHook(hook) {
-		return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : undefined);
+		return limitMaxConcurrency(async () => {
+			return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : undefined);
+		});
 	}
 	if (sequence === "parallel") {
 		callbacks.push(...await Promise.all(hooks.map((hook) => runHook(hook))));
@@ -1772,7 +1973,7 @@ 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) {
+	if (stackTraceError?.stack) {
 		error.stack = stackTraceError.stack.replace(stackTraceError.message, error.message);
 	}
 	return error;
@@ -1783,17 +1984,19 @@ async function callAroundHooks(runInner, options) {
 		await runInner();
 		return;
 	}
+	const hookErrors = [];
 	const createTimeoutPromise = (timeout, phase, stackTraceError) => {
 		let timer;
+		let timedout = false;
 		const promise = new Promise((_, reject) => {
 			if (timeout > 0 && timeout !== Number.POSITIVE_INFINITY) {
-				var _timer$unref;
 				timer = setTimeout(() => {
+					timedout = true;
 					const error = makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError);
-					onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(error);
+					onTimeout?.(error);
 					reject(error);
 				}, timeout);
-				(_timer$unref = timer.unref) === null || _timer$unref === void 0 ? void 0 : _timer$unref.call(timer);
+				timer.unref?.();
 			}
 		});
 		const clear = () => {
@@ -1804,7 +2007,8 @@ async function callAroundHooks(runInner, options) {
 		};
 		return {
 			promise,
-			clear
+			clear,
+			isTimedOut: () => timedout
 		};
 	};
 	const runNextHook = async (index) => {
@@ -1817,6 +2021,8 @@ async function callAroundHooks(runInner, options) {
 		let useCalled = false;
 		let setupTimeout;
 		let teardownTimeout;
+		let setupLimitConcurrencyRelease;
+		let teardownLimitConcurrencyRelease;
 		// Promise that resolves when use() is called (setup phase complete)
 		let resolveUseCalled;
 		const useCalledPromise = new Promise((resolve) => {
@@ -1835,6 +2041,13 @@ async function callAroundHooks(runInner, options) {
 			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.`);
 			}
@@ -1842,13 +2055,16 @@ async function callAroundHooks(runInner, options) {
 			resolveUseCalled();
 			// Setup phase completed - clear setup timer
 			setupTimeout.clear();
+			setupLimitConcurrencyRelease?.();
 			// Run inner hooks - don't time this against our teardown timeout
-			await runNextHook(index + 1);
+			await runNextHook(index + 1).catch((e) => hookErrors.push(e));
+			teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
 			// 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();
 		};
+		setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
 		// Start setup timeout
 		setupTimeout = createTimeoutPromise(timeout, "setup", stackTraceError);
 		(async () => {
@@ -1860,6 +2076,9 @@ async function callAroundHooks(runInner, options) {
 				resolveHookComplete();
 			} catch (error) {
 				rejectHookComplete(error);
+			} finally {
+				setupLimitConcurrencyRelease?.();
+				teardownLimitConcurrencyRelease?.();
 			}
 		})();
 		// Wait for either: use() to be called OR hook to complete (error) OR setup timeout
@@ -1870,6 +2089,7 @@ async function callAroundHooks(runInner, options) {
 				setupTimeout.promise
 			]);
 		} finally {
+			setupLimitConcurrencyRelease?.();
 			setupTimeout.clear();
 		}
 		// Wait for use() to return (inner hooks complete) OR hook to complete (error during inner hooks)
@@ -1877,12 +2097,16 @@ async function callAroundHooks(runInner, options) {
 		// Now teardownTimeout is guaranteed to be set
 		// Wait for hook to complete (teardown) OR teardown timeout
 		try {
-			await Promise.race([hookCompletePromise, teardownTimeout.promise]);
+			await Promise.race([hookCompletePromise, teardownTimeout?.promise]);
 		} finally {
-			teardownTimeout.clear();
+			teardownLimitConcurrencyRelease?.();
+			teardownTimeout?.clear();
 		}
 	};
-	await runNextHook(0);
+	await runNextHook(0).catch((e) => hookErrors.push(e));
+	if (hookErrors.length > 0) {
+		throw hookErrors;
+	}
 }
 async function callAroundAllHooks(suite, runSuiteInner) {
 	await callAroundHooks(runSuiteInner, {
@@ -1912,7 +2136,6 @@ const eventsPacks = [];
 const pendingTasksUpdates = [];
 function sendTasksUpdate(runner) {
 	if (packs.size) {
-		var _runner$onTaskUpdate;
 		const taskPacks = Array.from(packs).map(([id, task]) => {
 			return [
 				id,
@@ -1920,7 +2143,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,
@@ -1947,7 +2170,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
@@ -1971,14 +2194,14 @@ async function callCleanupHooks(runner, cleanups) {
 			if (typeof fn !== "function") {
 				return;
 			}
-			await fn();
+			await limitMaxConcurrency(() => fn());
 		}));
 	} else {
 		for (const fn of cleanups) {
 			if (typeof fn !== "function") {
 				continue;
 			}
-			await fn();
+			await limitMaxConcurrency(() => fn());
 		}
 	}
 }
@@ -2002,14 +2225,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
@@ -2031,48 +2253,40 @@ 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$result2, _test$result3;
 			let beforeEachCleanups = [];
 			// 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, {
+					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));
+						await $("test.callback", () => limitMaxConcurrency(() => 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 $("test.callback", () => limitMaxConcurrency(() => fn()));
 					}
-					await ((_runner$onAfterTryTas = runner.onAfterTryTask) === null || _runner$onAfterTryTas === void 0 ? void 0 : _runner$onAfterTryTas.call(runner, test, {
+					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";
-						}
+						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));
+					await runner.onTaskFinished?.(test);
 				} catch (e) {
 					failTask(test.result, e, runner.config.diffOptions);
 				}
@@ -2087,18 +2301,18 @@ async function runTest(test, runner) {
 				} catch (e) {
 					failTask(test.result, e, runner.config.diffOptions);
 				}
-				if ((_test$onFinished = test.onFinished) === null || _test$onFinished === void 0 ? void 0 : _test$onFinished.length) {
+				if (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)) {
+				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$onAfterRetryT = runner.onAfterRetryTask) === null || _runner$onAfterRetryT === void 0 ? void 0 : _runner$onAfterRetryT.call(runner, test, {
+				await runner.onAfterRetryTask?.(test, {
 					retry: retryCount,
 					repeats: repeatCount
-				}));
+				});
 			}).catch((error) => {
 				failTask(test.result, error, runner.config.diffOptions);
 			});
@@ -2110,12 +2324,11 @@ async function runTest(test, runner) {
 				failTask(test.result, e, runner.config.diffOptions);
 			}
 			// 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
 				};
@@ -2157,7 +2370,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) {
@@ -2167,12 +2380,17 @@ function failTask(result, err, diffOptions) {
 		result.pending = true;
 		return;
 	}
+	if (err instanceof TestRunAbortError) {
+		result.state = "skip";
+		result.note = err.message;
+		return;
+	}
 	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) {
@@ -2188,10 +2406,25 @@ function markTasksAsSkipped(suite, runner) {
 		}
 	});
 }
+function markPendingTasksAsSkipped(suite, runner, note) {
+	suite.tasks.forEach((t) => {
+		if (!t.result || t.result.state === "run") {
+			t.mode = "skip";
+			t.result = {
+				...t.result,
+				state: "skip",
+				note
+			};
+			updateTask("test-cancel", t, runner);
+		}
+		if (t.type === "suite") {
+			markPendingTasksAsSkipped(t, runner, note);
+		}
+	});
+}
 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);
@@ -2213,7 +2446,6 @@ async function runSuite(suite, runner) {
 		suite.result.state = "todo";
 		updateTask("suite-finished", suite, runner);
 	} else {
-		var _runner$onAfterRunSui;
 		let suiteRan = false;
 		try {
 			await callAroundAllHooks(suite, async () => {
@@ -2257,8 +2489,8 @@ async function runSuite(suite, runner) {
 							await $("suite.cleanup", () => callCleanupHooks(runner, beforeAllCleanups));
 						}
 						if (suite.file === suite) {
-							const context = getFileContext(suite);
-							await callFixtureCleanup(context);
+							const contexts = TestFixtures.getFileContexts(suite.file);
+							await Promise.all(contexts.map((context) => callFixtureCleanup(context)));
 						}
 					} catch (e) {
 						failTask(suite.result, e, runner.config.diffOptions);
@@ -2274,9 +2506,8 @@ async function runSuite(suite, runner) {
 		}
 		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];
 				}
@@ -2287,44 +2518,38 @@ 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);
 	}
 }
-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 $("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",
@@ -2346,37 +2571,35 @@ 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);
+		getRunningTests().forEach((test) => {
+			abortContextSignal(test.context, error);
+			markPendingTasksAsSkipped(test.file, runner, error.message);
+		});
+		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 {
@@ -2384,12 +2607,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;
 }
 
@@ -2403,12 +2625,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
@@ -2429,9 +2652,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 = {