@vitest/runner 3.0.8 → 3.0.9

package/dist/index.js

@@ -31,7 +31,7 @@ async function runWithSuite(suite, fn) {
   await fn();
   collectorContext.currentSuite = prev;
 }
-function withTimeout(fn, timeout, isHook = false) {
+function withTimeout(fn, timeout, isHook = false, stackTraceError) {
   if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
     return fn;
   }
@@ -42,13 +42,16 @@ function withTimeout(fn, timeout, isHook = false) {
       var _a;
       const timer = setTimeout(() => {
         clearTimeout(timer);
-        reject(new Error(makeTimeoutMsg(isHook, timeout)));
+        rejectTimeoutError();
       }, timeout);
       (_a = timer.unref) == null ? void 0 : _a.call(timer);
+      function rejectTimeoutError() {
+        reject_(makeTimeoutError(isHook, timeout, stackTraceError));
+      }
       function resolve(result) {
         clearTimeout(timer);
         if (now$2() - startTime >= timeout) {
-          reject_(new Error(makeTimeoutMsg(isHook, timeout)));
+          rejectTimeoutError();
           return;
         }
         resolve_(result);
@@ -84,20 +87,25 @@ function createTestContext(test, runner) {
   context.onTestFailed = (handler, timeout) => {
     test.onFailed || (test.onFailed = []);
     test.onFailed.push(
-      withTimeout(handler, timeout ?? runner.config.hookTimeout, true)
+      withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"))
     );
   };
   context.onTestFinished = (handler, timeout) => {
     test.onFinished || (test.onFinished = []);
     test.onFinished.push(
-      withTimeout(handler, timeout ?? runner.config.hookTimeout, true)
+      withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"))
     );
   };
   return ((_a = runner.extendTaskContext) == null ? void 0 : _a.call(runner, context)) || context;
 }
-function makeTimeoutMsg(isHook, timeout) {
-  return `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.
+function makeTimeoutError(isHook, timeout, stackTraceError) {
+  const message = `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.
 If 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 ? void 0 : stackTraceError.stack) {
+    error.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);
+  }
+  return error;
 }
 
 const fnMap = /* @__PURE__ */ new WeakMap();
@@ -426,6 +434,7 @@ function createSuiteCollector(name, factory = () => {
   initSuite(true);
   const task = function(name2 = "", options = {}) {
     var _a;
+    const timeout = (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout;
     const task2 = {
       id: "",
       name: name2,
@@ -435,6 +444,7 @@ function createSuiteCollector(name, factory = () => {
       context: void 0,
       type: "test",
       file: void 0,
+      timeout,
       retry: options.retry ?? runner.config.retry,
       repeats: options.repeats,
       mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
@@ -456,7 +466,7 @@ function createSuiteCollector(name, factory = () => {
         task2,
         withTimeout(
           withAwaitAsyncAssertions(withFixtures(handler, context), task2),
-          (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
+          timeout
         )
       );
     }
@@ -741,7 +751,7 @@ function createTest(fn, context) {
   return createTaskCollector(fn, context);
 }
 function formatName(name) {
-  return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
+  return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
 }
 function formatTitle(template, items, idx) {
   if (template.includes("%#")) {
@@ -810,33 +820,61 @@ 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) {
   if (typeof result === "function") {
     const timeout = CLEANUP_TIMEOUT_KEY in hook && typeof hook[CLEANUP_TIMEOUT_KEY] === "number" ? hook[CLEANUP_TIMEOUT_KEY] : getDefaultHookTimeout();
-    return withTimeout(result, timeout, true);
+    const stackTraceError = CLEANUP_STACK_TRACE_KEY in hook && hook[CLEANUP_STACK_TRACE_KEY] instanceof Error ? hook[CLEANUP_STACK_TRACE_KEY] : void 0;
+    return withTimeout(result, timeout, true, stackTraceError);
   }
 }
 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), { [CLEANUP_TIMEOUT_KEY]: timeout })
+    Object.assign(
+      withTimeout(
+        fn,
+        timeout,
+        true,
+        stackTraceError
+      ),
+      {
+        [CLEANUP_TIMEOUT_KEY]: timeout,
+        [CLEANUP_STACK_TRACE_KEY]: stackTraceError
+      }
+    )
   );
 }
 function afterAll(fn, timeout) {
   assertTypes(fn, '"afterAll" callback', ["function"]);
   return getCurrentSuite().on(
     "afterAll",
-    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
+    withTimeout(
+      fn,
+      timeout ?? getDefaultHookTimeout(),
+      true,
+      new Error("STACK_TRACE_ERROR")
+    )
   );
 }
 function beforeEach(fn, timeout = getDefaultHookTimeout()) {
   assertTypes(fn, '"beforeEach" callback', ["function"]);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
   return getCurrentSuite().on(
     "beforeEach",
     Object.assign(
-      withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true),
-      { [CLEANUP_TIMEOUT_KEY]: timeout }
+      withTimeout(
+        withFixtures(fn),
+        timeout ?? getDefaultHookTimeout(),
+        true,
+        stackTraceError
+      ),
+      {
+        [CLEANUP_TIMEOUT_KEY]: timeout,
+        [CLEANUP_STACK_TRACE_KEY]: stackTraceError
+      }
     )
   );
 }
@@ -844,7 +882,12 @@ function afterEach(fn, timeout) {
   assertTypes(fn, '"afterEach" callback', ["function"]);
   return getCurrentSuite().on(
     "afterEach",
-    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
+    withTimeout(
+      withFixtures(fn),
+      timeout ?? getDefaultHookTimeout(),
+      true,
+      new Error("STACK_TRACE_ERROR")
+    )
   );
 }
 const onTestFailed = createTestHook(
@@ -852,7 +895,12 @@ const onTestFailed = createTestHook(
   (test, handler, timeout) => {
     test.onFailed || (test.onFailed = []);
     test.onFailed.push(
-      withTimeout(handler, timeout ?? getDefaultHookTimeout(), true)
+      withTimeout(
+        handler,
+        timeout ?? getDefaultHookTimeout(),
+        true,
+        new Error("STACK_TRACE_ERROR")
+      )
     );
   }
 );
@@ -861,7 +909,12 @@ const onTestFinished = createTestHook(
   (test, handler, timeout) => {
     test.onFinished || (test.onFinished = []);
     test.onFinished.push(
-      withTimeout(handler, timeout ?? getDefaultHookTimeout(), true)
+      withTimeout(
+        handler,
+        timeout ?? getDefaultHookTimeout(),
+        true,
+        new Error("STACK_TRACE_ERROR")
+      )
     );
   }
 );

package/dist/tasks.d-D4e98wjH.d.ts

@@ -0,0 +1,484 @@
+import { ErrorWithDiff, Awaitable } from '@vitest/utils';
+
+interface FixtureItem extends FixtureOptions {
+	prop: string;
+	value: any;
+	/**
+	* Indicates whether the fixture is a function
+	*/
+	isFn: boolean;
+	/**
+	* The dependencies(fixtures) of current fixture function.
+	*/
+	deps?: FixtureItem[];
+}
+
+type ChainableFunction<
+	T extends string,
+	F extends (...args: any) => any,
+	C = object
+> = F & { [x in T] : ChainableFunction<T, F, C> } & {
+	fn: (this: Record<T, any>, ...args: Parameters<F>) => ReturnType<F>
+} & C;
+declare function createChainable<
+	T extends string,
+	Args extends any[],
+	R = any
+>(keys: T[], fn: (this: Record<T, any>, ...args: Args) => R): ChainableFunction<T, (...args: Args) => R>;
+
+type RunMode = "run" | "skip" | "only" | "todo" | "queued";
+type TaskState = RunMode | "pass" | "fail";
+interface TaskBase {
+	/**
+	* Unique task identifier. Based on the file id and the position of the task.
+	* The id of the file task is based on the file path relative to root and project name.
+	* It will not change between runs.
+	* @example `1201091390`, `1201091390_0`, `1201091390_0_1`
+	*/
+	id: string;
+	/**
+	* Task name provided by the user. If no name was provided, it will be an empty string.
+	*/
+	name: string;
+	/**
+	* Task mode.
+	* - **skip**: task is skipped
+	* - **only**: only this task and other tasks with `only` mode will run
+	* - **todo**: task is marked as a todo, alias for `skip`
+	* - **run**: task will run or already ran
+	* - **queued**: task will start running next. It can only exist on the File
+	*/
+	mode: RunMode;
+	/**
+	* Custom metadata for the task. JSON reporter will save this data.
+	*/
+	meta: TaskMeta;
+	/**
+	* Whether the task was produced with `.each()` method.
+	*/
+	each?: boolean;
+	/**
+	* Whether the task should run concurrently with other tasks.
+	*/
+	concurrent?: boolean;
+	/**
+	* Whether the tasks of the suite run in a random order.
+	*/
+	shuffle?: boolean;
+	/**
+	* Suite that this task is part of. File task or the global suite will have no parent.
+	*/
+	suite?: Suite;
+	/**
+	* Result of the task. Suite and file tasks will only have the result if there
+	* was an error during collection or inside `afterAll`/`beforeAll`.
+	*/
+	result?: TaskResult;
+	/**
+	* The amount of times the task should be retried if it fails.
+	* @default 0
+	*/
+	retry?: number;
+	/**
+	* The amount of times the task should be repeated after the successful run.
+	* If the task fails, it will not be retried unless `retry` is specified.
+	* @default 0
+	*/
+	repeats?: number;
+	/**
+	* Location of the task in the file. This field is populated only if
+	* `includeTaskLocation` option is set. It is generated by calling `new Error`
+	* and parsing the stack trace, so the location might differ depending on the runtime.
+	*/
+	location?: {
+		line: number
+		column: number
+	};
+}
+interface TaskPopulated extends TaskBase {
+	/**
+	* File task. It's the root task of the file.
+	*/
+	file: File;
+	/**
+	* Whether the task should succeed if it fails. If the task fails, it will be marked as passed.
+	*/
+	fails?: boolean;
+	/**
+	* Store promises (from async expects) to wait for them before finishing the test
+	*/
+	promises?: Promise<any>[];
+}
+/**
+* Custom metadata that can be used in reporters.
+*/
+interface TaskMeta {}
+/**
+* The result of calling a task.
+*/
+interface TaskResult {
+	/**
+	* State of the task. Inherits the `task.mode` during collection.
+	* When the task has finished, it will be changed to `pass` or `fail`.
+	* - **pass**: task ran successfully
+	* - **fail**: task failed
+	*/
+	state: TaskState;
+	/**
+	* Errors that occurred during the task execution. It is possible to have several errors
+	* if `expect.soft()` failed multiple times or `retry` was triggered.
+	*/
+	errors?: ErrorWithDiff[];
+	/**
+	* How long in milliseconds the task took to run.
+	*/
+	duration?: number;
+	/**
+	* Time in milliseconds when the task started running.
+	*/
+	startTime?: number;
+	/**
+	* Heap size in bytes after the task finished.
+	* Only available if `logHeapUsage` option is set and `process.memoryUsage` is defined.
+	*/
+	heap?: number;
+	/**
+	* State of related to this task hooks. Useful during reporting.
+	*/
+	hooks?: Partial<Record<keyof SuiteHooks, TaskState>>;
+	/**
+	* The amount of times the task was retried. The task is retried only if it
+	* failed and `retry` option is set.
+	*/
+	retryCount?: number;
+	/**
+	* The amount of times the task was repeated. The task is repeated only if
+	* `repeats` option is set. This number also contains `retryCount`.
+	*/
+	repeatCount?: number;
+	/** @private */
+	note?: string;
+}
+/**
+* The tuple representing a single task update.
+* Usually reported after the task finishes.
+*/
+type TaskResultPack = [id: string, result: TaskResult | undefined, meta: TaskMeta];
+type TaskEventPack = [id: string, event: TaskUpdateEvent];
+type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end";
+interface Suite extends TaskBase {
+	type: "suite";
+	/**
+	* File task. It's the root task of the file.
+	*/
+	file: File;
+	/**
+	* An array of tasks that are part of the suite.
+	*/
+	tasks: Task[];
+}
+interface File extends Suite {
+	/**
+	* The name of the pool that the file belongs to.
+	* @default 'forks'
+	*/
+	pool?: string;
+	/**
+	* The path to the file in UNIX format.
+	*/
+	filepath: string;
+	/**
+	* The name of the workspace project the file belongs to.
+	*/
+	projectName: string | undefined;
+	/**
+	* The time it took to collect all tests in the file.
+	* This time also includes importing all the file dependencies.
+	*/
+	collectDuration?: number;
+	/**
+	* The time it took to import the setup file.
+	*/
+	setupDuration?: number;
+}
+interface Test<ExtraContext = object> extends TaskPopulated {
+	type: "test";
+	/**
+	* Test context that will be passed to the test function.
+	*/
+	context: TestContext & ExtraContext;
+	/**
+	* The test timeout in milliseconds.
+	*/
+	timeout: number;
+}
+/**
+* @deprecated Use `Test` instead. `type: 'custom'` is not used since 2.2
+*/
+type Custom<ExtraContext = object> = Test<ExtraContext>;
+type Task = Test | Suite | File;
+/**
+* @deprecated Vitest doesn't provide `done()` anymore
+*/
+type DoneCallback = (error?: any) => void;
+type TestFunction<ExtraContext = object> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
+type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
+	1: [T[0]]
+	2: [T[0], T[1]]
+	3: [T[0], T[1], T[2]]
+	4: [T[0], T[1], T[2], T[3]]
+	5: [T[0], T[1], T[2], T[3], T[4]]
+	6: [T[0], T[1], T[2], T[3], T[4], T[5]]
+	7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6]]
+	8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7]]
+	9: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8]]
+	10: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8], T[9]]
+	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, options: TestCollectorOptions, fn: (...args: T) => Awaitable<void>): void;
+}
+interface TestEachFunction {
+	<T extends any[] | [any]>(cases: ReadonlyArray<T>): EachFunctionReturn<T>;
+	<T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): EachFunctionReturn<ExtractEachCallbackArgs<T>>;
+	<T>(cases: ReadonlyArray<T>): EachFunctionReturn<T[]>;
+	(...args: [TemplateStringsArray, ...any]): EachFunctionReturn<any[]>;
+}
+interface TestForFunctionReturn<
+	Arg,
+	Context
+> {
+	(name: string | Function, fn: (arg: Arg, context: Context) => Awaitable<void>): void;
+	(name: string | Function, options: TestCollectorOptions, fn: (args: Arg, context: Context) => Awaitable<void>): void;
+}
+interface TestForFunction<ExtraContext> {
+	<T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, TestContext & ExtraContext>;
+	(strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, TestContext & ExtraContext>;
+}
+interface SuiteForFunction {
+	<T>(cases: ReadonlyArray<T>): EachFunctionReturn<[T]>;
+	(...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, options?: TestCollectorOptions, fn?: TestFunction<ExtraContext>): void;
+}
+type ChainableTestAPI<ExtraContext = object> = ChainableFunction<"concurrent" | "sequential" | "only" | "skip" | "todo" | "fails", TestCollectorCallable<ExtraContext>, {
+	each: TestEachFunction
+	for: TestForFunction<ExtraContext>
+}>;
+type TestCollectorOptions = Omit<TestOptions, "shuffle">;
+interface TestOptions {
+	/**
+	* Test timeout.
+	*/
+	timeout?: number;
+	/**
+	* Times to retry the test if fails. Useful for making flaky tests more stable.
+	* When retries is up, the last test error will be thrown.
+	*
+	* @default 0
+	*/
+	retry?: number;
+	/**
+	* How many times the test will run again.
+	* Only inner tests will repeat if set on `describe()`, nested `describe()` will inherit parent's repeat by default.
+	*
+	* @default 0
+	*/
+	repeats?: number;
+	/**
+	* Whether suites and tests run concurrently.
+	* Tests inherit `concurrent` from `describe()` and nested `describe()` will inherit from parent's `concurrent`.
+	*/
+	concurrent?: boolean;
+	/**
+	* Whether tests run sequentially.
+	* Tests inherit `sequential` from `describe()` and nested `describe()` will inherit from parent's `sequential`.
+	*/
+	sequential?: boolean;
+	/**
+	* Whether the tasks of the suite run in a random order.
+	*/
+	shuffle?: boolean;
+	/**
+	* Whether the test should be skipped.
+	*/
+	skip?: boolean;
+	/**
+	* Should this test be the only one running in a suite.
+	*/
+	only?: boolean;
+	/**
+	* Whether the test should be skipped and marked as a todo.
+	*/
+	todo?: boolean;
+	/**
+	* Whether the test is expected to fail. If it does, the test will pass, otherwise it will fail.
+	*/
+	fails?: boolean;
+}
+interface ExtendedAPI<ExtraContext> {
+	skipIf: (condition: any) => ChainableTestAPI<ExtraContext>;
+	runIf: (condition: any) => ChainableTestAPI<ExtraContext>;
+}
+type TestAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedAPI<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 }>
+};
+
+interface FixtureOptions {
+	/**
+	* Whether to automatically set up current fixture, even though it's not being used in tests.
+	*/
+	auto?: boolean;
+	/**
+	* Indicated if the injected value from the config should be preferred over the fixture value
+	*/
+	injected?: boolean;
+}
+type Use<T> = (value: T) => Promise<void>;
+type FixtureFn<
+	T,
+	K extends keyof T,
+	ExtraContext
+> = (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>;
+type Fixture<
+	T,
+	K extends keyof T,
+	ExtraContext = object
+> = ((...args: any) => any) extends T[K] ? T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never);
+type Fixtures<
+	T extends Record<string, any>,
+	ExtraContext = object
+> = { [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, options: TestOptions, fn?: SuiteFactory<OverrideExtraContext>): SuiteCollector<OverrideExtraContext>;
+}
+type ChainableSuiteAPI<ExtraContext = object> = ChainableFunction<"concurrent" | "sequential" | "only" | "skip" | "todo" | "shuffle", SuiteCollectorCallable<ExtraContext>, {
+	each: TestEachFunction
+	for: SuiteForFunction
+}>;
+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>;
+}
+interface AfterAllListener {
+	(suite: Readonly<Suite | File>): Awaitable<unknown>;
+}
+interface BeforeEachListener<ExtraContext = object> {
+	(context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+}
+interface AfterEachListener<ExtraContext = object> {
+	(context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+}
+interface SuiteHooks<ExtraContext = object> {
+	beforeAll: BeforeAllListener[];
+	afterAll: AfterAllListener[];
+	beforeEach: BeforeEachListener<ExtraContext>[];
+	afterEach: AfterEachListener<ExtraContext>[];
+}
+interface TaskCustomOptions extends TestOptions {
+	/**
+	* Whether the task was produced with `.each()` method.
+	*/
+	each?: boolean;
+	/**
+	* Custom metadata for the task that will be assigned to `task.meta`.
+	*/
+	meta?: Record<string, unknown>;
+	/**
+	* Task fixtures.
+	*/
+	fixtures?: FixtureItem[];
+	/**
+	* Function that will be called when the task is executed.
+	* If nothing is provided, the runner will try to get the function using `getFn(task)`.
+	* If the runner cannot find the function, the task will be marked as failed.
+	*/
+	handler?: (context: TestContext) => Awaitable<void>;
+}
+interface SuiteCollector<ExtraContext = object> {
+	readonly name: string;
+	readonly mode: RunMode;
+	options?: TestOptions;
+	type: "collector";
+	test: TestAPI<ExtraContext>;
+	tasks: (Suite | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
+	suite?: Suite;
+	task: (name: string, options?: TaskCustomOptions) => Test<ExtraContext>;
+	collect: (file: File) => Promise<Suite>;
+	clear: () => void;
+	on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
+}
+type SuiteFactory<ExtraContext = object> = (test: TestAPI<ExtraContext>) => Awaitable<void>;
+interface RuntimeContext {
+	tasks: (SuiteCollector | Test)[];
+	currentSuite: SuiteCollector | null;
+}
+/**
+* User's custom test context.
+*/
+interface TestContext {
+	/**
+	* Metadata of the current test
+	*/
+	task: Readonly<Task>;
+	/**
+	* Extract hooks on test failed
+	*/
+	onTestFailed: (fn: OnTestFailedHandler, timeout?: number) => void;
+	/**
+	* Extract hooks on test failed
+	*/
+	onTestFinished: (fn: OnTestFinishedHandler, timeout?: number) => void;
+	/**
+	* Mark tests as skipped. All execution after this call will be skipped.
+	* This function throws an error, so make sure you are not catching it accidentally.
+	*/
+	skip: (note?: string) => never;
+}
+/**
+* Context that's always available in the test function.
+* @deprecated use `TestContext` instead
+*/
+interface TaskContext extends TestContext {}
+/** @deprecated use `TestContext` instead */
+type ExtendedContext = TaskContext & TestContext;
+type OnTestFailedHandler = (context: TestContext) => Awaitable<void>;
+type OnTestFinishedHandler = (context: TestContext) => Awaitable<void>;
+interface TaskHook<HookListener> {
+	(fn: HookListener, timeout?: number): void;
+}
+type SequenceHooks = "stack" | "list" | "parallel";
+type SequenceSetupFiles = "list" | "parallel";
+
+export { type AfterAllListener as A, type BeforeAllListener as B, type ChainableFunction as C, type DoneCallback as D, type ExtendedContext as E, type File as F, type TaskPopulated as G, type HookCleanupCallback as H, type InferFixturesTypes as I, type TaskResult as J, type TaskResultPack as K, type TaskState as L, type TestContext as M, type TestFunction as N, type OnTestFailedHandler as O, type TestOptions as P, type RunMode as R, type Suite as S, type Task as T, type Use as U, type Test as a, type AfterEachListener as b, createChainable as c, type BeforeEachListener as d, type TaskHook as e, type OnTestFinishedHandler as f, type Custom as g, type SuiteHooks as h, type TaskUpdateEvent as i, type TestAPI as j, type SuiteAPI as k, type SuiteCollector as l, type Fixture as m, type FixtureFn as n, type FixtureOptions as o, type Fixtures as p, type HookListener as q, type RuntimeContext as r, type SequenceHooks as s, type SequenceSetupFiles as t, type SuiteFactory as u, type TaskBase as v, type TaskContext as w, type TaskCustomOptions as x, type TaskEventPack as y, type TaskMeta as z };