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

package/dist/{tasks.d-WWG4yDf6.d.ts → tasks.d-C-iOiT8j.d.ts}

@@ -1,5 +1,5 @@
-import { DiffOptions } from '@vitest/utils/diff';
 import { TestError, Awaitable } from '@vitest/utils';
+import { DiffOptions } from '@vitest/utils/diff';
 
 /**
 * This is a subset of Vitest config that's required for the runner to work.
@@ -7,10 +7,10 @@ import { TestError, Awaitable } from '@vitest/utils';
 interface VitestRunnerConfig {
 	root: string;
 	setupFiles: string[];
-	name?: string;
+	name: string | undefined;
 	passWithNoTests: boolean;
-	testNamePattern?: RegExp;
-	allowOnly?: boolean;
+	testNamePattern: RegExp | undefined;
+	allowOnly: boolean;
 	sequence: {
 		shuffle?: boolean;
 		concurrent?: boolean;
@@ -18,17 +18,17 @@ interface VitestRunnerConfig {
 		hooks: SequenceHooks;
 		setupFiles: SequenceSetupFiles;
 	};
-	chaiConfig?: {
+	chaiConfig: {
 		truncateThreshold?: number;
-	};
+	} | undefined;
 	maxConcurrency: number;
 	testTimeout: number;
 	hookTimeout: number;
 	retry: SerializableRetry;
-	includeTaskLocation?: boolean;
+	includeTaskLocation: boolean | undefined;
 	diffOptions?: DiffOptions;
 	tags: TestTagDefinition[];
-	tagsFilter?: string[];
+	tagsFilter: string[] | undefined;
 	strictTags: boolean;
 }
 /**
@@ -187,10 +187,6 @@ interface VitestRunner {
 	* The current Vite environment that processes the files on the server.
 	*/
 	viteEnvironment?: string;
-	/**
-	* Return the worker context for fixtures specified with `scope: 'worker'`
-	*/
-	getWorkerContext?: () => Record<string, unknown>;
 	onCleanupWorkerContext?: (cleanup: () => unknown) => void;
 	trace?<T>(name: string, cb: () => T): T;
 	trace?<T>(name: string, attributes: Record<string, any>, cb: () => T): T;
@@ -200,18 +196,34 @@ interface VitestRunner {
 	_currentTaskTimeout?: number;
 }
 
-interface FixtureItem extends FixtureOptions {
-	prop: string;
-	value: any;
+interface TestFixtureItem extends FixtureOptions {
+	name: string;
+	value: unknown;
 	scope: "test" | "file" | "worker";
-	/**
-	* Indicates whether the fixture is a function
-	*/
-	isFn: boolean;
-	/**
-	* The dependencies(fixtures) of current fixture function.
-	*/
-	deps?: FixtureItem[];
+	deps: Set<string>;
+	parent?: TestFixtureItem;
+}
+type UserFixtures = Record<string, unknown>;
+type FixtureRegistrations = Map<string, TestFixtureItem>;
+declare class TestFixtures {
+	private _suiteContexts;
+	private _overrides;
+	private _registrations;
+	private static _definitions;
+	private static _builtinFixtures;
+	private static _fixtureOptionKeys;
+	private static _fixtureScopes;
+	private static _workerContextSymbol;
+	static clearDefinitions(): void;
+	static getWorkerContexts(): Record<string, any>[];
+	static getFileContexts(file: File): Record<string, any>[];
+	constructor(registrations?: FixtureRegistrations);
+	extend(runner: VitestRunner, userFixtures: UserFixtures): TestFixtures;
+	get(suite: Suite): FixtureRegistrations;
+	override(runner: VitestRunner, userFixtures: UserFixtures): void;
+	getFileContext(file: File): Record<string, any>;
+	getWorkerContext(): Record<string, any>;
+	private parseUserFixtures;
 }
 
 /**
@@ -231,7 +243,7 @@ interface FixtureItem extends FixtureOptions {
 * });
 * ```
 */
-declare function beforeAll(fn: BeforeAllListener, timeout?: number): void;
+declare function beforeAll<ExtraContext = object>(this: unknown, fn: BeforeAllListener<ExtraContext>, 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.
@@ -249,7 +261,7 @@ declare function beforeAll(fn: BeforeAllListener, timeout?: number): void;
 * });
 * ```
 */
-declare function afterAll(fn: AfterAllListener, timeout?: number): void;
+declare function afterAll<ExtraContext = object>(this: unknown, fn: AfterAllListener<ExtraContext>, 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.
@@ -338,9 +350,6 @@ declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
 * **Note:** When multiple `aroundAll` hooks are registered, they are nested inside each other.
 * The first registered hook is the outermost wrapper.
 *
-* **Note:** Unlike `aroundEach`, the `aroundAll` hook does not receive test context or support fixtures,
-* as it runs at the suite level before any individual test context is created.
-*
 * @param {Function} fn - The callback function that wraps the suite. Must call `runSuite()` to run the tests.
 * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
 * @returns {void}
@@ -353,13 +362,13 @@ declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
 * ```
 * @example
 * ```ts
-* // Example of using aroundAll with AsyncLocalStorage context
-* aroundAll(async (runSuite) => {
-*   await asyncLocalStorage.run({ suiteId: 'my-suite' }, runSuite);
+* // Example of using aroundAll with fixtures
+* aroundAll(async (runSuite, { db }) => {
+*   await db.transaction(() => runSuite());
 * });
 * ```
 */
-declare function aroundAll(fn: AroundAllListener, timeout?: number): void;
+declare function aroundAll<ExtraContext = object>(this: unknown, fn: AroundAllListener<ExtraContext>, timeout?: number): void;
 /**
 * Registers a callback function that wraps around each test within the current suite.
 * The callback receives a `runTest` function that must be called to run the test.
@@ -399,7 +408,7 @@ 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>;
+>(keys: T[], fn: (this: Record<T, any>, ...args: Args) => R, context?: Record<string, any>): ChainableFunction<T, (...args: Args) => R>;
 
 type RunMode = "run" | "skip" | "only" | "todo" | "queued";
 type TaskState = RunMode | "pass" | "fail";
@@ -501,10 +510,7 @@ interface TaskBase {
 	* `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;
-	};
+	location?: Location;
 	/**
 	* If the test was collected by parsing the file AST, and the name
 	* is not a static string, this property will be set to `true`.
@@ -828,17 +834,143 @@ interface ExtendedAPI<ExtraContext> {
 	runIf: (condition: any) => ChainableTestAPI<ExtraContext>;
 }
 interface Hooks<ExtraContext> {
-	beforeAll: typeof beforeAll;
-	afterAll: typeof afterAll;
+	/**
+	* Suite-level hooks only receive file/worker scoped fixtures.
+	* Test-scoped fixtures are NOT available in beforeAll/afterAll/aroundAll.
+	*/
+	beforeAll: typeof beforeAll<ExtractSuiteContext<ExtraContext>>;
+	afterAll: typeof afterAll<ExtractSuiteContext<ExtraContext>>;
+	aroundAll: typeof aroundAll<ExtractSuiteContext<ExtraContext>>;
+	/**
+	* Test-level hooks receive all fixtures including test-scoped ones.
+	*/
 	beforeEach: typeof beforeEach<ExtraContext>;
 	afterEach: typeof afterEach<ExtraContext>;
 	aroundEach: typeof aroundEach<ExtraContext>;
-	aroundAll: typeof aroundAll;
 }
 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: Partial<Fixtures<ExtraContext>>) => void;
+	/**
+	* Extend the test API with custom fixtures.
+	*
+	* @example
+	* ```ts
+	* // Simple test fixtures (backward compatible)
+	* const myTest = test.extend<{ foo: string }>({
+	*   foo: 'value',
+	* })
+	*
+	* // With scoped fixtures - use $test/$file/$worker structure
+	* const myTest = test.extend<{
+	*   $test: { testData: string }
+	*   $file: { fileDb: Database }
+	*   $worker: { workerConfig: Config }
+	* }>({
+	*   testData: async ({ fileDb }, use) => {
+	*     await use(await fileDb.getData())
+	*   },
+	*   fileDb: [async ({ workerConfig }, use) => {
+	*     // File fixture can only access workerConfig, NOT testData
+	*     const db = new Database(workerConfig)
+	*     await use(db)
+	*     await db.close()
+	*   }, { scope: 'file' }],
+	*   workerConfig: [async ({}, use) => {
+	*     // Worker fixture can only access other worker fixtures
+	*     await use(loadConfig())
+	*   }, { scope: 'worker' }],
+	* })
+	*
+	* // Builder pattern with automatic type inference
+	* const myTest = test
+	*   .extend('config', { scope: 'worker' }, async ({}) => {
+	*     return { port: 3000 }  // Type inferred as { port: number }
+	*   })
+	*   .extend('db', { scope: 'file' }, async ({ config }, { onCleanup }) => {
+	*     // TypeScript knows config is { port: number }
+	*     const db = new Database(config.port)
+	*     onCleanup(() => db.close())  // Register cleanup
+	*     return db  // Type inferred as Database
+	*   })
+	*   .extend('data', async ({ db }) => {
+	*     // TypeScript knows db is Database
+	*     return await db.getData()  // Type inferred from return
+	*   })
+	* ```
+	*/
+	extend: {
+		<
+			K extends string,
+			T extends (K extends keyof ExtraContext ? ExtraContext[K] : unknown)
+		>(name: K, options: WorkerScopeFixtureOptions, fn: BuilderFixtureFn<T, WorkerScopeContext<ExtraContext>>): TestAPI<AddBuilderWorker<ExtraContext, K, T>>;
+		<
+			K extends string,
+			T extends (K extends keyof ExtraContext ? ExtraContext[K] : unknown)
+		>(name: K, options: FileScopeFixtureOptions, fn: BuilderFixtureFn<T, FileScopeContext<ExtraContext>>): TestAPI<AddBuilderFile<ExtraContext, K, T>>;
+		<
+			K extends string,
+			T extends (K extends keyof ExtraContext ? ExtraContext[K] : unknown)
+		>(name: K, options: TestScopeFixtureOptions, fn: BuilderFixtureFn<T, TestScopeContext<ExtraContext>>): TestAPI<AddBuilderTest<ExtraContext, K, T>>;
+		<
+			K extends string,
+			T extends (K extends keyof ExtraContext ? ExtraContext[K] : unknown)
+		>(name: K, fn: BuilderFixtureFn<T, TestScopeContext<ExtraContext>>): TestAPI<AddBuilderTest<ExtraContext, K, T>>;
+		<
+			K extends string,
+			T extends (K extends keyof ExtraContext ? ExtraContext[K] : unknown)
+		>(name: K, options: WorkerScopeFixtureOptions, value: T extends (...args: any[]) => any ? never : T): TestAPI<AddBuilderWorker<ExtraContext, K, T>>;
+		<
+			K extends string,
+			T extends (K extends keyof ExtraContext ? ExtraContext[K] : unknown)
+		>(name: K, options: FileScopeFixtureOptions, value: T extends (...args: any[]) => any ? never : T): TestAPI<AddBuilderFile<ExtraContext, K, T>>;
+		<
+			K extends string,
+			T extends (K extends keyof ExtraContext ? ExtraContext[K] : unknown)
+		>(name: K, options: TestScopeFixtureOptions, value: T extends (...args: any[]) => any ? never : T): TestAPI<AddBuilderTest<ExtraContext, K, T>>;
+		<
+			K extends string,
+			T extends (K extends keyof ExtraContext ? ExtraContext[K] : unknown)
+		>(name: K, value: T extends (...args: any[]) => any ? never : T): TestAPI<AddBuilderTest<ExtraContext, K, T>>;
+		<T extends ScopedFixturesDef>(fixtures: ScopedFixturesObject<T, ExtraContext>): TestAPI<ExtractScopedFixtures<T> & ExtraContext>;
+		<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 }>;
+	};
+	/**
+	* Overwrite fixture values for the current suite scope.
+	* Supports both object syntax and builder pattern.
+	*
+	* @example
+	* ```ts
+	* describe('with custom config', () => {
+	*   // Object syntax
+	*   test.override({ config: { port: 4000 } })
+	*
+	*   // Builder pattern - value
+	*   test.override('config', { port: 4000 })
+	*
+	*   // Builder pattern - function
+	*   test.override('config', () => ({ port: 4000 }))
+	*
+	*   // Builder pattern - function with cleanup
+	*   test.override('db', async ({ config }, { onCleanup }) => {
+	*     const db = await createDb(config)
+	*     onCleanup(() => db.close())
+	*     return db
+	*   })
+	* })
+	* ```
+	*/
+	override: {
+		<K extends keyof ExtraContext>(name: K, options: FixtureOptions, fn: BuilderFixtureFn<ExtraContext[K], ExtraContext & TestContext>): TestAPI<ExtraContext>;
+		<K extends keyof ExtraContext>(name: K, fn: BuilderFixtureFn<ExtraContext[K], ExtraContext & TestContext>): TestAPI<ExtraContext>;
+		<K extends keyof ExtraContext>(name: K, options: FixtureOptions, value: ExtraContext[K] extends (...args: any[]) => any ? never : ExtraContext[K]): TestAPI<ExtraContext>;
+		<K extends keyof ExtraContext>(name: K, value: ExtraContext[K] extends (...args: any[]) => any ? never : ExtraContext[K]): TestAPI<ExtraContext>;
+		(fixtures: Partial<Fixtures<ExtraContext>>): TestAPI<ExtraContext>;
+	};
+	/**
+	* @deprecated Use `test.override()` instead
+	*/
+	scoped: (fixtures: Partial<Fixtures<ExtraContext>>) => TestAPI<ExtraContext>;
 	describe: SuiteAPI<ExtraContext>;
+	suite: SuiteAPI<ExtraContext>;
 };
 interface FixtureOptions {
 	/**
@@ -861,7 +993,141 @@ interface FixtureOptions {
 	*/
 	scope?: "test" | "worker" | "file";
 }
+/**
+* Options for test-scoped fixtures.
+* Test fixtures are set up before each test and have access to all fixtures.
+*/
+interface TestScopeFixtureOptions extends Omit<FixtureOptions, "scope"> {
+	/**
+	* @default 'test'
+	*/
+	scope?: "test";
+}
+/**
+* Options for file-scoped fixtures.
+* File fixtures are set up once per file and can only access other file fixtures and worker fixtures.
+*/
+interface FileScopeFixtureOptions extends Omit<FixtureOptions, "scope"> {
+	/**
+	* Must be 'file' for file-scoped fixtures.
+	*/
+	scope: "file";
+}
+/**
+* Options for worker-scoped fixtures.
+* Worker fixtures are set up once per worker and can only access other worker fixtures.
+*/
+interface WorkerScopeFixtureOptions extends Omit<FixtureOptions, "scope"> {
+	/**
+	* Must be 'worker' for worker-scoped fixtures.
+	*/
+	scope: "worker";
+}
 type Use<T> = (value: T) => Promise<void>;
+/**
+* Cleanup registration function for builder pattern fixtures.
+* Call this to register a cleanup function that runs after the test/file/worker completes.
+*
+* **Note:** This function can only be called once per fixture. If you need multiple
+* cleanup operations, either combine them into a single cleanup function or split
+* your fixture into multiple smaller fixtures.
+*/
+type OnCleanup = (cleanup: () => Awaitable<void>) => void;
+/**
+* Builder pattern fixture function with automatic type inference.
+* Returns the fixture value directly (type is inferred from return).
+* Use onCleanup to register teardown logic.
+*
+* Parameters can be omitted if not needed:
+* - `async () => value` - no dependencies, no cleanup
+* - `async ({ dep }) => value` - with dependencies, no cleanup
+* - `async ({ dep }, { onCleanup }) => value` - with dependencies and cleanup
+*/
+type BuilderFixtureFn<
+	T,
+	Context
+> = (context: Context, fixture: {
+	onCleanup: OnCleanup;
+}) => T | Promise<T>;
+type ExtractSuiteContext<C> = C extends {
+	$__worker?: any;
+} | {
+	$__file?: any;
+} | {
+	$__test?: any;
+} ? ExtractBuilderWorker<C> & ExtractBuilderFile<C> : C;
+/**
+* Extracts worker-scoped fixtures from a context that includes scope info.
+*/
+type ExtractBuilderWorker<C> = C extends {
+	$__worker?: infer W;
+} ? W extends Record<string, any> ? W : object : object;
+/**
+* Extracts file-scoped fixtures from a context that includes scope info.
+*/
+type ExtractBuilderFile<C> = C extends {
+	$__file?: infer F;
+} ? F extends Record<string, any> ? F : object : object;
+/**
+* Extracts test-scoped fixtures from a context that includes scope info.
+*/
+type ExtractBuilderTest<C> = C extends {
+	$__test?: infer T;
+} ? T extends Record<string, any> ? T : object : object;
+/**
+* Adds a worker fixture to the context with proper scope tracking.
+*/
+type AddBuilderWorker<
+	C,
+	K extends string,
+	V
+> = Omit<C, "$__worker"> & Record<K, V> & {
+	readonly $__worker?: ExtractBuilderWorker<C> & Record<K, V>;
+	readonly $__file?: ExtractBuilderFile<C>;
+	readonly $__test?: ExtractBuilderTest<C>;
+};
+/**
+* Adds a file fixture to the context with proper scope tracking.
+*/
+type AddBuilderFile<
+	C,
+	K extends string,
+	V
+> = Omit<C, "$__file"> & Record<K, V> & {
+	readonly $__worker?: ExtractBuilderWorker<C>;
+	readonly $__file?: ExtractBuilderFile<C> & Record<K, V>;
+	readonly $__test?: ExtractBuilderTest<C>;
+};
+/**
+* Adds a test fixture to the context with proper scope tracking.
+*/
+type AddBuilderTest<
+	C,
+	K extends string,
+	V
+> = Omit<C, "$__test"> & Record<K, V> & {
+	readonly $__worker?: ExtractBuilderWorker<C>;
+	readonly $__file?: ExtractBuilderFile<C>;
+	readonly $__test?: ExtractBuilderTest<C> & Record<K, V>;
+};
+/**
+* Context available to worker-scoped fixtures.
+* Worker fixtures can only access other worker fixtures.
+* They do NOT have access to test context (task, expect, onTestFailed, etc.)
+* since they run once per worker, outside of any specific test.
+*/
+type WorkerScopeContext<C> = ExtractBuilderWorker<C>;
+/**
+* Context available to file-scoped fixtures.
+* File fixtures can access worker and other file fixtures.
+* They do NOT have access to test context (task, expect, onTestFailed, etc.)
+* since they run once per file, outside of any specific test.
+*/
+type FileScopeContext<C> = ExtractBuilderWorker<C> & ExtractBuilderFile<C>;
+/**
+* Context available to test-scoped fixtures (all fixtures + test context).
+*/
+type TestScopeContext<C> = C & TestContext;
 type FixtureFn<
 	T,
 	K extends keyof T,
@@ -872,10 +1138,55 @@ type Fixture<
 	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);
+/**
+* Fixture function with explicit context type for scoped fixtures.
+*/
+type ScopedFixtureFn<
+	Value,
+	Context
+> = (context: Context, use: Use<Value>) => Promise<void>;
+/**
+* Fixtures definition for backward compatibility.
+* All fixtures are in T and any scope is allowed.
+*/
 type Fixtures<
 	T,
 	ExtraContext = object
 > = { [K in keyof T] : Fixture<T, K, ExtraContext & TestContext> | [Fixture<T, K, ExtraContext & TestContext>, FixtureOptions?] };
+/**
+* Scoped fixtures definition using a single generic with optional scope keys.
+* This provides better ergonomics than multiple generics.
+* Uses $ prefix to avoid conflicts with fixture names.
+*
+* @example
+* ```ts
+* test.extend<{
+*   $worker?: { config: Config }
+*   $file?: { db: Database }
+*   $test?: { data: string }
+* }>({ ... })
+* ```
+*/
+interface ScopedFixturesDef {
+	$test?: Record<string, any>;
+	$file?: Record<string, any>;
+	$worker?: Record<string, any>;
+}
+/**
+* Extracts fixture types from a ScopedFixturesDef.
+* Handles optional properties by using Exclude to remove undefined.
+*/
+type ExtractScopedFixtures<T extends ScopedFixturesDef> = ([Exclude<T["$test"], undefined>] extends [never] ? object : Exclude<T["$test"], undefined>) & ([Exclude<T["$file"], undefined>] extends [never] ? object : Exclude<T["$file"], undefined>) & ([Exclude<T["$worker"], undefined>] extends [never] ? object : Exclude<T["$worker"], undefined>);
+/**
+* Creates the fixtures object type for ScopedFixturesDef with proper scope validation.
+* - Test fixtures: can be defined as value, function, or tuple with optional scope
+* - File fixtures: MUST have { scope: 'file' }
+* - Worker fixtures: MUST have { scope: 'worker' }
+*/
+type ScopedFixturesObject<
+	T extends ScopedFixturesDef,
+	ExtraContext = object
+> = { [K in keyof NonNullable<T["$test"]>] : NonNullable<T["$test"]>[K] | ScopedFixtureFn<NonNullable<T["$test"]>[K], ExtractScopedFixtures<T> & ExtraContext & TestContext> | [ScopedFixtureFn<NonNullable<T["$test"]>[K], ExtractScopedFixtures<T> & ExtraContext & TestContext>, TestScopeFixtureOptions?] } & { [K in keyof NonNullable<T["$file"]>] : [ScopedFixtureFn<NonNullable<T["$file"]>[K], (NonNullable<T["$file"]> & NonNullable<T["$worker"]>) & ExtraContext>, FileScopeFixtureOptions] } & { [K in keyof NonNullable<T["$worker"]>] : [ScopedFixtureFn<NonNullable<T["$worker"]>[K], NonNullable<T["$worker"]> & ExtraContext>, WorkerScopeFixtureOptions] };
 type InferFixturesTypes<T> = T extends TestAPI<infer C> ? C : T;
 interface SuiteCollectorCallable<ExtraContext = object> {
 	<OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, fn?: SuiteFactory<OverrideExtraContext>, options?: number): SuiteCollector<OverrideExtraContext>;
@@ -889,11 +1200,11 @@ type SuiteAPI<ExtraContext = object> = ChainableSuiteAPI<ExtraContext> & {
 	skipIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
 	runIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
 };
-interface BeforeAllListener {
-	(suite: Readonly<Suite | File>): Awaitable<unknown>;
+interface BeforeAllListener<ExtraContext = object> {
+	(context: ExtraContext, suite: Readonly<Suite | File>): Awaitable<unknown>;
 }
-interface AfterAllListener {
-	(suite: Readonly<Suite | File>): Awaitable<unknown>;
+interface AfterAllListener<ExtraContext = object> {
+	(context: ExtraContext, suite: Readonly<Suite | File>): Awaitable<unknown>;
 }
 interface BeforeEachListener<ExtraContext = object> {
 	(context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
@@ -904,16 +1215,22 @@ interface AfterEachListener<ExtraContext = object> {
 interface AroundEachListener<ExtraContext = object> {
 	(runTest: () => Promise<void>, context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
 }
-interface AroundAllListener {
+interface AroundAllListener<ExtraContext = object> {
+	(runSuite: () => Promise<void>, context: ExtraContext, suite: Readonly<Suite | File>): Awaitable<unknown>;
+}
+interface RegisteredAllListener {
+	(suite: Readonly<Suite | File>): Awaitable<unknown>;
+}
+interface RegisteredAroundAllListener {
 	(runSuite: () => Promise<void>, suite: Readonly<Suite | File>): Awaitable<unknown>;
 }
 interface SuiteHooks<ExtraContext = object> {
-	beforeAll: BeforeAllListener[];
-	afterAll: AfterAllListener[];
+	beforeAll: RegisteredAllListener[];
+	afterAll: RegisteredAllListener[];
+	aroundAll: RegisteredAroundAllListener[];
 	beforeEach: BeforeEachListener<ExtraContext>[];
 	afterEach: AfterEachListener<ExtraContext>[];
 	aroundEach: AroundEachListener<ExtraContext>[];
-	aroundAll: AroundAllListener[];
 }
 interface TaskCustomOptions extends TestOptions {
 	/**
@@ -923,7 +1240,7 @@ interface TaskCustomOptions extends TestOptions {
 	/**
 	* Task fixtures.
 	*/
-	fixtures?: FixtureItem[];
+	fixtures?: TestFixtures;
 	/**
 	* 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)`.
@@ -938,9 +1255,7 @@ interface SuiteCollector<ExtraContext = object> {
 	type: "collector";
 	test: TestAPI<ExtraContext>;
 	tasks: (Suite | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
-	scoped: (fixtures: Fixtures<any, ExtraContext>) => void;
-	fixtures: () => FixtureItem[] | undefined;
-	file?: File;
+	file: File;
 	suite?: Suite;
 	task: (name: string, options?: TaskCustomOptions) => Test<ExtraContext>;
 	collect: (file: File) => Promise<Suite>;
@@ -1017,12 +1332,13 @@ interface TestAttachment {
 	/** Inline attachment content as a string or raw binary data */
 	body?: string | Uint8Array;
 }
-/**
-* Source code location information for a test artifact.
-*
-* Indicates where in the source code the artifact originated from.
-*/
-interface TestArtifactLocation {
+interface Location {
+	/** Line number in the source file (1-indexed) */
+	line: number;
+	/** Column number in the line (1-indexed) */
+	column: number;
+}
+interface FileLocation extends Location {
 	/** Line number in the source file (1-indexed) */
 	line: number;
 	/** Column number in the line (1-indexed) */
@@ -1031,11 +1347,19 @@ interface TestArtifactLocation {
 	file: string;
 }
 /**
+* Source code location information for a test artifact.
+*
+* Indicates where in the source code the artifact originated from.
+*/
+interface TestArtifactLocation extends FileLocation {}
+/**
 * @experimental
 *
 * Base interface for all test artifacts.
 *
 * Extend this interface when creating custom test artifacts. Vitest automatically manages the `attachments` array and injects the `location` property to indicate where the artifact was created in your test code.
+*
+* **Important**: when running with [`api.allowWrite`](https://vitest.dev/config/api#api-allowwrite) or [`browser.api.allowWrite`](https://vitest.dev/config/browser/api#api-allowwrite) disabled, Vitest empties the `attachments` array on every artifact before reporting it.
 */
 interface TestArtifactBase {
 	/** File or data attachments associated with this artifact */
@@ -1080,6 +1404,21 @@ interface VisualRegressionArtifact extends TestArtifactBase {
 	message: string;
 	attachments: VisualRegressionArtifactAttachment[];
 }
+interface FailureScreenshotArtifactAttachment extends TestAttachment {
+	path: string;
+	/** Original file system path to the screenshot, before attachment resolution */
+	originalPath: string;
+	body?: undefined;
+}
+/**
+* @experimental
+*
+* Artifact type for failure screenshots.
+*/
+interface FailureScreenshotArtifact extends TestArtifactBase {
+	type: "internal:failureScreenshot";
+	attachments: [FailureScreenshotArtifactAttachment] | [];
+}
 /**
 * @experimental
 * @advanced
@@ -1160,7 +1499,7 @@ interface TestArtifactRegistry {}
 *
 * This type automatically includes all artifacts registered via {@link TestArtifactRegistry}.
 */
-type TestArtifact = TestAnnotationArtifact | VisualRegressionArtifact | TestArtifactRegistry[keyof TestArtifactRegistry];
+type TestArtifact = FailureScreenshotArtifact | TestAnnotationArtifact | VisualRegressionArtifact | TestArtifactRegistry[keyof TestArtifactRegistry];
 
-export { afterAll as a7, afterEach as a8, aroundAll as a9, aroundEach as aa, beforeAll as ab, beforeEach as ac, onTestFailed as ad, onTestFinished as ae, createChainable as ag };
-export type { TestOptions as $, AfterAllListener as A, BeforeAllListener as B, CancelReason as C, TaskCustomOptions as D, TaskEventPack as E, FileSpecification as F, TaskHook as G, TaskMeta as H, ImportDuration as I, TaskPopulated as J, TaskResult as K, TaskResultPack as L, TaskState as M, TestAnnotation as N, OnTestFailedHandler as O, TestAnnotationArtifact as P, TestAnnotationLocation as Q, Retry as R, Suite as S, TestArtifact as T, TestArtifactBase as U, VitestRunner as V, TestArtifactLocation as W, TestArtifactRegistry as X, TestAttachment as Y, TestContext as Z, TestFunction as _, Test as a, TestTagDefinition as a0, TestTags as a1, Use as a2, VisualRegressionArtifact as a3, VitestRunnerConfig as a4, VitestRunnerConstructor as a5, VitestRunnerImportSource as a6, ChainableFunction as af, SuiteHooks as b, File as c, TaskUpdateEvent as d, Task as e, TestAPI as f, SuiteAPI as g, SuiteCollector as h, AfterEachListener as i, AroundAllListener as j, AroundEachListener as k, BeforeEachListener as l, Fixture as m, FixtureFn as n, FixtureOptions as o, Fixtures as p, InferFixturesTypes as q, OnTestFinishedHandler as r, RunMode as s, RuntimeContext as t, SequenceHooks as u, SequenceSetupFiles as v, SerializableRetry as w, SuiteFactory as x, SuiteOptions as y, TaskBase as z };
+export { afterAll as a8, afterEach as a9, aroundAll as aa, aroundEach as ab, beforeAll as ac, beforeEach as ad, onTestFailed as ae, onTestFinished as af, createChainable as ah };
+export type { TestFunction as $, AfterAllListener as A, BeforeAllListener as B, CancelReason as C, TaskBase as D, TaskCustomOptions as E, FileSpecification as F, TaskEventPack as G, TaskHook as H, ImportDuration as I, TaskMeta as J, TaskPopulated as K, TaskResult as L, TaskResultPack as M, TaskState as N, OnTestFailedHandler as O, TestAnnotation as P, TestAnnotationArtifact as Q, Retry as R, Suite as S, TestArtifact as T, TestAnnotationLocation as U, VitestRunner as V, TestArtifactBase as W, TestArtifactLocation as X, TestArtifactRegistry as Y, TestAttachment as Z, TestContext as _, Test as a, TestOptions as a0, TestTagDefinition as a1, TestTags as a2, Use as a3, VisualRegressionArtifact as a4, VitestRunnerConfig as a5, VitestRunnerConstructor as a6, VitestRunnerImportSource as a7, ChainableFunction as ag, SuiteHooks as b, File as c, TaskUpdateEvent as d, Task as e, TestAPI as f, SuiteAPI as g, SuiteCollector as h, AfterEachListener as i, AroundAllListener as j, AroundEachListener as k, BeforeEachListener as l, FailureScreenshotArtifact as m, Fixture as n, FixtureFn as o, FixtureOptions as p, Fixtures as q, InferFixturesTypes as r, OnTestFinishedHandler as s, RunMode as t, RuntimeContext as u, SequenceHooks as v, SequenceSetupFiles as w, SerializableRetry as x, SuiteFactory as y, SuiteOptions as z };

package/dist/types.d.ts

@@ -1,3 +1,3 @@
-export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, c as File, F as FileSpecification, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, I as ImportDuration, q as InferFixturesTypes, O as OnTestFailedHandler, r as OnTestFinishedHandler, R as Retry, s as RunMode, t as RuntimeContext, u as SequenceHooks, v as SequenceSetupFiles, w as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, x as SuiteFactory, b as SuiteHooks, y as SuiteOptions, e as Task, z as TaskBase, D as TaskCustomOptions, E as TaskEventPack, G as TaskHook, H as TaskMeta, J as TaskPopulated, K as TaskResult, L as TaskResultPack, M as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, N as TestAnnotation, P as TestAnnotationArtifact, Q as TestAnnotationLocation, T as TestArtifact, U as TestArtifactBase, W as TestArtifactLocation, X as TestArtifactRegistry, Y as TestAttachment, Z as TestContext, _ as TestFunction, $ as TestOptions, a0 as TestTagDefinition, a1 as TestTags, a2 as Use, a3 as VisualRegressionArtifact, V as VitestRunner, a4 as VitestRunnerConfig, a5 as VitestRunnerConstructor, a6 as VitestRunnerImportSource } from './tasks.d-WWG4yDf6.js';
-import '@vitest/utils/diff';
+export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, c as File, F as FileSpecification, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, y as SuiteFactory, b as SuiteHooks, z as SuiteOptions, e as Task, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, T as TestArtifact, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, V as VitestRunner, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource } from './tasks.d-C-iOiT8j.js';
 import '@vitest/utils';
+import '@vitest/utils/diff';

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, c as File, e as Task, a0 as TestTagDefinition, a4 as VitestRunnerConfig, a as Test } from './tasks.d-WWG4yDf6.js';
-export { af as ChainableFunction, ag as createChainable } from './tasks.d-WWG4yDf6.js';
+import { S as Suite, c as File, e as Task, a1 as TestTagDefinition, a5 as VitestRunnerConfig, a as Test } from './tasks.d-C-iOiT8j.js';
+export { ag as ChainableFunction, ah as createChainable } from './tasks.d-C-iOiT8j.js';
 import { ParsedStack, Arrayable } from '@vitest/utils';
 import '@vitest/utils/diff';