vitest 2.1.2 → 2.1.4

package/dist/chunks/{reporters.DAfKSDh5.d.ts → reporters.anwo7Y6a.d.ts}

@@ -1,261 +1,132 @@
+import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.Crbj2GAb.js';
+import { PrettyFormatOptions } from '@vitest/pretty-format';
 import * as _vitest_runner from '@vitest/runner';
-import { File, Test, Suite, TaskResultPack, Task, CancelReason, Custom, TaskMeta, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import { File, TaskResultPack, Task, Test, Suite, CancelReason, Custom, TaskMeta, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import * as vite from 'vite';
 import { ViteDevServer, TransformResult as TransformResult$1, ServerOptions, DepOptimizationConfig, AliasOptions, UserConfig as UserConfig$1, ConfigEnv } from 'vite';
-import { PrettyFormatOptions } from '@vitest/pretty-format';
-import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.Crbj2GAb.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.CzISCQ7o.js';
+import * as chai from 'chai';
+import { b as Awaitable, U as UserConsoleLog, P as ProvidedContext, A as AfterSuiteRunMeta, c as Arrayable$1, f as EnvironmentOptions, d as ArgumentsType, O as OnServerRestartHandler } from './environment.LoooBwUu.js';
 import { Writable } from 'node:stream';
+import { ParsedStack, Awaitable as Awaitable$1, ErrorWithDiff, TestError, Arrayable } from '@vitest/utils';
+import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { ViteNodeRunner } from 'vite-node/client';
-import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
-import { ParsedStack, Awaitable as Awaitable$1, ErrorWithDiff, TestError, Arrayable as Arrayable$1 } from '@vitest/utils';
-import { StackTraceParserOptions } from '@vitest/utils/source-map';
+import { SnapshotManager } from '@vitest/snapshot/manager';
 import { Stats } from 'node:fs';
-import * as chai from 'chai';
-import { B as BenchmarkResult } from './benchmark.JVlTzojj.js';
+import { B as BenchmarkResult } from './benchmark.geERunq4.js';
 
-type BuiltinPool = 'browser' | 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript';
-type Pool = BuiltinPool | (string & {});
-interface PoolOptions extends Record<string, unknown> {
-    /**
-     * Run tests in `node:worker_threads`.
-     *
-     * Test isolation (when enabled) is done by spawning a new thread for each test file.
-     *
-     * This pool is used by default.
-     */
-    threads?: ThreadsOptions & WorkerContextOptions;
-    /**
-     * Run tests in `node:child_process` using [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
-     *
-     * Test isolation (when enabled) is done by spawning a new child process for each test file.
-     */
-    forks?: ForksOptions & WorkerContextOptions;
-    /**
-     * Run tests in isolated `node:vm`.
-     * Test files are run parallel using `node:worker_threads`.
-     *
-     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
-     */
-    vmThreads?: ThreadsOptions & VmOptions;
-    /**
-     * Run tests in isolated `node:vm`.
-     *
-     * Test files are run parallel using `node:child_process` [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
-     *
-     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
-     */
-    vmForks?: ForksOptions & VmOptions;
+type SerializedTestSpecification = [
+    project: {
+        name: string | undefined;
+        root: string;
+    },
+    file: string,
+    options: {
+        pool: string;
+    }
+];
+
+type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
+
+interface Reporter {
+    onInit?: (ctx: Vitest) => void;
+    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+    onSpecsCollected?: (specs?: SerializedTestSpecification[]) => 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 ResolvedPoolOptions extends PoolOptions {
-    threads?: ResolvedThreadsOptions & WorkerContextOptions;
-    forks?: ResolvedForksOptions & WorkerContextOptions;
-    vmThreads?: ResolvedThreadsOptions & VmOptions;
-    vmForks?: ResolvedForksOptions & VmOptions;
+
+interface BaseOptions {
+    isTTY?: boolean;
 }
-interface ThreadsOptions {
-    /** Minimum amount of threads to use */
-    minThreads?: number | string;
-    /** Maximum amount of threads to use */
-    maxThreads?: number | string;
-    /**
-     * Run tests inside a single thread.
-     *
-     * @default false
-     */
-    singleThread?: boolean;
-    /**
-     * Use Atomics to synchronize threads
-     *
-     * This can improve performance in some cases, but might cause segfault in older Node versions.
-     *
-     * @default false
-     */
-    useAtomics?: 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;
+    private getDurationPrefix;
+    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 ResolvedThreadsOptions extends ThreadsOptions {
-    minThreads?: number;
-    maxThreads?: number;
+
+interface ParsedFile extends File {
+    start: number;
+    end: number;
 }
-interface ForksOptions {
-    /** Minimum amount of child processes to use */
-    minForks?: number | string;
-    /** Maximum amount of child processes to use */
-    maxForks?: number | string;
-    /**
-     * Run tests inside a single fork.
-     *
-     * @default false
-     */
-    singleFork?: boolean;
+interface ParsedTest extends Test {
+    start: number;
+    end: number;
 }
-interface ResolvedForksOptions extends ForksOptions {
-    minForks?: number;
-    maxForks?: number;
+interface ParsedSuite extends Suite {
+    start: number;
+    end: number;
 }
-interface WorkerContextOptions {
-    /**
-     * Isolate test environment by recycling `worker_threads` or `child_process` after each test
-     *
-     * @default true
-     */
-    isolate?: boolean;
-    /**
-     * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
-     *
-     * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
-     *
-     * Set to `process.execArgv` to pass all arguments of the current process.
-     *
-     * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
-     *
-     * @default [] // no execution arguments are passed
-     */
-    execArgv?: string[];
+interface LocalCallDefinition {
+    start: number;
+    end: number;
+    name: string;
+    type: 'suite' | 'test';
+    mode: 'run' | 'skip' | 'only' | 'todo';
+    task: ParsedSuite | ParsedFile | ParsedTest;
 }
-interface VmOptions {
-    /**
-     * Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
-     * If you see memory leaks, try to tinker this value.
-     */
-    memoryLimit?: string | number;
-    /** Isolation is always enabled */
-    isolate?: true;
-    /**
-     * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
-     *
-     * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
-     *
-     * Set to `process.execArgv` to pass all arguments of the current process.
-     *
-     * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
-     *
-     * @default [] // no execution arguments are passed
-     */
-    execArgv?: string[];
+interface FileInformation {
+    file: File;
+    filepath: string;
+    parsed: string;
+    map: RawSourceMap | null;
+    definitions: LocalCallDefinition[];
 }
 
-interface Options {
-	/**
-	Show the cursor. This can be useful when a CLI accepts input from a user.
-
-	@example
-	```
-	import {createLogUpdate} from 'log-update';
-
-	// Write output but don't hide the cursor
-	const log = createLogUpdate(process.stdout, {
-		showCursor: true
-	});
-	```
-	*/
-	readonly showCursor?: boolean;
+type RawErrsMap = Map<string, TscErrorInfo[]>;
+interface TscErrorInfo {
+    filePath: string;
+    errCode: number;
+    errMsg: string;
+    line: number;
+    column: number;
 }
-
-type LogUpdateMethods = {
-	/**
-	Clear the logged output.
-	*/
-	clear(): void;
-
-	/**
-	Persist the logged output. Useful if you want to start a new log session below the current one.
-	*/
-	done(): void;
-};
-
-/**
-Log to `stdout` by overwriting the previous output in the terminal.
-
-@param text - The text to log to `stdout`.
-
-@example
-```
-import logUpdate from 'log-update';
-
-const frames = ['-', '\\', '|', '/'];
-let index = 0;
-
-setInterval(() => {
-	const frame = frames[index = ++index % frames.length];
-
-	logUpdate(
-`
-		♥♥
-${frame} unicorns ${frame}
-		♥♥
-`
-	);
-}, 80);
-```
-*/
-declare const logUpdate: ((...text: string[]) => void) & LogUpdateMethods;
-
-
-/**
-Get a `logUpdate` method that logs to the specified stream.
-
-@param stream - The stream to log to.
-
-@example
-```
-import {createLogUpdate} from 'log-update';
-
-// Write output but don't hide the cursor
-const log = createLogUpdate(process.stdout);
-```
-*/
-declare function createLogUpdate(
-	stream: NodeJS.WritableStream,
-	options?: Options
-): typeof logUpdate;
-
-interface ParsedFile extends File {
-    start: number;
-    end: number;
-}
-interface ParsedTest extends Test {
-    start: number;
-    end: number;
-}
-interface ParsedSuite extends Suite {
-    start: number;
-    end: number;
-}
-interface LocalCallDefinition {
-    start: number;
-    end: number;
-    name: string;
-    type: 'suite' | 'test';
-    mode: 'run' | 'skip' | 'only' | 'todo';
-    task: ParsedSuite | ParsedFile | ParsedTest;
-}
-interface FileInformation {
-    file: File;
-    filepath: string;
-    parsed: string;
-    map: RawSourceMap | null;
-    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 CollectLineNumbers {
+    target: number;
+    next: number;
+    prev?: number;
+}
+type CollectLines = {
+    [key in keyof CollectLineNumbers]: string;
 };
 interface RootAndTarget {
     root: string;
@@ -326,6 +197,81 @@ interface PrintErrorResult {
     nearest?: ParsedStack;
 }
 
+interface Options {
+	/**
+	Show the cursor. This can be useful when a CLI accepts input from a user.
+
+	@example
+	```
+	import {createLogUpdate} from 'log-update';
+
+	// Write output but don't hide the cursor
+	const log = createLogUpdate(process.stdout, {
+		showCursor: true
+	});
+	```
+	*/
+	readonly showCursor?: boolean;
+}
+
+type LogUpdateMethods = {
+	/**
+	Clear the logged output.
+	*/
+	clear(): void;
+
+	/**
+	Persist the logged output. Useful if you want to start a new log session below the current one.
+	*/
+	done(): void;
+};
+
+/**
+Log to `stdout` by overwriting the previous output in the terminal.
+
+@param text - The text to log to `stdout`.
+
+@example
+```
+import logUpdate from 'log-update';
+
+const frames = ['-', '\\', '|', '/'];
+let index = 0;
+
+setInterval(() => {
+	const frame = frames[index = ++index % frames.length];
+
+	logUpdate(
+`
+		♥♥
+${frame} unicorns ${frame}
+		♥♥
+`
+	);
+}, 80);
+```
+*/
+declare const logUpdate: ((...text: string[]) => void) & LogUpdateMethods;
+
+
+/**
+Get a `logUpdate` method that logs to the specified stream.
+
+@param stream - The stream to log to.
+
+@example
+```
+import {createLogUpdate} from 'log-update';
+
+// Write output but don't hide the cursor
+const log = createLogUpdate(process.stdout);
+```
+*/
+declare function createLogUpdate(
+	stream: NodeJS.WritableStream,
+	options?: Options
+): typeof logUpdate;
+
 interface ErrorOptions {
     type?: string;
     fullStack?: boolean;
@@ -488,8 +434,13 @@ interface BrowserConfigOptions {
     screenshotFailures?: boolean;
     /**
      * Scripts injected into the tester iframe.
+     * @deprecated Will be removed in the future, use `testerHtmlPath` instead.
      */
     testerScripts?: BrowserScript[];
+    /**
+     * Path to the index.html file that will be used to run tests.
+     */
+    testerHtmlPath?: string;
     /**
      * Scripts injected into the main window.
      */
@@ -579,50 +530,6 @@ interface ResolvedBrowserOptions extends BrowserConfigOptions {
     };
 }
 
-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 {
     workspaceConfigPath: string;
     extends?: string;
@@ -681,90 +588,39 @@ declare class WorkspaceProject {
     initBrowserProvider(): Promise<void>;
 }
 
-type SerializedTestSpecification = [
-    project: {
-        name: string | undefined;
-        root: string;
-    },
-    file: string,
-    options: {
-        pool: 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>;
+}
 
-declare class TestSpecification {
+interface HTMLOptions {
+    outputFile?: string;
+}
+
+declare class ReportedTaskImplementation {
     /**
-     * @deprecated use `project` instead
+     * Task instance.
+     * @experimental Public runner task API is experimental and does not follow semver.
      */
-    readonly 0: WorkspaceProject;
+    readonly task: Task;
     /**
-     * @deprecated use `moduleId` instead
+     * The project assosiacted with the test or suite.
      */
-    readonly 1: string;
+    readonly project: TestProject;
     /**
-     * @deprecated use `pool` instead
+     * 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, module url and test position.
      */
-    readonly 2: {
-        pool: Pool;
-    };
-    readonly project: TestProject;
-    readonly moduleId: string;
-    readonly pool: Pool;
-    constructor(workspaceProject: WorkspaceProject, moduleId: string, pool: Pool);
-    toJSON(): SerializedTestSpecification;
+    readonly id: string;
     /**
-     * for backwards compatibility
-     * @deprecated
-     */
-    [Symbol.iterator](): Generator<string | WorkspaceProject, void, unknown>;
-}
-
-/**
- * @deprecated use TestSpecification instead
- */
-type WorkspaceSpec = TestSpecification & [
-    /**
-     * @deprecated use spec.project instead
-     */
-    project: WorkspaceProject,
-    /**
-     * @deprecated use spec.moduleId instead
-     */
-    file: string,
-    /**
-     * @deprecated use spec.pool instead
-     */
-    options: {
-        pool: Pool;
-    }
-];
-type RunWithFiles = (files: WorkspaceSpec[], invalidates?: string[]) => Awaitable$1<void>;
-interface ProcessPool {
-    name: string;
-    runTests: RunWithFiles;
-    collectTests: RunWithFiles;
-    close?: () => Awaitable$1<void>;
-}
-declare function getFilePoolName(project: WorkspaceProject, file: string): Pool;
-
-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, module url and test position.
-     */
-    readonly id: string;
-    /**
-     * Location in the module where the test or suite is defined.
+     * Location in the module where the test or suite is defined.
      */
     readonly location: {
         line: number;
@@ -774,7 +630,7 @@ declare class ReportedTaskImplementation {
     /**
      * Creates a new reported task instance and stores it in the project's state for future use.
      */
-    static register(task: Task, project: WorkspaceProject): TestModule | TestCase | TestSuite;
+    static register(task: Task, project: WorkspaceProject): TestCase | TestSuite | TestModule;
 }
 declare class TestCase extends ReportedTaskImplementation {
     #private;
@@ -838,20 +694,20 @@ declare class TestCollection {
     /**
      * Filters all tests that are part of this collection and its children.
      */
-    allTests(state?: TestResult['state'] | 'running'): IterableIterator<TestCase>;
+    allTests(state?: TestResult['state'] | 'running'): Generator<TestCase, undefined, void>;
     /**
      * Filters only the tests that are part of this collection.
      */
-    tests(state?: TestResult['state'] | 'running'): IterableIterator<TestCase>;
+    tests(state?: TestResult['state'] | 'running'): Generator<TestCase, undefined, void>;
     /**
      * Filters only the suites that are part of this collection.
      */
-    suites(): IterableIterator<TestSuite>;
+    suites(): Generator<TestSuite, undefined, void>;
     /**
      * Filters all suites that are part of this collection and its children.
      */
-    allSuites(): IterableIterator<TestSuite>;
-    [Symbol.iterator](): IterableIterator<TestSuite | TestCase>;
+    allSuites(): Generator<TestSuite, undefined, void>;
+    [Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
 }
 
 declare abstract class SuiteImplementation extends ReportedTaskImplementation {
@@ -948,6 +804,10 @@ interface TestResultSkipped {
     errors: undefined;
 }
 interface TestDiagnostic {
+    /**
+     * If the duration of the test is above `slowTestThreshold`.
+     */
+    slow: boolean;
     /**
      * The amount of memory used by the test in bytes.
      * This value is only available if the test was executed with `logHeapUsage` flag.
@@ -999,134 +859,368 @@ interface ModuleDiagnostic {
     duration: number;
 }
 
-declare class StateManager {
-    filesMap: Map<string, File[]>;
-    pathsSet: Set<string>;
-    idMap: Map<string, Task>;
-    taskFileMap: WeakMap<Task, File>;
-    errorsSet: Set<unknown>;
-    processTimeoutCauses: Set<string>;
-    reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
-    catchError(err: unknown, type: string): void;
-    clearErrors(): void;
-    getUnhandledErrors(): unknown[];
-    addProcessTimeoutCause(cause: string): void;
-    getProcessTimeoutCauses(): string[];
-    getPaths(): string[];
-    /**
-     * Return files that were running or collected.
-     */
-    getFiles(keys?: string[]): File[];
-    getFilepaths(): string[];
-    getFailedFilepaths(): string[];
-    collectPaths(paths?: string[]): void;
-    collectFiles(project: WorkspaceProject, files?: File[]): void;
-    clearFiles(project: WorkspaceProject, paths?: string[]): void;
-    updateId(task: Task, project: WorkspaceProject): void;
-    getReportedEntity(task: Task): TestModule | TestCase | TestSuite | undefined;
-    updateTasks(packs: TaskResultPack[]): void;
-    updateUserLog(log: UserConsoleLog): void;
-    getCountOfFailedTests(): number;
-    cancelFiles(files: string[], project: WorkspaceProject): void;
+declare class BasicReporter extends BaseReporter {
+    constructor();
+    reportSummary(files: File[], errors: unknown[]): void;
 }
 
-interface SuiteResultCache {
-    failed: boolean;
-    duration: number;
-}
-declare class ResultsCache {
-    private cache;
-    private workspacesKeyMap;
-    private cachePath;
-    private version;
-    private root;
-    constructor(version: string);
-    getCachePath(): string | null;
-    setConfig(root: string, config: ResolvedConfig['cache']): void;
-    getResults(key: string): SuiteResultCache | undefined;
-    readFromCache(): Promise<void>;
-    updateResults(files: File[]): void;
-    removeFromCache(filepath: string): void;
-    writeToCache(): 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(): any;
+    clear(): void;
+};
 
-type FileStatsCache = Pick<Stats, 'size'>;
-declare class FilesStatsCache {
-    cache: Map<string, FileStatsCache>;
-    getStats(key: string): FileStatsCache | undefined;
-    populateStats(root: string, specs: WorkspaceSpec[]): Promise<void>;
-    updateStats(fsPath: string, key: string): Promise<void>;
-    removeStats(fsPath: string): 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;
 }
 
-declare class VitestCache {
-    results: ResultsCache;
-    stats: FilesStatsCache;
-    constructor(version: string);
-    getFileTestResults(key: string): SuiteResultCache | undefined;
-    getFileStats(key: string): {
-        size: number;
-    } | undefined;
-    static resolveCacheDir(root: string, dir?: string, projectName?: string): string;
+interface DotRendererOptions {
+    logger: Logger;
 }
+declare function createDotRenderer(_tasks: Task[], options: DotRendererOptions): {
+    start(): any;
+    update(_tasks: Task[]): any;
+    stop(): Promise<any>;
+    clear(): void;
+};
 
-declare class VitestPackageInstaller {
-    ensureInstalled(dependency: string, root: string, version?: string): Promise<boolean>;
+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;
 }
 
-interface Node {
-    isRoot(): boolean;
-    visit(visitor: Visitor, state: any): void;
+declare class GithubActionsReporter implements Reporter {
+    ctx: Vitest;
+    onInit(ctx: Vitest): void;
+    onFinished(files?: File[], errors?: unknown[]): 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;
+declare class HangingProcessReporter implements Reporter {
+    whyRunning: (() => void) | undefined;
+    onInit(): void;
+    onProcessTimeout(): void;
 }
 
-interface FileOptions {
-    file: string;
+type Status = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
+type Milliseconds = number;
+interface Callsite {
+    line: number;
+    column: number;
 }
-
-interface ProjectOptions {
-    projectRoot: string;
+interface JsonAssertionResult {
+    ancestorTitles: Array<string>;
+    fullName: string;
+    status: Status;
+    title: string;
+    meta: TaskMeta;
+    duration?: Milliseconds | null;
+    failureMessages: Array<string> | null;
+    location?: Callsite | null;
 }
-
-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;
+interface JsonTestResult {
+    message: string;
+    name: string;
+    status: 'failed' | 'passed';
+    startTime: number;
+    endTime: number;
+    assertionResults: Array<JsonAssertionResult>;
 }
-
-interface CloverOptions extends FileOptions, ProjectOptions {}
-
-interface CoberturaOptions extends FileOptions, ProjectOptions {}
-
-interface HtmlSpaOptions extends HtmlOptions {
-    metricsToShow: Array<"lines" | "branches" | "functions" | "statements">;
+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 HtmlOptions {
-    verbose: boolean;
-    skipEmpty: boolean;
-    subdir: string;
-    linkMapper: LinkMapper;
+interface JsonOptions$1 {
+    outputFile?: 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>;
 }
 
-type JsonOptions$1 = FileOptions;
-type JsonSummaryOptions = FileOptions;
+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;
+}
+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 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 VerboseReporter extends DefaultReporter {
+    protected verbose: boolean;
+    constructor();
+    onTaskUpdate(packs: TaskResultPack[]): 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 = BenchmarkResult & {
+    id: string;
+};
+
+declare const BenchmarkReportsMap: {
+    default: typeof TableReporter;
+    verbose: typeof VerboseReporter;
+};
+type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
+
+/**
+ * @deprecated Use `TestModule` instead
+ */
+declare const TestFile: typeof TestModule;
+
+/**
+ * @deprecated Use `ModuleDiagnostic` instead
+ */
+type FileDiagnostic = ModuleDiagnostic;
+
+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;
+}
+
+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 BenchmarkUserOptions {
+    /**
+     * Include globs for benchmark test files
+     *
+     * @default ['**\/*.{bench,benchmark}.?(c|m)[jt]s?(x)']
+     */
+    include?: string[];
+    /**
+     * Exclude globs for benchmark test files
+     * @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
+     */
+    exclude?: string[];
+    /**
+     * Include globs for in-source benchmark test files
+     *
+     * @default []
+     */
+    includeSource?: string[];
+    /**
+     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+     * and/or paths to custom reporters
+     *
+     * @default ['default']
+     */
+    reporters?: Arrayable<BenchmarkBuiltinReporters | Reporter>;
+    /**
+     * @deprecated Use `benchmark.outputJson` instead
+     */
+    outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
+    /**
+     * benchmark output file to compare against
+     */
+    compare?: string;
+    /**
+     * benchmark output file
+     */
+    outputJson?: string;
+    /**
+     * Include `samples` array of benchmark results for API or custom reporter usages.
+     * This is disabled by default to reduce memory usage.
+     * @default false
+     */
+    includeSamples?: boolean;
+}
+
+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 {}
@@ -1271,7 +1365,7 @@ interface BaseCoverageOptions {
      *
      * @default ['text', 'html', 'clover', 'json']
      */
-    reporter?: Arrayable<CoverageReporter> | (CoverageReporter | [CoverageReporter] | CoverageReporterWithOptions)[];
+    reporter?: Arrayable$1<CoverageReporter> | (CoverageReporter | [CoverageReporter] | CoverageReporterWithOptions)[];
     /**
      * Do not show files with 100% statement, branch, and function coverage
      *
@@ -1381,509 +1475,125 @@ interface Thresholds {
     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[];
-    distPath: string;
-    private _cachedSpecs;
-    /** @deprecated use `_cachedSpecs` */
-    projectTestFiles: Map<string, WorkspaceSpec[]>;
-    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;
-    /**
-     * @deprecated internal, use `_createCoreProject` instead
-     */
-    createCoreProject(): Promise<WorkspaceProject>;
-    /**
-     * @internal
-     */
-    _createCoreProject(): Promise<WorkspaceProject>;
-    getCoreWorkspaceProject(): WorkspaceProject;
-    /**
-     * @deprecated use Reported Task API instead
-     */
-    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[];
-    }>;
-    listFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
-    start(filters?: string[]): Promise<void>;
-    init(): Promise<void>;
-    private getTestDependencies;
-    filterTestsBySource(specs: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
-    /**
-     * @deprecated remove when vscode extension supports "getFileWorkspaceSpecs"
-     */
-    getProjectsByTestFile(file: string): WorkspaceSpec[];
-    getFileWorkspaceSpecs(file: string): WorkspaceSpec[];
-    initializeGlobalSetup(paths: TestSpecification[]): Promise<void>;
-    runFiles(specs: TestSpecification[], 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 updateLastChanged;
-    onChange: (id: string) => void;
-    onUnlink: (id: string) => void;
-    onAdd: (id: string) => Promise<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[]>;
-    globTestSpecs(filters?: string[]): Promise<WorkspaceSpec[]>;
-    /**
-     * @deprecated use globTestSpecs instead
-     */
-    globTestFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
-    private ensureSpecCached;
-    shouldKeepServer(): boolean;
-    onServerRestart(fn: OnServerRestartHandler): void;
-    onAfterSetServer(fn: OnServerRestartHandler): void;
-    onCancel(fn: (reason: CancelReason) => void): void;
-    onClose(fn: () => void): void;
-}
-
-interface Reporter {
-    onInit?: (ctx: Vitest) => void;
-    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
-    onSpecsCollected?: (specs?: SerializedTestSpecification[]) => 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>;
+type BuiltinPool = 'browser' | 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript';
+type Pool = BuiltinPool | (string & {});
+interface PoolOptions extends Record<string, unknown> {
     /**
-     * Writes the report to an output file if specified in the config,
-     * or logs it to the console otherwise.
-     * @param report
+     * Run tests in `node:worker_threads`.
+     *
+     * Test isolation (when enabled) is done by spawning a new thread for each test file.
+     *
+     * This pool is used by default.
      */
-    writeReport(report: string): Promise<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;
-}
-
-interface JUnitOptions {
-    outputFile?: string;
-    classname?: string;
-    suiteName?: string;
+    threads?: ThreadsOptions & WorkerContextOptions;
     /**
-     * Write <system-out> and <system-err> for console output
-     * @default true
+     * Run tests in `node:child_process` using [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
+     *
+     * Test isolation (when enabled) is done by spawning a new child process for each test file.
      */
-    includeConsoleOutput?: boolean;
+    forks?: ForksOptions & WorkerContextOptions;
     /**
-     * Add <testcase file="..."> attribute (validated on CIRCLE CI and GitLab CI)
-     * @default false
+     * Run tests in isolated `node:vm`.
+     * Test files are run parallel using `node:worker_threads`.
+     *
+     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
      */
-    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 = BenchmarkResult & {
-    id: string;
-};
-
-declare const BenchmarkReportsMap: {
-    default: typeof TableReporter;
-    verbose: typeof VerboseReporter;
-};
-type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
-
-/**
- * @deprecated Use `TestModule` instead
- */
-declare const TestFile: typeof TestModule;
-
-/**
- * @deprecated Use `ModuleDiagnostic` instead
- */
-type FileDiagnostic = ModuleDiagnostic;
-
-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 {
+    vmThreads?: ThreadsOptions & VmOptions;
     /**
-     * Slicing tests into shards. Will be run before `sort`.
-     * Only run, if `shard` is defined.
+     * Run tests in isolated `node:vm`.
+     *
+     * Test files are run parallel using `node:child_process` [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
+     *
+     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
      */
-    shard: (files: WorkspaceSpec[]) => Awaitable<WorkspaceSpec[]>;
-    sort: (files: WorkspaceSpec[]) => Awaitable<WorkspaceSpec[]>;
-}
-interface TestSequencerConstructor {
-    new (ctx: Vitest): TestSequencer;
+    vmForks?: ForksOptions & VmOptions;
 }
-
-type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
-
-interface BenchmarkUserOptions {
+interface ResolvedPoolOptions extends PoolOptions {
+    threads?: ResolvedThreadsOptions & WorkerContextOptions;
+    forks?: ResolvedForksOptions & WorkerContextOptions;
+    vmThreads?: ResolvedThreadsOptions & VmOptions;
+    vmForks?: ResolvedForksOptions & VmOptions;
+}
+interface ThreadsOptions {
+    /** Minimum amount of threads to use */
+    minThreads?: number | string;
+    /** Maximum amount of threads to use */
+    maxThreads?: number | string;
     /**
-     * Include globs for benchmark test files
+     * Run tests inside a single thread.
      *
-     * @default ['**\/*.{bench,benchmark}.?(c|m)[jt]s?(x)']
-     */
-    include?: string[];
-    /**
-     * Exclude globs for benchmark test files
-     * @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
+     * @default false
      */
-    exclude?: string[];
+    singleThread?: boolean;
     /**
-     * Include globs for in-source benchmark test files
+     * Use Atomics to synchronize threads
      *
-     * @default []
+     * This can improve performance in some cases, but might cause segfault in older Node versions.
+     *
+     * @default false
      */
-    includeSource?: string[];
+    useAtomics?: boolean;
+}
+interface ResolvedThreadsOptions extends ThreadsOptions {
+    minThreads?: number;
+    maxThreads?: number;
+}
+interface ForksOptions {
+    /** Minimum amount of child processes to use */
+    minForks?: number | string;
+    /** Maximum amount of child processes to use */
+    maxForks?: number | string;
     /**
-     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
-     * and/or paths to custom reporters
+     * Run tests inside a single fork.
      *
-     * @default ['default']
+     * @default false
      */
-    reporters?: Arrayable$1<BenchmarkBuiltinReporters | Reporter>;
+    singleFork?: boolean;
+}
+interface ResolvedForksOptions extends ForksOptions {
+    minForks?: number;
+    maxForks?: number;
+}
+interface WorkerContextOptions {
     /**
-     * @deprecated Use `benchmark.outputJson` instead
+     * Isolate test environment by recycling `worker_threads` or `child_process` after each test
+     *
+     * @default true
      */
-    outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
+    isolate?: boolean;
     /**
-     * benchmark output file to compare against
+     * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
+     *
+     * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
+     *
+     * Set to `process.execArgv` to pass all arguments of the current process.
+     *
+     * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
+     *
+     * @default [] // no execution arguments are passed
      */
-    compare?: string;
+    execArgv?: string[];
+}
+interface VmOptions {
     /**
-     * benchmark output file
+     * Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
+     * If you see memory leaks, try to tinker this value.
      */
-    outputJson?: string;
+    memoryLimit?: string | number;
+    /** Isolation is always enabled */
+    isolate?: true;
     /**
-     * Include `samples` array of benchmark results for API or custom reporter usages.
-     * This is disabled by default to reduce memory usage.
-     * @default false
+     * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
+     *
+     * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
+     *
+     * Set to `process.execArgv` to pass all arguments of the current process.
+     *
+     * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
+     *
+     * @default [] // no execution arguments are passed
      */
-    includeSamples?: boolean;
+    execArgv?: string[];
 }
 
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
@@ -2207,7 +1917,7 @@ interface InlineConfig {
      *
      * @default []
      */
-    reporters?: Arrayable<ReporterName | InlineReporter> | ((ReporterName | InlineReporter) | [ReporterName] | ReporterWithOptions)[];
+    reporters?: Arrayable$1<ReporterName | InlineReporter> | ((ReporterName | InlineReporter) | [ReporterName] | ReporterWithOptions)[];
     /**
      * Write test results to a file when the --reporter=json` or `--reporter=junit` option is also specified.
      * Also definable individually per reporter by using an object instead.
@@ -2497,251 +2207,556 @@ interface InlineConfig {
      * const value = inject('someKey') // 'someValue'
      * ```
      */
-    provide?: Partial<ProvidedContext>;
+    provide?: Partial<ProvidedContext>;
+    /**
+     * 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
+     */
+    chaiConfig?: ChaiConfig;
+    /**
+     * Stop test execution when given number of tests have failed.
+     */
+    bail?: number;
+    /**
+     * Retry the test specific number of times if it fails.
+     *
+     * @default 0
+     */
+    retry?: number;
+    /**
+     * Show full diff when snapshot fails instead of a patch.
+     */
+    expandSnapshotDiff?: boolean;
+    /**
+     * By default, Vitest automatically intercepts console logging during tests for extra formatting of test file, test title, etc...
+     * This is also required for console log preview on Vitest UI.
+     * However, disabling such interception might help when you want to debug a code with normal synchronus terminal console logging.
+     *
+     * This option has no effect on browser pool since Vitest preserves original logging on browser devtools.
+     *
+     * @default false
+     */
+    disableConsoleIntercept?: boolean;
+    /**
+     * Always print console stack traces.
+     *
+     * @default false
+     */
+    printConsoleTrace?: boolean;
+    /**
+     * Include "location" property inside the test definition
+     *
+     * @default false
+     */
+    includeTaskLocation?: boolean;
+}
+interface TypecheckConfig {
+    /**
+     * Run typechecking tests alongisde regular tests.
+     */
+    enabled?: boolean;
+    /**
+     * When typechecking is enabled, only run typechecking tests.
+     */
+    only?: boolean;
+    /**
+     * What tools to use for type checking.
+     *
+     * @default 'tsc'
+     */
+    checker: 'tsc' | 'vue-tsc' | (string & Record<never, never>);
+    /**
+     * Pattern for files that should be treated as test files
+     *
+     * @default ['**\/*.{test,spec}-d.?(c|m)[jt]s?(x)']
+     */
+    include: string[];
+    /**
+     * Pattern for files that should not be treated as test files
+     *
+     * @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
+     */
+    exclude: string[];
+    /**
+     * Check JS files that have `@ts-check` comment.
+     * If you have it enabled in tsconfig, this will not overwrite it.
+     */
+    allowJs?: boolean;
+    /**
+     * Do not fail, if Vitest found errors outside the test files.
+     */
+    ignoreSourceErrors?: boolean;
+    /**
+     * Path to tsconfig, relative to the project root.
+     */
+    tsconfig?: string;
+}
+interface UserConfig extends InlineConfig {
+    /**
+     * Path to the config file.
+     *
+     * Default resolving to `vitest.config.*`, `vite.config.*`
+     *
+     * Setting to `false` will disable config resolving.
+     */
+    config?: string | false | undefined;
+    /**
+     * Do not run tests when Vitest starts.
+     *
+     * Vitest will only run tests if it's called programmatically or the test file changes.
+     *
+     * CLI file filters will be ignored.
+     */
+    standalone?: boolean;
+    /**
+     * Use happy-dom
+     */
+    dom?: boolean;
+    /**
+     * Run tests that cover a list of source files
+     */
+    related?: string[] | string;
+    /**
+     * Overrides Vite mode
+     * @default 'test'
+     */
+    mode?: string;
+    /**
+     * Runs tests that are affected by the changes in the repository, or between specified branch or commit hash
+     * Requires initialized git repository
+     * @default false
+     */
+    changed?: boolean | string;
+    /**
+     * Test suite shard to execute in a format of <index>/<count>.
+     * Will divide tests into a `count` numbers, and run only the `indexed` part.
+     * Cannot be used with enabled watch.
+     * @example --shard=2/3
+     */
+    shard?: string;
+    /**
+     * Name of the project or projects to run.
+     */
+    project?: string | string[];
+    /**
+     * Additional exclude patterns
+     */
+    cliExclude?: string[];
+    /**
+     * Override vite config's clearScreen from cli
+     */
+    clearScreen?: boolean;
+    /**
+     * benchmark.compare option exposed at the top level for cli
+     */
+    compare?: string;
+    /**
+     * benchmark.outputJson option exposed at the top level for cli
+     */
+    outputJson?: string;
     /**
-     * Configuration options for expect() matches.
+     * Directory of blob reports to merge
+     * @default '.vitest-reports'
      */
-    expect?: {
-        /**
-         * Throw an error if tests don't have any expect() assertions.
-         */
-        requireAssertions?: boolean;
+    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' | 'setupFiles' | 'snapshotEnvironment' | 'bail'> {
+    mode: VitestRunMode;
+    base?: string;
+    diff?: string;
+    bail?: number;
+    setupFiles: string[];
+    snapshotEnvironment?: string;
+    config?: string;
+    filters?: string[];
+    testNamePattern?: RegExp;
+    related?: string[];
+    coverage: ResolvedCoverageOptions;
+    snapshotOptions: SnapshotStateOptions;
+    browser: ResolvedBrowserOptions;
+    pool: Pool;
+    poolOptions?: ResolvedPoolOptions;
+    reporters: (InlineReporter | ReporterWithOptions)[];
+    defines: Record<string, any>;
+    api?: ApiConfig;
+    cliExclude?: string[];
+    benchmark?: Required<Omit<BenchmarkUserOptions, 'outputFile' | 'compare' | 'outputJson'>> & Pick<BenchmarkUserOptions, 'outputFile' | 'compare' | 'outputJson'>;
+    shard?: {
+        index: number;
+        count: number;
+    };
+    cache: {
         /**
-         * Default options for expect.poll()
+         * @deprecated
          */
-        poll?: {
-            /**
-             * Timeout in milliseconds
-             * @default 1000
-             */
-            timeout?: number;
-            /**
-             * Polling interval in milliseconds
-             * @default 50
-             */
-            interval?: number;
-        };
+        dir: string;
+    } | false;
+    sequence: {
+        sequencer: TestSequencerConstructor;
+        hooks: SequenceHooks;
+        setupFiles: SequenceSetupFiles;
+        shuffle?: boolean;
+        concurrent?: boolean;
+        seed: number;
+    };
+    typecheck: Omit<TypecheckConfig, 'enabled'> & {
+        enabled: boolean;
+    };
+    runner?: string;
+    maxWorkers: number;
+    minWorkers: number;
+}
+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?: {
+        threads?: Pick<NonNullable<PoolOptions['threads']>, 'singleThread' | 'isolate'>;
+        vmThreads?: Pick<NonNullable<PoolOptions['vmThreads']>, 'singleThread'>;
+        forks?: Pick<NonNullable<PoolOptions['forks']>, 'singleFork' | 'isolate'>;
     };
+};
+type ResolvedProjectConfig = Omit<ResolvedConfig, NonProjectOptions>;
+interface UserWorkspaceConfig extends UserConfig$1 {
+    test?: ProjectConfig;
+}
+type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
+type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
+type WorkspaceProjectConfiguration = string | (UserProjectConfigExport & {
     /**
-     * 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
+     * Relative path to the extendable config. All other options will be merged with this config.
+     * @example '../vite.config.ts'
      */
-    chaiConfig?: ChaiConfig;
+    extends?: string;
+});
+
+declare class TestProject {
     /**
-     * Stop test execution when given number of tests have failed.
+     * The global vitest instance.
+     * @experimental The public Vitest API is experimental and does not follow semver.
      */
-    bail?: number;
+    readonly vitest: Vitest;
     /**
-     * Retry the test specific number of times if it fails.
-     *
-     * @default 0
+     * The workspace project this test project is associated with.
+     * @experimental The public Vitest API is experimental and does not follow semver.
      */
-    retry?: number;
+    readonly workspaceProject: WorkspaceProject;
     /**
-     * Show full diff when snapshot fails instead of a patch.
+     * Resolved project configuration.
      */
-    expandSnapshotDiff?: boolean;
+    readonly config: ResolvedProjectConfig;
     /**
-     * By default, Vitest automatically intercepts console logging during tests for extra formatting of test file, test title, etc...
-     * This is also required for console log preview on Vitest UI.
-     * However, disabling such interception might help when you want to debug a code with normal synchronus terminal console logging.
-     *
-     * This option has no effect on browser pool since Vitest preserves original logging on browser devtools.
-     *
-     * @default false
+     * Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
      */
-    disableConsoleIntercept?: boolean;
+    readonly globalConfig: ResolvedConfig;
     /**
-     * Always print console stack traces.
-     *
-     * @default false
+     * The name of the project or an empty string if not set.
      */
-    printConsoleTrace?: boolean;
+    readonly name: string;
+    constructor(workspaceProject: WorkspaceProject);
     /**
-     * Include "location" property inside the test definition
-     *
-     * @default false
+     * Serialized project configuration. This is the config that tests receive.
      */
-    includeTaskLocation?: boolean;
-}
-interface TypecheckConfig {
+    get serializedConfig(): SerializedConfig;
     /**
-     * Run typechecking tests alongisde regular tests.
+     * Custom context provided to the project.
      */
-    enabled?: boolean;
+    context(): ProvidedContext;
     /**
-     * When typechecking is enabled, only run typechecking tests.
+     * Provide a custom serializable context to the project. This context will be available for tests once they run.
      */
-    only?: boolean;
+    provide<T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]): void;
+    toJSON(): SerializedTestProject;
+}
+interface SerializedTestProject {
+    name: string;
+    serializedConfig: SerializedConfig;
+    context: ProvidedContext;
+}
+
+declare class TestSpecification {
     /**
-     * What tools to use for type checking.
-     *
-     * @default 'tsc'
+     * @deprecated use `project` instead
      */
-    checker: 'tsc' | 'vue-tsc' | (string & Record<never, never>);
+    readonly 0: WorkspaceProject;
     /**
-     * Pattern for files that should be treated as test files
-     *
-     * @default ['**\/*.{test,spec}-d.?(c|m)[jt]s?(x)']
+     * @deprecated use `moduleId` instead
      */
-    include: string[];
+    readonly 1: string;
     /**
-     * Pattern for files that should not be treated as test files
-     *
-     * @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
+     * @deprecated use `pool` instead
      */
-    exclude: string[];
+    readonly 2: {
+        pool: Pool;
+    };
+    readonly project: TestProject;
+    readonly moduleId: string;
+    readonly pool: Pool;
+    constructor(workspaceProject: WorkspaceProject, moduleId: string, pool: Pool);
+    toJSON(): SerializedTestSpecification;
     /**
-     * Check JS files that have `@ts-check` comment.
-     * If you have it enabled in tsconfig, this will not overwrite it.
+     * for backwards compatibility
+     * @deprecated
      */
-    allowJs?: boolean;
+    [Symbol.iterator](): Generator<string | WorkspaceProject, void, unknown>;
+}
+
+/**
+ * @deprecated use TestSpecification instead
+ */
+type WorkspaceSpec = TestSpecification & [
     /**
-     * Do not fail, if Vitest found errors outside the test files.
+     * @deprecated use spec.project instead
      */
-    ignoreSourceErrors?: boolean;
+    project: WorkspaceProject,
     /**
-     * Path to tsconfig, relative to the project root.
+     * @deprecated use spec.moduleId instead
      */
-    tsconfig?: string;
+    file: string,
+    /**
+     * @deprecated use spec.pool instead
+     */
+    options: {
+        pool: Pool;
+    }
+];
+type RunWithFiles = (files: WorkspaceSpec[], invalidates?: string[]) => Awaitable$1<void>;
+interface ProcessPool {
+    name: string;
+    runTests: RunWithFiles;
+    collectTests: RunWithFiles;
+    close?: () => Awaitable$1<void>;
+}
+declare function getFilePoolName(project: WorkspaceProject, file: string): Pool;
+
+interface SuiteResultCache {
+    failed: boolean;
+    duration: number;
+}
+declare class ResultsCache {
+    private cache;
+    private workspacesKeyMap;
+    private cachePath;
+    private version;
+    private root;
+    constructor(version: string);
+    getCachePath(): string | null;
+    setConfig(root: string, config: ResolvedConfig['cache']): void;
+    getResults(key: string): SuiteResultCache | undefined;
+    readFromCache(): Promise<void>;
+    updateResults(files: File[]): void;
+    removeFromCache(filepath: string): void;
+    writeToCache(): Promise<void>;
+}
+
+type FileStatsCache = Pick<Stats, 'size'>;
+declare class FilesStatsCache {
+    cache: Map<string, FileStatsCache>;
+    getStats(key: string): FileStatsCache | undefined;
+    populateStats(root: string, specs: WorkspaceSpec[]): Promise<void>;
+    updateStats(fsPath: string, key: string): Promise<void>;
+    removeStats(fsPath: string): void;
+}
+
+declare class VitestCache {
+    results: ResultsCache;
+    stats: FilesStatsCache;
+    constructor(version: string);
+    getFileTestResults(key: string): SuiteResultCache | undefined;
+    getFileStats(key: string): {
+        size: number;
+    } | undefined;
+    static resolveCacheDir(root: string, dir?: string, projectName?: string): string;
+}
+
+declare class VitestPackageInstaller {
+    isPackageExists(name: string, options?: {
+        paths?: string[];
+    }): boolean;
+    ensureInstalled(dependency: string, root: string, version?: string): Promise<boolean>;
 }
-interface UserConfig extends InlineConfig {
-    /**
-     * Path to the config file.
-     *
-     * Default resolving to `vitest.config.*`, `vite.config.*`
-     *
-     * Setting to `false` will disable config resolving.
-     */
-    config?: string | false | undefined;
-    /**
-     * Do not run tests when Vitest starts.
-     *
-     * Vitest will only run tests if it's called programmatically or the test file changes.
-     *
-     * CLI file filters will be ignored.
-     */
-    standalone?: boolean;
-    /**
-     * Use happy-dom
-     */
-    dom?: boolean;
-    /**
-     * Run tests that cover a list of source files
-     */
-    related?: string[] | string;
+
+declare class StateManager {
+    filesMap: Map<string, File[]>;
+    pathsSet: Set<string>;
+    idMap: Map<string, Task>;
+    taskFileMap: WeakMap<Task, File>;
+    errorsSet: Set<unknown>;
+    processTimeoutCauses: Set<string>;
+    reportedTasksMap: WeakMap<Task, TestCase | TestSuite | TestModule>;
+    catchError(err: unknown, type: string): void;
+    clearErrors(): void;
+    getUnhandledErrors(): unknown[];
+    addProcessTimeoutCause(cause: string): void;
+    getProcessTimeoutCauses(): string[];
+    getPaths(): string[];
     /**
-     * Overrides Vite mode
-     * @default 'test'
+     * Return files that were running or collected.
      */
-    mode?: string;
+    getFiles(keys?: string[]): File[];
+    getFilepaths(): string[];
+    getFailedFilepaths(): string[];
+    collectPaths(paths?: string[]): void;
+    collectFiles(project: WorkspaceProject, files?: File[]): void;
+    clearFiles(project: WorkspaceProject, paths?: string[]): void;
+    updateId(task: Task, project: WorkspaceProject): void;
+    getReportedEntity(task: Task): TestCase | TestSuite | TestModule | undefined;
+    updateTasks(packs: TaskResultPack[]): void;
+    updateUserLog(log: UserConsoleLog): void;
+    getCountOfFailedTests(): number;
+    cancelFiles(files: string[], project: WorkspaceProject): void;
+}
+
+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[];
+    distPath: string;
+    private _cachedSpecs;
+    /** @deprecated use `_cachedSpecs` */
+    projectTestFiles: Map<string, WorkspaceSpec[]>;
+    /** @private */
+    _browserLastPort: number;
+    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;
     /**
-     * Runs tests that are affected by the changes in the repository, or between specified branch or commit hash
-     * Requires initialized git repository
-     * @default false
+     * @deprecated internal, use `_createCoreProject` instead
      */
-    changed?: boolean | string;
+    createCoreProject(): Promise<WorkspaceProject>;
     /**
-     * Test suite shard to execute in a format of <index>/<count>.
-     * Will divide tests into a `count` numbers, and run only the `indexed` part.
-     * Cannot be used with enabled watch.
-     * @example --shard=2/3
+     * @internal
      */
-    shard?: string;
+    _createCoreProject(): Promise<WorkspaceProject>;
+    getCoreWorkspaceProject(): WorkspaceProject;
     /**
-     * Name of the project or projects to run.
+     * @deprecated use Reported Task API instead
      */
-    project?: string | string[];
+    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[];
+    }>;
+    listFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
+    start(filters?: string[]): Promise<void>;
+    init(): Promise<void>;
+    private getTestDependencies;
+    filterTestsBySource(specs: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
     /**
-     * Additional exclude patterns
+     * @deprecated remove when vscode extension supports "getFileWorkspaceSpecs"
      */
-    cliExclude?: string[];
+    getProjectsByTestFile(file: string): WorkspaceSpec[];
+    getFileWorkspaceSpecs(file: string): WorkspaceSpec[];
+    initializeGlobalSetup(paths: TestSpecification[]): Promise<void>;
+    runFiles(specs: TestSpecification[], 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[];
     /**
-     * Override vite config's clearScreen from cli
+     * Watch only the specified tests. If no tests are provided, all tests will be watched.
      */
-    clearScreen?: boolean;
+    watchTests(tests: string[]): void;
+    private updateLastChanged;
+    onChange: (id: string) => void;
+    onUnlink: (id: string) => void;
+    onAdd: (id: string) => Promise<void>;
+    private unregisterWatcher;
+    private registerWatcher;
     /**
-     * benchmark.compare option exposed at the top level for cli
+     * @returns A value indicating whether rerun is needed (changedTests was mutated)
      */
-    compare?: string;
+    private handleFileChanged;
+    private reportCoverage;
+    close(): Promise<void>;
     /**
-     * benchmark.outputJson option exposed at the top level for cli
+     * Close the thread pool and exit the process
      */
-    outputJson?: string;
+    exit(force?: boolean): Promise<void>;
+    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType<Reporter[T]>): Promise<void>;
+    getTestFilepaths(): Promise<string[]>;
+    globTestSpecs(filters?: string[]): Promise<WorkspaceSpec[]>;
     /**
-     * Directory of blob reports to merge
-     * @default '.vitest-reports'
+     * @deprecated use globTestSpecs instead
      */
-    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' | 'setupFiles' | 'snapshotEnvironment' | 'bail'> {
-    mode: VitestRunMode;
-    base?: string;
-    diff?: string;
-    bail?: number;
-    setupFiles: string[];
-    snapshotEnvironment?: string;
-    config?: string;
-    filters?: string[];
-    testNamePattern?: RegExp;
-    related?: string[];
-    coverage: ResolvedCoverageOptions;
-    snapshotOptions: SnapshotStateOptions;
-    browser: ResolvedBrowserOptions;
-    pool: Pool;
-    poolOptions?: ResolvedPoolOptions;
-    reporters: (InlineReporter | ReporterWithOptions)[];
-    defines: Record<string, any>;
-    api?: ApiConfig;
-    cliExclude?: string[];
-    benchmark?: Required<Omit<BenchmarkUserOptions, 'outputFile' | 'compare' | 'outputJson'>> & Pick<BenchmarkUserOptions, 'outputFile' | 'compare' | 'outputJson'>;
-    shard?: {
-        index: number;
-        count: number;
-    };
-    cache: {
-        /**
-         * @deprecated
-         */
-        dir: string;
-    } | false;
-    sequence: {
-        sequencer: TestSequencerConstructor;
-        hooks: SequenceHooks;
-        setupFiles: SequenceSetupFiles;
-        shuffle?: boolean;
-        concurrent?: boolean;
-        seed: number;
-    };
-    typecheck: Omit<TypecheckConfig, 'enabled'> & {
-        enabled: boolean;
-    };
-    runner?: string;
-    maxWorkers: number;
-    minWorkers: number;
-}
-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?: {
-        threads?: Pick<NonNullable<PoolOptions['threads']>, 'singleThread' | 'isolate'>;
-        vmThreads?: Pick<NonNullable<PoolOptions['vmThreads']>, 'singleThread'>;
-        forks?: Pick<NonNullable<PoolOptions['forks']>, 'singleFork' | 'isolate'>;
-    };
-};
-type ResolvedProjectConfig = Omit<ResolvedConfig, NonProjectOptions>;
-interface UserWorkspaceConfig extends UserConfig$1 {
-    test?: ProjectConfig;
+    globTestFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
+    private ensureSpecCached;
+    shouldKeepServer(): boolean;
+    onServerRestart(fn: OnServerRestartHandler): void;
+    onAfterSetServer(fn: OnServerRestartHandler): void;
+    onCancel(fn: (reason: CancelReason) => void): void;
+    onClose(fn: () => void): void;
 }
-type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
-type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
-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;
-});
 
-export { type BrowserProviderInitializationOptions as $, type ApiConfig as A, type BaseCoverageOptions as B, type CoverageProvider as C, type DepsOptimizationOptions as D, type ResolvedConfig as E, type ProjectConfig as F, type BenchmarkUserOptions as G, type VitestOptions as H, type InlineConfig as I, WorkspaceProject as J, type TestSequencer as K, Logger as L, type WorkspaceSpec as M, TestModule as N, type ModuleDiagnostic as O, type Pool as P, type ProcessPool as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TscErrorInfo as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, getFilePoolName as X, VitestPackageInstaller as Y, TestSpecification as Z, type TestSequencerConstructor as _, type CoverageProviderModule as a, type BrowserProvider as a0, type CDPSession as a1, type BrowserProviderModule as a2, type ResolvedBrowserOptions as a3, type BrowserProviderOptions as a4, type BrowserBuiltinProvider as a5, type BrowserCommand as a6, type BrowserCommandContext as a7, type BrowserServer as a8, type BrowserServerState as a9, BaseReporter as aA, TestFile as aB, type FileDiagnostic as aC, ReportersMap as aD, type BuiltinReporters as aE, type BuiltinReporterOptions as aF, type JsonAssertionResult as aG, type JsonTestResult as aH, type JsonTestResults as aI, BenchmarkReportsMap as aJ, type BenchmarkBuiltinReporters as aK, type BrowserServerStateContext as aa, type BrowserOrchestrator as ab, type JsonOptions as ac, type JUnitOptions as ad, type HTMLOptions as ae, TestCase as af, TestSuite as ag, TestProject as ah, TestCollection as ai, type TaskOptions as aj, type TestDiagnostic as ak, type TestResult as al, type TestResultPassed as am, type TestResultFailed as an, type TestResultSkipped as ao, type ResolvedProjectConfig as ap, DefaultReporter as aq, BasicReporter as ar, DotReporter as as, JsonReporter as at, VerboseReporter as au, TapReporter as av, JUnitReporter as aw, TapFlatReporter as ax, HangingProcessReporter as ay, GithubActionsReporter as az, type CoverageV8Options as b, type UserProjectConfigFn as c, type UserProjectConfigExport as d, type VitestEnvironment as e, type RawErrsMap as f, type CollectLineNumbers as g, type CollectLines as h, type RootAndTarget as i, type Context as j, type ReportContext as k, type CoverageReporter as l, type CoverageProviderName as m, type CoverageOptions as n, type CoverageIstanbulOptions as o, type CustomProviderOptions as p, type Reporter as q, type BrowserScript as r, type BrowserConfigOptions as s, type BuiltinEnvironment as t, type PoolOptions as u, type CSSModuleScopeStrategy as v, type VitestRunMode as w, type TransformModePatterns as x, type TypecheckConfig as y, type UserConfig as z };
+export { type HTMLOptions as $, type ApiConfig as A, type BaseCoverageOptions as B, type CoverageProvider as C, type DepsOptimizationOptions as D, type ResolvedConfig as E, type ProjectConfig as F, type BenchmarkUserOptions as G, type VitestOptions as H, type InlineConfig as I, WorkspaceProject as J, type TestSequencer as K, Logger as L, type WorkspaceSpec as M, TestModule as N, type ModuleDiagnostic as O, type Pool as P, VitestPackageInstaller as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TscErrorInfo as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, type ProcessPool as X, getFilePoolName as Y, TestProject as Z, type SerializedTestProject as _, type ReportContext as a, type JsonOptions$1 as a0, type JUnitOptions as a1, TestCase as a2, TestSuite as a3, type TaskOptions as a4, TestCollection as a5, type TestDiagnostic as a6, type TestResult as a7, type TestResultFailed as a8, type TestResultPassed as a9, VerboseReporter as aA, BaseReporter as aB, TestFile as aC, type FileDiagnostic as aD, ReportersMap as aE, type BuiltinReporters as aF, type BuiltinReporterOptions as aG, type JsonAssertionResult as aH, type JsonTestResult as aI, type JsonTestResults as aJ, BenchmarkReportsMap as aK, type BenchmarkBuiltinReporters as aL, type TestResultSkipped as aa, type TestSequencerConstructor as ab, TestSpecification as ac, type BrowserBuiltinProvider as ad, type BrowserCommand as ae, type BrowserCommandContext as af, type BrowserOrchestrator as ag, type BrowserProvider as ah, type BrowserProviderInitializationOptions as ai, type BrowserProviderModule as aj, type BrowserProviderOptions as ak, type BrowserServer as al, type BrowserServerState as am, type BrowserServerStateContext as an, type CDPSession as ao, type ResolvedBrowserOptions as ap, type ResolvedProjectConfig as aq, BasicReporter as ar, DefaultReporter as as, DotReporter as at, GithubActionsReporter as au, HangingProcessReporter as av, JsonReporter as aw, JUnitReporter as ax, TapFlatReporter as ay, TapReporter as az, type CoverageProviderModule as b, type CoverageV8Options as c, type UserProjectConfigFn as d, type UserProjectConfigExport as e, type VitestEnvironment as f, type RawErrsMap as g, type CollectLineNumbers as h, type CollectLines as i, type RootAndTarget as j, type Context as k, type CoverageReporter as l, type CoverageProviderName as m, type CoverageOptions as n, type CoverageIstanbulOptions as o, type CustomProviderOptions as p, type Reporter as q, type BrowserScript as r, type BrowserConfigOptions as s, type BuiltinEnvironment as t, type PoolOptions as u, type CSSModuleScopeStrategy as v, type VitestRunMode as w, type TransformModePatterns as x, type TypecheckConfig as y, type UserConfig as z };