vitest 2.0.4 → 2.1.0-beta.1

package/dist/{reporters-B7ebVMkT.d.ts → chunks/reporters.DRZ7ndzr.d.ts}

@@ -1,80 +1,21 @@
+import * as _vitest_runner from '@vitest/runner';
+import { File, Test, Suite, TaskResultPack, Task, CancelReason, Custom, TaskMeta, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
 import * as vite from 'vite';
 import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, ConfigEnv, ServerOptions, DepOptimizationConfig, AliasOptions } from 'vite';
-import { PrettyFormatOptions, Plugin } from '@vitest/pretty-format';
-import * as _vitest_runner from '@vitest/runner';
-import { File, Test, Suite, TaskResultPack, Task, CancelReason, TaskMeta, Custom, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
-import { RawSourceMap, FetchResult, ViteNodeResolveId, ModuleCacheMap, ViteNodeServerOptions } from 'vite-node';
-import { SnapshotSummary, SnapshotResult, SnapshotStateOptions, SnapshotState } from '@vitest/snapshot';
-import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
-import { ChainableFunction } from '@vitest/runner/utils';
-import { ParsedStack, Awaitable as Awaitable$1, ErrorWithDiff, Arrayable as Arrayable$1 } from '@vitest/utils';
-import { TaskResult, Bench, Options as Options$1 } from 'tinybench';
+import { PrettyFormatOptions } from '@vitest/pretty-format';
+import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.CHuotKvS.js';
+import { RawSourceMap, ViteNodeServerOptions } from 'vite-node';
+import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
+import { b as Awaitable, P as ProvidedContext, U as UserConsoleLog, A as AfterSuiteRunMeta, c as Arrayable, d as ArgumentsType, O as OnServerRestartHandler, f as EnvironmentOptions } from './environment.0M5R1SX_.js';
 import { Writable } from 'node:stream';
 import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
-import { MessagePort } from 'node:worker_threads';
+import { ParsedStack, Awaitable as Awaitable$1, ErrorWithDiff, TestError, Arrayable as Arrayable$1 } from '@vitest/utils';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { Stats } from 'node:fs';
 import * as chai from 'chai';
-
-/**
- * Names of clock methods that may be faked by install.
- */
-type FakeMethod =
-    | "setTimeout"
-    | "clearTimeout"
-    | "setImmediate"
-    | "clearImmediate"
-    | "setInterval"
-    | "clearInterval"
-    | "Date"
-    | "nextTick"
-    | "hrtime"
-    | "requestAnimationFrame"
-    | "cancelAnimationFrame"
-    | "requestIdleCallback"
-    | "cancelIdleCallback"
-    | "performance"
-    | "queueMicrotask";
-
-interface FakeTimerInstallOpts {
-    /**
-     * Installs fake timers with the specified unix epoch (default: 0)
-     */
-    now?: number | Date | undefined;
-
-    /**
-     * An array with names of global methods and APIs to fake.
-     * For instance, `vi.useFakeTimer({ toFake: ['setTimeout', 'performance'] })` will fake only `setTimeout()` and `performance.now()`
-     * @default ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']
-     */
-    toFake?: FakeMethod[] | undefined;
-
-    /**
-     * The maximum number of timers that will be run when calling runAll()
-     * @default 10000
-     */
-    loopLimit?: number | undefined;
-
-    /**
-     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
-     * 20ms for every 20ms change in the real system time) (default: false)
-     */
-    shouldAdvanceTime?: boolean | undefined;
-
-    /**
-     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
-     * in the real system time (default: 20)
-     */
-    advanceTimeDelta?: number | undefined;
-
-    /**
-     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers.
-     * @default true
-     */
-    shouldClearNativeTimers?: boolean | undefined;
-}
+import { B as BenchmarkResult } from './benchmark.puBFxyfE.js';
 
 type BuiltinPool = 'browser' | 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript';
 type Pool = BuiltinPool | (string & {});
@@ -300,6 +241,32 @@ interface FileInformation {
     definitions: LocalCallDefinition[];
 }
 
+type RawErrsMap = Map<string, TscErrorInfo[]>;
+interface TscErrorInfo {
+    filePath: string;
+    errCode: number;
+    errMsg: string;
+    line: number;
+    column: number;
+}
+interface CollectLineNumbers {
+    target: number;
+    next: number;
+    prev?: number;
+}
+type CollectLines = {
+    [key in keyof CollectLineNumbers]: string;
+};
+interface RootAndTarget {
+    root: string;
+    targetAbsPath: string;
+}
+type Context = RootAndTarget & {
+    rawErrsMap: RawErrsMap;
+    openedDirs: Set<string>;
+    lastActivePath?: string;
+};
+
 declare class TypeCheckError extends Error {
     message: string;
     stacks: ParsedStack[];
@@ -497,6 +464,16 @@ interface BrowserConfigOptions {
          */
         height: number;
     };
+    /**
+     * Locator options
+     */
+    locators?: {
+        /**
+         * Attribute used to locate elements by test id
+         * @default 'data-testid'
+         */
+        testIdAttribute?: string;
+    };
     /**
      * 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.
@@ -596,6 +573,54 @@ interface ResolvedBrowserOptions extends BrowserConfigOptions {
         width: number;
         height: number;
     };
+    screenshotFailures: boolean;
+    locators: {
+        testIdAttribute: string;
+    };
+}
+
+declare class TestProject {
+    /**
+     * The global vitest instance.
+     * @experimental The public Vitest API is experimental and does not follow semver.
+     */
+    readonly vitest: Vitest;
+    /**
+     * The workspace project this test project is associated with.
+     * @experimental The public Vitest API is experimental and does not follow semver.
+     */
+    readonly workspaceProject: WorkspaceProject;
+    /**
+     * Resolved project configuration.
+     */
+    readonly config: ResolvedProjectConfig;
+    /**
+     * Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
+     */
+    readonly globalConfig: ResolvedConfig;
+    /**
+     * The name of the project or an empty string if not set.
+     */
+    readonly name: string;
+    constructor(workspaceProject: WorkspaceProject);
+    /**
+     * Serialized project configuration. This is the config that tests receive.
+     */
+    get serializedConfig(): SerializedConfig;
+    /**
+     * Custom context provided to the project.
+     */
+    context(): ProvidedContext;
+    /**
+     * Provide a custom serializable context to the project. This context will be available for tests once they run.
+     */
+    provide<T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]): void;
+    toJSON(): SerializedTestProject;
+}
+interface SerializedTestProject {
+    name: string;
+    serializedConfig: SerializedConfig;
+    context: ProvidedContext;
 }
 
 interface InitializeProjectOptions extends UserWorkspaceConfig {
@@ -615,6 +640,7 @@ declare class WorkspaceProject {
     typechecker?: Typechecker;
     closingPromise: Promise<unknown> | undefined;
     testFilesList: string[] | null;
+    testProject: TestProject;
     readonly id: string;
     readonly tmpDir: string;
     private _globalSetups;
@@ -630,7 +656,6 @@ declare class WorkspaceProject {
     getModulesByFilepath(file: string): Set<vite.ModuleNode>;
     getModuleById(id: string): vite.ModuleNode | undefined;
     getSourceMapModuleById(id: string): TransformResult$1['map'] | undefined;
-    getBrowserSourceMapModuleById(id: string): TransformResult$1['map'] | undefined;
     get reporters(): Reporter[];
     globTestFiles(filters?: string[]): Promise<string[]>;
     globAllTestFiles(include: string[], exclude: string[], includeSource: string[] | undefined, cwd: string): Promise<string[]>;
@@ -644,7 +669,7 @@ declare class WorkspaceProject {
     static createCoreProject(ctx: Vitest): Promise<WorkspaceProject>;
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
     isBrowserEnabled(): boolean;
-    getSerializableConfig(method?: 'run' | 'collect'): ResolvedConfig;
+    getSerializableConfig(): SerializedConfig;
     close(): Promise<unknown>;
     private clearTmpDir;
     initBrowserProvider(): Promise<void>;
@@ -660,52 +685,256 @@ interface ProcessPool {
 }
 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 MutableArray<T extends readonly any[]> = {
-    -readonly [k in keyof T]: T[k];
-};
-interface Constructable {
-    new (...args: any[]): any;
+declare class ReportedTaskImplementation {
+    /**
+     * Task instance.
+     * @experimental Public runner task API is experimental and does not follow semver.
+     */
+    readonly task: Task;
+    /**
+     * The project assosiacted with the test or suite.
+     */
+    readonly project: TestProject;
+    /**
+     * Unique identifier.
+     * This ID is deterministic and will be the same for the same test across multiple runs.
+     * The ID is based on the project name, file path and test position.
+     */
+    readonly id: string;
+    /**
+     * Location in the file where the test or suite is defined.
+     */
+    readonly location: {
+        line: number;
+        column: number;
+    } | undefined;
+    protected constructor(task: Task, project: WorkspaceProject);
+    /**
+     * Creates a new reported task instance and stores it in the project's state for future use.
+     */
+    static register(task: Task, project: WorkspaceProject): TestCase | TestSuite | TestFile;
 }
-interface ModuleCache {
-    promise?: Promise<any>;
-    exports?: any;
-    code?: string;
+declare class TestCase extends ReportedTaskImplementation {
+    #private;
+    readonly task: Test | Custom;
+    readonly type = "test";
+    /**
+     * Direct reference to the test file where the test or suite is defined.
+     */
+    readonly file: TestFile;
+    /**
+     * Name of the test.
+     */
+    readonly name: string;
+    /**
+     * Options that the test was initiated with.
+     */
+    readonly options: TaskOptions;
+    /**
+     * Parent suite. If the test was called directly inside the file, the parent will be the file.
+     */
+    readonly parent: TestSuite | TestFile;
+    protected constructor(task: Test | Custom, project: WorkspaceProject);
+    /**
+     * Full name of the test including all parent suites separated with `>`.
+     */
+    get fullName(): string;
+    /**
+     * Test results. Will be `undefined` if test is not finished yet or was just collected.
+     */
+    result(): TestResult | undefined;
+    /**
+     * Checks if the test did not fail the suite.
+     * If the test is not finished yet or was skipped, it will return `true`.
+     */
+    ok(): boolean;
+    /**
+     * Custom metadata that was attached to the test during its execution.
+     */
+    meta(): TaskMeta;
+    /**
+     * Useful information about the test like duration, memory usage, etc.
+     * Diagnostic is only available after the test has finished.
+     */
+    diagnostic(): TestDiagnostic | undefined;
 }
-interface EnvironmentReturn {
-    teardown: (global: any) => Awaitable<void>;
+declare class TestCollection {
+    #private;
+    constructor(task: Suite | File, project: WorkspaceProject);
+    /**
+     * Returns the test or suite at a specific index in the array.
+     */
+    at(index: number): TestCase | TestSuite | undefined;
+    /**
+     * The number of tests and suites in the collection.
+     */
+    get size(): number;
+    /**
+     * Returns the collection in array form for easier manipulation.
+     */
+    array(): (TestCase | TestSuite)[];
+    /**
+     * Filters all tests that are part of this collection and its children.
+     */
+    allTests(state?: TestResult['state'] | 'running'): IterableIterator<TestCase>;
+    /**
+     * Filters only the tests that are part of this collection.
+     */
+    tests(state?: TestResult['state'] | 'running'): IterableIterator<TestCase>;
+    /**
+     * Filters only the suites that are part of this collection.
+     */
+    suites(): IterableIterator<TestSuite>;
+    /**
+     * Filters all suites that are part of this collection and its children.
+     */
+    allSuites(): IterableIterator<TestSuite>;
+    [Symbol.iterator](): IterableIterator<TestSuite | TestCase>;
 }
-interface VmEnvironmentReturn {
-    getVmContext: () => {
-        [key: string]: any;
-    };
-    teardown: () => Awaitable<void>;
+
+declare abstract class SuiteImplementation extends ReportedTaskImplementation {
+    readonly task: Suite | File;
+    /**
+     * Collection of suites and tests that are part of this suite.
+     */
+    readonly children: TestCollection;
+    protected constructor(task: Suite | File, project: WorkspaceProject);
 }
-interface Environment {
-    name: string;
-    transformMode: 'web' | 'ssr';
-    setupVM?: (options: Record<string, any>) => Awaitable<VmEnvironmentReturn>;
-    setup: (global: any, options: Record<string, any>) => Awaitable<EnvironmentReturn>;
-}
-interface UserConsoleLog {
-    content: string;
-    origin?: string;
-    browser?: boolean;
-    type: 'stdout' | 'stderr';
-    taskId?: string;
-    time: number;
-    size: number;
+declare class TestSuite extends SuiteImplementation {
+    #private;
+    readonly task: Suite;
+    readonly type = "suite";
+    /**
+     * Name of the test or the suite.
+     */
+    readonly name: string;
+    /**
+     * Direct reference to the test file where the test or suite is defined.
+     */
+    readonly file: TestFile;
+    /**
+     * Parent suite. If suite was called directly inside the file, the parent will be the file.
+     */
+    readonly parent: TestSuite | TestFile;
+    /**
+     * Options that suite was initiated with.
+     */
+    readonly options: TaskOptions;
+    protected constructor(task: Suite, project: WorkspaceProject);
+    /**
+     * Full name of the suite including all parent suites separated with `>`.
+     */
+    get fullName(): string;
+}
+declare class TestFile extends SuiteImplementation {
+    readonly task: File;
+    readonly location: undefined;
+    readonly type = "file";
+    /**
+     * This is usually an absolute UNIX file path.
+     * It can be a virtual id if the file is not on the disk.
+     * This value corresponds to Vite's `ModuleGraph` id.
+     */
+    readonly moduleId: string;
+    protected constructor(task: File, project: WorkspaceProject);
+    /**
+     * Useful information about the file like duration, memory usage, etc.
+     * If the file was not executed yet, all diagnostic values will return `0`.
+     */
+    diagnostic(): FileDiagnostic;
+}
+interface TaskOptions {
+    each: boolean | undefined;
+    concurrent: boolean | undefined;
+    shuffle: boolean | undefined;
+    retry: number | undefined;
+    repeats: number | undefined;
+    mode: 'run' | 'only' | 'skip' | 'todo';
+}
+type TestResult = TestResultPassed | TestResultFailed | TestResultSkipped;
+interface TestResultPassed {
+    /**
+     * The test passed successfully.
+     */
+    state: 'passed';
+    /**
+     * Errors that were thrown during the test execution.
+     *
+     * **Note**: If test was retried successfully, errors will still be reported.
+     */
+    errors: TestError[] | undefined;
+}
+interface TestResultFailed {
+    /**
+     * The test failed to execute.
+     */
+    state: 'failed';
+    /**
+     * Errors that were thrown during the test execution.
+     */
+    errors: TestError[];
+}
+interface TestResultSkipped {
+    /**
+     * The test was skipped with `only`, `skip` or `todo` flag.
+     * You can see which one was used in the `mode` option.
+     */
+    state: 'skipped';
+    /**
+     * Skipped tests have no errors.
+     */
+    errors: undefined;
 }
-interface ModuleGraphData {
-    graph: Record<string, string[]>;
-    externalized: string[];
-    inlined: string[];
+interface TestDiagnostic {
+    /**
+     * The amount of memory used by the test in bytes.
+     * This value is only available if the test was executed with `logHeapUsage` flag.
+     */
+    heap: number | undefined;
+    /**
+     * The time it takes to execute the test in ms.
+     */
+    duration: number;
+    /**
+     * The time in ms when the test started.
+     */
+    startTime: number;
+    /**
+     * The amount of times the test was retried.
+     */
+    retryCount: number;
+    /**
+     * The amount of times the test was repeated as configured by `repeats` option.
+     * This value can be lower if the test failed during the repeat and no `retry` is configured.
+     */
+    repeatCount: number;
+    /**
+     * If test passed on a second retry.
+     */
+    flaky: boolean;
 }
-type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
-interface ProvidedContext {
+interface FileDiagnostic {
+    /**
+     * The time it takes to import and initiate an environment.
+     */
+    environmentSetupDuration: number;
+    /**
+     * The time it takes Vitest to setup test harness (runner, mocks, etc.).
+     */
+    prepareDuration: number;
+    /**
+     * The time it takes to import the test file.
+     * This includes importing everything in the file and executing suite callbacks.
+     */
+    collectDuration: number;
+    /**
+     * The time it takes to import the setup file.
+     */
+    setupDuration: number;
+    /**
+     * Accumulated duration of all tests and hooks in the file.
+     */
+    duration: number;
 }
 
 declare class StateManager {
@@ -715,6 +944,7 @@ declare class StateManager {
     taskFileMap: WeakMap<Task, File>;
     errorsSet: Set<unknown>;
     processTimeoutCauses: Set<string>;
+    reportedTasksMap: WeakMap<Task, TestCase | TestSuite | TestFile>;
     catchError(err: unknown, type: string): void;
     clearErrors(): void;
     getUnhandledErrors(): unknown[];
@@ -728,18 +958,14 @@ declare class StateManager {
     getFilepaths(): string[];
     getFailedFilepaths(): string[];
     collectPaths(paths?: string[]): void;
-    collectFiles(files?: File[]): void;
-    clearFiles(_project: {
-        config: {
-            name: string | undefined;
-            root: string;
-        };
-    }, paths?: string[]): void;
-    updateId(task: Task): void;
+    collectFiles(project: WorkspaceProject, files?: File[]): void;
+    clearFiles(project: WorkspaceProject, paths?: string[]): void;
+    updateId(task: Task, project: WorkspaceProject): void;
+    getReportedEntity(task: Task): TestCase | TestSuite | TestFile | undefined;
     updateTasks(packs: TaskResultPack[]): void;
     updateUserLog(log: UserConsoleLog): void;
     getCountOfFailedTests(): number;
-    cancelFiles(files: string[], root: string, projectName: string): void;
+    cancelFiles(files: string[], project: WorkspaceProject): void;
 }
 
 interface SuiteResultCache {
@@ -786,663 +1012,79 @@ declare class VitestPackageInstaller {
     ensureInstalled(dependency: string, root: string): Promise<boolean>;
 }
 
-interface VitestOptions {
-    packageInstaller?: VitestPackageInstaller;
-    stdin?: NodeJS.ReadStream;
-    stdout?: NodeJS.WriteStream | Writable;
-    stderr?: NodeJS.WriteStream | Writable;
-}
-declare class Vitest {
-    readonly mode: VitestRunMode;
-    version: string;
-    config: ResolvedConfig;
-    configOverride: Partial<ResolvedConfig>;
-    server: ViteDevServer;
-    state: StateManager;
-    snapshot: SnapshotManager;
-    cache: VitestCache;
-    reporters: Reporter[];
-    coverageProvider: CoverageProvider | null | undefined;
-    logger: Logger;
-    pool: ProcessPool | undefined;
-    vitenode: ViteNodeServer;
-    invalidates: Set<string>;
-    changedTests: Set<string>;
-    watchedTests: Set<string>;
-    filenamePattern?: string;
-    runningPromise?: Promise<void>;
-    closingPromise?: Promise<void>;
-    isCancelling: boolean;
-    isFirstRun: boolean;
-    restartsCount: number;
-    runner: ViteNodeRunner;
-    packageInstaller: VitestPackageInstaller;
-    private coreWorkspaceProject;
-    private resolvedProjects;
-    projects: WorkspaceProject[];
-    private projectsTestFiles;
-    distPath: string;
-    constructor(mode: VitestRunMode, options?: VitestOptions);
-    private _onRestartListeners;
-    private _onClose;
-    private _onSetServer;
-    private _onCancelListeners;
-    setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
-    provide<T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]): void;
-    private createCoreProject;
-    getCoreWorkspaceProject(): WorkspaceProject;
-    getProjectByTaskId(taskId: string): WorkspaceProject;
-    getProjectByName(name?: string): WorkspaceProject;
-    private getWorkspaceConfigPath;
-    private resolveWorkspace;
-    private initCoverageProvider;
-    private initBrowserProviders;
-    mergeReports(): Promise<void>;
-    collect(filters?: string[]): Promise<{
-        tests: File[];
-        errors: unknown[];
-    }>;
-    start(filters?: string[]): Promise<void>;
-    init(): Promise<void>;
-    private getTestDependencies;
-    filterTestsBySource(specs: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
-    getProjectsByTestFile(file: string): WorkspaceSpec[];
-    initializeGlobalSetup(paths: WorkspaceSpec[]): Promise<void>;
-    private initializeDistPath;
-    runFiles(specs: WorkspaceSpec[], allTestsRun: boolean): Promise<void>;
-    collectFiles(specs: WorkspaceSpec[]): Promise<void>;
-    cancelCurrentRun(reason: CancelReason): Promise<void>;
-    rerunFiles(files?: string[], trigger?: string): Promise<void>;
-    changeProjectName(pattern: string): Promise<void>;
-    changeNamePattern(pattern: string, files?: string[], trigger?: string): Promise<void>;
-    changeFilenamePattern(pattern: string, files?: string[]): Promise<void>;
-    rerunFailed(): Promise<void>;
-    updateSnapshot(files?: string[]): Promise<void>;
-    private _rerunTimer;
-    private scheduleRerun;
-    getModuleProjects(filepath: string): WorkspaceProject[];
-    /**
-     * Watch only the specified tests. If no tests are provided, all tests will be watched.
-     */
-    watchTests(tests: string[]): void;
-    private unregisterWatcher;
-    private registerWatcher;
-    /**
-     * @returns A value indicating whether rerun is needed (changedTests was mutated)
-     */
-    private handleFileChanged;
-    private reportCoverage;
-    close(): Promise<void>;
-    /**
-     * 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>;
-    getTestFilepaths(): Promise<string[]>;
-    globTestFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
-    shouldKeepServer(): boolean;
-    onServerRestart(fn: OnServerRestartHandler): void;
-    onAfterSetServer(fn: OnServerRestartHandler): void;
-    onCancel(fn: (reason: CancelReason) => void): void;
-    onClose(fn: () => void): void;
+interface Node {
+    isRoot(): boolean;
+    visit(visitor: Visitor, state: any): void;
 }
 
-interface TestSequencer {
-    /**
-     * Slicing tests into shards. Will be run before `sort`.
-     * Only run, if `shard` is defined.
-     */
-    shard: (files: WorkspaceSpec[]) => Awaitable<WorkspaceSpec[]>;
-    sort: (files: WorkspaceSpec[]) => Awaitable<WorkspaceSpec[]>;
-}
-interface TestSequencerConstructor {
-    new (ctx: Vitest): TestSequencer;
+interface Visitor<N extends Node = Node> {
+    onStart(root: N, state: any): void;
+    onSummary(root: N, state: any): void;
+    onDetail(root: N, state: any): void;
+    onSummaryEnd(root: N, state: any): void;
+    onEnd(root: N, state: any): void;
 }
 
-type Status = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
-type Milliseconds = number;
-interface Callsite {
-    line: number;
-    column: number;
-}
-interface JsonAssertionResult {
-    ancestorTitles: Array<string>;
-    fullName: string;
-    status: Status;
-    title: string;
-    meta: TaskMeta;
-    duration?: Milliseconds | null;
-    failureMessages: Array<string> | null;
-    location?: Callsite | null;
-}
-interface JsonTestResult {
-    message: string;
-    name: string;
-    status: 'failed' | 'passed';
-    startTime: number;
-    endTime: number;
-    assertionResults: Array<JsonAssertionResult>;
-}
-interface JsonTestResults {
-    numFailedTests: number;
-    numFailedTestSuites: number;
-    numPassedTests: number;
-    numPassedTestSuites: number;
-    numPendingTests: number;
-    numPendingTestSuites: number;
-    numTodoTests: number;
-    numTotalTests: number;
-    numTotalTestSuites: number;
-    startTime: number;
-    success: boolean;
-    testResults: Array<JsonTestResult>;
-    snapshot: SnapshotSummary;
-}
-interface JsonOptions$1 {
-    outputFile?: string;
+interface FileOptions {
+    file: string;
 }
-declare class JsonReporter implements Reporter {
-    start: number;
-    ctx: Vitest;
-    options: JsonOptions$1;
-    constructor(options: JsonOptions$1);
-    onInit(ctx: Vitest): void;
-    protected logTasks(files: File[]): Promise<void>;
-    onFinished(files?: File[]): Promise<void>;
-    /**
-     * Writes the report to an output file if specified in the config,
-     * or logs it to the console otherwise.
-     * @param report
-     */
-    writeReport(report: string): Promise<void>;
+
+interface ProjectOptions {
+    projectRoot: string;
 }
 
-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[], coverage?: unknown) => Awaitable<void>;
-    onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
-    onTestRemoved?: (trigger?: string) => Awaitable<void>;
-    onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
-    onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
-    onServerRestart?: (reason?: string) => Awaitable<void>;
-    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
-    onProcessTimeout?: () => Awaitable<void>;
+interface ReportOptions {
+    clover: CloverOptions;
+    cobertura: CoberturaOptions;
+    "html-spa": HtmlSpaOptions;
+    html: HtmlOptions;
+    json: JsonOptions$1;
+    "json-summary": JsonSummaryOptions;
+    lcov: LcovOptions;
+    lcovonly: LcovOnlyOptions;
+    none: never;
+    teamcity: TeamcityOptions;
+    text: TextOptions;
+    "text-lcov": TextLcovOptions;
+    "text-summary": TextSummaryOptions;
 }
 
-type SerializableSpec = [
-    project: {
-        name: string | undefined;
-        root: string;
-    },
-    file: string
-];
+interface CloverOptions extends FileOptions, ProjectOptions {}
 
-interface JUnitOptions {
-    outputFile?: string;
-    classname?: string;
-    suiteName?: string;
-    /**
-     * Write <system-out> and <system-err> for console output
-     * @default true
-     */
-    includeConsoleOutput?: boolean;
-    /**
-     * Add <testcase file="..."> attribute (validated on CIRCLE CI and GitLab CI)
-     * @default false
-     */
-    addFileAttribute?: boolean;
+interface CoberturaOptions extends FileOptions, ProjectOptions {}
+
+interface HtmlSpaOptions extends HtmlOptions {
+    metricsToShow: Array<"lines" | "branches" | "functions" | "statements">;
 }
-declare class JUnitReporter implements Reporter {
-    private ctx;
-    private reportFile?;
-    private baseLog;
-    private logger;
-    private _timeStart;
-    private fileFd?;
-    private options;
-    constructor(options: JUnitOptions);
-    onInit(ctx: Vitest): Promise<void>;
-    writeElement(name: string, attrs: Record<string, any>, children: () => Promise<void>): Promise<void>;
-    writeLogs(task: Task, type: 'err' | 'out'): Promise<void>;
-    writeTasks(tasks: Task[], filename: string): Promise<void>;
-    onFinished(files?: _vitest_runner.File[]): Promise<void>;
+interface HtmlOptions {
+    verbose: boolean;
+    skipEmpty: boolean;
+    subdir: string;
+    linkMapper: LinkMapper;
 }
 
-interface HTMLOptions {
-    outputFile?: string;
-}
+type JsonOptions$1 = FileOptions;
+type JsonSummaryOptions = FileOptions;
 
-interface BaseOptions {
-    isTTY?: boolean;
-}
-declare abstract class BaseReporter implements Reporter {
-    start: number;
-    end: number;
-    watchFilters?: string[];
-    failedUnwatchedFiles: Task[];
-    isTTY: boolean;
-    ctx: Vitest;
-    protected verbose: boolean;
-    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;
-    protected printTask(task: Task): 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;
-}
+interface LcovOptions extends FileOptions, ProjectOptions {}
+interface LcovOnlyOptions extends FileOptions, ProjectOptions {}
 
-declare class BasicReporter extends BaseReporter {
-    constructor();
-    reportSummary(files: File[], errors: unknown[]): void;
+interface TeamcityOptions extends FileOptions {
+    blockName: string;
 }
 
-interface ListRendererOptions {
-    renderSucceed?: boolean;
-    logger: Logger;
-    showHeap: boolean;
-    slowTestThreshold: number;
-    mode: VitestRunMode;
+interface TextOptions extends FileOptions {
+    maxCols: number;
+    skipEmpty: boolean;
+    skipFull: boolean;
 }
-declare function createListRenderer(_tasks: Task[], options: ListRendererOptions): {
-    start(): any;
-    update(_tasks: Task[]): any;
-    stop(): any;
-    clear(): void;
-};
+type TextLcovOptions = ProjectOptions;
+type TextSummaryOptions = FileOptions;
 
-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 {
-    protected verbose: boolean;
-    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[]): void;
-}
-
-declare class HangingProcessReporter implements Reporter {
-    whyRunning: (() => void) | undefined;
-    onInit(): void;
-    onProcessTimeout(): void;
-}
-
-declare class GithubActionsReporter implements Reporter {
-    ctx: Vitest;
-    onInit(ctx: Vitest): 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 {
-    renderSucceed?: boolean;
-    logger: Logger;
-    showHeap: boolean;
-    slowTestThreshold: number;
-    compare?: FlatBenchmarkReport;
-}
-declare function createTableRenderer(_tasks: Task[], options: TableRendererOptions): {
-    start(): any;
-    update(_tasks: Task[]): any;
-    stop(): any;
-    clear(): void;
-};
-
-declare class TableReporter extends BaseReporter {
-    renderer?: ReturnType<typeof createTableRenderer>;
-    rendererOptions: TableRendererOptions;
-    onTestRemoved(trigger?: string): void;
-    onCollected(): Promise<void>;
-    onTaskUpdate(packs: TaskResultPack[]): void;
-    onFinished(files?: File[], errors?: unknown[]): Promise<void>;
-    onWatcherStart(): Promise<void>;
-    stopListRender(): void;
-    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
-    onUserConsoleLog(log: UserConsoleLog): void;
-}
-interface FlatBenchmarkReport {
-    [id: string]: FormattedBenchmarkResult;
-}
-type FormattedBenchmarkResult = Omit<BenchmarkResult, 'samples'> & {
-    id: string;
-    sampleCount: number;
-    median: number;
-};
-
-declare const BenchmarkReportsMap: {
-    default: typeof TableReporter;
-    verbose: typeof VerboseReporter;
-};
-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;
-    tap: typeof TapReporter;
-    'tap-flat': typeof TapFlatReporter;
-    junit: typeof JUnitReporter;
-    'hanging-process': typeof HangingProcessReporter;
-    'github-actions': typeof GithubActionsReporter;
-};
-type BuiltinReporters = keyof typeof ReportersMap;
-interface BuiltinReporterOptions {
-    'default': BaseOptions;
-    'basic': BaseOptions;
-    'verbose': never;
-    'dot': BaseOptions;
-    'json': JsonOptions$1;
-    'blob': BlobOptions;
-    'tap': never;
-    'tap-flat': never;
-    'junit': JUnitOptions;
-    'hanging-process': never;
-    'html': HTMLOptions;
-}
-
-type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
-
-interface Node {
-    isRoot(): boolean;
-    visit(visitor: Visitor, state: any): void;
-}
-
-interface Visitor<N extends Node = Node> {
-    onStart(root: N, state: any): void;
-    onSummary(root: N, state: any): void;
-    onDetail(root: N, state: any): void;
-    onSummaryEnd(root: N, state: any): void;
-    onEnd(root: N, state: any): void;
-}
-
-interface FileOptions {
-    file: string;
-}
-
-interface ProjectOptions {
-    projectRoot: string;
-}
-
-interface ReportOptions {
-    clover: CloverOptions;
-    cobertura: CoberturaOptions;
-    "html-spa": HtmlSpaOptions;
-    html: HtmlOptions;
-    json: JsonOptions;
-    "json-summary": JsonSummaryOptions;
-    lcov: LcovOptions;
-    lcovonly: LcovOnlyOptions;
-    none: never;
-    teamcity: TeamcityOptions;
-    text: TextOptions;
-    "text-lcov": TextLcovOptions;
-    "text-summary": TextSummaryOptions;
-}
-
-interface CloverOptions extends FileOptions, ProjectOptions {}
-
-interface CoberturaOptions extends FileOptions, ProjectOptions {}
-
-interface HtmlSpaOptions extends HtmlOptions {
-    metricsToShow: Array<"lines" | "branches" | "functions" | "statements">;
-}
-interface HtmlOptions {
-    verbose: boolean;
-    skipEmpty: boolean;
-    subdir: string;
-    linkMapper: LinkMapper;
-}
-
-type JsonOptions = FileOptions;
-type JsonSummaryOptions = FileOptions;
-
-interface LcovOptions extends FileOptions, ProjectOptions {}
-interface LcovOnlyOptions extends FileOptions, ProjectOptions {}
-
-interface TeamcityOptions extends FileOptions {
-    blockName: string;
-}
-
-interface TextOptions extends FileOptions {
-    maxCols: number;
-    skipEmpty: boolean;
-    skipFull: boolean;
-}
-type TextLcovOptions = ProjectOptions;
-type TextSummaryOptions = FileOptions;
-
-interface LinkMapper {
-    getPath(node: string | Node): string;
-    relativePath(source: string | Node, target: string | Node): string;
-    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<M = unknown> = (importOriginal: <T extends M>() => Promise<T>) => any;
-type MockFactory = () => any;
-type MockMap = Map<string, Record<string, string | null | MockFactory>>;
-interface PendingSuiteMock {
-    id: string;
-    importer: string;
-    type: 'mock' | 'unmock';
-    throwIfCached: boolean;
-    factory?: MockFactory;
-}
-
-type TransformMode = 'web' | 'ssr';
-interface RuntimeRPC {
-    fetch: (id: string, environment: TransformMode) => Promise<{
-        externalize?: string;
-        id?: string;
-    }>;
-    transform: (id: string, environment: TransformMode) => Promise<FetchResult>;
-    resolveId: (id: string, importer: string | undefined, environment: TransformMode) => Promise<ViteNodeResolveId | null>;
-    getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
-    onFinished: (files: File[], errors?: unknown[]) => void;
-    onPathsCollected: (paths: string[]) => void;
-    onUserConsoleLog: (log: UserConsoleLog) => void;
-    onUnhandledError: (err: unknown, type: string) => void;
-    onCollected: (files: File[]) => Promise<void>;
-    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
-    onTaskUpdate: (pack: TaskResultPack[]) => Promise<void>;
-    onCancel: (reason: CancelReason) => void;
-    getCountOfFailedTests: () => number;
-    snapshotSaved: (snapshot: SnapshotResult) => void;
-    resolveSnapshotPath: (testPath: string) => string;
-}
-interface RunnerRPC {
-    onCancel: (reason: CancelReason) => void;
-}
-interface ContextTestEnvironment {
-    name: VitestEnvironment;
-    transformMode?: TransformMode;
-    options: EnvironmentOptions | null;
-}
-interface ResolvedTestEnvironment {
-    environment: Environment;
-    options: EnvironmentOptions | null;
-}
-interface ContextRPC {
-    pool: Pool;
-    worker: string;
-    workerId: number;
-    config: ResolvedConfig;
-    projectName: string;
-    files: string[];
-    environment: ContextTestEnvironment;
-    providedContext: Record<string, any>;
-    invalidates?: string[];
-}
-
-interface WorkerContext extends ContextRPC {
-    port: MessagePort;
-}
-type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
-interface AfterSuiteRunMeta {
-    coverage?: unknown;
-    transformMode: Environment['transformMode'];
-    projectName?: string;
-}
-type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
-interface WorkerGlobalState {
-    ctx: ContextRPC;
-    config: ResolvedConfig;
-    rpc: WorkerRPC;
-    current?: Task;
-    filepath?: string;
-    environment: Environment;
-    environmentTeardownRun?: boolean;
-    onCancel: Promise<CancelReason>;
-    moduleCache: ModuleCacheMap;
-    mockMap: MockMap;
-    providedContext: Record<string, any>;
-    durations: {
-        environment: number;
-        prepare: number;
-    };
+interface LinkMapper {
+    getPath(node: string | Node): string;
+    relativePath(source: string | Node, target: string | Node): string;
+    assetPath(node: Node, name: string): string;
 }
 
 type TransformResult = string | Partial<TransformResult$1> | undefined | null | void;
@@ -1490,8 +1132,8 @@ interface CoverageProviderModule {
 }
 type CoverageReporter = keyof ReportOptions | (string & {});
 type CoverageReporterWithOptions<ReporterName extends CoverageReporter = CoverageReporter> = ReporterName extends keyof ReportOptions ? ReportOptions[ReporterName] extends never ? [ReporterName, object] : [ReporterName, Partial<ReportOptions[ReporterName]>] : [ReporterName, Record<string, unknown>];
-type Provider = 'v8' | 'istanbul' | 'custom' | undefined;
-type CoverageOptions<T extends Provider = Provider> = T extends 'istanbul' ? {
+type CoverageProviderName = 'v8' | 'istanbul' | 'custom' | undefined;
+type CoverageOptions<T extends CoverageProviderName = CoverageProviderName> = T extends 'istanbul' ? {
     provider: T;
 } & CoverageIstanbulOptions : T extends 'v8' ? {
     /**
@@ -1507,7 +1149,7 @@ type CoverageOptions<T extends Provider = Provider> = T extends 'istanbul' ? {
 } & CoverageV8Options;
 /** Fields that have default values. Internally these will always be defined. */
 type FieldsWithDefaultValues = 'enabled' | 'clean' | 'cleanOnRerun' | 'reportsDirectory' | 'exclude' | 'extension' | 'reportOnFailure' | 'allowExternal' | 'processingConcurrency';
-type ResolvedCoverageOptions<T extends Provider = Provider> = CoverageOptions<T> & Required<Pick<CoverageOptions<T>, FieldsWithDefaultValues>> & {
+type ResolvedCoverageOptions<T extends CoverageProviderName = CoverageProviderName> = CoverageOptions<T> & Required<Pick<CoverageOptions<T>, FieldsWithDefaultValues>> & {
     reporter: CoverageReporterWithOptions[];
 };
 interface BaseCoverageOptions {
@@ -1649,125 +1291,456 @@ interface Thresholds {
     /** Check thresholds per file. */
     perFile?: boolean;
     /**
-     * Update threshold values automatically when current coverage is higher than earlier thresholds
-     *
-     * @default false
+     * Update threshold values automatically when current coverage is higher than earlier thresholds
+     *
+     * @default false
+     */
+    autoUpdate?: boolean;
+    /** Thresholds for statements */
+    statements?: number;
+    /** Thresholds for functions */
+    functions?: number;
+    /** Thresholds for branches */
+    branches?: number;
+    /** Thresholds for lines */
+    lines?: number;
+}
+
+interface VitestOptions {
+    packageInstaller?: VitestPackageInstaller;
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream | Writable;
+    stderr?: NodeJS.WriteStream | Writable;
+}
+declare class Vitest {
+    readonly mode: VitestRunMode;
+    version: string;
+    config: ResolvedConfig;
+    configOverride: Partial<ResolvedConfig>;
+    server: ViteDevServer;
+    state: StateManager;
+    snapshot: SnapshotManager;
+    cache: VitestCache;
+    reporters: Reporter[];
+    coverageProvider: CoverageProvider | null | undefined;
+    logger: Logger;
+    pool: ProcessPool | undefined;
+    vitenode: ViteNodeServer;
+    invalidates: Set<string>;
+    changedTests: Set<string>;
+    watchedTests: Set<string>;
+    filenamePattern?: string;
+    runningPromise?: Promise<void>;
+    closingPromise?: Promise<void>;
+    isCancelling: boolean;
+    isFirstRun: boolean;
+    restartsCount: number;
+    runner: ViteNodeRunner;
+    packageInstaller: VitestPackageInstaller;
+    private coreWorkspaceProject;
+    private resolvedProjects;
+    projects: WorkspaceProject[];
+    private projectsTestFiles;
+    distPath: string;
+    constructor(mode: VitestRunMode, options?: VitestOptions);
+    private _onRestartListeners;
+    private _onClose;
+    private _onSetServer;
+    private _onCancelListeners;
+    setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
+    provide<T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]): void;
+    private createCoreProject;
+    getCoreWorkspaceProject(): WorkspaceProject;
+    getProjectByTaskId(taskId: string): WorkspaceProject;
+    getProjectByName(name?: string): WorkspaceProject;
+    private getWorkspaceConfigPath;
+    private resolveWorkspace;
+    private initCoverageProvider;
+    private initBrowserProviders;
+    mergeReports(): Promise<void>;
+    collect(filters?: string[]): Promise<{
+        tests: File[];
+        errors: unknown[];
+    }>;
+    start(filters?: string[]): Promise<void>;
+    init(): Promise<void>;
+    private getTestDependencies;
+    filterTestsBySource(specs: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
+    getProjectsByTestFile(file: string): WorkspaceSpec[];
+    initializeGlobalSetup(paths: WorkspaceSpec[]): Promise<void>;
+    private initializeDistPath;
+    runFiles(specs: WorkspaceSpec[], allTestsRun: boolean): Promise<void>;
+    collectFiles(specs: WorkspaceSpec[]): Promise<void>;
+    cancelCurrentRun(reason: CancelReason): Promise<void>;
+    rerunFiles(files?: string[], trigger?: string): Promise<void>;
+    changeProjectName(pattern: string): Promise<void>;
+    changeNamePattern(pattern: string, files?: string[], trigger?: string): Promise<void>;
+    changeFilenamePattern(pattern: string, files?: string[]): Promise<void>;
+    rerunFailed(): Promise<void>;
+    updateSnapshot(files?: string[]): Promise<void>;
+    private _rerunTimer;
+    private scheduleRerun;
+    getModuleProjects(filepath: string): WorkspaceProject[];
+    /**
+     * Watch only the specified tests. If no tests are provided, all tests will be watched.
+     */
+    watchTests(tests: string[]): void;
+    private unregisterWatcher;
+    private registerWatcher;
+    /**
+     * @returns A value indicating whether rerun is needed (changedTests was mutated)
+     */
+    private handleFileChanged;
+    private reportCoverage;
+    close(): Promise<void>;
+    /**
+     * Close the thread pool and exit the process
+     */
+    exit(force?: boolean): 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;
+    onServerRestart(fn: OnServerRestartHandler): void;
+    onAfterSetServer(fn: OnServerRestartHandler): void;
+    onCancel(fn: (reason: CancelReason) => void): void;
+    onClose(fn: () => void): void;
+}
+
+type SerializedSpec = [
+    project: {
+        name: string | undefined;
+        root: string;
+    },
+    file: string
+];
+
+interface Reporter {
+    onInit?: (ctx: Vitest) => void;
+    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+    onSpecsCollected?: (specs?: SerializedSpec[]) => Awaitable<void>;
+    onCollected?: (files?: File[]) => 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>;
+    onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
+    onServerRestart?: (reason?: string) => Awaitable<void>;
+    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
+    onProcessTimeout?: () => Awaitable<void>;
+}
+
+interface BaseOptions {
+    isTTY?: boolean;
+}
+declare abstract class BaseReporter implements Reporter {
+    start: number;
+    end: number;
+    watchFilters?: string[];
+    failedUnwatchedFiles: Task[];
+    isTTY: boolean;
+    ctx: Vitest;
+    protected verbose: boolean;
+    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;
+    protected printTask(task: Task): 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 {
+    constructor();
+    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;
+}
+
+type Status = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
+type Milliseconds = number;
+interface Callsite {
+    line: number;
+    column: number;
+}
+interface JsonAssertionResult {
+    ancestorTitles: Array<string>;
+    fullName: string;
+    status: Status;
+    title: string;
+    meta: TaskMeta;
+    duration?: Milliseconds | null;
+    failureMessages: Array<string> | null;
+    location?: Callsite | null;
+}
+interface JsonTestResult {
+    message: string;
+    name: string;
+    status: 'failed' | 'passed';
+    startTime: number;
+    endTime: number;
+    assertionResults: Array<JsonAssertionResult>;
+}
+interface JsonTestResults {
+    numFailedTests: number;
+    numFailedTestSuites: number;
+    numPassedTests: number;
+    numPassedTestSuites: number;
+    numPendingTests: number;
+    numPendingTestSuites: number;
+    numTodoTests: number;
+    numTotalTests: number;
+    numTotalTestSuites: number;
+    startTime: number;
+    success: boolean;
+    testResults: Array<JsonTestResult>;
+    snapshot: SnapshotSummary;
+}
+interface JsonOptions {
+    outputFile?: string;
+}
+declare class JsonReporter implements Reporter {
+    start: number;
+    ctx: Vitest;
+    options: JsonOptions;
+    constructor(options: JsonOptions);
+    onInit(ctx: Vitest): void;
+    protected logTasks(files: File[]): Promise<void>;
+    onFinished(files?: File[]): Promise<void>;
+    /**
+     * Writes the report to an output file if specified in the config,
+     * or logs it to the console otherwise.
+     * @param report
      */
-    autoUpdate?: boolean;
-    /** Thresholds for statements */
-    statements?: number;
-    /** Thresholds for functions */
-    functions?: number;
-    /** Thresholds for branches */
-    branches?: number;
-    /** Thresholds for lines */
-    lines?: number;
+    writeReport(report: string): Promise<void>;
 }
 
-interface JSDOMOptions {
-    /**
-     * The html content for the test.
-     *
-     * @default '<!DOCTYPE html>'
-     */
-    html?: string | Buffer | ArrayBufferLike;
-    /**
-     * referrer just affects the value read from document.referrer.
-     * It defaults to no referrer (which reflects as the empty string).
-     */
-    referrer?: string;
-    /**
-     * userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
-     *
-     * @default `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
-     */
-    userAgent?: string;
-    /**
-     * url sets the value returned by window.location, document.URL, and document.documentURI,
-     * and affects things like resolution of relative URLs within the document
-     * and the same-origin restrictions and referrer used while fetching subresources.
-     *
-     * @default 'http://localhost:3000'.
-     */
-    url?: string;
-    /**
-     * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
-     * Values that are not "text/html" or an XML mime type will throw.
-     *
-     * @default 'text/html'.
-     */
-    contentType?: string;
-    /**
-     * The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.
-     * Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set
-     * to 5,000,000 code units per origin, as inspired by the HTML specification.
-     *
-     * @default 5_000_000
-     */
-    storageQuota?: number;
-    /**
-     * Enable console?
-     *
-     * @default false
-     */
-    console?: boolean;
+declare class VerboseReporter extends DefaultReporter {
+    protected verbose: boolean;
+    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;
+}
+
+interface JUnitOptions {
+    outputFile?: string;
+    classname?: string;
+    suiteName?: string;
     /**
-     * jsdom does not have the capability to render visual content, and will act like a headless browser by default.
-     * It provides hints to web pages through APIs such as document.hidden that their content is not visible.
-     *
-     * When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
-     * content.
-     *
+     * Write <system-out> and <system-err> for console output
      * @default true
      */
-    pretendToBeVisual?: boolean;
+    includeConsoleOutput?: boolean;
     /**
-     * `includeNodeLocations` preserves the location info produced by the HTML parser,
-     * allowing you to retrieve it with the nodeLocation() method (described below).
-     *
-     * It defaults to false to give the best performance,
-     * and cannot be used with an XML content type since our XML parser does not support location info.
-     *
+     * Add <testcase file="..."> attribute (validated on CIRCLE CI and GitLab CI)
      * @default false
      */
-    includeNodeLocations?: boolean | undefined;
-    /**
-     * @default 'dangerously'
-     */
-    runScripts?: 'dangerously' | 'outside-only';
+    addFileAttribute?: boolean;
+}
+declare class JUnitReporter implements Reporter {
+    private ctx;
+    private reportFile?;
+    private baseLog;
+    private logger;
+    private _timeStart;
+    private fileFd?;
+    private options;
+    constructor(options: JUnitOptions);
+    onInit(ctx: Vitest): Promise<void>;
+    writeElement(name: string, attrs: Record<string, any>, children: () => Promise<void>): Promise<void>;
+    writeLogs(task: Task, type: 'err' | 'out'): Promise<void>;
+    writeTasks(tasks: Task[], filename: string): Promise<void>;
+    onFinished(files?: _vitest_runner.File[]): Promise<void>;
+}
+
+declare class TapFlatReporter extends TapReporter {
+    onInit(ctx: Vitest): void;
+    onFinished(files?: _vitest_runner.File[]): void;
+}
+
+declare class HangingProcessReporter implements Reporter {
+    whyRunning: (() => void) | undefined;
+    onInit(): void;
+    onProcessTimeout(): void;
+}
+
+declare class GithubActionsReporter implements Reporter {
+    ctx: Vitest;
+    onInit(ctx: Vitest): void;
+    onFinished(files?: File[], errors?: unknown[]): void;
+}
+
+interface HTMLOptions {
+    outputFile?: string;
+}
+
+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 {
+    renderSucceed?: boolean;
+    logger: Logger;
+    showHeap: boolean;
+    slowTestThreshold: number;
+    compare?: FlatBenchmarkReport;
+}
+declare function createTableRenderer(_tasks: Task[], options: TableRendererOptions): {
+    start(): any;
+    update(_tasks: Task[]): any;
+    stop(): any;
+    clear(): void;
+};
+
+declare class TableReporter extends BaseReporter {
+    renderer?: ReturnType<typeof createTableRenderer>;
+    rendererOptions: TableRendererOptions;
+    onTestRemoved(trigger?: string): void;
+    onCollected(): Promise<void>;
+    onTaskUpdate(packs: TaskResultPack[]): void;
+    onFinished(files?: File[], errors?: unknown[]): Promise<void>;
+    onWatcherStart(): Promise<void>;
+    stopListRender(): void;
+    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
+    onUserConsoleLog(log: UserConsoleLog): void;
+}
+interface FlatBenchmarkReport {
+    [id: string]: FormattedBenchmarkResult;
+}
+type FormattedBenchmarkResult = Omit<BenchmarkResult, 'samples'> & {
+    id: string;
+    sampleCount: number;
+    median: number;
+};
+
+declare const BenchmarkReportsMap: {
+    default: typeof TableReporter;
+    verbose: typeof VerboseReporter;
+};
+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;
+    tap: typeof TapReporter;
+    'tap-flat': typeof TapFlatReporter;
+    junit: typeof JUnitReporter;
+    'hanging-process': typeof HangingProcessReporter;
+    'github-actions': typeof GithubActionsReporter;
+};
+type BuiltinReporters = keyof typeof ReportersMap;
+interface BuiltinReporterOptions {
+    'default': BaseOptions;
+    'basic': BaseOptions;
+    'verbose': never;
+    'dot': BaseOptions;
+    'json': JsonOptions;
+    'blob': BlobOptions;
+    'tap': never;
+    'tap-flat': never;
+    'junit': JUnitOptions;
+    'hanging-process': never;
+    'html': HTMLOptions;
+}
+
+interface TestSequencer {
     /**
-     * Enable CookieJar
-     *
-     * @default false
+     * Slicing tests into shards. Will be run before `sort`.
+     * Only run, if `shard` is defined.
      */
-    cookieJar?: boolean;
-    resources?: 'usable' | any;
+    shard: (files: WorkspaceSpec[]) => Awaitable<WorkspaceSpec[]>;
+    sort: (files: WorkspaceSpec[]) => Awaitable<WorkspaceSpec[]>;
 }
-
-/**
- * Happy DOM options.
- */
-interface HappyDOMOptions {
-    width?: number;
-    height?: number;
-    url?: string;
-    settings?: {
-        disableJavaScriptEvaluation?: boolean;
-        disableJavaScriptFileLoading?: boolean;
-        disableCSSFileLoading?: boolean;
-        disableIframePageLoading?: boolean;
-        disableComputedStyleRendering?: boolean;
-        enableFileSystemHttpRequests?: boolean;
-        navigator?: {
-            userAgent?: string;
-        };
-        device?: {
-            prefersColorScheme?: string;
-            mediaType?: string;
-        };
-    };
+interface TestSequencerConstructor {
+    new (ctx: Vitest): TestSequencer;
 }
 
+type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
+
 interface BenchmarkUserOptions {
     /**
      * Include globs for benchmark test files
@@ -1807,25 +1780,9 @@ interface BenchmarkUserOptions {
      */
     outputJson?: string;
 }
-interface Benchmark extends Custom {
-    meta: {
-        benchmark: true;
-        result?: TaskResult;
-    };
-}
-interface BenchmarkResult extends TaskResult {
-    name: string;
-    rank: number;
-}
-type BenchFunction = (this: Bench) => Promise<void> | void;
-type ChainableBenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', (name: string | Function, fn?: BenchFunction, options?: Options$1) => void>;
-type BenchmarkAPI = ChainableBenchmarkAPI & {
-    skipIf: (condition: any) => ChainableBenchmarkAPI;
-    runIf: (condition: any) => ChainableBenchmarkAPI;
-};
 
 declare const defaultBrowserPort = 63315;
-declare const extraInlineDeps: (string | RegExp)[];
+declare const extraInlineDeps: RegExp[];
 
 declare const defaultInclude: string[];
 declare const defaultExclude: string[];
@@ -1840,6 +1797,8 @@ declare const configDefaults: Readonly<{
     clearMocks: false;
     restoreMocks: false;
     mockReset: false;
+    unstubGlobals: false;
+    unstubEnvs: false;
     include: string[];
     exclude: string[];
     teardownTimeout: number;
@@ -1886,11 +1845,18 @@ declare function defineConfig(config: UserConfig$1): UserConfig$1;
 declare function defineConfig(config: Promise<UserConfig$1>): Promise<UserConfig$1>;
 declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
 declare function defineConfig(config: UserConfigExport): UserConfigExport;
-declare function defineProject<T extends UserProjectConfigExport>(config: T): T;
-type Workspace = string | (UserProjectConfigExport & {
+declare function defineProject(config: UserWorkspaceConfig): UserWorkspaceConfig;
+declare function defineProject(config: Promise<UserWorkspaceConfig>): Promise<UserWorkspaceConfig>;
+declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn;
+declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
+type WorkspaceProjectConfiguration = string | (UserProjectConfigExport & {
+    /**
+     * Relative path to the extendable config. All other options will be merged with this config.
+     * @example '../vite.config.ts'
+     */
     extends?: string;
 });
-declare function defineWorkspace(config: Workspace[]): Workspace[];
+declare function defineWorkspace(config: WorkspaceProjectConfiguration[]): WorkspaceProjectConfiguration[];
 
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
@@ -1898,14 +1864,6 @@ type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
 type CSSModuleScopeStrategy = 'stable' | 'scoped' | 'non-scoped';
 type ApiConfig = Pick<ServerOptions, 'port' | 'strictPort' | 'host' | 'middlewareMode'>;
 
-interface EnvironmentOptions {
-    /**
-     * jsdom options.
-     */
-    jsdom?: JSDOMOptions;
-    happyDOM?: HappyDOMOptions;
-    [x: string]: unknown;
-}
 type VitestRunMode = 'test' | 'benchmark';
 interface SequenceOptions {
     /**
@@ -2397,7 +2355,7 @@ interface InlineConfig {
      *
      * Return `false` to omit the frame.
      */
-    onStackTrace?: (error: Error, frame: ParsedStack) => boolean | void;
+    onStackTrace?: (error: ErrorWithDiff, frame: ParsedStack) => boolean | void;
     /**
      * Indicates if CSS files should be processed.
      *
@@ -2668,10 +2626,13 @@ interface UserConfig extends InlineConfig {
      */
     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' | 'diff'> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'browser' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck' | 'runner' | 'poolOptions' | 'pool' | 'cliExclude' | 'diff' | 'setupFiles' | 'snapshotEnvironment' | 'bail'> {
     mode: VitestRunMode;
     base?: string;
     diff?: string;
+    bail?: number;
+    setupFiles: string[];
+    snapshotEnvironment?: string;
     config?: string;
     filters?: string[];
     testNamePattern?: RegExp;
@@ -2711,7 +2672,8 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     maxWorkers: number;
     minWorkers: number;
 }
-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' | 'maxWorkers' | 'minWorkers' | 'fileParallelism'> & {
+type NonProjectOptions = 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'teardownTimeout' | 'silent' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'onStackTrace' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'coverage' | 'maxWorkers' | 'minWorkers' | 'fileParallelism';
+type ProjectConfig = Omit<UserConfig, NonProjectOptions | 'sequencer' | 'deps' | 'poolOptions'> & {
     sequencer?: Omit<SequenceOptions, 'sequencer' | 'seed'>;
     deps?: Omit<DepsOptions, 'moduleDirectories'>;
     poolOptions?: {
@@ -2720,12 +2682,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' | 'expect' | 'printConsoleTrace'> & {
-    sequence?: {
-        concurrent?: boolean;
-        hooks?: SequenceHooks;
-    };
-};
+type ResolvedProjectConfig = Omit<ResolvedConfig, NonProjectOptions>;
 
 type VitestInlineConfig = InlineConfig;
 declare module 'vite' {
@@ -2737,101 +2694,4 @@ declare module 'vite' {
     }
 }
 
-declare global {
-    namespace Chai {
-        interface Assertion {
-            containSubset: (expected: any) => Assertion;
-        }
-        interface Assert {
-            containSubset: (val: any, exp: any, msg?: string) => void;
-        }
-    }
-}
-interface SnapshotMatcher<T> {
-    <U extends {
-        [P in keyof T]: any;
-    }>(snapshot: Partial<U>, message?: string): void;
-    (message?: string): void;
-}
-interface InlineSnapshotMatcher<T> {
-    <U extends {
-        [P in keyof T]: any;
-    }>(properties: Partial<U>, snapshot?: string, message?: string): void;
-    (message?: string): void;
-}
-declare module '@vitest/expect' {
-    interface MatcherState {
-        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) => void;
-    }
-    interface Assertion<T> {
-        matchSnapshot: SnapshotMatcher<T>;
-        toMatchSnapshot: SnapshotMatcher<T>;
-        toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
-        toThrowErrorMatchingSnapshot: (message?: string) => void;
-        toThrowErrorMatchingInlineSnapshot: (snapshot?: string, message?: string) => void;
-        toMatchFileSnapshot: (filepath: string, message?: string) => Promise<void>;
-    }
-}
-declare module '@vitest/runner' {
-    interface TestContext {
-        expect: ExpectStatic;
-    }
-    interface TaskMeta {
-        typecheck?: boolean;
-        benchmark?: boolean;
-        failScreenshotPath?: string;
-    }
-    interface File {
-        prepareDuration?: number;
-        environmentLoad?: number;
-    }
-    interface TaskBase {
-        logs?: UserConsoleLog[];
-    }
-    interface TaskResult {
-        benchmark?: BenchmarkResult;
-    }
-}
-
-type RawErrsMap = Map<string, TscErrorInfo[]>;
-interface TscErrorInfo {
-    filePath: string;
-    errCode: number;
-    errMsg: string;
-    line: number;
-    column: number;
-}
-interface CollectLineNumbers {
-    target: number;
-    next: number;
-    prev?: number;
-}
-type CollectLines = {
-    [key in keyof CollectLineNumbers]: string;
-};
-interface RootAndTarget {
-    root: string;
-    targetAbsPath: string;
-}
-type Context = RootAndTarget & {
-    rawErrsMap: RawErrsMap;
-    openedDirs: Set<string>;
-    lastActivePath?: string;
-};
-
-export { type Nullable 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 BrowserConfigOptions as G, type HappyDOMOptions as H, type InlineConfig as I, type JSDOMOptions as J, type UserWorkspaceConfig as K, type RunnerRPC as L, type MockFactoryWithHelper as M, type ContextTestEnvironment as N, type ResolvedTestEnvironment as O, type Pool as P, Vitest 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 ResolveIdFunction as X, type AfterSuiteRunMeta as Y, type WorkerRPC as Z, type Awaitable as _, type ResolvedCoverageOptions as a, BasicReporter as a$, type Arrayable as a0, type ArgumentsType$1 as a1, type MutableArray as a2, type Constructable as a3, type ModuleCache as a4, type EnvironmentReturn as a5, type VmEnvironmentReturn as a6, type UserConsoleLog as a7, type OnServerRestartHandler as a8, type ReportContext as a9, type BrowserCommandContext as aA, type BrowserServer as aB, type BrowserServerState as aC, type BrowserServerStateContext as aD, type BrowserOrchestrator as aE, type JsonOptions$1 as aF, type JUnitOptions as aG, type HTMLOptions as aH, type PendingSuiteMock as aI, type MockFactory as aJ, type MockMap as aK, type UserConfigFnObject as aL, type UserConfigFnPromise as aM, type UserConfigFn as aN, type UserConfigExport as aO, type UserProjectConfigFn as aP, type UserProjectConfigExport as aQ, defineConfig as aR, defineProject as aS, defineWorkspace as aT, defaultBrowserPort as aU, configDefaults as aV, defaultInclude as aW, defaultExclude as aX, coverageConfigDefaults as aY, extraInlineDeps as aZ, DefaultReporter as a_, type CoverageReporter as aa, type CoverageIstanbulOptions as ab, type CoverageV8Options as ac, type CustomProviderOptions as ad, type BenchmarkUserOptions as ae, type Benchmark as af, type BenchmarkResult as ag, type BenchFunction as ah, type BenchmarkAPI as ai, type VitestOptions as aj, WorkspaceProject as ak, Logger as al, type TestSequencer as am, type WorkspaceSpec as an, type ProcessPool as ao, getFilePoolName as ap, VitestPackageInstaller as aq, type TestSequencerConstructor as ar, type BrowserProviderInitializationOptions as as, type BrowserProvider as at, type CDPSession as au, type BrowserProviderModule as av, type ResolvedBrowserOptions as aw, type BrowserProviderOptions as ax, type BrowserBuiltinProvider as ay, type BrowserCommand as az, type CoverageProvider as b, DotReporter as b0, JsonReporter as b1, VerboseReporter as b2, TapReporter as b3, JUnitReporter as b4, TapFlatReporter as b5, HangingProcessReporter as b6, GithubActionsReporter as b7, BaseReporter as b8, ReportersMap as b9, type BuiltinReporters as ba, type BuiltinReporterOptions as bb, type JsonAssertionResult as bc, type JsonTestResult as bd, type JsonTestResults as be, BenchmarkReportsMap as bf, type BenchmarkBuiltinReporters as bg, 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 ProvidedContext as i, type ModuleGraphData as j, type Reporter as k, type BirpcReturn as l, type RawErrsMap as m, type CollectLineNumbers as n, type CollectLines as o, type RootAndTarget as p, type Context as q, type PoolOptions as r, type BuiltinEnvironment as s, type CSSModuleScopeStrategy as t, type EnvironmentOptions as u, type VitestRunMode as v, type TransformModePatterns as w, type TypecheckConfig as x, type ProjectConfig as y, type BrowserScript as z };
+export { type BrowserBuiltinProvider as $, type ApiConfig as A, type BaseCoverageOptions as B, type CoverageProvider as C, type DepsOptimizationOptions as D, type BenchmarkUserOptions as E, type VitestOptions as F, type TestSequencer as G, type WorkspaceSpec as H, type InlineConfig as I, type ProcessPool as J, getFilePoolName as K, Logger as L, VitestPackageInstaller as M, type TestSequencerConstructor as N, type BrowserProviderInitializationOptions as O, type Pool as P, type BrowserProvider as Q, type ResolvedCoverageOptions as R, type SerializedSpec as S, type TscErrorInfo as T, type UserConfig as U, type VitestEnvironment as V, WorkspaceProject as W, type CDPSession as X, type BrowserProviderModule as Y, type ResolvedBrowserOptions as Z, type BrowserProviderOptions as _, type CoverageProviderModule as a, type BrowserCommand as a0, type BrowserCommandContext as a1, type BrowserServer as a2, type BrowserServerState as a3, type BrowserServerStateContext as a4, type BrowserOrchestrator as a5, type JsonOptions as a6, type JUnitOptions as a7, type HTMLOptions as a8, TestCase as a9, extraInlineDeps as aA, DefaultReporter as aB, BasicReporter as aC, DotReporter as aD, JsonReporter as aE, VerboseReporter as aF, TapReporter as aG, JUnitReporter as aH, TapFlatReporter as aI, HangingProcessReporter as aJ, GithubActionsReporter as aK, BaseReporter as aL, ReportersMap as aM, type BuiltinReporters as aN, type BuiltinReporterOptions as aO, type JsonAssertionResult as aP, type JsonTestResult as aQ, type JsonTestResults as aR, BenchmarkReportsMap as aS, type BenchmarkBuiltinReporters as aT, TestFile as aa, TestSuite as ab, TestProject as ac, TestCollection as ad, type TaskOptions as ae, type TestDiagnostic as af, type FileDiagnostic as ag, type TestResult as ah, type TestResultPassed as ai, type TestResultFailed as aj, type TestResultSkipped as ak, type ResolvedProjectConfig as al, type UserConfigFnObject as am, type UserConfigFnPromise as an, type UserConfigFn as ao, type UserConfigExport as ap, type UserProjectConfigFn as aq, type UserProjectConfigExport as ar, defineConfig as as, defineProject as at, defineWorkspace as au, defaultBrowserPort as av, configDefaults as aw, defaultInclude as ax, defaultExclude as ay, coverageConfigDefaults as az, type RawErrsMap as b, type CollectLineNumbers as c, type CollectLines as d, type RootAndTarget as e, type Context as f, type ReportContext as g, type CoverageReporter as h, type CoverageProviderName as i, type CoverageOptions as j, type CoverageIstanbulOptions as k, type CoverageV8Options as l, type CustomProviderOptions as m, type Reporter as n, Vitest as o, type BrowserScript as p, type BrowserConfigOptions as q, type BuiltinEnvironment as r, type PoolOptions as s, type CSSModuleScopeStrategy as t, type VitestRunMode as u, type TransformModePatterns as v, type TypecheckConfig as w, type ResolvedConfig as x, type ProjectConfig as y, type UserWorkspaceConfig as z };