@vitest/runner 4.0.0-beta.9 → 4.0.1

package/dist/chunk-tasks.js

@@ -0,0 +1,332 @@
+import { processError } from '@vitest/utils/error';
+import { parseSingleStack } from '@vitest/utils/source-map';
+import { relative } from 'pathe';
+import { toArray } from '@vitest/utils/helpers';
+
+function createChainable(keys, fn) {
+	function create(context) {
+		const chain = function(...args) {
+			return fn.apply(context, args);
+		};
+		Object.assign(chain, fn);
+		chain.withContext = () => chain.bind(context);
+		chain.setContext = (key, value) => {
+			context[key] = value;
+		};
+		chain.mergeContext = (ctx) => {
+			Object.assign(context, ctx);
+		};
+		for (const key of keys) {
+			Object.defineProperty(chain, key, { get() {
+				return create({
+					...context,
+					[key]: true
+				});
+			} });
+		}
+		return chain;
+	}
+	const chain = create({});
+	chain.fn = fn;
+	return chain;
+}
+
+/**
+* If any tasks been marked as `only`, mark all other tasks as `skip`.
+*/
+function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIsOnly, allowOnly) {
+	const matchedLocations = [];
+	const traverseSuite = (suite, parentIsOnly, parentMatchedWithLocation) => {
+		const suiteIsOnly = parentIsOnly || suite.mode === "only";
+		suite.tasks.forEach((t) => {
+			// Check if either the parent suite or the task itself are marked as included
+			const includeTask = suiteIsOnly || t.mode === "only";
+			if (onlyMode) {
+				if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
+					// Don't skip this suite
+					if (t.mode === "only") {
+						checkAllowOnly(t, allowOnly);
+						t.mode = "run";
+					}
+				} else if (t.mode === "run" && !includeTask) {
+					t.mode = "skip";
+				} else if (t.mode === "only") {
+					checkAllowOnly(t, allowOnly);
+					t.mode = "run";
+				}
+			}
+			let hasLocationMatch = parentMatchedWithLocation;
+			// Match test location against provided locations, only run if present
+			// in `testLocations`. Note: if `includeTaskLocations` is not enabled,
+			// all test will be skipped.
+			if (testLocations !== undefined && testLocations.length !== 0) {
+				if (t.location && (testLocations === null || testLocations === void 0 ? void 0 : testLocations.includes(t.location.line))) {
+					t.mode = "run";
+					matchedLocations.push(t.location.line);
+					hasLocationMatch = true;
+				} else if (parentMatchedWithLocation) {
+					t.mode = "run";
+				} else if (t.type === "test") {
+					t.mode = "skip";
+				}
+			}
+			if (t.type === "test") {
+				if (namePattern && !getTaskFullName(t).match(namePattern)) {
+					t.mode = "skip";
+				}
+			} else if (t.type === "suite") {
+				if (t.mode === "skip") {
+					skipAllTasks(t);
+				} else if (t.mode === "todo") {
+					todoAllTasks(t);
+				} else {
+					traverseSuite(t, includeTask, hasLocationMatch);
+				}
+			}
+		});
+		// if all subtasks are skipped, mark as skip
+		if (suite.mode === "run" || suite.mode === "queued") {
+			if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run" && i.mode !== "queued")) {
+				suite.mode = "skip";
+			}
+		}
+	};
+	traverseSuite(file, parentIsOnly, false);
+	const nonMatching = testLocations === null || testLocations === void 0 ? void 0 : testLocations.filter((loc) => !matchedLocations.includes(loc));
+	if (nonMatching && nonMatching.length !== 0) {
+		const message = nonMatching.length === 1 ? `line ${nonMatching[0]}` : `lines ${nonMatching.join(", ")}`;
+		if (file.result === undefined) {
+			file.result = {
+				state: "fail",
+				errors: []
+			};
+		}
+		if (file.result.errors === undefined) {
+			file.result.errors = [];
+		}
+		file.result.errors.push(processError(new Error(`No test found in ${file.name} in ${message}`)));
+	}
+}
+function getTaskFullName(task) {
+	return `${task.suite ? `${getTaskFullName(task.suite)} ` : ""}${task.name}`;
+}
+function someTasksAreOnly(suite) {
+	return suite.tasks.some((t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t));
+}
+function skipAllTasks(suite) {
+	suite.tasks.forEach((t) => {
+		if (t.mode === "run" || t.mode === "queued") {
+			t.mode = "skip";
+			if (t.type === "suite") {
+				skipAllTasks(t);
+			}
+		}
+	});
+}
+function todoAllTasks(suite) {
+	suite.tasks.forEach((t) => {
+		if (t.mode === "run" || t.mode === "queued") {
+			t.mode = "todo";
+			if (t.type === "suite") {
+				todoAllTasks(t);
+			}
+		}
+	});
+}
+function checkAllowOnly(task, allowOnly) {
+	if (allowOnly) {
+		return;
+	}
+	const error = processError(new Error("[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"));
+	task.result = {
+		state: "fail",
+		errors: [error]
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function generateHash(str) {
+	let hash = 0;
+	if (str.length === 0) {
+		return `${hash}`;
+	}
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return `${hash}`;
+}
+function calculateSuiteHash(parent) {
+	parent.tasks.forEach((t, idx) => {
+		t.id = `${parent.id}_${idx}`;
+		if (t.type === "suite") {
+			calculateSuiteHash(t);
+		}
+	});
+}
+function createFileTask(filepath, root, projectName, pool) {
+	const path = relative(root, filepath);
+	const file = {
+		id: generateFileHash(path, projectName),
+		name: path,
+		type: "suite",
+		mode: "queued",
+		filepath,
+		tasks: [],
+		meta: Object.create(null),
+		projectName,
+		file: undefined,
+		pool
+	};
+	file.file = file;
+	return file;
+}
+/**
+* Generate a unique ID for a file based on its path and project name
+* @param file File relative to the root of the project to keep ID the same between different machines
+* @param projectName The name of the test project
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function generateFileHash(file, projectName) {
+	return /* @__PURE__ */ generateHash(`${file}${projectName || ""}`);
+}
+function findTestFileStackTrace(testFilePath, error) {
+	// first line is the error message
+	const lines = error.split("\n").slice(1);
+	for (const line of lines) {
+		const stack = parseSingleStack(line);
+		if (stack && stack.file === testFilePath) {
+			return stack;
+		}
+	}
+}
+
+/**
+* Return a function for running multiple async operations with limited concurrency.
+*/
+function limitConcurrency(concurrency = Infinity) {
+	// The number of currently active + pending tasks.
+	let count = 0;
+	// The head and tail of the pending task queue, built using a singly linked list.
+	// Both head and tail are initially undefined, signifying an empty queue.
+	// They both become undefined again whenever there are no pending tasks.
+	let head;
+	let tail;
+	// A bookkeeping function executed whenever a task has been run to completion.
+	const finish = () => {
+		count--;
+		// Check if there are further pending tasks in the queue.
+		if (head) {
+			// Allow the next pending task to run and pop it from the queue.
+			head[0]();
+			head = head[1];
+			// The head may now be undefined if there are no further pending tasks.
+			// In that case, set tail to undefined as well.
+			tail = head && tail;
+		}
+	};
+	return (func, ...args) => {
+		// Create a promise chain that:
+		//  1. Waits for its turn in the task queue (if necessary).
+		//  2. Runs the task.
+		//  3. Allows the next pending task (if any) to run.
+		return new Promise((resolve) => {
+			if (count++ < concurrency) {
+				// No need to queue if fewer than maxConcurrency tasks are running.
+				resolve();
+			} else if (tail) {
+				// There are pending tasks, so append to the queue.
+				tail = tail[1] = [resolve];
+			} else {
+				// No other pending tasks, initialize the queue with a new tail and head.
+				head = tail = [resolve];
+			}
+		}).then(() => {
+			// Running func here ensures that even a non-thenable result or an
+			// immediately thrown error gets wrapped into a Promise.
+			return func(...args);
+		}).finally(finish);
+	};
+}
+
+/**
+* Partition in tasks groups by consecutive concurrent
+*/
+function partitionSuiteChildren(suite) {
+	let tasksGroup = [];
+	const tasksGroups = [];
+	for (const c of suite.tasks) {
+		if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {
+			tasksGroup.push(c);
+		} else {
+			tasksGroups.push(tasksGroup);
+			tasksGroup = [c];
+		}
+	}
+	if (tasksGroup.length > 0) {
+		tasksGroups.push(tasksGroup);
+	}
+	return tasksGroups;
+}
+
+function isTestCase(s) {
+	return s.type === "test";
+}
+function getTests(suite) {
+	const tests = [];
+	const arraySuites = toArray(suite);
+	for (const s of arraySuites) {
+		if (isTestCase(s)) {
+			tests.push(s);
+		} else {
+			for (const task of s.tasks) {
+				if (isTestCase(task)) {
+					tests.push(task);
+				} else {
+					const taskTests = getTests(task);
+					for (const test of taskTests) {
+						tests.push(test);
+					}
+				}
+			}
+		}
+	}
+	return tests;
+}
+function getTasks(tasks = []) {
+	return toArray(tasks).flatMap((s) => isTestCase(s) ? [s] : [s, ...getTasks(s.tasks)]);
+}
+function getSuites(suite) {
+	return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+}
+function hasTests(suite) {
+	return toArray(suite).some((s) => s.tasks.some((c) => isTestCase(c) || hasTests(c)));
+}
+function hasFailed(suite) {
+	return toArray(suite).some((s) => {
+		var _s$result;
+		return ((_s$result = s.result) === null || _s$result === void 0 ? void 0 : _s$result.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
+	});
+}
+function getNames(task) {
+	const names = [task.name];
+	let current = task;
+	while (current === null || current === void 0 ? void 0 : current.suite) {
+		current = current.suite;
+		if (current === null || current === void 0 ? void 0 : current.name) {
+			names.unshift(current.name);
+		}
+	}
+	if (current !== task.file) {
+		names.unshift(task.file.name);
+	}
+	return names;
+}
+function getFullName(task, separator = " > ") {
+	return getNames(task).join(separator);
+}
+function getTestName(task, separator = " > ") {
+	return getNames(task).slice(1).join(separator);
+}
+
+export { calculateSuiteHash as a, createFileTask as b, createChainable as c, generateHash as d, getFullName as e, findTestFileStackTrace as f, generateFileHash as g, getNames as h, interpretTaskModes as i, getSuites as j, getTasks as k, limitConcurrency as l, getTestName as m, getTests as n, hasFailed as o, partitionSuiteChildren as p, hasTests as q, isTestCase as r, someTasksAreOnly as s };

package/dist/{tasks.d-Bsp8b7Fx.d.ts → hooks.d-C0RE9A6t.d.ts}

@@ -251,7 +251,6 @@ interface TestAnnotation {
 }
 type Task = Test | Suite | File;
 type TestFunction<ExtraContext = object> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
-// jest's ExtractEachCallbackArgs
 type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
 	1: [T[0]];
 	2: [T[0], T[1]];
@@ -266,11 +265,7 @@ type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
 	fallback: Array<T extends ReadonlyArray<infer U> ? U : any>;
 }[T extends Readonly<[any]> ? 1 : T extends Readonly<[any, any]> ? 2 : T extends Readonly<[any, any, any]> ? 3 : T extends Readonly<[any, any, any, any]> ? 4 : T extends Readonly<[any, any, any, any, any]> ? 5 : T extends Readonly<[any, any, any, any, any, any]> ? 6 : T extends Readonly<[any, any, any, any, any, any, any]> ? 7 : T extends Readonly<[any, any, any, any, any, any, any, any]> ? 8 : T extends Readonly<[any, any, any, any, any, any, any, any, any]> ? 9 : T extends Readonly<[any, any, any, any, any, any, any, any, any, any]> ? 10 : "fallback"];
 interface EachFunctionReturn<T extends any[]> {
-	/**
-	* @deprecated Use options as the second argument instead
-	*/
-	(name: string | Function, fn: (...args: T) => Awaitable<void>, options: TestCollectorOptions): void;
-	(name: string | Function, fn: (...args: T) => Awaitable<void>, options?: number | TestCollectorOptions): void;
+	(name: string | Function, fn: (...args: T) => Awaitable<void>, options?: number): void;
 	(name: string | Function, options: TestCollectorOptions, fn: (...args: T) => Awaitable<void>): void;
 }
 interface TestEachFunction {
@@ -287,14 +282,7 @@ interface TestForFunctionReturn<
 	(name: string | Function, options: TestCollectorOptions, fn: (args: Arg, context: Context) => Awaitable<void>): void;
 }
 interface TestForFunction<ExtraContext> {
-	// test.for([1, 2, 3])
-	// test.for([[1, 2], [3, 4, 5]])
 	<T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, TestContext & ExtraContext>;
-	// test.for`
-	//    a  |  b
-	//   {1} | {2}
-	//   {3} | {4}
-	// `
 	(strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, TestContext & ExtraContext>;
 }
 interface SuiteForFunction {
@@ -302,11 +290,7 @@ interface SuiteForFunction {
 	(...args: [TemplateStringsArray, ...any]): EachFunctionReturn<any[]>;
 }
 interface TestCollectorCallable<C = object> {
-	/**
-	* @deprecated Use options as the second argument instead
-	*/
-	<ExtraContext extends C>(name: string | Function, fn: TestFunction<ExtraContext>, options: TestCollectorOptions): void;
-	<ExtraContext extends C>(name: string | Function, fn?: TestFunction<ExtraContext>, options?: number | TestCollectorOptions): void;
+	<ExtraContext extends C>(name: string | Function, fn?: TestFunction<ExtraContext>, options?: number): void;
 	<ExtraContext extends C>(name: string | Function, options?: TestCollectorOptions, fn?: TestFunction<ExtraContext>): void;
 }
 type ChainableTestAPI<ExtraContext = object> = ChainableFunction<"concurrent" | "sequential" | "only" | "skip" | "todo" | "fails", TestCollectorCallable<ExtraContext>, {
@@ -368,7 +352,13 @@ interface ExtendedAPI<ExtraContext> {
 	skipIf: (condition: any) => ChainableTestAPI<ExtraContext>;
 	runIf: (condition: any) => ChainableTestAPI<ExtraContext>;
 }
-type TestAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & {
+interface Hooks<ExtraContext> {
+	beforeAll: typeof beforeAll;
+	afterAll: typeof afterAll;
+	beforeEach: typeof beforeEach<ExtraContext>;
+	afterEach: typeof afterEach<ExtraContext>;
+}
+type TestAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & Hooks<ExtraContext> & {
 	extend: <T extends Record<string, any> = object>(fixtures: Fixtures<T, ExtraContext>) => TestAPI<{ [K in keyof T | keyof ExtraContext] : K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never }>;
 	scoped: (fixtures: Fixtures<Partial<ExtraContext>>) => void;
 };
@@ -410,11 +400,7 @@ type Fixtures<
 > = { [K in keyof T] : Fixture<T, K, ExtraContext & TestContext> | [Fixture<T, K, ExtraContext & TestContext>, FixtureOptions?] };
 type InferFixturesTypes<T> = T extends TestAPI<infer C> ? C : T;
 interface SuiteCollectorCallable<ExtraContext = object> {
-	/**
-	* @deprecated Use options as the second argument instead
-	*/
-	<OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, fn: SuiteFactory<OverrideExtraContext>, options: TestOptions): SuiteCollector<OverrideExtraContext>;
-	<OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, fn?: SuiteFactory<OverrideExtraContext>, options?: number | TestOptions): SuiteCollector<OverrideExtraContext>;
+	<OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, fn?: SuiteFactory<OverrideExtraContext>, options?: number): SuiteCollector<OverrideExtraContext>;
 	<OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, options: TestOptions, fn?: SuiteFactory<OverrideExtraContext>): SuiteCollector<OverrideExtraContext>;
 }
 type ChainableSuiteAPI<ExtraContext = object> = ChainableFunction<"concurrent" | "sequential" | "only" | "skip" | "todo" | "shuffle", SuiteCollectorCallable<ExtraContext>, {
@@ -425,17 +411,6 @@ type SuiteAPI<ExtraContext = object> = ChainableSuiteAPI<ExtraContext> & {
 	skipIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
 	runIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
 };
-/**
-* @deprecated
-*/
-type HookListener<
-	T extends any[],
-	Return = void
-> = (...args: T) => Awaitable<Return>;
-/**
-* @deprecated
-*/
-type HookCleanupCallback = unknown;
 interface BeforeAllListener {
 	(suite: Readonly<Suite | File>): Awaitable<unknown>;
 }
@@ -544,5 +519,121 @@ interface TaskHook<HookListener> {
 type SequenceHooks = "stack" | "list" | "parallel";
 type SequenceSetupFiles = "list" | "parallel";
 
-export { createChainable as c };
-export type { AfterAllListener as A, BeforeAllListener as B, ChainableFunction as C, TaskResult as D, TaskResultPack as E, File as F, TaskState as G, HookCleanupCallback as H, ImportDuration as I, TestAnnotation as J, TestAnnotationLocation as K, TestAttachment as L, TestContext as M, TestFunction as N, OnTestFailedHandler as O, TestOptions as P, RunMode as R, Suite as S, Task as T, Use as U, Test as a, AfterEachListener as b, BeforeEachListener as d, TaskHook as e, OnTestFinishedHandler as f, SuiteHooks as g, TaskUpdateEvent as h, TestAPI as i, SuiteAPI as j, SuiteCollector as k, Fixture as l, FixtureFn as m, FixtureOptions as n, Fixtures as o, HookListener as p, InferFixturesTypes as q, RuntimeContext as r, SequenceHooks as s, SequenceSetupFiles as t, SuiteFactory as u, TaskBase as v, TaskCustomOptions as w, TaskEventPack as x, TaskMeta as y, TaskPopulated as z };
+/**
+* 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();
+* });
+* ```
+*/
+declare function beforeAll(fn: BeforeAllListener, timeout?: number): void;
+/**
+* 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();
+* });
+* ```
+*/
+declare function afterAll(fn: AfterAllListener, timeout?: number): void;
+/**
+* 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();
+* });
+* ```
+*/
+declare function beforeEach<ExtraContext = object>(fn: BeforeEachListener<ExtraContext>, timeout?: number): void;
+/**
+* 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();
+* });
+* ```
+*/
+declare function afterEach<ExtraContext = object>(fn: AfterEachListener<ExtraContext>, timeout?: number): void;
+/**
+* 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);
+* });
+* ```
+*/
+declare const onTestFailed: TaskHook<OnTestFailedHandler>;
+/**
+* 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();
+* });
+* ```
+*/
+declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
+
+export { createChainable as X, afterAll as g, afterEach as h, beforeAll as i, beforeEach as j, onTestFinished as k, onTestFailed as o };
+export type { AfterAllListener as A, BeforeAllListener as B, TaskEventPack as C, TaskHook as D, TaskMeta as E, File as F, TaskPopulated as G, TaskResult as H, ImportDuration as I, TaskResultPack as J, TaskState as K, TestAnnotation as L, TestAnnotationLocation as M, TestAttachment as N, OnTestFailedHandler as O, TestContext as P, TestFunction as Q, RunMode as R, Suite as S, Test as T, TestOptions as U, Use as V, ChainableFunction as W, SuiteHooks as a, TaskUpdateEvent as b, Task as c, TestAPI as d, SuiteAPI as e, SuiteCollector as f, AfterEachListener as l, BeforeEachListener as m, Fixture as n, FixtureFn as p, FixtureOptions as q, Fixtures as r, InferFixturesTypes as s, OnTestFinishedHandler as t, RuntimeContext as u, SequenceHooks as v, SequenceSetupFiles as w, SuiteFactory as x, TaskBase as y, TaskCustomOptions as z };