vitest 0.27.2 → 0.27.3

package/dist/{types-d97c72c7.d.ts → types-c1386a7d.d.ts}

@@ -159,6 +159,282 @@ interface FakeTimerInstallOpts {
     shouldClearNativeTimers?: boolean | undefined;
 }
 
+type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
+    (...args: Args): R;
+} & {
+    [x in T]: ChainableFunction<T, Args, R, E>;
+} & {
+    fn: (this: Record<T, boolean | undefined>, ...args: Args) => R;
+} & E;
+
+interface BenchmarkUserOptions {
+    /**
+     * Include globs for benchmark test files
+     *
+     * @default ['**\/*.{bench,benchmark}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}']
+     */
+    include?: string[];
+    /**
+     * Exclude globs for benchmark test files
+     * @default ['node_modules', 'dist', '.idea', '.git', '.cache']
+     */
+    exclude?: string[];
+    /**
+     * Include globs for in-source benchmark test files
+     *
+     * @default []
+     */
+    includeSource?: string[];
+    /**
+     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+     * and/or paths to custom reporters
+     */
+    reporters?: Arrayable<BenchmarkBuiltinReporters | Reporter>;
+    /**
+     * Write test results to a file when the `--reporter=json` option is also specified.
+     * Also definable individually per reporter by using an object instead.
+     */
+    outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
+}
+interface Benchmark extends TaskBase {
+    type: 'benchmark';
+    suite: Suite;
+    result?: TaskResult;
+    fails?: boolean;
+    task?: Task$1;
+}
+interface BenchmarkResult extends TaskResult$1 {
+    name: string;
+    rank: number;
+}
+type BenchFunction = (this: Bench) => Promise<void> | void;
+type BenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', [
+    name: string,
+    fn?: BenchFunction,
+    options?: Options
+], void> & {
+    skipIf(condition: any): BenchmarkAPI;
+    runIf(condition: any): BenchmarkAPI;
+};
+
+type Awaitable<T> = T | PromiseLike<T>;
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type ArgumentsType$1<T> = T extends (...args: infer U) => any ? U : never;
+type MergeInsertions<T> = T extends object ? {
+    [K in keyof T]: MergeInsertions<T[K]>;
+} : T;
+type DeepMerge<F, S> = MergeInsertions<{
+    [K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
+}>;
+type MutableArray<T extends readonly any[]> = {
+    -readonly [k in keyof T]: T[k];
+};
+interface Constructable {
+    new (...args: any[]): any;
+}
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    code?: string;
+}
+interface EnvironmentReturn {
+    teardown: (global: any) => Awaitable<void>;
+}
+interface Environment {
+    name: string;
+    setup(global: any, options: Record<string, any>): Awaitable<EnvironmentReturn>;
+}
+interface UserConsoleLog {
+    content: string;
+    type: 'stdout' | 'stderr';
+    taskId?: string;
+    time: number;
+    size: number;
+}
+interface ParsedStack {
+    method: string;
+    file: string;
+    line: number;
+    column: number;
+}
+interface ErrorWithDiff extends Error {
+    name: string;
+    nameStr?: string;
+    stack?: string;
+    stackStr?: string;
+    stacks?: ParsedStack[];
+    showDiff?: boolean;
+    actual?: any;
+    expected?: any;
+    operator?: string;
+    type?: string;
+    frame?: string;
+}
+interface ModuleGraphData {
+    graph: Record<string, string[]>;
+    externalized: string[];
+    inlined: string[];
+}
+type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+
+type RunMode = 'run' | 'skip' | 'only' | 'todo';
+type TaskState = RunMode | 'pass' | 'fail';
+interface TaskBase {
+    id: string;
+    name: string;
+    mode: RunMode;
+    concurrent?: boolean;
+    shuffle?: boolean;
+    suite?: Suite;
+    file?: File;
+    result?: TaskResult;
+    retry?: number;
+    logs?: UserConsoleLog[];
+    meta?: any;
+}
+interface TaskResult {
+    state: TaskState;
+    duration?: number;
+    startTime?: number;
+    heap?: number;
+    /**
+     * @deprecated Use "errors" instead
+     */
+    error?: ErrorWithDiff;
+    errors?: ErrorWithDiff[];
+    htmlError?: string;
+    hooks?: Partial<Record<keyof SuiteHooks, TaskState>>;
+    benchmark?: BenchmarkResult;
+    retryCount?: number;
+}
+type TaskResultPack = [id: string, result: TaskResult | undefined];
+interface Suite extends TaskBase {
+    type: 'suite';
+    tasks: Task[];
+    filepath?: string;
+    benchmark?: Bench;
+    projectName?: string;
+}
+interface File extends Suite {
+    filepath: string;
+    collectDuration?: number;
+    setupDuration?: number;
+}
+interface Test<ExtraContext = {}> extends TaskBase {
+    type: 'test';
+    suite: Suite;
+    result?: TaskResult;
+    fails?: boolean;
+    context: TestContext & ExtraContext;
+    onFailed?: OnTestFailedHandler[];
+}
+type Task = Test | Suite | File | Benchmark;
+type DoneCallback = (error?: any) => void;
+type TestFunction<ExtraContext = {}> = (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 SuiteEachFunction {
+    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>) => void;
+    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>) => void;
+    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>) => void;
+}
+interface TestEachFunction {
+    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>, options?: number | TestOptions) => void;
+    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>, options?: number | TestOptions) => void;
+    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>, options?: number | TestOptions) => void;
+    (...args: [TemplateStringsArray, ...any]): (name: string, fn: (...args: any[]) => Awaitable<void>, options?: number | TestOptions) => void;
+}
+type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
+    name: string,
+    fn?: TestFunction<ExtraContext>,
+    options?: number | TestOptions
+], void, {
+    each: TestEachFunction;
+    <T extends ExtraContext>(name: string, fn?: TestFunction<T>, options?: number | TestOptions): void;
+}>;
+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 1
+     */
+    retry?: number;
+}
+type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
+    each: TestEachFunction;
+    skipIf(condition: any): ChainableTestAPI<ExtraContext>;
+    runIf(condition: any): ChainableTestAPI<ExtraContext>;
+};
+type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'shuffle', [
+    name: string,
+    factory?: SuiteFactory<ExtraContext>,
+    options?: number | TestOptions
+], SuiteCollector<ExtraContext>, {
+    each: TestEachFunction;
+    <T extends ExtraContext>(name: string, factory?: SuiteFactory<T>): SuiteCollector<T>;
+}>;
+type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI<ExtraContext> & {
+    each: SuiteEachFunction;
+    skipIf(condition: any): ChainableSuiteAPI<ExtraContext>;
+    runIf(condition: any): ChainableSuiteAPI<ExtraContext>;
+};
+type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
+type HookCleanupCallback = (() => Awaitable<unknown>) | void;
+interface SuiteHooks<ExtraContext = {}> {
+    beforeAll: HookListener<[Suite | File], HookCleanupCallback>[];
+    afterAll: HookListener<[Suite | File]>[];
+    beforeEach: HookListener<[TestContext & ExtraContext, Suite], HookCleanupCallback>[];
+    afterEach: HookListener<[TestContext & ExtraContext, Suite]>[];
+}
+interface SuiteCollector<ExtraContext = {}> {
+    readonly name: string;
+    readonly mode: RunMode;
+    type: 'collector';
+    test: TestAPI<ExtraContext>;
+    benchmark: BenchmarkAPI;
+    tasks: (Suite | Test | Benchmark | SuiteCollector<ExtraContext>)[];
+    collect: (file?: File) => Promise<Suite>;
+    clear: () => void;
+    on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
+}
+type SuiteFactory<ExtraContext = {}> = (test: (name: string, fn: TestFunction<ExtraContext>) => void) => Awaitable<void>;
+interface RuntimeContext {
+    tasks: (SuiteCollector | Test)[];
+    currentSuite: SuiteCollector | null;
+}
+interface TestContext {
+    /**
+     * Metadata of the current test
+     */
+    meta: Readonly<Test>;
+    /**
+     * A expect instance bound to the test
+     */
+    expect: Vi.ExpectStatic;
+    /**
+     * Extract hooks on test failed
+     */
+    onTestFailed: (fn: OnTestFailedHandler) => void;
+}
+type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
+
 declare class SnapshotManager {
     options: SnapshotStateOptions;
     summary: SnapshotSummary;
@@ -440,7 +716,7 @@ declare abstract class BaseReporter implements Reporter {
     start: number;
     end: number;
     watchFilters?: string[];
-    isTTY: false;
+    isTTY: boolean;
     ctx: Vitest;
     private _filesInWatchMode;
     private _lastRunTimeout;
@@ -467,6 +743,11 @@ declare abstract class BaseReporter implements Reporter {
     registerUnhandledRejection(): void;
 }
 
+declare class BasicReporter extends BaseReporter {
+    isTTY: boolean;
+    reportSummary(files: File[]): Promise<void>;
+}
+
 interface ListRendererOptions$1 {
     renderSucceed?: boolean;
     logger: Logger;
@@ -608,6 +889,7 @@ type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
 
 declare const ReportersMap: {
     default: typeof DefaultReporter;
+    basic: typeof BasicReporter;
     verbose: typeof VerboseReporter;
     dot: typeof DotReporter;
     json: typeof JsonReporter$1;
@@ -799,90 +1081,29 @@ interface PluginContextMeta {
 	watchMode: boolean;
 }
 
-interface ResolvedId extends ModuleOptions {
-	external: boolean | 'absolute';
-	id: string;
-}
-
-type IsExternal = (
-	source: string,
-	importer: string | undefined,
-	isResolved: boolean
-) => boolean;
-
-interface TransformPluginContext extends PluginContext {
-	getCombinedSourcemap: () => SourceMap;
-}
-
-type TransformResult = string | null | void | Partial<SourceDescription>;
-type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
-
-interface AcornNode {
-	end: number;
-	start: number;
-	type: string;
-}
-
-type Awaitable<T> = T | PromiseLike<T>;
-type Nullable<T> = T | null | undefined;
-type Arrayable<T> = T | Array<T>;
-type ArgumentsType$1<T> = T extends (...args: infer U) => any ? U : never;
-type MergeInsertions<T> = T extends object ? {
-    [K in keyof T]: MergeInsertions<T[K]>;
-} : T;
-type DeepMerge<F, S> = MergeInsertions<{
-    [K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
-}>;
-type MutableArray<T extends readonly any[]> = {
-    -readonly [k in keyof T]: T[k];
-};
-interface Constructable {
-    new (...args: any[]): any;
-}
-interface ModuleCache {
-    promise?: Promise<any>;
-    exports?: any;
-    code?: string;
-}
-interface EnvironmentReturn {
-    teardown: (global: any) => Awaitable<void>;
-}
-interface Environment {
-    name: string;
-    setup(global: any, options: Record<string, any>): Awaitable<EnvironmentReturn>;
-}
-interface UserConsoleLog {
-    content: string;
-    type: 'stdout' | 'stderr';
-    taskId?: string;
-    time: number;
-    size: number;
-}
-interface ParsedStack {
-    method: string;
-    file: string;
-    line: number;
-    column: number;
+interface ResolvedId extends ModuleOptions {
+	external: boolean | 'absolute';
+	id: string;
 }
-interface ErrorWithDiff extends Error {
-    name: string;
-    nameStr?: string;
-    stack?: string;
-    stackStr?: string;
-    stacks?: ParsedStack[];
-    showDiff?: boolean;
-    actual?: any;
-    expected?: any;
-    operator?: string;
-    type?: string;
-    frame?: string;
+
+type IsExternal = (
+	source: string,
+	importer: string | undefined,
+	isResolved: boolean
+) => boolean;
+
+interface TransformPluginContext extends PluginContext {
+	getCombinedSourcemap: () => SourceMap;
 }
-interface ModuleGraphData {
-    graph: Record<string, string[]>;
-    externalized: string[];
-    inlined: string[];
+
+type TransformResult = string | null | void | Partial<SourceDescription>;
+type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
+
+interface AcornNode {
+	end: number;
+	start: number;
+	type: string;
 }
-type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
 
 declare type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
 declare type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
@@ -897,221 +1118,6 @@ declare type BirpcReturn<RemoteFunctions> = {
     [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
 };
 
-type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
-    (...args: Args): R;
-} & {
-    [x in T]: ChainableFunction<T, Args, R, E>;
-} & {
-    fn: (this: Record<T, boolean | undefined>, ...args: Args) => R;
-} & E;
-
-interface BenchmarkUserOptions {
-    /**
-     * Include globs for benchmark test files
-     *
-     * @default ['**\/*.{bench,benchmark}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}']
-     */
-    include?: string[];
-    /**
-     * Exclude globs for benchmark test files
-     * @default ['node_modules', 'dist', '.idea', '.git', '.cache']
-     */
-    exclude?: string[];
-    /**
-     * Include globs for in-source benchmark test files
-     *
-     * @default []
-     */
-    includeSource?: string[];
-    /**
-     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
-     * and/or paths to custom reporters
-     */
-    reporters?: Arrayable<BenchmarkBuiltinReporters | Reporter>;
-    /**
-     * Write test results to a file when the `--reporter=json` option is also specified.
-     * Also definable individually per reporter by using an object instead.
-     */
-    outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
-}
-interface Benchmark extends TaskBase {
-    type: 'benchmark';
-    suite: Suite;
-    result?: TaskResult;
-    fails?: boolean;
-    task?: Task$1;
-}
-interface BenchmarkResult extends TaskResult$1 {
-    name: string;
-    rank: number;
-}
-type BenchFunction = (this: Bench) => Promise<void> | void;
-type BenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', [
-    name: string,
-    fn?: BenchFunction,
-    options?: Options
-], void> & {
-    skipIf(condition: any): BenchmarkAPI;
-    runIf(condition: any): BenchmarkAPI;
-};
-
-type RunMode = 'run' | 'skip' | 'only' | 'todo';
-type TaskState = RunMode | 'pass' | 'fail';
-interface TaskBase {
-    id: string;
-    name: string;
-    mode: RunMode;
-    concurrent?: boolean;
-    shuffle?: boolean;
-    suite?: Suite;
-    file?: File;
-    result?: TaskResult;
-    retry?: number;
-    logs?: UserConsoleLog[];
-    meta?: any;
-}
-interface TaskResult {
-    state: TaskState;
-    duration?: number;
-    startTime?: number;
-    heap?: number;
-    /**
-     * @deprecated Use "errors" instead
-     */
-    error?: ErrorWithDiff;
-    errors?: ErrorWithDiff[];
-    htmlError?: string;
-    hooks?: Partial<Record<keyof SuiteHooks, TaskState>>;
-    benchmark?: BenchmarkResult;
-    retryCount?: number;
-}
-type TaskResultPack = [id: string, result: TaskResult | undefined];
-interface Suite extends TaskBase {
-    type: 'suite';
-    tasks: Task[];
-    filepath?: string;
-    benchmark?: Bench;
-    projectName?: string;
-}
-interface File extends Suite {
-    filepath: string;
-    collectDuration?: number;
-    setupDuration?: number;
-}
-interface Test<ExtraContext = {}> extends TaskBase {
-    type: 'test';
-    suite: Suite;
-    result?: TaskResult;
-    fails?: boolean;
-    context: TestContext & ExtraContext;
-    onFailed?: OnTestFailedHandler[];
-}
-type Task = Test | Suite | File | Benchmark;
-type DoneCallback = (error?: any) => void;
-type TestFunction<ExtraContext = {}> = (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 SuiteEachFunction {
-    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>) => void;
-    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>) => void;
-    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>) => void;
-}
-interface TestEachFunction {
-    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>, options?: number | TestOptions) => void;
-    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>, options?: number | TestOptions) => void;
-    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>, options?: number | TestOptions) => void;
-    (...args: [TemplateStringsArray, ...any]): (name: string, fn: (...args: any[]) => Awaitable<void>, options?: number | TestOptions) => void;
-}
-type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
-    name: string,
-    fn?: TestFunction<ExtraContext>,
-    options?: number | TestOptions
-], void, {
-    each: TestEachFunction;
-    <T extends ExtraContext>(name: string, fn?: TestFunction<T>, options?: number | TestOptions): void;
-}>;
-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 1
-     */
-    retry?: number;
-}
-type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
-    each: TestEachFunction;
-    skipIf(condition: any): ChainableTestAPI<ExtraContext>;
-    runIf(condition: any): ChainableTestAPI<ExtraContext>;
-};
-type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'shuffle', [
-    name: string,
-    factory?: SuiteFactory<ExtraContext>,
-    options?: number | TestOptions
-], SuiteCollector<ExtraContext>, {
-    each: TestEachFunction;
-    <T extends ExtraContext>(name: string, factory?: SuiteFactory<T>): SuiteCollector<T>;
-}>;
-type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI<ExtraContext> & {
-    each: SuiteEachFunction;
-    skipIf(condition: any): ChainableSuiteAPI<ExtraContext>;
-    runIf(condition: any): ChainableSuiteAPI<ExtraContext>;
-};
-type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
-type HookCleanupCallback = (() => Awaitable<unknown>) | void;
-interface SuiteHooks<ExtraContext = {}> {
-    beforeAll: HookListener<[Suite | File], HookCleanupCallback>[];
-    afterAll: HookListener<[Suite | File]>[];
-    beforeEach: HookListener<[TestContext & ExtraContext, Suite], HookCleanupCallback>[];
-    afterEach: HookListener<[TestContext & ExtraContext, Suite]>[];
-}
-interface SuiteCollector<ExtraContext = {}> {
-    readonly name: string;
-    readonly mode: RunMode;
-    type: 'collector';
-    test: TestAPI<ExtraContext>;
-    benchmark: BenchmarkAPI;
-    tasks: (Suite | Test | Benchmark | SuiteCollector<ExtraContext>)[];
-    collect: (file?: File) => Promise<Suite>;
-    clear: () => void;
-    on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
-}
-type SuiteFactory<ExtraContext = {}> = (test: (name: string, fn: TestFunction<ExtraContext>) => void) => Awaitable<void>;
-interface RuntimeContext {
-    tasks: (SuiteCollector | Test)[];
-    currentSuite: SuiteCollector | null;
-}
-interface TestContext {
-    /**
-     * Metadata of the current test
-     */
-    meta: Readonly<Test>;
-    /**
-     * A expect instance bound to the test
-     */
-    expect: Vi.ExpectStatic;
-    /**
-     * Extract hooks on test failed
-     */
-    onTestFailed: (fn: OnTestFailedHandler) => void;
-}
-type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
-
 type SnapshotData = Record<string, string>;
 type SnapshotUpdateState = 'all' | 'new' | 'none';
 interface SnapshotStateOptions {
@@ -1178,7 +1184,7 @@ interface WorkerRPC {
     onWorkerExit: (error: unknown, code?: number) => void;
     onPathsCollected: (paths: string[]) => void;
     onUserConsoleLog: (log: UserConsoleLog) => void;
-    onUnhandledRejection: (err: unknown) => void;
+    onUnhandledError: (err: unknown, type: string) => void;
     onCollected: (files: File[]) => void;
     onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
     onTaskUpdate: (pack: TaskResultPack[]) => void;
@@ -1203,7 +1209,7 @@ interface CoverageProvider {
     clean(clean?: boolean): void | Promise<void>;
     onBeforeFilesRun?(): void | Promise<void>;
     onAfterSuiteRun(meta: AfterSuiteRunMeta): void | Promise<void>;
-    reportCoverage(reportContext: ReportContext): void | Promise<void>;
+    reportCoverage(reportContext?: ReportContext): void | Promise<void>;
     onFileTransform?(sourceCode: string, id: string, pluginCtx: TransformPluginContext): TransformResult | Promise<TransformResult>;
 }
 interface ReportContext {
@@ -1221,16 +1227,19 @@ interface CoverageProviderModule {
     takeCoverage?(): unknown | Promise<unknown>;
 }
 type CoverageReporter = 'clover' | 'cobertura' | 'html-spa' | 'html' | 'json-summary' | 'json' | 'lcov' | 'lcovonly' | 'none' | 'teamcity' | 'text-lcov' | 'text-summary' | 'text';
-type CoverageOptions = BaseCoverageOptions & {
-    provider?: null | CoverageProviderModule;
-} | CoverageC8Options & {
-    provider?: 'c8';
-} | CoverageIstanbulOptions & {
-    provider?: 'istanbul';
+type Provider = 'c8' | 'istanbul' | CoverageProviderModule | undefined;
+type CoverageOptions<T extends Provider = Provider> = T extends CoverageProviderModule ? ({
+    provider: T;
+} & BaseCoverageOptions) : T extends 'istanbul' ? ({
+    provider: T;
+} & CoverageIstanbulOptions) : ({
+    provider?: T;
+} & CoverageC8Options);
+/** Fields that have default values. Internally these will always be defined. */
+type FieldsWithDefaultValues = 'enabled' | 'clean' | 'cleanOnRerun' | 'reportsDirectory' | 'exclude' | 'extension' | 'reporter';
+type ResolvedCoverageOptions<T extends Provider = Provider> = CoverageOptions<T> & Required<Pick<CoverageOptions<T>, FieldsWithDefaultValues>> & {
+    reporter: CoverageReporter[];
 };
-type ResolvedCoverageOptions = {
-    tempDirectory: string;
-} & Required<CoverageOptions>;
 interface BaseCoverageOptions {
     /**
      * Enables coverage collection. Can be overriden using `--coverage` CLI option.
@@ -1570,6 +1579,21 @@ interface InlineConfig {
      * Environment options.
      */
     environmentOptions?: EnvironmentOptions;
+    /**
+     * Automatically assign environment based on globs. The first match will be used.
+     *
+     * Format: [glob, environment-name]
+     *
+     * @default []
+     * @example [
+     *   // all tests in tests/dom will run in jsdom
+     *   ['tests/dom/**', 'jsdom'],
+     *   // all tests in tests/ with .edge.test.ts will run in edge-runtime
+     *   ['**\/*.edge.test.ts', 'edge-runtime'],
+     *   // ...
+     * ]
+     */
+    environmentMatchGlobs?: [string, VitestEnvironment][];
     /**
      * Update snapshot
      *