vitest 5.0.0-beta.6 → 5.0.0-beta.7

package/dist/chunks/{config.d.CKWK3nld.d.ts → config.d.DsC1jkby.d.ts}

@@ -1,10 +1,5 @@
-import { OptionsReceived, Plugin, PrettyFormatOptions } from '@vitest/pretty-format';
-import { ParsedStack, TestError, Awaitable } from '@vitest/utils';
-import { diff, printDiffOrStringify, SerializedDiffOptions } from '@vitest/utils/diff';
-import { MockInstance } from '@vitest/spy';
-import { Formatter } from 'tinyrainbow';
-import { stringify } from '@vitest/utils/display';
-import { Fn, FnOptions, BenchOptions, TaskResultCompleted, TaskResultRuntimeInfo, TaskResultTimestampProviderInfo, Statistics } from 'tinybench';
+import { Disposable } from 'vitest/optional-runtime-types.js';
+import { Fn, FnOptions, BenchOptions as BenchOptions$1, TaskResultCompleted, TaskResultRuntimeInfo, TaskResultTimestampProviderInfo, Statistics } from 'tinybench';
 
 type VoidVarArgsFunc = (...args: unknown[]) => void;
 type SetImmediate = (callback: VoidVarArgsFunc, ...args: unknown[]) => NodeImmediate;
@@ -72,7 +67,7 @@ type TimerInitialProps = {
     order?: number;
     heapIndex?: number;
 };
-type Config = {
+type Config$1 = {
     now?: number | Date | TemporalTimelike;
     toFake?: FakeMethod[];
     toNotFake?: FakeMethod[];
@@ -93,6 +88,241 @@ type NodeImmediate = {
     unref: NodeImmediateUnref;
 };
 
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+interface Colors {
+	comment: {
+		close: string;
+		open: string;
+	};
+	content: {
+		close: string;
+		open: string;
+	};
+	prop: {
+		close: string;
+		open: string;
+	};
+	tag: {
+		close: string;
+		open: string;
+	};
+	value: {
+		close: string;
+		open: string;
+	};
+}
+type Indent = (arg0: string) => string;
+type Refs = Array<unknown>;
+type Print = (arg0: unknown) => string;
+/**
+* compare function used when sorting object keys, `null` can be used to skip over sorting.
+*/
+type CompareKeys = ((a: string, b: string) => number) | null | undefined;
+interface PrettyFormatOptions {
+	/**
+	* Call `toJSON` on objects before formatting them.
+	* Ignored after the formatter has already called `toJSON` once for a value.
+	* @default true
+	*/
+	callToJSON?: boolean;
+	/**
+	* Whether to escape special characters in regular expressions.
+	* @default false
+	*/
+	escapeRegex?: boolean;
+	/**
+	* Whether to escape special characters in strings.
+	* @default true
+	*/
+	escapeString?: boolean;
+	/**
+	* Whether to highlight syntax using terminal colors.
+	* @default false
+	*/
+	highlight?: boolean;
+	/**
+	* Number of spaces to use for each level of indentation.
+	* @default 2
+	*/
+	indent?: number;
+	/**
+	* Maximum depth to recurse into nested values.
+	* @default Infinity
+	*/
+	maxDepth?: number;
+	/**
+	* Maximum number of items to print in arrays, sets, maps, and similar collections.
+	* @default Infinity
+	*/
+	maxWidth?: number;
+	/**
+	* Approximate per-depth-level budget for output length.
+	* When the accumulated output at any single depth level exceeds this value,
+	* further nesting is collapsed. This is a heuristic safety valve, not a hard
+	* limit — total output can reach up to roughly `maxDepth × maxOutputLength`.
+	* @default 1_000_000
+	*/
+	maxOutputLength?: number;
+	/**
+	* Whether to minimize added whitespace, including indentation and line breaks.
+	*
+	* When `true`, pretty-format defaults `spacingInner` to `' '`, `spacingOuter` to `''`,
+	* and ignores indentation. It also changes the default for `printBasicPrototype`
+	* from `true` to `false`, although an explicit `printBasicPrototype` still wins.
+	* Explicit `spacingInner` / `spacingOuter` overrides still apply.
+	* @default false
+	*/
+	min?: boolean;
+	/**
+	* Whether to print `Object` / `Array` prefixes for plain objects and arrays.
+	*
+	* Defaults to `true`, unless `min` is `true`, in which case it defaults to `false`.
+	* An explicit `printBasicPrototype` value always overrides the `min` default.
+	*/
+	printBasicPrototype?: boolean;
+	/**
+	* Whether to include the function name when formatting functions.
+	* @default true
+	*/
+	printFunctionName?: boolean;
+	/**
+	* Whether to include shadow-root contents when formatting DOM nodes.
+	* @default true
+	*/
+	printShadowRoot?: boolean;
+	/**
+	* Compare function used when sorting object keys. Set to `null` to disable sorting.
+	*/
+	compareKeys?: CompareKeys;
+	/**
+	* Plugins used to serialize application-specific data types.
+	* @default []
+	*/
+	plugins?: Plugins;
+	/**
+	* Whitespace inserted after commas between items or entries.
+	*
+	* For example, in `{a: 1, b: 2}` or `[1, 2]`, this controls the gap after each comma:
+	* `{a: 1,${spacingInner}b: 2}`
+	* `[1,${spacingInner}2]`
+	*
+	* Defaults to `'\n'` in regular mode and `' '` when `min` is `true`.
+	* Can be overridden independently of `min`.
+	*/
+	spacingInner?: string;
+	/**
+	* Whitespace inserted immediately inside collection/object delimiters.
+	*
+	* For example, this controls the space or newline right after the opening delimiter
+	* and right before the closing delimiter:
+	* `{${spacingOuter}a: 1${spacingOuter}}`
+	* `[${spacingOuter}1${spacingOuter}]`
+	*
+	* Defaults to `'\n'` in regular mode and `''` when `min` is `true`.
+	* Can be overridden independently of `min`.
+	*/
+	spacingOuter?: string;
+	/**
+	* Whether to print strings using single quotes instead of double quotes.
+	*
+	* For example:
+	* `"hello"` when `false`
+	* `'hello'` when `true`
+	*
+	* @default false
+	*/
+	singleQuote?: boolean;
+	/**
+	* Whether to always quote object property keys.
+	*
+	* For example:
+	* `{"a": 1}` when `true`
+	* `{a: 1}` when `false` and the key is a valid identifier
+	* `{"my-key": 1}` still stays quoted because it is not a valid identifier
+	*
+	* @default true
+	*/
+	quoteKeys?: boolean;
+}
+type OptionsReceived = PrettyFormatOptions;
+interface Config {
+	callToJSON: boolean;
+	compareKeys: CompareKeys;
+	colors: Colors;
+	escapeRegex: boolean;
+	escapeString: boolean;
+	indent: string;
+	maxDepth: number;
+	maxWidth: number;
+	min: boolean;
+	plugins: Plugins;
+	printBasicPrototype: boolean;
+	printFunctionName: boolean;
+	printShadowRoot: boolean;
+	spacingInner: string;
+	spacingOuter: string;
+	singleQuote: boolean;
+	quoteKeys: boolean;
+	maxOutputLength: number;
+}
+type Printer = (val: unknown, config: Config, indentation: string, depth: number, refs: Refs, hasCalledToJSON?: boolean) => string;
+type Test$1 = (arg0: any) => boolean;
+interface NewPlugin {
+	serialize: (val: any, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer) => string;
+	test: Test$1;
+}
+interface PluginOptions {
+	edgeSpacing: string;
+	min: boolean;
+	spacing: string;
+}
+interface OldPlugin {
+	print: (val: unknown, print: Print, indent: Indent, options: PluginOptions, colors: Colors) => string;
+	test: Test$1;
+}
+type Plugin = NewPlugin | OldPlugin;
+type Plugins = Array<Plugin>;
+
+interface StringifyOptions extends PrettyFormatOptions {
+	maxLength?: number;
+	filterNode?: string | ((node: any) => boolean);
+}
+declare function stringify(object: unknown, maxDepth?: number, { maxLength, filterNode, ...options }?: StringifyOptions): string;
+declare function format(args: unknown[], options?: InspectOptions): string;
+interface InspectOptions extends StringifyOptions {
+	truncate?: number;
+	multiline?: boolean;
+}
+declare function inspect(obj: unknown, options?: InspectOptions): string;
+
+type Awaitable<T> = T | PromiseLike<T>;
+type Arrayable<T> = T | Array<T>;
+interface ParsedStack {
+	method: string;
+	file: string;
+	line: number;
+	column: number;
+}
+interface SerializedError {
+	message: string;
+	stacks?: ParsedStack[];
+	stack?: string;
+	name?: string;
+	cause?: SerializedError;
+	[key: string]: unknown;
+}
+interface TestError extends SerializedError {
+	cause?: TestError;
+	diff?: string;
+	actual?: string;
+	expected?: string;
+}
+
 interface SnapshotEnvironment {
 	getVersion: () => string;
 	getHeader: () => string;
@@ -306,6 +536,79 @@ interface RawSnapshotInfo {
 	content?: string;
 }
 
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+type DiffOptionsColor = (arg: string) => string;
+interface DiffOptions {
+	aAnnotation?: string;
+	aColor?: DiffOptionsColor;
+	aIndicator?: string;
+	bAnnotation?: string;
+	bColor?: DiffOptionsColor;
+	bIndicator?: string;
+	changeColor?: DiffOptionsColor;
+	changeLineTrailingSpaceColor?: DiffOptionsColor;
+	commonColor?: DiffOptionsColor;
+	commonIndicator?: string;
+	commonLineTrailingSpaceColor?: DiffOptionsColor;
+	contextLines?: number;
+	emptyFirstOrLastLinePlaceholder?: string;
+	expand?: boolean;
+	includeChangeCounts?: boolean;
+	omitAnnotationLines?: boolean;
+	patchColor?: DiffOptionsColor;
+	printBasicPrototype?: boolean;
+	maxDepth?: number;
+	compareKeys?: CompareKeys;
+	truncateThreshold?: number;
+	truncateAnnotation?: string;
+	truncateAnnotationColor?: DiffOptionsColor;
+}
+interface SerializedDiffOptions {
+	aAnnotation?: string;
+	aIndicator?: string;
+	bAnnotation?: string;
+	bIndicator?: string;
+	commonIndicator?: string;
+	contextLines?: number;
+	emptyFirstOrLastLinePlaceholder?: string;
+	expand?: boolean;
+	includeChangeCounts?: boolean;
+	omitAnnotationLines?: boolean;
+	printBasicPrototype?: boolean;
+	maxDepth?: number;
+	truncateThreshold?: number;
+	truncateAnnotation?: string;
+}
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+interface StringifiedMemory {
+	expected?: string;
+	actual?: string;
+}
+interface Memorize {
+	(pointer: "expected" | "actual", stringifiedValue: string): string;
+}
+/**
+* @param a Expected value
+* @param b Received value
+* @param options Diff options
+* @returns {string | null} a string diff
+*/
+declare function diff(a: any, b: any, options?: DiffOptions, memorize?: Memorize): string | undefined;
+declare function printDiffOrStringify(received: unknown, expected: unknown, options?: DiffOptions, memory?: StringifiedMemory): string | undefined;
+
 interface AfterSuiteRunMeta {
 	coverage?: unknown;
 	testFiles: string[];
@@ -332,6 +635,7 @@ interface ResolveFunctionResult {
 	file: string;
 	url: string;
 }
+type ModuleType = "cjs" | "esm";
 interface FetchCachedFileSystemResult {
 	cached: true;
 	tmp: string;
@@ -339,6 +643,7 @@ interface FetchCachedFileSystemResult {
 	file: string | null;
 	url: string;
 	invalidate: boolean;
+	moduleType?: ModuleType;
 }
 type LabelColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
 interface AsyncLeak {
@@ -348,6 +653,484 @@ interface AsyncLeak {
 	type: string;
 }
 
+interface MockResultReturn<T> {
+	type: "return";
+	/**
+	* The value that was returned from the function. If function returned a Promise, then this will be a resolved value.
+	*/
+	value: T;
+}
+interface MockResultIncomplete {
+	type: "incomplete";
+	value: undefined;
+}
+interface MockResultThrow {
+	type: "throw";
+	/**
+	* An error that was thrown during function execution.
+	*/
+	value: any;
+}
+interface MockSettledResultIncomplete {
+	type: "incomplete";
+	value: undefined;
+}
+interface MockSettledResultFulfilled<T> {
+	type: "fulfilled";
+	value: T;
+}
+interface MockSettledResultRejected {
+	type: "rejected";
+	value: any;
+}
+type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
+type MockSettledResult<T> = MockSettledResultFulfilled<T> | MockSettledResultRejected | MockSettledResultIncomplete;
+type MockParameters<T extends Procedure | Constructable> = T extends Constructable ? ConstructorParameters<T> : T extends Procedure ? Parameters<T> : never;
+type MockReturnType<T extends Procedure | Constructable> = T extends Constructable ? InstanceType<T> : T extends Procedure ? ReturnType<T> : never;
+type MockProcedureContext<T extends Procedure | Constructable> = T extends Constructable ? InstanceType<T> : ThisParameterType<T>;
+interface MockContext<T extends Procedure | Constructable = Procedure> {
+	/**
+	* This is an array containing all arguments for each call. One item of the array is the arguments of that call.
+	*
+	* @see https://vitest.dev/api/mock#mock-calls
+	* @example
+	* const fn = vi.fn()
+	*
+	* fn('arg1', 'arg2')
+	* fn('arg3')
+	*
+	* fn.mock.calls === [
+	*   ['arg1', 'arg2'], // first call
+	*   ['arg3'], // second call
+	* ]
+	*/
+	calls: MockParameters<T>[];
+	/**
+	* This is an array containing all instances that were instantiated when mock was called with a `new` keyword. Note that this is an actual context (`this`) of the function, not a return value.
+	* @see https://vitest.dev/api/mock#mock-instances
+	*/
+	instances: MockProcedureContext<T>[];
+	/**
+	* An array of `this` values that were used during each call to the mock function.
+	* @see https://vitest.dev/api/mock#mock-contexts
+	*/
+	contexts: MockProcedureContext<T>[];
+	/**
+	* The order of mock's execution. This returns an array of numbers which are shared between all defined mocks.
+	*
+	* @see https://vitest.dev/api/mock#mock-invocationcallorder
+	* @example
+	* const fn1 = vi.fn()
+	* const fn2 = vi.fn()
+	*
+	* fn1()
+	* fn2()
+	* fn1()
+	*
+	* fn1.mock.invocationCallOrder === [1, 3]
+	* fn2.mock.invocationCallOrder === [2]
+	*/
+	invocationCallOrder: number[];
+	/**
+	* This is an array containing all values that were `returned` from the function.
+	*
+	* The `value` property contains the returned value or thrown error. If the function returned a `Promise`, then `result` will always be `'return'` even if the promise was rejected.
+	*
+	* @see https://vitest.dev/api/mock#mock-results
+	* @example
+	* const fn = vi.fn()
+	*   .mockReturnValueOnce('result')
+	*   .mockImplementationOnce(() => { throw new Error('thrown error') })
+	*
+	* const result = fn()
+	*
+	* try {
+	*   fn()
+	* }
+	* catch {}
+	*
+	* fn.mock.results === [
+	*   {
+	*     type: 'return',
+	*     value: 'result',
+	*   },
+	*   {
+	*     type: 'throw',
+	*     value: Error,
+	*   },
+	* ]
+	*/
+	results: MockResult<MockReturnType<T>>[];
+	/**
+	* An array containing all values that were `resolved` or `rejected` from the function.
+	*
+	* This array will be empty if the function was never resolved or rejected.
+	*
+	* @see https://vitest.dev/api/mock#mock-settledresults
+	* @example
+	* const fn = vi.fn().mockResolvedValueOnce('result')
+	*
+	* const result = fn()
+	*
+	* fn.mock.settledResults === [
+	*   {
+	*     type: 'incomplete',
+	*     value: undefined,
+	*   }
+	* ]
+	* fn.mock.results === [
+	*   {
+	*     type: 'return',
+	*     value: Promise<'result'>,
+	*   },
+	* ]
+	*
+	* await result
+	*
+	* fn.mock.settledResults === [
+	*   {
+	*     type: 'fulfilled',
+	*     value: 'result',
+	*   },
+	* ]
+	*/
+	settledResults: MockSettledResult<Awaited<MockReturnType<T>>>[];
+	/**
+	* This contains the arguments of the last call. If spy wasn't called, will return `undefined`.
+	* @see https://vitest.dev/api/mock#mock-lastcall
+	*/
+	lastCall: MockParameters<T> | undefined;
+}
+type Procedure = (...args: any[]) => any;
+type NormalizedProcedure<T extends Procedure | Constructable> = T extends Constructable ? ({
+	new (...args: ConstructorParameters<T>): InstanceType<T>;
+}) | ({
+	(this: InstanceType<T>, ...args: ConstructorParameters<T>): void;
+}) : T extends Procedure ? (...args: Parameters<T>) => ReturnType<T> : never;
+type Methods<T> = keyof { [K in keyof T as T[K] extends Procedure ? K : never] : T[K] };
+type Properties<T> = { [K in keyof T] : T[K] extends Procedure ? never : K }[keyof T] & (string | symbol);
+type Classes<T> = { [K in keyof T] : T[K] extends new (...args: any[]) => any ? K : never }[keyof T] & (string | symbol);
+interface MockInstance<T extends Procedure | Constructable = Procedure> extends Disposable {
+	/**
+	* Use it to return the name assigned to the mock with the `.mockName(name)` method. By default, it will return `vi.fn()`.
+	* @see https://vitest.dev/api/mock#getmockname
+	*/
+	getMockName(): string;
+	/**
+	* Sets the internal mock name. This is useful for identifying the mock when an assertion fails.
+	* @see https://vitest.dev/api/mock#mockname
+	*/
+	mockName(name: string): this;
+	/**
+	* Current context of the mock. It stores information about all invocation calls, instances, and results.
+	*/
+	mock: MockContext<T>;
+	/**
+	* Clears all information about every call. After calling it, all properties on `.mock` will return to their initial state. This method does not reset implementations. It is useful for cleaning up mocks between different assertions.
+	*
+	* To automatically call this method before each test, enable the [`clearMocks`](https://vitest.dev/config/clearmocks) setting in the configuration.
+	* @see https://vitest.dev/api/mock#mockclear
+	*/
+	mockClear(): this;
+	/**
+	* Does what `mockClear` does and resets inner implementation to the original function. This also resets all "once" implementations.
+	*
+	* Note that resetting a mock from `vi.fn()` will set implementation to an empty function that returns `undefined`.
+	* Resetting a mock from `vi.fn(impl)` will set implementation to `impl`. It is useful for completely resetting a mock to its default state.
+	*
+	* To automatically call this method before each test, enable the [`mockReset`](https://vitest.dev/config/mockreset) setting in the configuration.
+	* @see https://vitest.dev/api/mock#mockreset
+	*/
+	mockReset(): this;
+	/**
+	* Does what `mockReset` does and restores original descriptors of spied-on objects.
+	* @see https://vitest.dev/api/mock#mockrestore
+	*/
+	mockRestore(): void;
+	/**
+	* Returns current permanent mock implementation if there is one.
+	*
+	* If mock was created with `vi.fn`, it will consider passed down method as a mock implementation.
+	*
+	* If mock was created with `vi.spyOn`, it will return `undefined` unless a custom implementation was provided.
+	*/
+	getMockImplementation(): NormalizedProcedure<T> | undefined;
+	/**
+	* Accepts a function to be used as the mock implementation. TypeScript expects the arguments and return type to match those of the original function.
+	* @see https://vitest.dev/api/mock#mockimplementation
+	* @example
+	* const increment = vi.fn().mockImplementation(count => count + 1);
+	* expect(increment(3)).toBe(4);
+	*/
+	mockImplementation(fn: NormalizedProcedure<T>): this;
+	/**
+	* Accepts a function to be used as the mock implementation. TypeScript expects the arguments and return type to match those of the original function. This method can be chained to produce different results for multiple function calls.
+	*
+	* When the mocked function runs out of implementations, it will invoke the default implementation set with `vi.fn(() => defaultValue)` or `.mockImplementation(() => defaultValue)` if they were called.
+	* @see https://vitest.dev/api/mock#mockimplementationonce
+	* @example
+	* const fn = vi.fn(count => count).mockImplementationOnce(count => count + 1);
+	* expect(fn(3)).toBe(4);
+	* expect(fn(3)).toBe(3);
+	*/
+	mockImplementationOnce(fn: NormalizedProcedure<T>): this;
+	/**
+	* Overrides the original mock implementation temporarily while the callback is being executed.
+	*
+	* Note that this method takes precedence over the [`mockImplementationOnce`](https://vitest.dev/api/mock#mockimplementationonce).
+	* @see https://vitest.dev/api/mock#withimplementation
+	* @example
+	* const myMockFn = vi.fn(() => 'original')
+	*
+	* myMockFn.withImplementation(() => 'temp', () => {
+	*   myMockFn() // 'temp'
+	* })
+	*
+	* myMockFn() // 'original'
+	*/
+	withImplementation(fn: NormalizedProcedure<T>, cb: () => Promise<unknown>): Promise<this>;
+	withImplementation(fn: NormalizedProcedure<T>, cb: () => unknown): this;
+	/**
+	* Use this if you need to return the `this` context from the method without invoking the actual implementation.
+	* @see https://vitest.dev/api/mock#mockreturnthis
+	*/
+	mockReturnThis(): this;
+	/**
+	* Accepts a value that will be returned whenever the mock function is called. TypeScript will only accept values that match the return type of the original function.
+	* @see https://vitest.dev/api/mock#mockreturnvalue
+	* @example
+	* const mock = vi.fn()
+	* mock.mockReturnValue(42)
+	* mock() // 42
+	* mock.mockReturnValue(43)
+	* mock() // 43
+	*/
+	mockReturnValue(value: MockReturnType<T>): this;
+	/**
+	* Accepts a value that will be returned whenever the mock function is called. TypeScript will only accept values that match the return type of the original function.
+	*
+	* When the mocked function runs out of implementations, it will invoke the default implementation set with `vi.fn(() => defaultValue)` or `.mockImplementation(() => defaultValue)` if they were called.
+	* @example
+	* const myMockFn = vi
+	*   .fn()
+	*   .mockReturnValue('default')
+	*   .mockReturnValueOnce('first call')
+	*   .mockReturnValueOnce('second call')
+	*
+	* // 'first call', 'second call', 'default'
+	* console.log(myMockFn(), myMockFn(), myMockFn())
+	*/
+	mockReturnValueOnce(value: MockReturnType<T>): this;
+	/**
+	* Accepts a value that will be thrown whenever the mock function is called.
+	* @see https://vitest.dev/api/mock#mockthrow
+	* @example
+	* const myMockFn = vi.fn().mockThrow(new Error('error'))
+	* myMockFn() // throws 'error'
+	*/
+	mockThrow(value: unknown): this;
+	/**
+	* Accepts a value that will be thrown during the next function call. If chained, every consecutive call will throw the specified value.
+	* @example
+	* const myMockFn = vi
+	*   .fn()
+	*   .mockReturnValue('default')
+	*   .mockThrowOnce(new Error('first call error'))
+	*   .mockThrowOnce('second call error')
+	*
+	* expect(() => myMockFn()).toThrowError('first call error')
+	* expect(() => myMockFn()).toThrowError('second call error')
+	* expect(myMockFn()).toEqual('default')
+	*/
+	mockThrowOnce(value: unknown): this;
+	/**
+	* Accepts a value that will be resolved when the async function is called. TypeScript will only accept values that match the return type of the original function.
+	* @example
+	* const asyncMock = vi.fn().mockResolvedValue(42)
+	* asyncMock() // Promise<42>
+	*/
+	mockResolvedValue(value: Awaited<MockReturnType<T>>): this;
+	/**
+	* Accepts a value that will be resolved during the next function call. TypeScript will only accept values that match the return type of the original function. If chained, each consecutive call will resolve the specified value.
+	* @example
+	* const myMockFn = vi
+	*   .fn()
+	*   .mockResolvedValue('default')
+	*   .mockResolvedValueOnce('first call')
+	*   .mockResolvedValueOnce('second call')
+	*
+	* // Promise<'first call'>, Promise<'second call'>, Promise<'default'>
+	* console.log(myMockFn(), myMockFn(), myMockFn())
+	*/
+	mockResolvedValueOnce(value: Awaited<MockReturnType<T>>): this;
+	/**
+	* Accepts an error that will be rejected when async function is called.
+	* @example
+	* const asyncMock = vi.fn().mockRejectedValue(new Error('Async error'))
+	* await asyncMock() // throws Error<'Async error'>
+	*/
+	mockRejectedValue(error: unknown): this;
+	/**
+	* Accepts a value that will be rejected during the next function call. If chained, each consecutive call will reject the specified value.
+	* @example
+	* const asyncMock = vi
+	*   .fn()
+	*   .mockResolvedValueOnce('first call')
+	*   .mockRejectedValueOnce(new Error('Async error'))
+	*
+	* await asyncMock() // first call
+	* await asyncMock() // throws Error<'Async error'>
+	*/
+	mockRejectedValueOnce(error: unknown): this;
+}
+type Mock<T extends Procedure | Constructable = Procedure> = MockInstance<T> & (T extends Constructable ? (T extends Procedure ? {
+	new (...args: ConstructorParameters<T>): InstanceType<T>;
+	(...args: Parameters<T>): ReturnType<T>;
+} : {
+	new (...args: ConstructorParameters<T>): InstanceType<T>;
+}) : {
+	new (...args: MockParameters<T>): MockReturnType<T>;
+	(...args: MockParameters<T>): MockReturnType<T>;
+}) & { [P in keyof T] : T[P] };
+type PartialMaybePromise<T> = T extends Promise<Awaited<T>> ? Promise<Partial<Awaited<T>>> : Partial<T>;
+type PartialResultFunction<T> = T extends Constructable ? ({
+	new (...args: ConstructorParameters<T>): InstanceType<T>;
+}) | ({
+	(this: InstanceType<T>, ...args: ConstructorParameters<T>): void;
+}) : T extends Procedure ? (...args: Parameters<T>) => PartialMaybePromise<ReturnType<T>> : T;
+type PartialMock<T extends Procedure | Constructable = Procedure> = Mock<PartialResultFunction<T extends Mock ? NonNullable<ReturnType<T["getMockImplementation"]>> : T>>;
+type DeepPartial<T> = T extends Procedure ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? { [K in keyof T]? : DeepPartial<T[K]> } : T;
+type DeepPartialMaybePromise<T> = T extends Promise<Awaited<T>> ? Promise<DeepPartial<Awaited<T>>> : DeepPartial<T>;
+type DeepPartialResultFunction<T> = T extends Constructable ? ({
+	new (...args: ConstructorParameters<T>): InstanceType<T>;
+}) | ({
+	(this: InstanceType<T>, ...args: ConstructorParameters<T>): void;
+}) : T extends Procedure ? (...args: Parameters<T>) => DeepPartialMaybePromise<ReturnType<T>> : T;
+type DeepPartialMock<T extends Procedure | Constructable = Procedure> = Mock<DeepPartialResultFunction<T extends Mock ? NonNullable<ReturnType<T["getMockImplementation"]>> : T>>;
+type MaybeMockedConstructor<T> = T extends Constructable ? Mock<T> : T;
+type MockedFunction<T extends Procedure | Constructable> = Mock<T> & MockedObject<T>;
+type PartiallyMockedFunction<T extends Procedure | Constructable> = PartialMock<T> & MockedObject<T>;
+type MockedFunctionDeep<T extends Procedure | Constructable> = Mock<T> & MockedObjectDeep<T>;
+type PartiallyMockedFunctionDeep<T extends Procedure | Constructable> = DeepPartialMock<T> & MockedObjectDeep<T>;
+type MockedObject<T> = MaybeMockedConstructor<T> & { [K in Methods<T>] : T[K] extends Procedure ? MockedFunction<T[K]> : T[K] } & { [K in Properties<T>] : T[K] };
+type MockedObjectDeep<T> = MaybeMockedConstructor<T> & { [K in Methods<T>] : T[K] extends Procedure ? MockedFunctionDeep<T[K]> : T[K] } & { [K in Properties<T>] : MaybeMockedDeep<T[K]> };
+type MaybeMockedDeep<T> = T extends Procedure | Constructable ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+type MaybePartiallyMockedDeep<T> = T extends Procedure | Constructable ? PartiallyMockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+type MaybeMocked<T> = T extends Procedure | Constructable ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+type MaybePartiallyMocked<T> = T extends Procedure | Constructable ? PartiallyMockedFunction<T> : T extends object ? MockedObject<T> : T;
+interface Constructable {
+	new (...args: any[]): any;
+}
+type MockedClass<T extends Constructable> = MockInstance<T> & {
+	prototype: T extends {
+		prototype: any;
+	} ? Mocked<T["prototype"]> : never;
+} & T;
+type Mocked<T> = { [P in keyof T] : T[P] extends Procedure ? MockInstance<T[P]> : T[P] extends Constructable ? MockedClass<T[P]> : T[P] } & T;
+interface MockConfig {
+	mockImplementation: Procedure | Constructable | undefined;
+	mockOriginal: Procedure | Constructable | undefined;
+	mockName: string;
+	onceMockImplementations: Array<Procedure | Constructable>;
+}
+interface MockInstanceOption {
+	originalImplementation?: Procedure | Constructable;
+	mockImplementation?: Procedure | Constructable;
+	resetToMockImplementation?: boolean;
+	restore?: () => void;
+	prototypeMembers?: (string | symbol)[];
+	keepMembersImplementation?: boolean;
+	prototypeState?: MockContext;
+	prototypeConfig?: MockConfig;
+	resetToMockName?: boolean;
+	name?: string | symbol;
+}
+
+declare function isMockFunction(fn: any): fn is Mock;
+declare function createMockInstance(options?: MockInstanceOption): Mock<Procedure | Constructable>;
+declare function fn<T extends Procedure | Constructable = Procedure>(originalImplementation?: T): Mock<T>;
+type SpyOnValue<
+	T extends object,
+	K extends keyof any
+> = K extends keyof Required<T> ? Required<T>[K] : (T & Record<K, unknown>)[K];
+type SpyOnMethod<
+	T extends object,
+	K extends keyof any
+> = SpyOnValue<T, K> extends Constructable | Procedure ? SpyOnValue<T, K> : never;
+type SpyOnMethodKey<
+	T extends object,
+	K extends keyof any
+> = SpyOnValue<T, K> extends Constructable | Procedure ? K : never;
+declare function spyOn<
+	T extends object,
+	S extends Properties<Required<T>>
+>(object: T, key: S, accessor: "get"): Mock<() => T[S]>;
+declare function spyOn<
+	T extends object,
+	G extends Properties<Required<T>>
+>(object: T, key: G, accessor: "set"): Mock<(arg: T[G]) => void>;
+declare function spyOn<
+	T extends object,
+	M extends Classes<Required<T>> | Methods<Required<T>>
+>(object: T, key: M): Required<T>[M] extends Constructable | Procedure ? Mock<Required<T>[M]> : never;
+declare function spyOn<
+	T extends object,
+	K extends keyof any
+>(object: T, key: SpyOnMethodKey<T, K>): Mock<SpyOnMethod<T, K>>;
+declare function restoreAllMocks(): void;
+declare function clearAllMocks(): void;
+declare function resetAllMocks(): void;
+
+type _vitest_spy_Constructable = Constructable;
+type _vitest_spy_MaybeMocked<T> = MaybeMocked<T>;
+type _vitest_spy_MaybeMockedConstructor<T> = MaybeMockedConstructor<T>;
+type _vitest_spy_MaybeMockedDeep<T> = MaybeMockedDeep<T>;
+type _vitest_spy_MaybePartiallyMocked<T> = MaybePartiallyMocked<T>;
+type _vitest_spy_MaybePartiallyMockedDeep<T> = MaybePartiallyMockedDeep<T>;
+type _vitest_spy_Mock<T extends Procedure | Constructable = Procedure> = Mock<T>;
+type _vitest_spy_MockContext<T extends Procedure | Constructable = Procedure> = MockContext<T>;
+type _vitest_spy_MockInstance<T extends Procedure | Constructable = Procedure> = MockInstance<T>;
+type _vitest_spy_MockInstanceOption = MockInstanceOption;
+type _vitest_spy_MockParameters<T extends Procedure | Constructable> = MockParameters<T>;
+type _vitest_spy_MockProcedureContext<T extends Procedure | Constructable> = MockProcedureContext<T>;
+type _vitest_spy_MockResult<T> = MockResult<T>;
+type _vitest_spy_MockResultIncomplete = MockResultIncomplete;
+type _vitest_spy_MockResultReturn<T> = MockResultReturn<T>;
+type _vitest_spy_MockResultThrow = MockResultThrow;
+type _vitest_spy_MockReturnType<T extends Procedure | Constructable> = MockReturnType<T>;
+type _vitest_spy_MockSettledResult<T> = MockSettledResult<T>;
+type _vitest_spy_MockSettledResultFulfilled<T> = MockSettledResultFulfilled<T>;
+type _vitest_spy_MockSettledResultIncomplete = MockSettledResultIncomplete;
+type _vitest_spy_MockSettledResultRejected = MockSettledResultRejected;
+type _vitest_spy_Mocked<T> = Mocked<T>;
+type _vitest_spy_MockedClass<T extends Constructable> = MockedClass<T>;
+type _vitest_spy_MockedFunction<T extends Procedure | Constructable> = MockedFunction<T>;
+type _vitest_spy_MockedFunctionDeep<T extends Procedure | Constructable> = MockedFunctionDeep<T>;
+type _vitest_spy_MockedObject<T> = MockedObject<T>;
+type _vitest_spy_MockedObjectDeep<T> = MockedObjectDeep<T>;
+type _vitest_spy_PartialMock<T extends Procedure | Constructable = Procedure> = PartialMock<T>;
+type _vitest_spy_PartiallyMockedFunction<T extends Procedure | Constructable> = PartiallyMockedFunction<T>;
+type _vitest_spy_PartiallyMockedFunctionDeep<T extends Procedure | Constructable> = PartiallyMockedFunctionDeep<T>;
+type _vitest_spy_Procedure = Procedure;
+declare const _vitest_spy_clearAllMocks: typeof clearAllMocks;
+declare const _vitest_spy_createMockInstance: typeof createMockInstance;
+declare const _vitest_spy_fn: typeof fn;
+declare const _vitest_spy_isMockFunction: typeof isMockFunction;
+declare const _vitest_spy_resetAllMocks: typeof resetAllMocks;
+declare const _vitest_spy_restoreAllMocks: typeof restoreAllMocks;
+declare const _vitest_spy_spyOn: typeof spyOn;
+declare namespace _vitest_spy {
+  export { _vitest_spy_clearAllMocks as clearAllMocks, _vitest_spy_createMockInstance as createMockInstance, _vitest_spy_fn as fn, _vitest_spy_isMockFunction as isMockFunction, _vitest_spy_resetAllMocks as resetAllMocks, _vitest_spy_restoreAllMocks as restoreAllMocks, _vitest_spy_spyOn as spyOn };
+  export type { _vitest_spy_Constructable as Constructable, _vitest_spy_MaybeMocked as MaybeMocked, _vitest_spy_MaybeMockedConstructor as MaybeMockedConstructor, _vitest_spy_MaybeMockedDeep as MaybeMockedDeep, _vitest_spy_MaybePartiallyMocked as MaybePartiallyMocked, _vitest_spy_MaybePartiallyMockedDeep as MaybePartiallyMockedDeep, _vitest_spy_Mock as Mock, _vitest_spy_MockContext as MockContext, _vitest_spy_MockInstance as MockInstance, _vitest_spy_MockInstanceOption as MockInstanceOption, _vitest_spy_MockParameters as MockParameters, _vitest_spy_MockProcedureContext as MockProcedureContext, _vitest_spy_MockResult as MockResult, _vitest_spy_MockResultIncomplete as MockResultIncomplete, _vitest_spy_MockResultReturn as MockResultReturn, _vitest_spy_MockResultThrow as MockResultThrow, _vitest_spy_MockReturnType as MockReturnType, _vitest_spy_MockSettledResult as MockSettledResult, _vitest_spy_MockSettledResultFulfilled as MockSettledResultFulfilled, _vitest_spy_MockSettledResultIncomplete as MockSettledResultIncomplete, _vitest_spy_MockSettledResultRejected as MockSettledResultRejected, _vitest_spy_Mocked as Mocked, _vitest_spy_MockedClass as MockedClass, _vitest_spy_MockedFunction as MockedFunction, _vitest_spy_MockedFunctionDeep as MockedFunctionDeep, _vitest_spy_MockedObject as MockedObject, _vitest_spy_MockedObjectDeep as MockedObjectDeep, _vitest_spy_PartialMock as PartialMock, _vitest_spy_PartiallyMockedFunction as PartiallyMockedFunction, _vitest_spy_PartiallyMockedFunctionDeep as PartiallyMockedFunctionDeep, _vitest_spy_Procedure as Procedure };
+}
+
+interface Formatter {
+    (input?: unknown): string;
+    open: string;
+    close: string;
+}
+declare function disableDefaultColors(): void;
+
 interface AsymmetricMatcherInterface {
 	asymmetricMatch: (other: unknown, customTesters?: Array<Tester>) => boolean;
 	toString: () => string;
@@ -1161,16 +1944,77 @@ declare global {
 }
 
 type ExtractBenchNames<T extends BenchRegistration<any>[]> = Exclude<{ [K in keyof T] : T[K] extends BenchRegistration<infer N> ? N : never }[number], never>;
-type BenchResult = TaskResultCompleted & TaskResultRuntimeInfo & TaskResultTimestampProviderInfo;
+/**
+* A benchmarked function. Vitest-owned and engine-agnostic.
+*/
+type BenchFn = Fn;
+/**
+* Per-benchmark initialization options passed to `bench(name, options, fn)`.
+*/
+type BenchOptions = FnOptions;
+/**
+* Engine-neutral run options forwarded to a {@link BenchmarkProvider}. These
+* come from the optional trailing options argument of `bench.compare()` and
+* `registration.run()`.
+*/
+type BenchRunOptions = BenchOptions$1;
+/**
+* The result of a single benchmark, produced by a {@link BenchmarkProvider}.
+* Structurally compatible with tinybench's task statistics so it flows
+* unchanged into the reporter, `bench.from()` baselines and comparison tables.
+* The `name` matches the corresponding {@link BenchRegistration}.
+*/
+interface BenchResult extends TaskResultCompleted, TaskResultRuntimeInfo, TaskResultTimestampProviderInfo {
+	/** The registered benchmark name this result belongs to. */
+	name: string;
+}
+/**
+* A benchmark defined by `bench()` (or `bench.from()`), as seen by a
+* {@link BenchmarkProvider}. `fn`/`fnOpts` are absent for `bench.from()`
+* registrations, which are resolved from a stored baseline instead of run.
+*/
+interface BenchRegistrationInput {
+	name: string;
+	fn: BenchFn;
+	fnOpts?: BenchOptions;
+}
+/**
+* The set of benchmarks registered by a single test, handed to
+* {@link BenchmarkProvider.run}.
+*/
+interface BenchmarkGroup {
+	/** The test that registered these benchmarks. */
+	test: Test;
+	/** The resolved benchmark configuration for the current project. */
+	config: SerializedConfig["benchmark"];
+	/** The runnable registrations, in registration order. */
+	registrations: BenchRegistrationInput[];
+	/** Engine-neutral run options, when provided by the caller. */
+	options?: BenchRunOptions;
+}
+/**
+* Executes the benchmarks of a single test and returns their results.
+*
+* A custom provider module must default-export an object of this shape.
+*
+* The returned array is the sole source of results: it's what `bench().run()`
+* resolves to and what the reporter serializes. Results are matched to
+* registrations by `name`; return one {@link BenchResult} per registration.
+*
+* @experimental
+*/
+interface BenchmarkProvider {
+	run: (group: BenchmarkGroup) => Promise<BenchResult[]>;
+}
 interface BenchStorage<T extends string> {
 	get: (name: T) => BenchResult;
 }
 
 /**
-* Options accepted by `bench(name, options, fn)`. Extends tinybench's
-* `FnOptions` with Vitest-specific fields.
+* Options accepted by `bench(name, options, fn)`. Extends the per-benchmark
+* lifecycle hooks with Vitest-specific fields.
 */
-interface BenchFnOptions extends FnOptions {
+interface BenchFnOptions extends BenchOptions {
 	/**
 	* Path (relative to the project root) where the benchmark result is written
 	* after a successful run. The string `${projectName}` is substituted with
@@ -1191,21 +2035,21 @@ interface BenchRegistration<Name extends string> {
 	/**
 	* The benchmark function. Absent for registrations created via `bench.from()`.
 	*/
-	fn?: Fn;
+	fn?: BenchFn;
 	/**
 	* Per-benchmark options (`beforeEach`, `beforeAll`, etc.). Absent for
 	* registrations created via `bench.from()`.
 	*/
-	fnOpts?: FnOptions;
-	run: (options?: BenchOptions) => Promise<BenchResult>;
+	fnOpts?: BenchOptions;
+	run: (options?: BenchRunOptions) => Promise<BenchResult>;
 }
 interface BenchCompare {
 	<Args extends BenchRegistration<any>[]>(...args: Args): Promise<BenchStorage<ExtractBenchNames<Args>>>;
-	<Args extends BenchRegistration<any>[]>(...args: [...Args, BenchOptions]): Promise<BenchStorage<ExtractBenchNames<Args>>>;
+	<Args extends BenchRegistration<any>[]>(...args: [...Args, BenchRunOptions]): Promise<BenchStorage<ExtractBenchNames<Args>>>;
 }
 interface BenchFactory {
-	<Name extends string>(name: Name | Function, fn: Fn): BenchRegistration<Name>;
-	<Name extends string>(name: Name | Function, options: BenchFnOptions, fn: Fn): BenchRegistration<Name>;
+	<Name extends string>(name: Name | Function, fn: BenchFn): BenchRegistration<Name>;
+	<Name extends string>(name: Name | Function, options: BenchFnOptions, fn: BenchFn): BenchRegistration<Name>;
 }
 interface BenchFromSource {
 	(): BaselineData | Promise<BaselineData>;
@@ -2461,7 +3305,7 @@ interface TestArtifactLocation extends FileLocation {}
 *
 * 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.
+* **Important**: when running with [`api.allowWrite`](https://vitest.dev/config/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 */
@@ -2768,6 +3612,7 @@ interface SerializedConfig {
 	strictTags: boolean;
 	color?: LabelColor;
 	globals: boolean;
+	injectCjsGlobals: boolean;
 	base: string | undefined;
 	snapshotEnvironment?: string;
 	disableConsoleIntercept: boolean | undefined;
@@ -2781,7 +3626,7 @@ interface SerializedConfig {
 	restoreMocks: boolean;
 	unstubGlobals: boolean;
 	unstubEnvs: boolean;
-	fakeTimers: Config;
+	fakeTimers: Config$1;
 	defines: Record<string, any>;
 	expect: {
 		requireAssertions?: boolean;
@@ -2838,8 +3683,6 @@ interface SerializedConfig {
 	browser: {
 		name: string;
 		headless: boolean;
-		isolate: boolean;
-		fileParallelism: boolean;
 		ui: boolean;
 		viewport: {
 			width: number;
@@ -2870,12 +3713,13 @@ interface SerializedConfig {
 	benchmark: {
 		enabled: boolean;
 		retainSamples: boolean;
+		provider: string | undefined;
 		suppressExportGetterWarnings: boolean;
 		projectName: string;
 	};
 	serializedDefines: string;
+	fsModuleCache: boolean;
 	experimental: {
-		fsModuleCache: boolean;
 		importDurations: {
 			print: boolean | "on-warn";
 			limit: number;
@@ -2900,6 +3744,8 @@ interface SerializedConfig {
 interface SerializedCoverageConfig {
 	provider: "istanbul" | "v8" | "custom" | undefined;
 	reportsDirectory: string;
+	/** Directory where workers write raw coverage results, shard-aware */
+	coverageFilesDirectory: string;
 	htmlDir: string | undefined;
 	enabled: boolean;
 	customProviderModule: string | undefined;
@@ -2916,5 +3762,5 @@ type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookT
 type RuntimeOptions = Partial<RuntimeConfig>;
 type BrowserTraceViewMode = "on" | "off" | "on-first-retry" | "on-all-retries" | "retain-on-failure";
 
-export { onTestFailed as aA, onTestFinished as aB, SnapshotState as aE, afterAll as au, afterEach as av, aroundAll as aw, aroundEach as ax, beforeAll as ay, beforeEach as az, createChainable as t };
-export type { OnTestFinishedHandler as $, AsyncExpectationResult as A, BaselineData as B, Config as C, DomainSnapshotAdapter as D, ExpectStatic as E, File as F, BenchRegistration as G, BenchResult as H, ImportDuration as I, BenchStorage as J, BrowserTraceArtifact as K, LabelColor as L, ModuleGraphData as M, DeeplyAllowMatchers as N, DomainMatchResult as O, ProvidedContext as P, FailureScreenshotArtifact as Q, RuntimeOptions as R, SerializedRootConfig as S, TestAnnotation as T, UserConsoleLog as U, VitestRunner as V, JestAssertion as W, RawMatcherFn as X, Matchers as Y, MatchersObject as Z, OnTestFailedHandler as _, TestArtifact as a, RunMode as a0, TaskBase as a1, TaskResult as a2, RuntimeConfig as a3, SerializedCoverageConfig as a4, SnapshotData as a5, SnapshotMatchOptions as a6, SnapshotResult as a7, SnapshotSerializer as a8, SnapshotStateOptions as a9, SequenceHooks as aC, SequenceSetupFiles as aD, PromisifyAssertion as aF, Tester as aG, FileSpecification as aH, SnapshotEnvironment as aI, SnapshotEnvironmentOptions as aJ, SerializableRetry as aK, AsyncLeak as aL, BrowserTraceViewMode as aM, FetchCachedFileSystemResult as aN, ResolveFunctionResult as aO, SnapshotSummary as aa, SnapshotUpdateState as ab, SuiteFactory as ac, SuiteOptions as ad, TaskCustomOptions as ae, TaskMeta as af, TaskState as ag, TestAnnotationArtifact as ah, TestArtifactBase as ai, TestArtifactLocation as aj, TestArtifactRegistry as ak, TestAttachment as al, TestBenchmark as am, TestBenchmarkTask as an, TestFunction as ao, TestOptions as ap, TestTagDefinition as aq, TestTags as ar, UncheckedSnapshot as as, VisualRegressionArtifact as at, TaskResultPack as b, TaskEventPack as c, Test as d, TaskPopulated as e, MatcherState as f, SyncExpectationResult as g, ExpectationResult as h, TestAPI as i, SuiteCollector as j, SuiteAPI as k, Suite as l, SuiteHooks as m, SerializedConfig as n, VitestRunnerImportSource as o, Task as p, CancelReason as q, TestTryOptions as r, TestContext as s, AfterSuiteRunMeta as u, Assertion as v, AsymmetricMatchersContaining as w, Bench as x, BenchFnOptions as y, BenchFromSource as z };
+export { createChainable as J, afterAll as a$, afterEach as b0, aroundAll as b1, aroundEach as b2, beforeAll as b3, beforeEach as b4, onTestFailed as b5, onTestFinished as b6, disableDefaultColors as b9, SnapshotState as ba, _vitest_spy as bg, format as bi, inspect as bj, stringify as bk, fn as l, spyOn as s };
+export type { BenchRegistration as $, Awaitable as A, CancelReason as B, Config$1 as C, DomainSnapshotAdapter as D, ExpectStatic as E, File as F, TestTryOptions as G, TestContext as H, ImportDuration as I, AfterSuiteRunMeta as K, LabelColor as L, ModuleGraphData as M, Assertion as N, AsymmetricMatchersContaining as O, ProvidedContext as P, BaselineData as Q, RuntimeOptions as R, SerializedRootConfig as S, TestAnnotation as T, UserConsoleLog as U, VitestRunner as V, Bench as W, BenchFn as X, BenchFnOptions as Y, BenchFromSource as Z, BenchOptions as _, TestArtifact as a, BenchRegistrationInput as a0, BenchResult as a1, BenchRunOptions as a2, BenchStorage as a3, BenchmarkGroup as a4, BenchmarkProvider as a5, BrowserTraceArtifact as a6, DeeplyAllowMatchers as a7, DiffOptions as a8, DomainMatchResult as a9, SerializedError as aA, SnapshotData as aB, SnapshotMatchOptions as aC, SnapshotResult as aD, SnapshotSerializer as aE, SnapshotStateOptions as aF, SnapshotSummary as aG, SnapshotUpdateState as aH, SuiteFactory as aI, SuiteOptions as aJ, TaskCustomOptions as aK, TaskMeta as aL, TaskState as aM, TestAnnotationArtifact as aN, TestArtifactBase as aO, TestArtifactLocation as aP, TestArtifactRegistry as aQ, TestAttachment as aR, TestBenchmark as aS, TestBenchmarkTask as aT, TestError as aU, TestFunction as aV, TestOptions as aW, TestTagDefinition as aX, TestTags as aY, UncheckedSnapshot as aZ, VisualRegressionArtifact as a_, FailureScreenshotArtifact as aa, JestAssertion as ab, RawMatcherFn as ac, Matchers as ad, MatchersObject as ae, MockContext as af, MockResult as ag, MockResultIncomplete as ah, MockResultReturn as ai, MockResultThrow as aj, MockSettledResult as ak, MockSettledResultFulfilled as al, MockSettledResultIncomplete as am, MockSettledResultRejected as an, Mocked as ao, MockedClass as ap, MockedFunction as aq, MockedObject as ar, OnTestFailedHandler as as, OnTestFinishedHandler as at, ParsedStack as au, RunMode as av, TaskBase as aw, TaskResult as ax, RuntimeConfig as ay, SerializedCoverageConfig as az, TaskResultPack as b, SequenceHooks as b7, SequenceSetupFiles as b8, PromisifyAssertion as bb, Tester as bc, Plugin as bd, FileSpecification as be, SerializedDiffOptions as bf, StringifyOptions as bh, SnapshotEnvironment as bl, SnapshotEnvironmentOptions as bm, SerializableRetry as bn, BrowserTraceViewMode as bo, Arrayable as bp, ModuleType as bq, AsyncLeak as br, PrettyFormatOptions as bs, FetchCachedFileSystemResult as bt, ResolveFunctionResult as bu, TaskEventPack as c, Test as d, TaskPopulated as e, MatcherState as f, SyncExpectationResult as g, AsyncExpectationResult as h, ExpectationResult as i, Procedure as j, Mock as k, MaybeMockedDeep as m, MaybeMocked as n, MaybePartiallyMocked as o, MaybePartiallyMockedDeep as p, MockInstance as q, TestAPI as r, SuiteCollector as t, SuiteAPI as u, Suite as v, SuiteHooks as w, SerializedConfig as x, VitestRunnerImportSource as y, Task as z };