vitest 1.6.0 → 2.0.0-beta.10

package/dist/{reporters-yx5ZTtEV.d.ts → reporters-CYVC6LOl.d.ts}

@@ -1,10 +1,10 @@
 import * as vite from 'vite';
-import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, ConfigEnv, ServerOptions, DepOptimizationConfig, AliasOptions } from 'vite';
+import { TransformResult as TransformResult$1, ViteDevServer, UserConfig as UserConfig$1, ConfigEnv, ServerOptions, DepOptimizationConfig, AliasOptions } from 'vite';
 import * as _vitest_runner from '@vitest/runner';
-import { File, Test as Test$1, Suite, TaskResultPack, Task, CancelReason, Custom, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
-import { RawSourceMap, FetchResult, ViteNodeResolveId, ModuleCacheMap, ViteNodeServerOptions } from 'vite-node';
-import { SnapshotResult, SnapshotStateOptions, SnapshotState } from '@vitest/snapshot';
-import { ExpectStatic } from '@vitest/expect';
+import { File, Test as Test$1, Suite, TaskResultPack, CancelReason, Task, TaskMeta, Custom, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import { RawSourceMap, ViteNodeResolveId, FetchResult, ModuleCacheMap, ViteNodeServerOptions } from 'vite-node';
+import { SnapshotResult, SnapshotSummary, SnapshotStateOptions, SnapshotState } from '@vitest/snapshot';
+import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
 import { ChainableFunction } from '@vitest/runner/utils';
 import { ParsedStack, Awaitable as Awaitable$1, Arrayable as Arrayable$1 } from '@vitest/utils';
 import { TaskResult, Bench, Options as Options$1 } from 'tinybench';
@@ -632,13 +632,13 @@ declare class Logger {
     clearFullScreen(message: string): void;
     clearScreen(message: string, force?: boolean): void;
     private _clearScreen;
-    printError(err: unknown, options?: ErrorOptions): Promise<void>;
+    printError(err: unknown, options?: ErrorOptions): void;
     clearHighlightCache(filename?: string): void;
     highlight(filename: string, source: string): string;
     printNoTestFound(filters?: string[]): void;
     printBanner(): void;
-    printUnhandledErrors(errors: unknown[]): Promise<void>;
-    printSourceTypeErrors(errors: TypeCheckError[]): Promise<void>;
+    printUnhandledErrors(errors: unknown[]): void;
+    printSourceTypeErrors(errors: TypeCheckError[]): void;
 }
 
 interface BrowserProviderInitializationOptions {
@@ -647,8 +647,15 @@ interface BrowserProviderInitializationOptions {
 }
 interface BrowserProvider {
     name: string;
+    /**
+     * @experimental opt-in into file parallelisation
+     */
+    supportsParallelism: boolean;
     getSupportedBrowsers: () => readonly string[];
-    openPage: (url: string) => Awaitable$1<void>;
+    beforeCommand?: (command: string, args: unknown[]) => Awaitable$1<void>;
+    afterCommand?: (command: string, args: unknown[]) => Awaitable$1<void>;
+    getCommandsContext: (contextId: string) => Record<string, unknown>;
+    openPage: (contextId: string, url: string) => Promise<void>;
     close: () => Awaitable$1<void>;
     initialize(ctx: WorkspaceProject, options: BrowserProviderInitializationOptions): Awaitable$1<void>;
 }
@@ -668,9 +675,9 @@ interface BrowserConfigOptions {
     /**
      * Browser provider
      *
-     * @default 'webdriverio'
+     * @default 'preview'
      */
-    provider?: 'webdriverio' | 'playwright' | 'none' | (string & {});
+    provider?: 'webdriverio' | 'playwright' | 'preview' | (string & {});
     /**
      * Options that are passed down to a browser provider.
      * To support type hinting, add one of the types to your tsconfig.json "compilerOptions.types" field:
@@ -694,14 +701,6 @@ interface BrowserConfigOptions {
      * The default port is 63315.
      */
     api?: ApiConfig | number;
-    /**
-     * Update ESM imports so they can be spied/stubbed with vi.spyOn.
-     * Enabled by default when running in browser.
-     *
-     * @default false
-     * @experimental
-     */
-    slowHijackESM?: boolean;
     /**
      * Isolate test environment after each test
      *
@@ -709,11 +708,40 @@ interface BrowserConfigOptions {
      */
     isolate?: boolean;
     /**
-     * Run test files in parallel. Fallbacks to `test.fileParallelism`.
+     * Run test files in parallel if provider supports this option
+     * This option only has effect in headless mode (enabled in CI by default)
      *
-     * @default test.fileParallelism
+     * @default // Same as "test.fileParallelism"
      */
     fileParallelism?: boolean;
+    /**
+     * Show Vitest UI
+     *
+     * @default !process.env.CI
+     */
+    ui?: boolean;
+    /**
+     * Default viewport size
+     */
+    viewport?: {
+        /**
+         * Width of the viewport
+         * @default 414
+         */
+        width: number;
+        /**
+         * Height of the viewport
+         * @default 896
+         */
+        height: number;
+    };
+    /**
+     * Directory where screenshots will be saved when page.screenshot() is called
+     * If not set, all screenshots are saved to __screenshots__ directory in the same folder as the test file.
+     * If this is set, it will be resolved relative to the project root.
+     * @default __screenshots__
+     */
+    screenshotDirectory?: string;
     /**
      * Scripts injected into the tester iframe.
      */
@@ -721,7 +749,22 @@ interface BrowserConfigOptions {
     /**
      * Scripts injected into the main window.
      */
-    indexScripts?: BrowserScript[];
+    orchestratorScripts?: BrowserScript[];
+    /**
+     * Commands that will be executed on the server
+     * via the browser `import("@vitest/browser/context").commands` API.
+     * @see {@link https://vitest.dev/guide/browser#commands}
+     */
+    commands?: Record<string, BrowserCommand<any>>;
+}
+interface BrowserCommandContext {
+    testPath: string | undefined;
+    provider: BrowserProvider;
+    project: WorkspaceProject;
+    contextId: string;
+}
+interface BrowserCommand<Payload extends unknown[]> {
+    (context: BrowserCommandContext, ...payload: Payload): Awaitable$1<any>;
 }
 interface BrowserScript {
     /**
@@ -755,8 +798,159 @@ interface ResolvedBrowserOptions extends BrowserConfigOptions {
     enabled: boolean;
     headless: boolean;
     isolate: boolean;
+    fileParallelism: boolean;
     api: ApiConfig;
+    ui: boolean;
+    viewport: {
+        width: number;
+        height: number;
+    };
+}
+
+declare class VitestBrowserServerMocker {
+    #private;
+    mocks: Map<string, {
+        sessionId: string;
+        mock: string | null | undefined;
+    }>;
+    constructor(project: WorkspaceProject);
+    resolveMock(rawId: string, importer: string, hasFactory: boolean): Promise<{
+        type: "factory";
+        resolvedId: string;
+        mockPath?: undefined;
+    } | {
+        type: "redirect" | "automock";
+        mockPath: string | null;
+        resolvedId: string;
+    }>;
+    private resolveId;
+    resolveMockPath(mockPath: string, external: string | null): string | null;
+}
+
+type ArgumentsType$1<T> = T extends (...args: infer A) => any ? A : never;
+type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
+type PromisifyFn<T> = ReturnType$1<T> extends Promise<any> ? T : (...args: ArgumentsType$1<T>) => Promise<Awaited<ReturnType$1<T>>>;
+type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
+interface ChannelOptions {
+    /**
+     * Function to post raw message
+     */
+    post: (data: any, ...extras: any[]) => any | Promise<any>;
+    /**
+     * Listener to receive raw message
+     */
+    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Custom function to serialize data
+     *
+     * by default it passes the data as-is
+     */
+    serialize?: (data: any) => any;
+    /**
+     * Custom function to deserialize data
+     *
+     * by default it passes the data as-is
+     */
+    deserialize?: (data: any) => any;
+}
+interface EventOptions<Remote> {
+    /**
+     * Names of remote functions that do not need response.
+     */
+    eventNames?: (keyof Remote)[];
+    /**
+     * Maximum timeout for waiting for response, in milliseconds.
+     *
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Custom resolver to resolve function to be called
+     *
+     * For advanced use cases only
+     */
+    resolver?: BirpcResolver;
+    /**
+     * Custom error handler
+     */
+    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for timeouts
+     */
+    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType$1<T>) => void;
+};
+type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+} & {
+    $functions: LocalFunctions;
+};
+
+interface TransformResultWithSource extends TransformResult$1 {
+    source?: string;
+}
+interface WebSocketHandlers {
+    onCollected: (files?: File[]) => Promise<void>;
+    onTaskUpdate: (packs: TaskResultPack[]) => void;
+    getFiles: () => File[];
+    getTestFiles: () => Promise<[{
+        name: string;
+        root: string;
+    }, file: string][]>;
+    getPaths: () => string[];
+    getConfig: () => ResolvedConfig;
+    getModuleGraph: (projectName: string, id: string, browser?: boolean) => Promise<ModuleGraphData>;
+    getTransformResult: (projectName: string, id: string, browser?: boolean) => Promise<TransformResultWithSource | undefined>;
+    readTestFile: (id: string) => Promise<string | null>;
+    saveTestFile: (id: string, content: string) => Promise<void>;
+    rerun: (files: string[]) => Promise<void>;
+    updateSnapshot: (file?: File) => Promise<void>;
+    getUnhandledErrors: () => unknown[];
+}
+interface WebSocketBrowserHandlers {
+    resolveSnapshotPath: (testPath: string) => string;
+    resolveSnapshotRawPath: (testPath: string, rawPath: string) => string;
+    onUnhandledError: (error: unknown, type: string) => Promise<void>;
+    onCollected: (files?: File[]) => Promise<void>;
+    onTaskUpdate: (packs: TaskResultPack[]) => void;
+    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+    onCancel: (reason: CancelReason) => void;
+    getCountOfFailedTests: () => number;
+    readSnapshotFile: (id: string) => Promise<string | null>;
+    saveSnapshotFile: (id: string, content: string) => Promise<void>;
+    removeSnapshotFile: (id: string) => Promise<void>;
+    sendLog: (log: UserConsoleLog) => void;
+    finishBrowserTests: (contextId: string) => void;
+    snapshotSaved: (snapshot: SnapshotResult) => void;
+    debug: (...args: string[]) => void;
+    resolveId: (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+    triggerCommand: <T>(contextId: string, command: string, testPath: string | undefined, payload: unknown[]) => Promise<T>;
+    resolveMock: (id: string, importer: string, hasFactory: boolean) => Promise<{
+        type: 'factory' | 'redirect' | 'automock';
+        mockPath?: string | null;
+        resolvedId: string;
+    }>;
+    automock: (id: string) => Promise<string>;
+    invalidate: (ids: string[]) => void;
+    getBrowserFileSourceMap: (id: string) => Promise<TransformResult$1['map'] | undefined>;
+    getProvidedContext: () => ProvidedContext;
+}
+interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog' | 'onPathsCollected' | 'onSpecsCollected'> {
+    onFinishedReportCoverage: () => void;
+}
+interface WebSocketBrowserEvents {
+    onCancel: (reason: CancelReason) => void;
+    startMocking: (id: string) => Promise<string[]>;
+    createTesters: (files: string[]) => Promise<void>;
 }
+type WebSocketRPC = BirpcReturn<WebSocketEvents, WebSocketHandlers>;
+type WebSocketBrowserRPC = BirpcReturn<WebSocketBrowserEvents, WebSocketBrowserHandlers>;
 
 interface InitializeProjectOptions extends UserWorkspaceConfig {
     workspaceConfigPath: string;
@@ -775,11 +969,16 @@ declare class WorkspaceProject {
     typechecker?: Typechecker;
     closingPromise: Promise<unknown> | undefined;
     browserProvider: BrowserProvider | undefined;
-    browserState: {
+    browserMocker: VitestBrowserServerMocker;
+    browserRpc: {
+        orchestrators: Map<string, WebSocketBrowserRPC>;
+        testers: Map<string, WebSocketBrowserRPC>;
+    };
+    browserState: Map<string, {
         files: string[];
         resolve: () => void;
         reject: (v: unknown) => void;
-    } | undefined;
+    }>;
     testFilesList: string[] | null;
     readonly id: string;
     readonly tmpDir: string;
@@ -823,11 +1022,12 @@ interface ProcessPool {
     runTests: RunWithFiles;
     close?: () => Awaitable$1<void>;
 }
+declare function getFilePoolName(project: WorkspaceProject, file: string): Pool;
 
 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 ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
 type MutableArray<T extends readonly any[]> = {
     -readonly [k in keyof T]: T[k];
 };
@@ -856,6 +1056,8 @@ interface Environment {
 }
 interface UserConsoleLog {
     content: string;
+    origin?: string;
+    browser?: boolean;
     type: 'stdout' | 'stderr';
     taskId?: string;
     time: number;
@@ -890,7 +1092,8 @@ declare class StateManager {
     collectFiles(files?: File[]): void;
     clearFiles(_project: {
         config: {
-            name: string;
+            name: string | undefined;
+            root: string;
         };
     }, paths?: string[]): void;
     updateId(task: Task): void;
@@ -910,6 +1113,7 @@ declare class ResultsCache {
     private cachePath;
     private version;
     private root;
+    constructor(version: string);
     getCachePath(): string | null;
     setConfig(root: string, config: ResolvedConfig['cache']): void;
     getResults(key: string): SuiteResultCache | undefined;
@@ -931,6 +1135,7 @@ declare class FilesStatsCache {
 declare class VitestCache {
     results: ResultsCache;
     stats: FilesStatsCache;
+    constructor(version: string);
     getFileTestResults(key: string): SuiteResultCache | undefined;
     getFileStats(key: string): {
         size: number;
@@ -950,6 +1155,7 @@ interface VitestOptions {
 }
 declare class Vitest {
     readonly mode: VitestRunMode;
+    version: string;
     config: ResolvedConfig;
     configOverride: Partial<ResolvedConfig>;
     server: ViteDevServer;
@@ -986,10 +1192,12 @@ declare class Vitest {
     private createCoreProject;
     getCoreWorkspaceProject(): WorkspaceProject;
     getProjectByTaskId(taskId: string): WorkspaceProject;
+    getProjectByName(name?: string): WorkspaceProject;
     private getWorkspaceConfigPath;
     private resolveWorkspace;
     private initCoverageProvider;
     private initBrowserProviders;
+    mergeReports(): Promise<void>;
     start(filters?: string[]): Promise<void>;
     init(): Promise<void>;
     private getTestDependencies;
@@ -997,7 +1205,7 @@ declare class Vitest {
     getProjectsByTestFile(file: string): WorkspaceSpec[];
     initializeGlobalSetup(paths: WorkspaceSpec[]): Promise<void>;
     private initializeDistPath;
-    runFiles(paths: WorkspaceSpec[], allTestsRun: boolean): Promise<void>;
+    runFiles(specs: WorkspaceSpec[], allTestsRun: boolean): Promise<void>;
     cancelCurrentRun(reason: CancelReason): Promise<void>;
     rerunFiles(files?: string[], trigger?: string): Promise<void>;
     changeProjectName(pattern: string): Promise<void>;
@@ -1024,7 +1232,7 @@ declare class Vitest {
      * Close the thread pool and exit the process
      */
     exit(force?: boolean): Promise<void>;
-    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
+    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType<Reporter[T]>): Promise<void>;
     getTestFilepaths(): Promise<string[]>;
     globTestFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
     shouldKeepServer(): boolean;
@@ -1046,91 +1254,6 @@ interface TestSequencerConstructor {
     new (ctx: Vitest): TestSequencer;
 }
 
-declare abstract class BaseReporter implements Reporter {
-    start: number;
-    end: number;
-    watchFilters?: string[];
-    isTTY: boolean;
-    ctx: Vitest;
-    private _filesInWatchMode;
-    private _lastRunTimeout;
-    private _lastRunTimer;
-    private _lastRunCount;
-    private _timeStart;
-    private _offUnhandledRejection?;
-    constructor();
-    get mode(): VitestRunMode;
-    onInit(ctx: Vitest): void;
-    relative(path: string): string;
-    onFinished(files?: File[], errors?: unknown[]): Promise<void>;
-    onTaskUpdate(packs: TaskResultPack[]): void;
-    onWatcherStart(files?: File[], errors?: unknown[]): Promise<void>;
-    private resetLastRunLog;
-    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
-    onUserConsoleLog(log: UserConsoleLog): void;
-    shouldLog(log: UserConsoleLog): boolean;
-    onServerRestart(reason?: string): void;
-    reportSummary(files: File[], errors: unknown[]): Promise<void>;
-    reportTestSummary(files: File[], errors: unknown[]): Promise<void>;
-    private printErrorsSummary;
-    reportBenchmarkSummary(files: File[]): Promise<void>;
-    private printTaskErrors;
-    registerUnhandledRejection(): void;
-}
-
-declare class BasicReporter extends BaseReporter {
-    isTTY: boolean;
-    reportSummary(files: File[], errors: unknown[]): Promise<void>;
-}
-
-interface ListRendererOptions {
-    renderSucceed?: boolean;
-    logger: Logger;
-    showHeap: boolean;
-    slowTestThreshold: number;
-    mode: VitestRunMode;
-}
-declare function createListRenderer(_tasks: Task[], options: ListRendererOptions): {
-    start(): any;
-    update(_tasks: Task[]): any;
-    stop(): Promise<any>;
-    clear(): void;
-};
-
-declare class DefaultReporter extends BaseReporter {
-    renderer?: ReturnType<typeof createListRenderer>;
-    rendererOptions: ListRendererOptions;
-    private renderSucceedDefault?;
-    onPathsCollected(paths?: string[]): void;
-    onTestRemoved(trigger?: string): Promise<void>;
-    onCollected(): void;
-    onFinished(files?: _vitest_runner.File[], errors?: unknown[]): Promise<void>;
-    onWatcherStart(files?: _vitest_runner.File[], errors?: unknown[]): Promise<void>;
-    stopListRender(): Promise<void>;
-    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
-    onUserConsoleLog(log: UserConsoleLog): void;
-}
-
-interface DotRendererOptions {
-    logger: Logger;
-}
-declare function createDotRenderer(_tasks: Task[], options: DotRendererOptions): {
-    start(): any;
-    update(_tasks: Task[]): any;
-    stop(): Promise<any>;
-    clear(): void;
-};
-
-declare class DotReporter extends BaseReporter {
-    renderer?: ReturnType<typeof createDotRenderer>;
-    onCollected(): void;
-    onFinished(files?: _vitest_runner.File[], errors?: unknown[]): Promise<void>;
-    onWatcherStart(): Promise<void>;
-    stopListRender(): Promise<void>;
-    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
-    onUserConsoleLog(log: UserConsoleLog): void;
-}
-
 type Status = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
 type Milliseconds = number;
 interface Callsite {
@@ -1142,8 +1265,9 @@ interface JsonAssertionResult {
     fullName: string;
     status: Status;
     title: string;
+    meta: TaskMeta;
     duration?: Milliseconds | null;
-    failureMessages: Array<string>;
+    failureMessages: Array<string> | null;
     location?: Callsite | null;
 }
 interface JsonTestResult {
@@ -1167,6 +1291,7 @@ interface JsonTestResults {
     startTime: number;
     success: boolean;
     testResults: Array<JsonTestResult>;
+    snapshot: SnapshotSummary;
 }
 interface JsonOptions$1 {
     outputFile?: string;
@@ -1185,19 +1310,14 @@ declare class JsonReporter implements Reporter {
      * @param report
      */
     writeReport(report: string): Promise<void>;
-    protected getFailureLocation(test: Task): Promise<Callsite | undefined>;
-}
-
-declare class VerboseReporter extends DefaultReporter {
-    constructor();
-    onTaskUpdate(packs: TaskResultPack[]): void;
 }
 
 interface Reporter {
     onInit?: (ctx: Vitest) => void;
     onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+    onSpecsCollected?: (specs?: SerializableSpec[]) => Awaitable<void>;
     onCollected?: (files?: File[]) => Awaitable<void>;
-    onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
+    onFinished?: (files?: File[], errors?: unknown[], coverage?: unknown) => Awaitable<void>;
     onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
     onTestRemoved?: (trigger?: string) => Awaitable<void>;
     onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
@@ -1207,15 +1327,10 @@ interface Reporter {
     onProcessTimeout?: () => Awaitable<void>;
 }
 
-declare class TapReporter implements Reporter {
-    protected ctx: Vitest;
-    private logger;
-    onInit(ctx: Vitest): void;
-    static getComment(task: Task): string;
-    private logErrorDetails;
-    protected logTasks(tasks: Task[]): void;
-    onFinished(files?: _vitest_runner.File[]): Promise<void>;
-}
+type SerializableSpec = [project: {
+    name: string | undefined;
+    root: string;
+}, file: string];
 
 interface JUnitOptions {
     outputFile?: string;
@@ -1248,9 +1363,116 @@ declare class JUnitReporter implements Reporter {
     onFinished(files?: _vitest_runner.File[]): Promise<void>;
 }
 
+interface HTMLOptions {
+    outputFile?: string;
+}
+
+interface BaseOptions {
+    isTTY?: boolean;
+}
+declare abstract class BaseReporter implements Reporter {
+    start: number;
+    end: number;
+    watchFilters?: string[];
+    isTTY: boolean;
+    ctx: Vitest;
+    private _filesInWatchMode;
+    private _lastRunTimeout;
+    private _lastRunTimer;
+    private _lastRunCount;
+    private _timeStart;
+    private _offUnhandledRejection?;
+    constructor(options?: BaseOptions);
+    get mode(): VitestRunMode;
+    onInit(ctx: Vitest): void;
+    relative(path: string): string;
+    onFinished(files?: File[], errors?: unknown[]): void;
+    onTaskUpdate(packs: TaskResultPack[]): void;
+    onWatcherStart(files?: File[], errors?: unknown[]): void;
+    private resetLastRunLog;
+    onWatcherRerun(files: string[], trigger?: string): void;
+    onUserConsoleLog(log: UserConsoleLog): void;
+    shouldLog(log: UserConsoleLog): boolean;
+    onServerRestart(reason?: string): void;
+    reportSummary(files: File[], errors: unknown[]): void;
+    reportTestSummary(files: File[], errors: unknown[]): void;
+    private printErrorsSummary;
+    reportBenchmarkSummary(files: File[]): void;
+    private printTaskErrors;
+    registerUnhandledRejection(): void;
+}
+
+declare class BasicReporter extends BaseReporter {
+    isTTY: boolean;
+    reportSummary(files: File[], errors: unknown[]): void;
+}
+
+interface ListRendererOptions {
+    renderSucceed?: boolean;
+    logger: Logger;
+    showHeap: boolean;
+    slowTestThreshold: number;
+    mode: VitestRunMode;
+}
+declare function createListRenderer(_tasks: Task[], options: ListRendererOptions): {
+    start(): any;
+    update(_tasks: Task[]): any;
+    stop(): any;
+    clear(): void;
+};
+
+declare class DefaultReporter extends BaseReporter {
+    renderer?: ReturnType<typeof createListRenderer>;
+    rendererOptions: ListRendererOptions;
+    private renderSucceedDefault?;
+    onPathsCollected(paths?: string[]): void;
+    onTestRemoved(trigger?: string): Promise<void>;
+    onCollected(): void;
+    onFinished(files?: _vitest_runner.File[], errors?: unknown[]): void;
+    onWatcherStart(files?: _vitest_runner.File[], errors?: unknown[]): Promise<void>;
+    stopListRender(): void;
+    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
+    onUserConsoleLog(log: UserConsoleLog): void;
+}
+
+interface DotRendererOptions {
+    logger: Logger;
+}
+declare function createDotRenderer(_tasks: Task[], options: DotRendererOptions): {
+    start(): any;
+    update(_tasks: Task[]): any;
+    stop(): Promise<any>;
+    clear(): void;
+};
+
+declare class DotReporter extends BaseReporter {
+    renderer?: ReturnType<typeof createDotRenderer>;
+    onCollected(): void;
+    onFinished(files?: _vitest_runner.File[], errors?: unknown[]): Promise<void>;
+    onWatcherStart(): Promise<void>;
+    stopListRender(): Promise<void>;
+    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
+    onUserConsoleLog(log: UserConsoleLog): void;
+}
+
+declare class VerboseReporter extends DefaultReporter {
+    constructor();
+    onTaskUpdate(packs: TaskResultPack[]): void;
+}
+
+declare class TapReporter implements Reporter {
+    protected ctx: Vitest;
+    private logger;
+    onInit(ctx: Vitest): void;
+    static getComment(task: Task): string;
+    private logErrorDetails;
+    protected logTasks(tasks: Task[]): void;
+    onFinished(files?: _vitest_runner.File[]): void;
+}
+
 declare class TapFlatReporter extends TapReporter {
     onInit(ctx: Vitest): void;
-    onFinished(files?: _vitest_runner.File[]): Promise<void>;
+    onFinished(files?: _vitest_runner.File[]): void;
 }
 
 declare class HangingProcessReporter implements Reporter {
@@ -1262,7 +1484,18 @@ declare class HangingProcessReporter implements Reporter {
 declare class GithubActionsReporter implements Reporter {
     ctx: Vitest;
     onInit(ctx: Vitest): void;
-    onFinished(files?: File[], errors?: unknown[]): Promise<void>;
+    onFinished(files?: File[], errors?: unknown[]): void;
+}
+
+interface BlobOptions {
+    outputFile?: string;
+}
+declare class BlobReporter implements Reporter {
+    ctx: Vitest;
+    options: BlobOptions;
+    constructor(options: BlobOptions);
+    onInit(ctx: Vitest): void;
+    onFinished(files: File[] | undefined, errors: unknown[] | undefined, coverage: unknown): Promise<void>;
 }
 
 interface TableRendererOptions {
@@ -1275,19 +1508,19 @@ interface TableRendererOptions {
 declare function createTableRenderer(_tasks: Task[], options: TableRendererOptions): {
     start(): any;
     update(_tasks: Task[]): any;
-    stop(): Promise<any>;
+    stop(): any;
     clear(): void;
 };
 
 declare class TableReporter extends BaseReporter {
     renderer?: ReturnType<typeof createTableRenderer>;
     rendererOptions: TableRendererOptions;
-    onTestRemoved(trigger?: string): Promise<void>;
+    onTestRemoved(trigger?: string): void;
     onCollected(): Promise<void>;
     onTaskUpdate(packs: TaskResultPack[]): void;
     onFinished(files?: File[], errors?: unknown[]): Promise<void>;
     onWatcherStart(): Promise<void>;
-    stopListRender(): Promise<void>;
+    stopListRender(): void;
     onWatcherRerun(files: string[], trigger?: string): Promise<void>;
     onUserConsoleLog(log: UserConsoleLog): void;
 }
@@ -1297,6 +1530,7 @@ interface FlatBenchmarkReport {
 type FormattedBenchmarkResult = Omit<BenchmarkResult, 'samples'> & {
     id: string;
     sampleCount: number;
+    median: number;
 };
 
 declare const BenchmarkReportsMap: {
@@ -1308,6 +1542,7 @@ type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
 declare const ReportersMap: {
     default: typeof DefaultReporter;
     basic: typeof BasicReporter;
+    blob: typeof BlobReporter;
     verbose: typeof VerboseReporter;
     dot: typeof DotReporter;
     json: typeof JsonReporter;
@@ -1319,18 +1554,17 @@ declare const ReportersMap: {
 };
 type BuiltinReporters = keyof typeof ReportersMap;
 interface BuiltinReporterOptions {
-    'default': never;
-    'basic': never;
+    'default': BaseOptions;
+    'basic': BaseOptions;
     'verbose': never;
-    'dot': never;
+    'dot': BaseOptions;
     'json': JsonOptions$1;
+    'blob': BlobOptions;
     'tap': never;
     'tap-flat': never;
     'junit': JUnitOptions;
     'hanging-process': never;
-    'html': {
-        outputFile?: string;
-    };
+    'html': HTMLOptions;
 }
 
 type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
@@ -1410,72 +1644,7 @@ interface LinkMapper {
     assetPath(node: Node, name: string): string;
 }
 
-type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
-type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
-type PromisifyFn<T> = ReturnType$1<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType$1<T>>>;
-type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
-interface ChannelOptions {
-    /**
-     * Function to post raw message
-     */
-    post: (data: any, ...extras: any[]) => any | Promise<any>;
-    /**
-     * Listener to receive raw message
-     */
-    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
-    /**
-     * Custom function to serialize data
-     *
-     * by default it passes the data as-is
-     */
-    serialize?: (data: any) => any;
-    /**
-     * Custom function to deserialize data
-     *
-     * by default it passes the data as-is
-     */
-    deserialize?: (data: any) => any;
-}
-interface EventOptions<Remote> {
-    /**
-     * Names of remote functions that do not need response.
-     */
-    eventNames?: (keyof Remote)[];
-    /**
-     * Maximum timeout for waiting for response, in milliseconds.
-     *
-     * @default 60_000
-     */
-    timeout?: number;
-    /**
-     * Custom resolver to resolve function to be called
-     *
-     * For advanced use cases only
-     */
-    resolver?: BirpcResolver;
-    /**
-     * Custom error handler
-     */
-    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
-    /**
-     * Custom error handler for timeouts
-     */
-    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
-}
-type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
-type BirpcFn<T> = PromisifyFn<T> & {
-    /**
-     * Send event without asking for response
-     */
-    asEvent(...args: ArgumentsType<T>): void;
-};
-type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
-    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
-} & {
-    $functions: LocalFunctions;
-};
-
-type MockFactoryWithHelper = (importOriginal: <T = unknown>() => Promise<T>) => any;
+type MockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M>() => Promise<T>) => any;
 type MockFactory = () => any;
 type MockMap = Map<string, Record<string, string | null | MockFactory>>;
 interface PendingSuiteMock {
@@ -1560,13 +1729,24 @@ interface WorkerGlobalState {
 }
 
 type TransformResult = string | Partial<TransformResult$1> | undefined | null | void;
+type CoverageResults = unknown;
 interface CoverageProvider {
     name: string;
+    /** Called when provider is being initialized before tests run */
     initialize: (ctx: Vitest) => Promise<void> | void;
+    /** Called when setting coverage options for Vitest context (`ctx.config.coverage`) */
     resolveOptions: () => ResolvedCoverageOptions;
+    /** Callback to clean previous reports */
     clean: (clean?: boolean) => void | Promise<void>;
+    /** Called with coverage results after a single test file has been run */
     onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void | Promise<void>;
-    reportCoverage: (reportContext?: ReportContext) => void | Promise<void>;
+    /** Callback to generate final coverage results */
+    generateCoverage: (reportContext: ReportContext) => CoverageResults | Promise<CoverageResults>;
+    /** Callback to convert coverage results to coverage reports. Called with results returned from `generateCoverage` */
+    reportCoverage: (coverage: CoverageResults, reportContext: ReportContext) => void | Promise<void>;
+    /** Callback for `--merge-reports` options. Called with multiple coverage results generated by `generateCoverage`. */
+    mergeReports?: (coverages: CoverageResults[]) => void | Promise<void>;
+    /** Callback called for instrumenting files with coverage counters. */
     onFileTransform?: (sourceCode: string, id: string, pluginCtx: any) => TransformResult | Promise<TransformResult>;
 }
 interface ReportContext {
@@ -1936,7 +2116,7 @@ declare const configDefaults: Readonly<{
     watch: boolean;
     globals: false;
     environment: "node";
-    pool: "threads";
+    pool: "forks";
     clearMocks: false;
     restoreMocks: false;
     mockReset: false;
@@ -1945,7 +2125,6 @@ declare const configDefaults: Readonly<{
     testTimeout: number;
     hookTimeout: number;
     teardownTimeout: number;
-    watchExclude: string[];
     forceRerunTriggers: string[];
     update: false;
     reporters: never[];
@@ -2370,11 +2549,6 @@ interface InlineConfig {
      * Path to global setup files
      */
     globalSetup?: string | string[];
-    /**
-     * Glob pattern of file paths to be ignore from triggering watch rerun
-     * @deprecated Use server.watch.ignored instead
-     */
-    watchExclude?: string[];
     /**
      * Glob patter of file paths that will trigger the whole suite rerun
      *
@@ -2490,7 +2664,7 @@ interface InlineConfig {
     /**
      * Custom environment variables assigned to `process.env` before running tests.
      */
-    env?: Record<string, string>;
+    env?: Partial<NodeJS.ProcessEnv>;
     /**
      * Options for @sinon/fake-timers
      */
@@ -2602,6 +2776,30 @@ interface InlineConfig {
          */
         waitForDebugger?: boolean;
     };
+    /**
+     * Configuration options for expect() matches.
+     */
+    expect?: {
+        /**
+         * Throw an error if tests don't have any expect() assertions.
+         */
+        requireAssertions?: boolean;
+        /**
+         * Default options for expect.poll()
+         */
+        poll?: {
+            /**
+             * Timeout in milliseconds
+             * @default 1000
+             */
+            timeout?: number;
+            /**
+             * Polling interval in milliseconds
+             * @default 50
+             */
+            interval?: number;
+        };
+    };
     /**
      * Modify default Chai config. Vitest uses Chai for `expect` and `assert` matches.
      * https://github.com/chaijs/chai/blob/4.x.x/lib/chai/config.js
@@ -2631,6 +2829,12 @@ interface InlineConfig {
      * @default false
      */
     disableConsoleIntercept?: boolean;
+    /**
+     * Always print console stack traces.
+     *
+     * @default false
+     */
+    printConsoleTrace?: boolean;
     /**
      * Include "location" property inside the test definition
      *
@@ -2742,6 +2946,11 @@ interface UserConfig extends InlineConfig {
      * benchmark.outputJson option exposed at the top level for cli
      */
     outputJson?: string;
+    /**
+     * Directory of blob reports to merge
+     * @default '.vitest-reports'
+     */
+    mergeReports?: string;
 }
 interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'browser' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck' | 'runner' | 'poolOptions' | 'pool' | 'cliExclude'> {
     mode: VitestRunMode;
@@ -2783,7 +2992,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     };
     runner?: string;
 }
-type ProjectConfig = Omit<UserConfig, 'sequencer' | 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'poolOptions' | 'teardownTimeout' | 'silent' | 'watchExclude' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'onStackTrace' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'deps' | 'coverage'> & {
+type ProjectConfig = Omit<UserConfig, 'sequencer' | 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'poolOptions' | 'teardownTimeout' | 'silent' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'onStackTrace' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'deps' | 'coverage'> & {
     sequencer?: Omit<SequenceOptions, 'sequencer' | 'seed'>;
     deps?: Omit<DepsOptions, 'moduleDirectories'>;
     poolOptions?: {
@@ -2792,7 +3001,7 @@ type ProjectConfig = Omit<UserConfig, 'sequencer' | 'shard' | 'watch' | 'run' |
         forks?: Pick<NonNullable<PoolOptions['forks']>, 'singleFork' | 'isolate'>;
     };
 };
-type RuntimeConfig = Pick<UserConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency'> & {
+type RuntimeConfig = Pick<UserConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency' | 'expect' | 'printConsoleTrace'> & {
     sequence?: {
         concurrent?: boolean;
         hooks?: SequenceHooks;
@@ -2836,7 +3045,18 @@ declare module '@vitest/expect' {
         environment: VitestEnvironment;
         snapshotState: SnapshotState;
     }
+    interface ExpectPollOptions {
+        interval?: number;
+        timeout?: number;
+        message?: string;
+    }
     interface ExpectStatic {
+        unreachable: (message?: string) => never;
+        soft: <T>(actual: T, message?: string) => Assertion<T>;
+        poll: <T>(actual: () => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+        addEqualityTesters: (testers: Array<Tester>) => void;
+        assertions: (expected: number) => void;
+        hasAssertions: () => void;
         addSnapshotSerializer: (plugin: Plugin_2) => void;
     }
     interface Assertion<T> {
@@ -2894,4 +3114,4 @@ type Context = RootAndTarget & {
     lastActivePath?: string;
 };
 
-export { type ProjectConfig as $, type AfterSuiteRunMeta as A, type BaseCoverageOptions as B, type CoverageOptions as C, type RootAndTarget as D, type Environment as E, type FakeTimerInstallOpts as F, type Context as G, type Pool as H, type PoolOptions as I, type JSDOMOptions as J, type HappyDOMOptions as K, type BuiltinEnvironment as L, type MockFactoryWithHelper as M, type VitestEnvironment as N, type CSSModuleScopeStrategy as O, type ProvidedContext as P, type ApiConfig as Q, type ResolvedConfig as R, type EnvironmentOptions as S, type TestSequencer as T, type UserConfig as U, type VitestRunMode as V, type WorkerGlobalState as W, type DepsOptimizationOptions as X, type TransformModePatterns as Y, type InlineConfig as Z, type TypecheckConfig as _, type ResolvedCoverageOptions as a, type BrowserConfigOptions as a0, type UserWorkspaceConfig as a1, type RunnerRPC as a2, type ContextTestEnvironment as a3, type ResolvedTestEnvironment as a4, type ResolveIdFunction as a5, type WorkerRPC as a6, type Awaitable as a7, type Nullable as a8, type Arrayable as a9, defineConfig as aA, defineProject as aB, defineWorkspace as aC, configDefaults as aD, defaultInclude as aE, defaultExclude as aF, coverageConfigDefaults as aG, extraInlineDeps as aH, DefaultReporter as aI, BasicReporter as aJ, DotReporter as aK, JsonReporter as aL, VerboseReporter as aM, TapReporter as aN, JUnitReporter as aO, TapFlatReporter as aP, HangingProcessReporter as aQ, GithubActionsReporter as aR, BaseReporter as aS, ReportersMap as aT, type BuiltinReporters as aU, type BuiltinReporterOptions as aV, type JsonAssertionResult as aW, type JsonTestResult as aX, type JsonTestResults as aY, BenchmarkReportsMap as aZ, type BenchmarkBuiltinReporters as a_, type ArgumentsType$1 as aa, type MutableArray as ab, type Constructable as ac, type ModuleCache as ad, type EnvironmentReturn as ae, type VmEnvironmentReturn as af, type OnServerRestartHandler as ag, type ReportContext as ah, type CoverageReporter as ai, type CoverageIstanbulOptions as aj, type CoverageV8Options as ak, type CustomProviderOptions as al, type BenchmarkUserOptions as am, type Benchmark as an, type BenchmarkResult as ao, type BenchFunction as ap, type BenchmarkAPI as aq, type PendingSuiteMock as ar, type MockFactory as as, type MockMap as at, type UserConfigFnObject as au, type UserConfigFnPromise as av, type UserConfigFn as aw, type UserConfigExport as ax, type UserProjectConfigFn as ay, type UserProjectConfigExport as az, type CoverageProvider as b, type CoverageProviderModule as c, type BirpcOptions as d, type RuntimeRPC as e, type ContextRPC as f, type WorkerContext as g, type VitestOptions as h, Vitest as i, WorkspaceProject as j, type WorkspaceSpec as k, type ProcessPool as l, VitestPackageInstaller as m, type TestSequencerConstructor as n, type BrowserProviderInitializationOptions as o, type BrowserProvider as p, type BrowserProviderOptions as q, type BrowserScript as r, type RuntimeConfig as s, type UserConsoleLog as t, type ModuleGraphData as u, type Reporter as v, type RawErrsMap as w, type TscErrorInfo as x, type CollectLineNumbers as y, type CollectLines as z };
+export { type ArgumentsType as $, type ApiConfig as A, type BaseCoverageOptions as B, type CoverageOptions as C, type DepsOptimizationOptions as D, type Environment as E, type FakeTimerInstallOpts as F, type ContextTestEnvironment as G, type HappyDOMOptions as H, type InlineConfig as I, type JSDOMOptions as J, type ResolvedTestEnvironment as K, Vitest as L, type MockFactoryWithHelper as M, type Reporter as N, type ResolveIdFunction as O, type ProvidedContext as P, type AfterSuiteRunMeta as Q, type ResolvedConfig as R, type SerializableSpec as S, type TscErrorInfo as T, type UserConfig as U, type VitestEnvironment as V, type WorkerGlobalState as W, type WorkerRPC as X, type Awaitable as Y, type Nullable as Z, type Arrayable as _, type ResolvedCoverageOptions as a, TapReporter as a$, type MutableArray as a0, type Constructable as a1, type ModuleCache as a2, type EnvironmentReturn as a3, type VmEnvironmentReturn as a4, type UserConsoleLog as a5, type ModuleGraphData as a6, type OnServerRestartHandler as a7, type ReportContext as a8, type CoverageReporter as a9, type BrowserCommand as aA, type BrowserCommandContext as aB, type JsonOptions$1 as aC, type JUnitOptions as aD, type HTMLOptions as aE, type PendingSuiteMock as aF, type MockFactory as aG, type MockMap as aH, type UserConfigFnObject as aI, type UserConfigFnPromise as aJ, type UserConfigFn as aK, type UserConfigExport as aL, type UserProjectConfigFn as aM, type UserProjectConfigExport as aN, defineConfig as aO, defineProject as aP, defineWorkspace as aQ, configDefaults as aR, defaultInclude as aS, defaultExclude as aT, coverageConfigDefaults as aU, extraInlineDeps as aV, DefaultReporter as aW, BasicReporter as aX, DotReporter as aY, JsonReporter as aZ, VerboseReporter as a_, type CoverageIstanbulOptions as aa, type CoverageV8Options as ab, type CustomProviderOptions as ac, type BenchmarkUserOptions as ad, type Benchmark as ae, type BenchmarkResult as af, type BenchFunction as ag, type BenchmarkAPI as ah, type TransformResultWithSource as ai, type WebSocketHandlers as aj, type WebSocketBrowserHandlers as ak, type WebSocketEvents as al, type WebSocketBrowserEvents as am, type WebSocketRPC as an, type WebSocketBrowserRPC as ao, type VitestOptions as ap, WorkspaceProject as aq, type TestSequencer as ar, type WorkspaceSpec as as, type ProcessPool as at, getFilePoolName as au, VitestPackageInstaller as av, type TestSequencerConstructor as aw, type BrowserProviderInitializationOptions as ax, type BrowserProvider as ay, type BrowserProviderOptions as az, type CoverageProvider as b, JUnitReporter as b0, TapFlatReporter as b1, HangingProcessReporter as b2, GithubActionsReporter as b3, BaseReporter as b4, ReportersMap as b5, type BuiltinReporters as b6, type BuiltinReporterOptions as b7, type JsonAssertionResult as b8, type JsonTestResult as b9, type JsonTestResults as ba, BenchmarkReportsMap as bb, type BenchmarkBuiltinReporters as bc, type CoverageProviderModule as c, type BirpcOptions as d, type RuntimeRPC as e, type ContextRPC as f, type WorkerContext as g, type RuntimeConfig as h, type RawErrsMap as i, type CollectLineNumbers as j, type CollectLines as k, type RootAndTarget as l, type Context as m, type Pool as n, type PoolOptions as o, type BuiltinEnvironment as p, type CSSModuleScopeStrategy as q, type EnvironmentOptions as r, type VitestRunMode as s, type TransformModePatterns as t, type TypecheckConfig as u, type ProjectConfig as v, type BrowserScript as w, type BrowserConfigOptions as x, type UserWorkspaceConfig as y, type RunnerRPC as z };