@vitest/runner 4.0.9 → 4.0.11

package/dist/index.js

@@ -1,6 +1,6 @@
-import { isObject, createDefer, toArray, isNegativeNaN, objectAttr, shuffle, assertTypes } from '@vitest/utils/helpers';
-import { getSafeTimers } from '@vitest/utils/timers';
 import { processError } from '@vitest/utils/error';
+import { isObject, createDefer, assertTypes, toArray, isNegativeNaN, objectAttr, shuffle } from '@vitest/utils/helpers';
+import { getSafeTimers } from '@vitest/utils/timers';
 import { format, formatRegExp, objDisplay } from '@vitest/utils/display';
 import { c as createChainable, f as findTestFileStackTrace, b as createFileTask, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, l as limitConcurrency, p as partitionSuiteChildren, q as hasTests, o as hasFailed } from './chunk-tasks.js';
 import '@vitest/utils/source-map';
@@ -48,18 +48,6 @@ function getHooks(key) {
 	return hooksMap.get(key);
 }
 
-async function runSetupFiles(config, files, runner) {
-	if (config.sequence.setupFiles === "parallel") {
-		await Promise.all(files.map(async (fsPath) => {
-			await runner.importFile(fsPath, "setup");
-		}));
-	} else {
-		for (const fsPath of files) {
-			await runner.importFile(fsPath, "setup");
-		}
-	}
-}
-
 function mergeScopedFixtures(testFixtures, scopedFixtures) {
 	const scopedFixturesMap = scopedFixtures.reduce((map, fixture) => {
 		map[fixture.prop] = fixture;
@@ -390,6 +378,176 @@ function getRunningTests() {
 	return tests;
 }
 
+function getDefaultHookTimeout() {
+	return getRunner().config.hookTimeout;
+}
+const CLEANUP_TIMEOUT_KEY = Symbol.for("VITEST_CLEANUP_TIMEOUT");
+const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_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();
+		const stackTraceError = CLEANUP_STACK_TRACE_KEY in hook && hook[CLEANUP_STACK_TRACE_KEY] instanceof Error ? hook[CLEANUP_STACK_TRACE_KEY] : undefined;
+		return withTimeout(result, timeout, true, stackTraceError, (_, error) => {
+			if (context) {
+				abortContextSignal(context, error);
+			}
+		});
+	}
+}
+/**
+* Registers a callback function to be executed once before all tests within the current suite.
+* This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
+*
+* **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before all 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 beforeAll to set up a database connection
+* beforeAll(async () => {
+*   await database.connect();
+* });
+* ```
+*/
+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), {
+		[CLEANUP_TIMEOUT_KEY]: timeout,
+		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Registers a callback function to be executed once after all tests within the current suite have completed.
+* This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
+*
+* **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after all 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 afterAll to close a database connection
+* afterAll(async () => {
+*   await database.disconnect();
+* });
+* ```
+*/
+function afterAll(fn, timeout) {
+	assertTypes(fn, "\"afterAll\" callback", ["function"]);
+	return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR")));
+}
+/**
+* Registers a callback function to be executed before each test within the current suite.
+* This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+*
+* **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @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 beforeEach to reset a database state
+* beforeEach(async () => {
+*   await database.reset();
+* });
+* ```
+*/
+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), {
+		[CLEANUP_TIMEOUT_KEY]: timeout,
+		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Registers a callback function to be executed after each test within the current suite has completed.
+* This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
+*
+* **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @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 afterEach to delete temporary files created during a test
+* afterEach(async () => {
+*   await fileSystem.deleteTempFiles();
+* });
+* ```
+*/
+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));
+}
+/**
+* Registers a callback function to be executed when a test fails within the current suite.
+* This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.
+*
+* **Note:** The `onTestFailed` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed upon a test failure. The function receives the test result (including errors).
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @throws {Error} Throws an error if the function is not called within a test.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using onTestFailed to log failure details
+* onTestFailed(({ errors }) => {
+*   console.log(`Test failed: ${test.name}`, errors);
+* });
+* ```
+*/
+const onTestFailed = createTestHook("onTestFailed", (test, handler, timeout) => {
+	test.onFailed || (test.onFailed = []);
+	test.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+});
+/**
+* Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).
+* This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.
+*
+* This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.
+*
+* **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* **Note:** The `onTestFinished` hook is not called if the test is canceled with a dynamic `ctx.skip()` call.
+*
+* @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @throws {Error} Throws an error if the function is not called within a test.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using onTestFinished for cleanup
+* const db = await connectToDatabase();
+* onTestFinished(async () => {
+*   await db.disconnect();
+* });
+* ```
+*/
+const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout) => {
+	test.onFinished || (test.onFinished = []);
+	test.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+});
+function createTestHook(name, handler) {
+	return (fn, timeout) => {
+		assertTypes(fn, `"${name}" callback`, ["function"]);
+		const current = getCurrentTest();
+		if (!current) {
+			throw new Error(`Hook ${name}() can only be called inside a test`);
+		}
+		return handler(current, fn, timeout);
+	};
+}
+
 /**
 * Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
 * Suites can contain both tests and other suites, enabling complex test structures.
@@ -610,7 +768,8 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 			repeats: options.repeats,
 			mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
 			meta: options.meta ?? Object.create(null),
-			annotations: []
+			annotations: [],
+			artifacts: []
 		};
 		const handler = options.handler;
 		if (task.mode === "run" && !handler) {
@@ -1015,86 +1174,264 @@ function formatTemplateString(cases, args) {
 	return res;
 }
 
-const now$2 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
-async function collectTests(specs, runner) {
-	const files = [];
-	const config = runner.config;
-	for (const spec of specs) {
-		var _runner$onCollectStar;
-		const filepath = typeof spec === "string" ? spec : spec.filepath;
-		const testLocations = typeof spec === "string" ? undefined : spec.testLocations;
-		const file = createFileTask(filepath, config.root, config.name, runner.pool);
-		setFileContext(file, Object.create(null));
-		file.shuffle = config.sequence.shuffle;
-		(_runner$onCollectStar = runner.onCollectStart) === null || _runner$onCollectStar === void 0 ? void 0 : _runner$onCollectStar.call(runner, file);
-		clearCollectorContext(filepath, runner);
-		try {
-			var _runner$getImportDura;
-			const setupFiles = toArray(config.setupFiles);
-			if (setupFiles.length) {
-				const setupStart = now$2();
-				await runSetupFiles(config, setupFiles, runner);
-				const setupEnd = now$2();
-				file.setupDuration = setupEnd - setupStart;
-			} else {
-				file.setupDuration = 0;
-			}
-			const collectStart = now$2();
-			await runner.importFile(filepath, "collect");
-			const durations = (_runner$getImportDura = runner.getImportDurations) === null || _runner$getImportDura === void 0 ? void 0 : _runner$getImportDura.call(runner);
-			if (durations) {
-				file.importDurations = durations;
+const now$2 = Date.now;
+const collectorContext = {
+	tasks: [],
+	currentSuite: null
+};
+function collectTask(task) {
+	var _collectorContext$cur;
+	(_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.tasks.push(task);
+}
+async function runWithSuite(suite, fn) {
+	const prev = collectorContext.currentSuite;
+	collectorContext.currentSuite = suite;
+	await fn();
+	collectorContext.currentSuite = prev;
+}
+function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
+	if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
+		return fn;
+	}
+	const { setTimeout, clearTimeout } = getSafeTimers();
+	// this function name is used to filter error in test/cli/test/fails.test.ts
+	return (function runWithTimeout(...args) {
+		const startTime = now$2();
+		const runner = getRunner();
+		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);
+			function rejectTimeoutError() {
+				const error = makeTimeoutError(isHook, timeout, stackTraceError);
+				onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(args, error);
+				reject_(error);
 			}
-			const defaultTasks = await getDefaultSuite().collect(file);
-			const fileHooks = createSuiteHooks();
-			mergeHooks(fileHooks, getHooks(defaultTasks));
-			for (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) {
-				if (c.type === "test" || c.type === "suite") {
-					file.tasks.push(c);
-				} else if (c.type === "collector") {
-					const suite = await c.collect(file);
-					if (suite.name || suite.tasks.length) {
-						mergeHooks(fileHooks, getHooks(suite));
-						file.tasks.push(suite);
-					}
-				} else {
-					// check that types are exhausted
-					c;
+			function resolve(result) {
+				runner._currentTaskStartTime = undefined;
+				runner._currentTaskTimeout = undefined;
+				clearTimeout(timer);
+				// if test/hook took too long in microtask, setTimeout won't be triggered,
+				// but we still need to fail the test, see
+				// https://github.com/vitest-dev/vitest/issues/2920
+				if (now$2() - startTime >= timeout) {
+					rejectTimeoutError();
+					return;
 				}
+				resolve_(result);
 			}
-			setHooks(file, fileHooks);
-			file.collectDuration = now$2() - collectStart;
-		} catch (e) {
-			var _runner$getImportDura2;
-			const error = processError(e);
-			file.result = {
-				state: "fail",
-				errors: [error]
-			};
-			const durations = (_runner$getImportDura2 = runner.getImportDurations) === null || _runner$getImportDura2 === void 0 ? void 0 : _runner$getImportDura2.call(runner);
-			if (durations) {
-				file.importDurations = durations;
+			function reject(error) {
+				runner._currentTaskStartTime = undefined;
+				runner._currentTaskTimeout = undefined;
+				clearTimeout(timer);
+				reject_(error);
 			}
-		}
-		calculateSuiteHash(file);
-		const hasOnlyTasks = someTasksAreOnly(file);
-		interpretTaskModes(file, config.testNamePattern, testLocations, hasOnlyTasks, false, config.allowOnly);
-		if (file.mode === "queued") {
-			file.mode = "run";
-		}
-		files.push(file);
-	}
-	return files;
-}
-function mergeHooks(baseHooks, hooks) {
-	for (const _key in hooks) {
-		const key = _key;
-		baseHooks[key].push(...hooks[key]);
-	}
-	return baseHooks;
+			// sync test/hook will be caught by try/catch
+			try {
+				const result = fn(...args);
+				// the result is a thenable, we don't wrap this in Promise.resolve
+				// to avoid creating new promises
+				if (typeof result === "object" && result != null && typeof result.then === "function") {
+					result.then(resolve, reject);
+				} else {
+					resolve(result);
+				}
+			} 
+			// user sync test/hook throws an error
+catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
+const abortControllers = new WeakMap();
+function abortIfTimeout([context], error) {
+	if (context) {
+		abortContextSignal(context, error);
+	}
+}
+function abortContextSignal(context, error) {
+	const abortController = abortControllers.get(context);
+	abortController === null || abortController === void 0 ? void 0 : abortController.abort(error);
+}
+function createTestContext(test, runner) {
+	var _runner$extendTaskCon;
+	const context = function() {
+		throw new Error("done() callback is deprecated, use promise instead");
+	};
+	let abortController = abortControllers.get(context);
+	if (!abortController) {
+		abortController = new AbortController();
+		abortControllers.set(context, abortController);
+	}
+	context.signal = abortController.signal;
+	context.task = test;
+	context.skip = (condition, note) => {
+		if (condition === false) {
+			// do nothing
+			return undefined;
+		}
+		test.result ?? (test.result = { state: "skip" });
+		test.result.pending = true;
+		throw new PendingError("test is skipped; abort execution", test, typeof condition === "string" ? condition : note);
+	};
+	context.annotate = ((message, type, attachment) => {
+		if (test.result && test.result.state !== "run") {
+			throw new Error(`Cannot annotate tests outside of the test run. The test "${test.name}" finished running with the "${test.result.state}" state already.`);
+		}
+		const annotation = {
+			message,
+			type: typeof type === "object" || type === undefined ? "notice" : type
+		};
+		const annotationAttachment = typeof type === "object" ? type : attachment;
+		if (annotationAttachment) {
+			annotation.attachment = annotationAttachment;
+			manageArtifactAttachment(annotation.attachment);
+		}
+		return recordAsyncOperation(test, recordArtifact(test, {
+			type: "internal:annotation",
+			annotation
+		}).then(async ({ annotation }) => {
+			if (!runner.onTestAnnotate) {
+				throw new Error(`Test runner doesn't support test annotations.`);
+			}
+			await finishSendTasksUpdate(runner);
+			const resolvedAnnotation = await runner.onTestAnnotate(test, annotation);
+			test.annotations.push(resolvedAnnotation);
+			return resolvedAnnotation;
+		}));
+	});
+	context.onTestFailed = (handler, timeout) => {
+		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.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;
+}
+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) {
+		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") {
+		await Promise.all(files.map(async (fsPath) => {
+			await runner.importFile(fsPath, "setup");
+		}));
+	} else {
+		for (const fsPath of files) {
+			await runner.importFile(fsPath, "setup");
+		}
+	}
 }
 
 const now$1 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+async function collectTests(specs, runner) {
+	const files = [];
+	const config = runner.config;
+	const $ = runner.trace;
+	for (const spec of specs) {
+		const filepath = typeof spec === "string" ? spec : spec.filepath;
+		await $("collect_spec", { "code.file.path": filepath }, async () => {
+			var _runner$onCollectStar;
+			const testLocations = typeof spec === "string" ? undefined : spec.testLocations;
+			const file = createFileTask(filepath, config.root, config.name, runner.pool);
+			setFileContext(file, Object.create(null));
+			file.shuffle = config.sequence.shuffle;
+			(_runner$onCollectStar = runner.onCollectStart) === null || _runner$onCollectStar === void 0 ? void 0 : _runner$onCollectStar.call(runner, file);
+			clearCollectorContext(filepath, runner);
+			try {
+				var _runner$getImportDura;
+				const setupFiles = toArray(config.setupFiles);
+				if (setupFiles.length) {
+					const setupStart = now$1();
+					await runSetupFiles(config, setupFiles, runner);
+					const setupEnd = now$1();
+					file.setupDuration = setupEnd - setupStart;
+				} else {
+					file.setupDuration = 0;
+				}
+				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);
+				if (durations) {
+					file.importDurations = durations;
+				}
+				const defaultTasks = await getDefaultSuite().collect(file);
+				const fileHooks = createSuiteHooks();
+				mergeHooks(fileHooks, getHooks(defaultTasks));
+				for (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) {
+					if (c.type === "test" || c.type === "suite") {
+						file.tasks.push(c);
+					} else if (c.type === "collector") {
+						const suite = await c.collect(file);
+						if (suite.name || suite.tasks.length) {
+							mergeHooks(fileHooks, getHooks(suite));
+							file.tasks.push(suite);
+						}
+					} else {
+						// check that types are exhausted
+						c;
+					}
+				}
+				setHooks(file, fileHooks);
+				file.collectDuration = now$1() - collectStart;
+			} catch (e) {
+				var _runner$getImportDura2;
+				const error = processError(e);
+				file.result = {
+					state: "fail",
+					errors: [error]
+				};
+				const durations = (_runner$getImportDura2 = runner.getImportDurations) === null || _runner$getImportDura2 === void 0 ? void 0 : _runner$getImportDura2.call(runner);
+				if (durations) {
+					file.importDurations = durations;
+				}
+			}
+			calculateSuiteHash(file);
+			const hasOnlyTasks = someTasksAreOnly(file);
+			interpretTaskModes(file, config.testNamePattern, testLocations, hasOnlyTasks, false, config.allowOnly);
+			if (file.mode === "queued") {
+				file.mode = "run";
+			}
+			files.push(file);
+		});
+	}
+	return files;
+}
+function mergeHooks(baseHooks, hooks) {
+	for (const _key in hooks) {
+		const key = _key;
+		baseHooks[key].push(...hooks[key]);
+	}
+	return baseHooks;
+}
+
+const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const unixNow = Date.now;
 const { clearTimeout, setTimeout } = getSafeTimers();
 function updateSuiteHookState(task, name, state, runner) {
@@ -1275,7 +1612,7 @@ async function runTest(test, runner) {
 		updateTask("test-failed-early", test, runner);
 		return;
 	}
-	const start = now$1();
+	const start = now();
 	test.result = {
 		state: "run",
 		startTime: unixNow(),
@@ -1285,11 +1622,12 @@ async function runTest(test, runner) {
 	const cleanupRunningTest = addRunningTest(test);
 	setCurrentTest(test);
 	const suite = test.suite || test.file;
+	const $ = runner.trace;
 	const repeats = test.repeats ?? 0;
 	for (let repeatCount = 0; repeatCount <= repeats; repeatCount++) {
 		const retry = test.retry ?? 0;
 		for (let retryCount = 0; retryCount <= retry; retryCount++) {
-			var _runner$onAfterRetryT, _test$result2, _test$result3;
+			var _test$onFinished, _test$onFailed, _runner$onAfterRetryT, _test$result2, _test$result3;
 			let beforeEachCleanups = [];
 			try {
 				var _runner$onBeforeTryTa, _runner$onAfterTryTas;
@@ -1298,15 +1636,15 @@ async function runTest(test, runner) {
 					repeats: repeatCount
 				}));
 				test.result.repeatCount = repeatCount;
-				beforeEachCleanups = await callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]);
+				beforeEachCleanups = await $("test.beforeEach", () => callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]));
 				if (runner.runTask) {
-					await runner.runTask(test);
+					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 fn();
+					await $("test.callback", () => fn());
 				}
 				await ((_runner$onAfterTryTas = runner.onAfterTryTask) === null || _runner$onAfterTryTas === void 0 ? void 0 : _runner$onAfterTryTas.call(runner, test, {
 					retry: retryCount,
@@ -1329,15 +1667,19 @@ async function runTest(test, runner) {
 				failTask(test.result, e, runner.config.diffOptions);
 			}
 			try {
-				await callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]);
-				await callCleanupHooks(runner, beforeEachCleanups);
+				await $("test.afterEach", () => callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]));
+				if (beforeEachCleanups.length) {
+					await $("test.cleanup", () => callCleanupHooks(runner, beforeEachCleanups));
+				}
 				await callFixtureCleanup(test.context);
 			} catch (e) {
 				failTask(test.result, e, runner.config.diffOptions);
 			}
-			await callTestHooks(runner, test, test.onFinished || [], "stack");
-			if (test.result.state === "fail") {
-				await callTestHooks(runner, test, test.onFailed || [], runner.config.sequence.hooks);
+			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;
@@ -1353,7 +1695,7 @@ async function runTest(test, runner) {
 					state: "skip",
 					note: (_test$result4 = test.result) === null || _test$result4 === void 0 ? void 0 : _test$result4.note,
 					pending: true,
-					duration: now$1() - start
+					duration: now() - start
 				};
 				updateTask("test-finished", test, runner);
 				setCurrentTest(undefined);
@@ -1385,7 +1727,7 @@ async function runTest(test, runner) {
 	}
 	cleanupRunningTest();
 	setCurrentTest(undefined);
-	test.result.duration = now$1() - start;
+	test.result.duration = now() - start;
 	await ((_runner$onAfterRunTas = runner.onAfterRunTask) === null || _runner$onAfterRunTas === void 0 ? void 0 : _runner$onAfterRunTas.call(runner, test));
 	updateTask("test-finished", test, runner);
 }
@@ -1426,12 +1768,13 @@ async function runSuite(suite, runner) {
 		updateTask("suite-failed-early", suite, runner);
 		return;
 	}
-	const start = now$1();
+	const start = now();
 	const mode = suite.mode;
 	suite.result = {
 		state: mode === "skip" || mode === "todo" ? mode : "run",
 		startTime: unixNow()
 	};
+	const $ = runner.trace;
 	updateTask("suite-prepare", suite, runner);
 	let beforeAllCleanups = [];
 	if (suite.mode === "skip") {
@@ -1444,7 +1787,7 @@ async function runSuite(suite, runner) {
 		var _runner$onAfterRunSui;
 		try {
 			try {
-				beforeAllCleanups = await callSuiteHook(suite, suite, "beforeAll", runner, [suite]);
+				beforeAllCleanups = await $("suite.beforeAll", () => callSuiteHook(suite, suite, "beforeAll", runner, [suite]));
 			} catch (e) {
 				markTasksAsSkipped(suite, runner);
 				throw e;
@@ -1474,8 +1817,10 @@ async function runSuite(suite, runner) {
 			failTask(suite.result, e, runner.config.diffOptions);
 		}
 		try {
-			await callSuiteHook(suite, suite, "afterAll", runner, [suite]);
-			await callCleanupHooks(runner, beforeAllCleanups);
+			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);
@@ -1497,17 +1842,37 @@ async function runSuite(suite, runner) {
 				suite.result.state = "pass";
 			}
 		}
-		suite.result.duration = now$1() - start;
+		suite.result.duration = now() - start;
 		await ((_runner$onAfterRunSui = runner.onAfterRunSuite) === null || _runner$onAfterRunSui === void 0 ? void 0 : _runner$onAfterRunSui.call(runner, suite));
 		updateTask("suite-finished", suite, runner);
 	}
 }
 let limitMaxConcurrency;
 async function runSuiteChild(c, runner) {
+	const $ = runner.trace;
 	if (c.type === "test") {
-		return limitMaxConcurrency(() => runTest(c, runner));
+		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));
+		});
 	} else if (c.type === "suite") {
-		return runSuite(c, runner);
+		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
+		}, () => runSuite(c, runner));
 	}
 }
 async function runFiles(files, runner) {
@@ -1523,12 +1888,22 @@ async function runFiles(files, runner) {
 				};
 			}
 		}
-		await runSuite(file, runner);
+		await runner.trace("run.spec", {
+			"code.file.path": file.filepath,
+			"vitest.suite.tasks.length": file.tasks.length
+		}, () => runSuite(file, runner));
 	}
 }
 const workerRunners = new WeakSet();
+function defaultTrace(_, attributes, cb) {
+	if (typeof attributes === "function") {
+		return attributes();
+	}
+	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);
 	// 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)
@@ -1566,6 +1941,7 @@ async function startTests(specs, runner) {
 }
 async function publicCollect(specs, runner) {
 	var _runner$onBeforeColle2, _runner$onCollected2;
+	runner.trace ?? (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));
 	const files = await collectTests(specs, runner);
@@ -1573,189 +1949,72 @@ async function publicCollect(specs, runner) {
 	return files;
 }
 
-const now = Date.now;
-const collectorContext = {
-	tasks: [],
-	currentSuite: null
-};
-function collectTask(task) {
-	var _collectorContext$cur;
-	(_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.tasks.push(task);
-}
-async function runWithSuite(suite, fn) {
-	const prev = collectorContext.currentSuite;
-	collectorContext.currentSuite = suite;
-	await fn();
-	collectorContext.currentSuite = prev;
-}
-function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
-	if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
-		return fn;
-	}
-	const { setTimeout, clearTimeout } = getSafeTimers();
-	// this function name is used to filter error in test/cli/test/fails.test.ts
-	return (function runWithTimeout(...args) {
-		const startTime = now();
-		const runner = getRunner();
-		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);
-			function rejectTimeoutError() {
-				const error = makeTimeoutError(isHook, timeout, stackTraceError);
-				onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(args, error);
-				reject_(error);
-			}
-			function resolve(result) {
-				runner._currentTaskStartTime = undefined;
-				runner._currentTaskTimeout = undefined;
-				clearTimeout(timer);
-				// if test/hook took too long in microtask, setTimeout won't be triggered,
-				// but we still need to fail the test, see
-				// https://github.com/vitest-dev/vitest/issues/2920
-				if (now() - startTime >= timeout) {
-					rejectTimeoutError();
-					return;
-				}
-				resolve_(result);
-			}
-			function reject(error) {
-				runner._currentTaskStartTime = undefined;
-				runner._currentTaskTimeout = undefined;
-				clearTimeout(timer);
-				reject_(error);
-			}
-			// sync test/hook will be caught by try/catch
-			try {
-				const result = fn(...args);
-				// the result is a thenable, we don't wrap this in Promise.resolve
-				// to avoid creating new promises
-				if (typeof result === "object" && result != null && typeof result.then === "function") {
-					result.then(resolve, reject);
-				} else {
-					resolve(result);
-				}
-			} 
-			// user sync test/hook throws an error
-catch (error) {
-				reject(error);
-			}
-		});
-	});
-}
-const abortControllers = new WeakMap();
-function abortIfTimeout([context], error) {
-	if (context) {
-		abortContextSignal(context, error);
-	}
-}
-function abortContextSignal(context, error) {
-	const abortController = abortControllers.get(context);
-	abortController === null || abortController === void 0 ? void 0 : abortController.abort(error);
-}
-function createTestContext(test, runner) {
-	var _runner$extendTaskCon;
-	const context = function() {
-		throw new Error("done() callback is deprecated, use promise instead");
-	};
-	let abortController = abortControllers.get(context);
-	if (!abortController) {
-		abortController = new AbortController();
-		abortControllers.set(context, abortController);
-	}
-	context.signal = abortController.signal;
-	context.task = test;
-	context.skip = (condition, note) => {
-		if (condition === false) {
-			// do nothing
-			return undefined;
-		}
-		test.result ?? (test.result = { state: "skip" });
-		test.result.pending = true;
-		throw new PendingError("test is skipped; abort execution", test, typeof condition === "string" ? condition : note);
-	};
-	async function annotate(message, location, type, attachment) {
-		const annotation = {
-			message,
-			type: type || "notice"
+/**
+* @experimental
+* @advanced
+*
+* Records a custom test artifact during test execution.
+*
+* This function allows you to attach structured data, files, or metadata to a test.
+*
+* Vitest automatically injects the source location where the artifact was created and manages any attachments you include.
+*
+* @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
+* ```ts
+* // In a custom assertion
+* async function toHaveValidSchema(this: MatcherState, actual: unknown) {
+*   const validation = validateSchema(actual)
+*
+*   await recordArtifact(this.task, {
+*     type: 'my-plugin:schema-validation',
+*     passed: validation.valid,
+*     errors: validation.errors,
+*   })
+*
+*   return { pass: validation.valid, message: () => '...' }
+* }
+* ```
+*/
+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 = {
+			file: stack.file,
+			line: stack.line,
+			column: stack.column
 		};
-		if (attachment) {
-			if (attachment.body == null && !attachment.path) {
-				throw new TypeError(`Test attachment requires "body" or "path" to be set. Both are missing.`);
-			}
-			if (attachment.body && attachment.path) {
-				throw new TypeError(`Test attachment requires only one of "body" or "path" to be set. Both are specified.`);
-			}
-			annotation.attachment = attachment;
-			// convert to a string so it's easier to serialise
-			if (attachment.body instanceof Uint8Array) {
-				attachment.body = encodeUint8Array(attachment.body);
-			}
-		}
-		if (location) {
-			annotation.location = location;
-		}
-		if (!runner.onTestAnnotate) {
-			throw new Error(`Test runner doesn't support test annotations.`);
+		if (artifact.type === "internal:annotation") {
+			artifact.annotation.location = artifact.location;
 		}
-		await finishSendTasksUpdate(runner);
-		const resolvedAnnotation = await runner.onTestAnnotate(test, annotation);
-		test.annotations.push(resolvedAnnotation);
-		return resolvedAnnotation;
 	}
-	context.annotate = ((message, type, attachment) => {
-		if (test.result && test.result.state !== "run") {
-			throw new Error(`Cannot annotate tests outside of the test run. The test "${test.name}" finished running with the "${test.result.state}" state already.`);
+	if (Array.isArray(artifact.attachments)) {
+		for (const attachment of artifact.attachments) {
+			manageArtifactAttachment(attachment);
 		}
-		const stack = findTestFileStackTrace(test.file.filepath, new Error("STACK_TRACE").stack);
-		let location;
-		if (stack) {
-			location = {
-				file: stack.file,
-				line: stack.line,
-				column: stack.column
-			};
-		}
-		if (typeof type === "object") {
-			return recordAsyncAnnotation(test, annotate(message, location, undefined, type));
-		} else {
-			return recordAsyncAnnotation(test, annotate(message, location, type, attachment));
-		}
-	});
-	context.onTestFailed = (handler, timeout) => {
-		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.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;
-}
-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) {
-		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}`);
+	// annotations won't resolve as artifacts for backwards compatibility until next major
+	if (artifact.type === "internal:annotation") {
+		return artifact;
 	}
-	return context;
-}
-function setFileContext(file, context) {
-	fileContexts.set(file, context);
+	if (!runner.onTestArtifactRecord) {
+		throw new Error(`Test runner doesn't support test artifacts.`);
+	}
+	await finishSendTasksUpdate(runner);
+	const resolvedArtifact = await runner.onTestArtifactRecord(task, artifact);
+	task.artifacts.push(resolvedArtifact);
+	return resolvedArtifact;
 }
 const table = [];
 for (let i = 65; i < 91; i++) {
@@ -1799,7 +2058,13 @@ function encodeUint8Array(bytes) {
 	}
 	return base64;
 }
-function recordAsyncAnnotation(test, promise) {
+/**
+* Records an async operation associated with a test task.
+*
+* This function tracks promises that should be awaited before a test completes.
+* The promise is automatically removed from the test's promise list once it settles.
+*/
+function recordAsyncOperation(test, promise) {
 	// if promise is explicitly awaited, remove it from the list
 	promise = promise.finally(() => {
 		if (!test.promises) {
@@ -1817,175 +2082,27 @@ function recordAsyncAnnotation(test, promise) {
 	test.promises.push(promise);
 	return promise;
 }
-
-function getDefaultHookTimeout() {
-	return getRunner().config.hookTimeout;
-}
-const CLEANUP_TIMEOUT_KEY = Symbol.for("VITEST_CLEANUP_TIMEOUT");
-const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_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();
-		const stackTraceError = CLEANUP_STACK_TRACE_KEY in hook && hook[CLEANUP_STACK_TRACE_KEY] instanceof Error ? hook[CLEANUP_STACK_TRACE_KEY] : undefined;
-		return withTimeout(result, timeout, true, stackTraceError, (_, error) => {
-			if (context) {
-				abortContextSignal(context, error);
-			}
-		});
-	}
-}
-/**
-* Registers a callback function to be executed once before all tests within the current suite.
-* This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
-*
-* **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
-*
-* @param {Function} fn - The callback function to be executed before all 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 beforeAll to set up a database connection
-* beforeAll(async () => {
-*   await database.connect();
-* });
-* ```
-*/
-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), {
-		[CLEANUP_TIMEOUT_KEY]: timeout,
-		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
-	}));
-}
-/**
-* Registers a callback function to be executed once after all tests within the current suite have completed.
-* This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
-*
-* **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
-*
-* @param {Function} fn - The callback function to be executed after all 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 afterAll to close a database connection
-* afterAll(async () => {
-*   await database.disconnect();
-* });
-* ```
-*/
-function afterAll(fn, timeout) {
-	assertTypes(fn, "\"afterAll\" callback", ["function"]);
-	return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR")));
-}
 /**
-* Registers a callback function to be executed before each test within the current suite.
-* This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+* Validates and prepares a test attachment for serialization.
 *
-* **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+* This function ensures attachments have either `body` or `path` set (but not both), and converts `Uint8Array` bodies to base64-encoded strings for easier serialization.
 *
-* @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
-* @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 beforeEach to reset a database state
-* beforeEach(async () => {
-*   await database.reset();
-* });
-* ```
-*/
-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), {
-		[CLEANUP_TIMEOUT_KEY]: timeout,
-		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
-	}));
-}
-/**
-* Registers a callback function to be executed after each test within the current suite has completed.
-* This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
-*
-* **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+* @param attachment - The attachment to validate and prepare
 *
-* @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
-* @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 afterEach to delete temporary files created during a test
-* afterEach(async () => {
-*   await fileSystem.deleteTempFiles();
-* });
-* ```
+* @throws {TypeError} If neither `body` nor `path` is provided
+* @throws {TypeError} If both `body` and `path` are provided
 */
-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));
-}
-/**
-* Registers a callback function to be executed when a test fails within the current suite.
-* This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.
-*
-* **Note:** The `onTestFailed` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
-*
-* @param {Function} fn - The callback function to be executed upon a test failure. The function receives the test result (including errors).
-* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
-* @throws {Error} Throws an error if the function is not called within a test.
-* @returns {void}
-* @example
-* ```ts
-* // Example of using onTestFailed to log failure details
-* onTestFailed(({ errors }) => {
-*   console.log(`Test failed: ${test.name}`, errors);
-* });
-* ```
-*/
-const onTestFailed = createTestHook("onTestFailed", (test, handler, timeout) => {
-	test.onFailed || (test.onFailed = []);
-	test.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
-});
-/**
-* Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).
-* This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.
-*
-* This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.
-*
-* **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
-*
-* **Note:** The `onTestFinished` hook is not called if the test is canceled with a dynamic `ctx.skip()` call.
-*
-* @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
-* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
-* @throws {Error} Throws an error if the function is not called within a test.
-* @returns {void}
-* @example
-* ```ts
-* // Example of using onTestFinished for cleanup
-* const db = await connectToDatabase();
-* onTestFinished(async () => {
-*   await db.disconnect();
-* });
-* ```
-*/
-const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout) => {
-	test.onFinished || (test.onFinished = []);
-	test.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
-});
-function createTestHook(name, handler) {
-	return (fn, timeout) => {
-		assertTypes(fn, `"${name}" callback`, ["function"]);
-		const current = getCurrentTest();
-		if (!current) {
-			throw new Error(`Hook ${name}() can only be called inside a test`);
-		}
-		return handler(current, fn, timeout);
-	};
+function manageArtifactAttachment(attachment) {
+	if (attachment.body == null && !attachment.path) {
+		throw new TypeError(`Test attachment requires "body" or "path" to be set. Both are missing.`);
+	}
+	if (attachment.body && attachment.path) {
+		throw new TypeError(`Test attachment requires only one of "body" or "path" to be set. Both are specified.`);
+	}
+	// convert to a string so it's easier to serialise
+	if (attachment.body instanceof Uint8Array) {
+		attachment.body = encodeUint8Array(attachment.body);
+	}
 }
 
-export { afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };
+export { afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, recordArtifact, setFn, setHooks, startTests, suite, test, updateTask };