vitest 3.0.0-beta.1 → 3.0.0-beta.3

package/dist/chunks/{reporters.BZbwTvrM.d.ts → reporters.DCiyjXOg.d.ts}

@@ -1,19 +1,17 @@
 import * as _vitest_runner from '@vitest/runner';
-import { File, TaskResultPack, Task, Test, TaskMeta, Suite, SequenceHooks, SequenceSetupFiles, CancelReason } from '@vitest/runner';
-import { b as Awaitable, U as UserConsoleLog, A as AfterSuiteRunMeta, c as Arrayable$1, f as EnvironmentOptions, P as ProvidedContext, h as OnTestsRerunHandler, d as ArgumentsType, O as OnServerRestartHandler } from './environment.CT0jpO-1.js';
+import { TaskMeta, Suite, File, TaskResultPack, Task, SequenceHooks, SequenceSetupFiles, CancelReason } from '@vitest/runner';
+import { b as Awaitable, U as UserConsoleLog, A as AfterSuiteRunMeta, c as Arrayable$1, f as EnvironmentOptions, P as ProvidedContext } from './environment.d8YfPkTm.js';
+import { TestError, ParsedStack, Arrayable, ErrorWithDiff, Awaitable as Awaitable$1 } from '@vitest/utils';
 import { Writable } from 'node:stream';
 import { TransformResult as TransformResult$1, ServerOptions, DepOptimizationConfig, AliasOptions, UserConfig as UserConfig$1, ConfigEnv, ViteDevServer, ModuleNode } from 'vite';
-import { TestError, ParsedStack, Arrayable, ErrorWithDiff, Awaitable as Awaitable$1 } from '@vitest/utils';
-import { RawSourceMap, ViteNodeServerOptions } from 'vite-node';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.BTPBhmK5.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
+import { ViteNodeServerOptions } from 'vite-node';
 import * as chai from 'chai';
 import { B as BenchmarkResult } from './benchmark.CFFwLv-O.js';
-import { ViteNodeRunner } from 'vite-node/client';
-import { ViteNodeServer } from 'vite-node/server';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { Stats } from 'node:fs';
 
@@ -25,95 +23,11 @@ type SerializedTestSpecification = [
     file: string,
     options: {
         pool: string;
+        testLines?: number[] | undefined;
     }
 ];
 
-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;
-    renderSucceed: boolean;
-    protected verbose: boolean;
-    private _filesInWatchMode;
-    private _timeStart;
-    constructor(options?: BaseOptions);
-    onInit(ctx: Vitest): void;
-    log(...messages: any): void;
-    error(...messages: any): 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;
-    onWatcherRerun(files: string[], trigger?: string): void;
-    onUserConsoleLog(log: UserConsoleLog): void;
-    onTestRemoved(trigger?: string): 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;
-}
-
-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 DefaultReporterOptions extends BaseOptions {
-    summary?: boolean;
-}
-declare class DefaultReporter extends BaseReporter {
-    private options;
-    private summary?;
-    constructor(options?: DefaultReporterOptions);
-    onInit(ctx: Vitest): void;
-    onPathsCollected(paths?: string[]): void;
-    onTaskUpdate(packs: TaskResultPack[]): void;
-    onWatcherRerun(files: string[], trigger?: string): void;
-    onFinished(files?: File[], errors?: unknown[]): void;
-}
-
-interface HTMLOptions {
-    outputFile?: string;
-}
-
 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.
      */
@@ -121,7 +35,7 @@ declare class ReportedTaskImplementation {
     /**
      * 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.
+     * The ID is based on the project name, module url and test order.
      */
     readonly id: string;
     /**
@@ -131,15 +45,14 @@ declare class ReportedTaskImplementation {
         line: number;
         column: number;
     } | undefined;
-    protected constructor(task: Task, project: TestProject);
     /**
-     * Creates a new reported task instance and stores it in the project's state for future use.
+     * Checks if the test did not fail the suite.
+     * If the test is not finished yet or was skipped, it will return `true`.
      */
-    static register(task: Task, project: TestProject): TestCase | TestSuite | TestModule;
+    ok(): boolean;
 }
 declare class TestCase extends ReportedTaskImplementation {
     #private;
-    readonly task: Test;
     readonly type = "test";
     /**
      * Direct reference to the test module where the test or suite is defined.
@@ -157,20 +70,18 @@ declare class TestCase extends ReportedTaskImplementation {
      * Parent suite. If the test was called directly inside the module, the parent will be the module itself.
      */
     readonly parent: TestSuite | TestModule;
-    protected constructor(task: Test, project: TestProject);
     /**
      * 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.
+     * Test results. Will be `undefined` if test is skipped, 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`.
+     * Checks if the test was skipped during collection or dynamically with `ctx.skip()`.
      */
-    ok(): boolean;
+    skipped(): boolean;
     /**
      * Custom metadata that was attached to the test during its execution.
      */
@@ -185,7 +96,7 @@ declare class TestCollection {
     #private;
     constructor(task: Suite | File, project: TestProject);
     /**
-     * Returns the test or suite at a specific index in the array.
+     * Returns the test or suite at a specific index.
      */
     at(index: number): TestCase | TestSuite | undefined;
     /**
@@ -216,16 +127,21 @@ declare class TestCollection {
 }
 
 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: TestProject);
+    /**
+     * Checks if the suite was skipped during collection.
+     */
+    skipped(): boolean;
+    /**
+     * Errors that happened outside of the test run during collection, like syntax errors.
+     */
+    errors(): TestError[];
 }
 declare class TestSuite extends SuiteImplementation {
     #private;
-    readonly task: Suite;
     readonly type = "suite";
     /**
      * Name of the test or the suite.
@@ -243,14 +159,17 @@ declare class TestSuite extends SuiteImplementation {
      * Options that suite was initiated with.
      */
     readonly options: TaskOptions;
-    protected constructor(task: Suite, project: TestProject);
+    /**
+     * Checks if the suite has any failed tests.
+     * This will also return `false` if suite failed during collection.
+     */
+    ok: () => boolean;
     /**
      * Full name of the suite including all parent suites separated with `>`.
      */
     get fullName(): string;
 }
 declare class TestModule extends SuiteImplementation {
-    readonly task: File;
     readonly location: undefined;
     readonly type = "module";
     /**
@@ -259,7 +178,15 @@ declare class TestModule extends SuiteImplementation {
      * This value corresponds to Vite's `ModuleGraph` id.
      */
     readonly moduleId: string;
-    protected constructor(task: File, project: TestProject);
+    /**
+     * Checks if the module has any failed tests.
+     * This will also return `false` if module failed during collection.
+     */
+    ok: () => boolean;
+    /**
+     * Checks if the module was skipped and didn't run.
+     */
+    skipped: () => boolean;
     /**
      * Useful information about the module like duration, memory usage, etc.
      * If the module was not executed yet, all diagnostic values will return `0`.
@@ -272,7 +199,7 @@ interface TaskOptions {
     shuffle: boolean | undefined;
     retry: number | undefined;
     repeats: number | undefined;
-    mode: 'run' | 'only' | 'skip' | 'todo';
+    mode: 'run' | 'only' | 'skip' | 'todo' | 'queued';
 }
 type TestResult = TestResultPassed | TestResultFailed | TestResultSkipped;
 interface TestResultPassed {
@@ -299,8 +226,8 @@ interface TestResultFailed {
 }
 interface TestResultSkipped {
     /**
-     * The test was skipped with `only`, `skip` or `todo` flag.
-     * You can see which one was used in the `mode` option.
+     * The test was skipped with `only` (on another test), `skip` or `todo` flag.
+     * You can see which one was used in the `options.mode` option.
      */
     state: 'skipped';
     /**
@@ -308,7 +235,7 @@ interface TestResultSkipped {
      */
     errors: undefined;
     /**
-     * A custom note.
+     * A custom note passed down to `ctx.skip(note)`.
      */
     note: string | undefined;
 }
@@ -368,6 +295,88 @@ interface ModuleDiagnostic {
     duration: number;
 }
 
+interface Reporter {
+    onInit?: (ctx: Vitest) => void;
+    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+    onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable<void>;
+    onTestModuleQueued?: (file: TestModule) => 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;
+    renderSucceed: boolean;
+    protected verbose: boolean;
+    private _filesInWatchMode;
+    private _timeStart;
+    constructor(options?: BaseOptions);
+    onInit(ctx: Vitest): void;
+    log(...messages: any): void;
+    error(...messages: any): 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;
+    onWatcherRerun(files: string[], trigger?: string): void;
+    onUserConsoleLog(log: UserConsoleLog): void;
+    onTestRemoved(trigger?: string): 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;
+}
+
+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 DefaultReporterOptions extends BaseOptions {
+    summary?: boolean;
+}
+declare class DefaultReporter extends BaseReporter {
+    private options;
+    private summary?;
+    constructor(options?: DefaultReporterOptions);
+    onTestModuleQueued(file: TestModule): void;
+    onInit(ctx: Vitest): void;
+    onPathsCollected(paths?: string[]): void;
+    onTaskUpdate(packs: TaskResultPack[]): void;
+    onWatcherRerun(files: string[], trigger?: string): void;
+    onFinished(files?: File[], errors?: unknown[]): void;
+}
+
+interface HTMLOptions {
+    outputFile?: string;
+}
+
 declare class BasicReporter extends BaseReporter {
     constructor();
     onInit(ctx: Vitest): void;
@@ -618,114 +627,12 @@ declare class VerboseReporter extends DefaultReporter {
     onTaskUpdate(packs: TaskResultPack[]): void;
 }
 
-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 RootAndTarget {
-    root: string;
-    targetAbsPath: string;
-}
-type Context = RootAndTarget & {
-    rawErrsMap: RawErrsMap;
-    openedDirs: Set<string>;
-    lastActivePath?: string;
-};
-
 declare class TypeCheckError extends Error {
     message: string;
     stacks: ParsedStack[];
     name: string;
     constructor(message: string, stacks: ParsedStack[]);
 }
-interface TypecheckResults {
-    files: File[];
-    sourceErrors: TypeCheckError[];
-    time: number;
-}
-type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>;
-declare class Typechecker {
-    protected ctx: TestProject;
-    private _onParseStart?;
-    private _onParseEnd?;
-    private _onWatcherRerun?;
-    private _result;
-    private _startTime;
-    private _output;
-    private _tests;
-    private tempConfigPath?;
-    private allowJs?;
-    private process?;
-    protected files: string[];
-    constructor(ctx: TestProject);
-    setFiles(files: string[]): void;
-    onParseStart(fn: Callback): void;
-    onParseEnd(fn: Callback<[TypecheckResults]>): void;
-    onWatcherRerun(fn: Callback): void;
-    protected collectFileTests(filepath: string): Promise<FileInformation | null>;
-    protected getFiles(): string[];
-    collectTests(): Promise<Record<string, FileInformation>>;
-    protected markPassed(file: File): void;
-    protected prepareResults(output: string): Promise<{
-        files: File[];
-        sourceErrors: TypeCheckError[];
-        time: number;
-    }>;
-    protected parseTscLikeOutput(output: string): Promise<Map<string, {
-        error: TypeCheckError;
-        originalError: TscErrorInfo;
-    }[]>>;
-    clear(): Promise<void>;
-    stop(): Promise<void>;
-    protected ensurePackageInstalled(ctx: Vitest, checker: string): Promise<void>;
-    prepare(): Promise<void>;
-    getExitCode(): number | false;
-    getOutput(): string;
-    start(): Promise<void>;
-    getResult(): TypecheckResults;
-    getTestFiles(): File[];
-    getTestPacks(): TaskResultPack[];
-}
 
 interface PrintErrorResult {
     nearest?: ParsedStack;
@@ -920,13 +827,175 @@ interface BuiltinReporterOptions {
 
 type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
 
+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;
+}
+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;
+    /**
+     * 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;
+}
+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;
+    /**
+     * Run tests inside a single fork.
+     *
+     * @default false
+     */
+    singleFork?: boolean;
+}
+interface ResolvedForksOptions extends ForksOptions {
+    minForks?: number;
+    maxForks?: 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 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[];
+}
+
+declare class TestSpecification {
+    /**
+     * @deprecated use `project` instead
+     */
+    readonly 0: TestProject;
+    /**
+     * @deprecated use `moduleId` instead
+     */
+    readonly 1: string;
+    /**
+     * @deprecated use `pool` instead
+     */
+    readonly 2: {
+        pool: Pool;
+    };
+    /**
+     * The test project that the module belongs to.
+     */
+    readonly project: TestProject;
+    /**
+     * The ID of the module in the Vite module graph. It is usually an absolute file path.
+     */
+    readonly moduleId: string;
+    /**
+     * The current test pool. It's possible to have multiple pools in a single test project with `poolMatchGlob` and `typecheck.enabled`.
+     * @experimental In Vitest 4, the project will only support a single pool and this property will be removed.
+     */
+    readonly pool: Pool;
+    /**
+     * Line numbers of the test locations to run.
+     */
+    readonly testLines: number[] | undefined;
+    constructor(project: TestProject, moduleId: string, pool: Pool, testLines?: number[] | undefined);
+    toJSON(): SerializedTestSpecification;
+    /**
+     * for backwards compatibility
+     * @deprecated
+     */
+    [Symbol.iterator](): Generator<string | TestProject, void, unknown>;
+}
+
 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[]>;
+    shard: (files: TestSpecification[]) => Awaitable<TestSpecification[]>;
+    sort: (files: TestSpecification[]) => Awaitable<TestSpecification[]>;
 }
 interface TestSequencerConstructor {
     new (ctx: Vitest): TestSequencer;
@@ -1087,7 +1156,9 @@ interface CoverageProviderModule {
     /**
      * Executed before tests are run in the worker thread.
      */
-    startCoverage?: () => unknown | Promise<unknown>;
+    startCoverage?: (runtimeOptions: {
+        isolate: boolean;
+    }) => unknown | Promise<unknown>;
     /**
      * Executed on after each run in the worker thread. Possible to return a payload passed to the provider
      */
@@ -1095,7 +1166,9 @@ interface CoverageProviderModule {
     /**
      * Executed after all tests have been run in the worker thread.
      */
-    stopCoverage?: () => unknown | Promise<unknown>;
+    stopCoverage?: (runtimeOptions: {
+        isolate: boolean;
+    }) => unknown | Promise<unknown>;
 }
 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>];
@@ -1201,208 +1274,87 @@ interface BaseCoverageOptions {
      *   }
      * }
      * ```
-     */
-    thresholds?: Thresholds | ({
-        [glob: string]: Pick<Thresholds, 100 | 'statements' | 'functions' | 'branches' | 'lines'>;
-    } & Thresholds);
-    /**
-     * Watermarks for statements, lines, branches and functions.
-     *
-     * Default value is `[50,80]` for each property.
-     */
-    watermarks?: {
-        statements?: [number, number];
-        functions?: [number, number];
-        branches?: [number, number];
-        lines?: [number, number];
-    };
-    /**
-     * Generate coverage report even when tests fail.
-     *
-     * @default false
-     */
-    reportOnFailure?: boolean;
-    /**
-     * Collect coverage of files outside the project `root`.
-     *
-     * @default false
-     */
-    allowExternal?: boolean;
-    /**
-     * Apply exclusions again after coverage has been remapped to original sources.
-     * This is useful when your source files are transpiled and may contain source maps
-     * of non-source files.
-     *
-     * Use this option when you are seeing files that show up in report even if they
-     * match your `coverage.exclude` patterns.
-     *
-     * @default false
-     */
-    excludeAfterRemap?: boolean;
-    /**
-     * Concurrency limit used when processing the coverage results.
-     * Defaults to `Math.min(20, os.availableParallelism?.() ?? os.cpus().length)`
-     */
-    processingConcurrency?: number;
-}
-interface CoverageIstanbulOptions extends BaseCoverageOptions {
-    /**
-     * Set to array of class method names to ignore for coverage
-     *
-     * @default []
-     */
-    ignoreClassMethods?: string[];
-}
-interface CoverageV8Options extends BaseCoverageOptions {
-    /**
-     * Ignore empty lines, comments and other non-runtime code, e.g. Typescript types
-     */
-    ignoreEmptyLines?: boolean;
-}
-interface CustomProviderOptions extends Pick<BaseCoverageOptions, FieldsWithDefaultValues> {
-    /** Name of the module or path to a file to load the custom provider from */
-    customProviderModule: string;
-}
-interface Thresholds {
-    /** Set global thresholds to `100` */
-    100?: boolean;
-    /** Check thresholds per file. */
-    perFile?: boolean;
-    /**
-     * 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;
-}
-
-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;
-}
-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;
+     */
+    thresholds?: Thresholds | ({
+        [glob: string]: Pick<Thresholds, 100 | 'statements' | 'functions' | 'branches' | 'lines'>;
+    } & Thresholds);
     /**
-     * Run tests inside a single thread.
+     * Watermarks for statements, lines, branches and functions.
      *
-     * @default false
+     * Default value is `[50,80]` for each property.
      */
-    singleThread?: boolean;
+    watermarks?: {
+        statements?: [number, number];
+        functions?: [number, number];
+        branches?: [number, number];
+        lines?: [number, number];
+    };
     /**
-     * Use Atomics to synchronize threads
-     *
-     * This can improve performance in some cases, but might cause segfault in older Node versions.
+     * Generate coverage report even when tests fail.
      *
      * @default false
      */
-    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;
+    reportOnFailure?: boolean;
     /**
-     * Run tests inside a single fork.
+     * Collect coverage of files outside the project `root`.
      *
      * @default false
      */
-    singleFork?: boolean;
-}
-interface ResolvedForksOptions extends ForksOptions {
-    minForks?: number;
-    maxForks?: number;
-}
-interface WorkerContextOptions {
+    allowExternal?: boolean;
     /**
-     * Isolate test environment by recycling `worker_threads` or `child_process` after each test
+     * Apply exclusions again after coverage has been remapped to original sources.
+     * This is useful when your source files are transpiled and may contain source maps
+     * of non-source files.
      *
-     * @default true
+     * Use this option when you are seeing files that show up in report even if they
+     * match your `coverage.exclude` patterns.
+     *
+     * @default false
      */
-    isolate?: boolean;
+    excludeAfterRemap?: 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
+     * Concurrency limit used when processing the coverage results.
+     * Defaults to `Math.min(20, os.availableParallelism?.() ?? os.cpus().length)`
+     */
+    processingConcurrency?: number;
+}
+interface CoverageIstanbulOptions extends BaseCoverageOptions {
+    /**
+     * Set to array of class method names to ignore for coverage
      *
-     * @default [] // no execution arguments are passed
+     * @default []
      */
-    execArgv?: string[];
+    ignoreClassMethods?: string[];
 }
-interface VmOptions {
+interface CoverageV8Options extends BaseCoverageOptions {
     /**
-     * Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
-     * If you see memory leaks, try to tinker this value.
+     * Ignore empty lines, comments and other non-runtime code, e.g. Typescript types
      */
-    memoryLimit?: string | number;
-    /** Isolation is always enabled */
-    isolate?: true;
+    ignoreEmptyLines?: boolean;
+}
+interface CustomProviderOptions extends Pick<BaseCoverageOptions, FieldsWithDefaultValues> {
+    /** Name of the module or path to a file to load the custom provider from */
+    customProviderModule: string;
+}
+interface Thresholds {
+    /** Set global thresholds to `100` */
+    100?: boolean;
+    /** Check thresholds per file. */
+    perFile?: 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
+     * Update threshold values automatically when current coverage is higher than earlier thresholds
      *
-     * @default [] // no execution arguments are passed
+     * @default false
      */
-    execArgv?: string[];
+    autoUpdate?: boolean;
+    /** Thresholds for statements */
+    statements?: number;
+    /** Thresholds for functions */
+    functions?: number;
+    /** Thresholds for branches */
+    branches?: number;
+    /** Thresholds for lines */
+    lines?: number;
 }
 
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
@@ -2245,8 +2197,9 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     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'> & {
+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' | 'workspace';
+type ProjectConfig = Omit<InlineConfig, NonProjectOptions | 'sequencer' | 'deps' | 'poolOptions'> & {
+    mode?: string;
     sequencer?: Omit<SequenceOptions, 'sequencer' | 'seed'>;
     deps?: Omit<DepsOptions, 'moduleDirectories'>;
     poolOptions?: {
@@ -2291,9 +2244,9 @@ interface BrowserProvider {
     getSupportedBrowsers: () => readonly string[];
     beforeCommand?: (command: string, args: unknown[]) => Awaitable$1<void>;
     afterCommand?: (command: string, args: unknown[]) => Awaitable$1<void>;
-    getCommandsContext: (contextId: string) => Record<string, unknown>;
-    openPage: (contextId: string, url: string, beforeNavigate?: () => Promise<void>) => Promise<void>;
-    getCDPSession?: (contextId: string) => Promise<CDPSession>;
+    getCommandsContext: (sessionId: string) => Record<string, unknown>;
+    openPage: (sessionId: string, url: string, beforeNavigate?: () => Promise<void>) => Promise<void>;
+    getCDPSession?: (sessionId: string) => Promise<CDPSession>;
     close: () => Awaitable$1<void>;
     initialize(ctx: TestProject, options: BrowserProviderInitializationOptions): Awaitable$1<void>;
 }
@@ -2303,6 +2256,13 @@ interface BrowserProviderModule {
 interface BrowserProviderOptions {
 }
 type BrowserBuiltinProvider = 'webdriverio' | 'playwright' | 'preview';
+type UnsupportedProperties = 'browser' | 'typecheck' | 'alias' | 'sequence' | 'root' | 'pool' | 'poolOptions' | 'runner' | 'api' | 'deps' | 'testTransformMode' | 'poolMatchGlobs' | 'environmentMatchGlobs' | 'environment' | 'environmentOptions' | 'server' | 'benchmark';
+interface BrowserInstanceOption extends BrowserProviderOptions, Omit<ProjectConfig, UnsupportedProperties>, Pick<BrowserConfigOptions, 'headless' | 'locators' | 'viewport' | 'testerHtmlPath' | 'screenshotDirectory' | 'screenshotFailures'> {
+    /**
+     * Name of the browser
+     */
+    browser: string;
+}
 interface BrowserConfigOptions {
     /**
      * if running tests in the browser should be the default
@@ -2312,8 +2272,13 @@ interface BrowserConfigOptions {
     enabled?: boolean;
     /**
      * Name of the browser
+     * @deprecated use `configs` instead. if both are defined, this will filter `configs` by name.
      */
-    name: string;
+    name?: string;
+    /**
+     * Configurations for different browser setups
+     */
+    instances?: BrowserInstanceOption[];
     /**
      * Browser provider
      *
@@ -2329,6 +2294,7 @@ interface BrowserConfigOptions {
      *
      * @example
      * { playwright: { launch: { devtools: true } }
+     * @deprecated use `configs` instead
      */
     providerOptions?: BrowserProviderOptions;
     /**
@@ -2418,16 +2384,25 @@ interface BrowserConfigOptions {
      * @see {@link https://vitest.dev/guide/browser/commands}
      */
     commands?: Record<string, BrowserCommand<any>>;
+    /**
+     * Timeout for connecting to the browser
+     * @default 30000
+     */
+    connectTimeout?: number;
 }
 interface BrowserCommandContext {
     testPath: string | undefined;
     provider: BrowserProvider;
     project: TestProject;
+    /** @deprecated use `sessionId` instead */
     contextId: string;
+    sessionId: string;
 }
-interface BrowserServerStateContext {
+interface BrowserServerStateSession {
     files: string[];
     method: 'run' | 'collect';
+    project: TestProject;
+    connected: () => void;
     resolve: () => void;
     reject: (v: unknown) => void;
 }
@@ -2438,15 +2413,16 @@ interface BrowserOrchestrator {
 }
 interface BrowserServerState {
     orchestrators: Map<string, BrowserOrchestrator>;
-    getContext: (contextId: string) => BrowserServerStateContext | undefined;
-    createAsyncContext: (method: 'collect' | 'run', contextId: string, files: string[]) => Promise<void>;
 }
-interface BrowserServer {
+interface ParentProjectBrowser {
+    spawn: (project: TestProject) => ProjectBrowser;
+}
+interface ProjectBrowser {
     vite: ViteDevServer;
     state: BrowserServerState;
     provider: BrowserProvider;
     close: () => Promise<void>;
-    initBrowserProvider: () => Promise<void>;
+    initBrowserProvider: (project: TestProject) => Promise<void>;
     parseStacktrace: (stack: string) => ParsedStack[];
     parseErrorStacktrace: (error: ErrorWithDiff, options?: StackTraceParserOptions) => ParsedStack[];
 }
@@ -2482,6 +2458,8 @@ interface BrowserScript {
     type?: string;
 }
 interface ResolvedBrowserOptions extends BrowserConfigOptions {
+    name: string;
+    providerOptions?: BrowserProviderOptions;
     enabled: boolean;
     headless: boolean;
     isolate: boolean;
@@ -2498,39 +2476,9 @@ interface ResolvedBrowserOptions extends BrowserConfigOptions {
     };
 }
 
-declare class TestSpecification {
-    /**
-     * @deprecated use `project` instead
-     */
-    readonly 0: TestProject;
-    /**
-     * @deprecated use `moduleId` instead
-     */
-    readonly 1: string;
-    /**
-     * @deprecated use `pool` instead
-     */
-    readonly 2: {
-        pool: Pool;
-    };
-    readonly project: TestProject;
-    readonly moduleId: string;
-    readonly pool: Pool;
-    /** @private */
-    readonly testLocations: number[] | undefined;
-    constructor(project: TestProject, moduleId: string, pool: Pool, testLocations?: number[] | undefined);
-    toJSON(): SerializedTestSpecification;
-    /**
-     * for backwards compatibility
-     * @deprecated
-     */
-    [Symbol.iterator](): Generator<string | TestProject, void, unknown>;
-}
-
 declare class TestProject {
     /** @deprecated */
     path: string | number;
-    /** @deprecated */
     options?: InitializeProjectOptions | undefined;
     /**
      * The global Vitest instance.
@@ -2544,28 +2492,23 @@ declare class TestProject {
     /**
      * Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
      */
-    browser?: BrowserServer;
+    browser?: ProjectBrowser;
     /** @deprecated use `vitest` instead */
     ctx: Vitest;
     /**
      * Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
      */
     readonly tmpDir: string;
-    vitenode: ViteNodeServer;
-    runner: ViteNodeRunner;
-    typechecker?: Typechecker;
+    private runner;
     private closingPromise;
     private testFilesList;
     private typecheckFilesList;
     private _globalSetups?;
     private _provided;
-    private _config?;
     private _vite?;
     constructor(
     /** @deprecated */
-    path: string | number, vitest: Vitest, 
-    /** @deprecated */
-    options?: InitializeProjectOptions | undefined);
+    path: string | number, vitest: Vitest, options?: InitializeProjectOptions | undefined);
     /**
      * Provide a value to the test context. This value will be available to all tests with `inject`.
      */
@@ -2578,7 +2521,9 @@ declare class TestProject {
      * Creates a new test specification. Specifications describe how to run tests.
      * @param moduleId The file path
      */
-    createSpecification(moduleId: string, pool?: string, testLocations?: number[] | undefined): TestSpecification;
+    createSpecification(moduleId: string, locations?: number[] | undefined, 
+    /** @internal */
+    pool?: string): TestSpecification;
     toJSON(): SerializedTestProject;
     /**
      * Vite's dev server instance. Every workspace project has its own server.
@@ -2637,12 +2582,13 @@ declare class TestProject {
     }>;
     private globAllTestFiles;
     isBrowserEnabled(): boolean;
+    private markTestFile;
     /** @deprecated use `serializedConfig` instead */
     getSerializableConfig(): SerializedConfig;
     /**
-     * Test if a file matches the test globs. This does the actual glob matching unlike `isTestFile`.
+     * Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
      */
-    matchesTestGlob(filepath: string, source?: string): boolean;
+    matchesTestGlob(moduleId: string, source?: () => string): boolean;
     /** @deprecated use `matchesTestGlob` instead */
     isTargetFile(id: string, source?: string): Promise<boolean>;
     private isInSourceTestCode;
@@ -2652,6 +2598,11 @@ declare class TestProject {
      * If the resources are needed again, create a new project.
      */
     close(): Promise<void>;
+    /**
+     * Import a file using Vite module runner.
+     * @param moduleId The ID of the module in Vite module graph
+     */
+    import<T>(moduleId: string): Promise<T>;
     /** @deprecated use `name` instead */
     getName(): string;
     /** @deprecated internal */
@@ -2691,7 +2642,7 @@ type WorkspaceSpec = TestSpecification & [
         pool: Pool;
     }
 ];
-type RunWithFiles = (files: WorkspaceSpec[], invalidates?: string[]) => Awaitable$1<void>;
+type RunWithFiles = (files: TestSpecification[], invalidates?: string[]) => Awaitable$1<void>;
 interface ProcessPool {
     name: string;
     runTests: RunWithFiles;
@@ -2700,6 +2651,11 @@ interface ProcessPool {
 }
 declare function getFilePoolName(project: TestProject, file: string): Pool;
 
+interface TestRunResult {
+    testModules: TestModule[];
+    unhandledErrors: unknown[];
+}
+
 interface SuiteResultCache {
     failed: boolean;
     duration: number;
@@ -2724,7 +2680,7 @@ type FileStatsCache = Pick<Stats, 'size'>;
 declare class FilesStatsCache {
     cache: Map<string, FileStatsCache>;
     getStats(key: string): FileStatsCache | undefined;
-    populateStats(root: string, specs: WorkspaceSpec[]): Promise<void>;
+    populateStats(root: string, specs: TestSpecification[]): Promise<void>;
     updateStats(fsPath: string, key: string): Promise<void>;
     removeStats(fsPath: string): void;
 }
@@ -2754,7 +2710,7 @@ declare class StateManager {
     taskFileMap: WeakMap<Task, File>;
     errorsSet: Set<unknown>;
     processTimeoutCauses: Set<string>;
-    reportedTasksMap: WeakMap<Task, TestCase | TestSuite | TestModule>;
+    reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
     catchError(err: unknown, type: string): void;
     clearErrors(): void;
     getUnhandledErrors(): unknown[];
@@ -2772,7 +2728,7 @@ declare class StateManager {
     collectFiles(project: TestProject, files?: File[]): void;
     clearFiles(project: TestProject, paths?: string[]): void;
     updateId(task: Task, project: TestProject): void;
-    getReportedEntity(task: Task): TestCase | TestSuite | TestModule | undefined;
+    getReportedEntity(task: Task): TestModule | TestCase | TestSuite | undefined;
     updateTasks(packs: TaskResultPack[]): void;
     updateUserLog(log: UserConsoleLog): void;
     getCountOfFailedTests(): number;
@@ -2787,120 +2743,266 @@ interface VitestOptions {
 }
 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 */
-    resolvedProjects: TestProject[];
+    /**
+     * Current Vitest version.
+     * @example '2.0.0'
+     */
+    readonly version: string;
+    static readonly version: string;
+    /**
+     * The logger instance used to log messages. It's recommended to use this logger instead of `console`.
+     * It's possible to override stdout and stderr streams when initiating Vitest.
+     * @example
+     * new Vitest('test', {
+     *   stdout: new Writable(),
+     * })
+     */
+    readonly logger: Logger;
+    /**
+     * The package installer instance used to install Vitest packages.
+     * @example
+     * await vitest.packageInstaller.ensureInstalled('@vitest/browser', process.cwd())
+     */
+    readonly packageInstaller: VitestPackageInstaller;
+    /**
+     * A path to the built Vitest directory. This is usually a folder in `node_modules`.
+     */
+    readonly distPath: string;
+    /**
+     * A list of projects that are currently running.
+     * If projects were filtered with `--project` flag, they won't appear here.
+     */
     projects: TestProject[];
-    distPath: string;
-    private _cachedSpecs;
+    private isFirstRun;
+    private restartsCount;
+    private readonly specifications;
+    private readonly watcher;
+    private pool;
+    private _config?;
+    private _vite?;
+    private _state?;
+    private _cache?;
+    private _snapshot?;
     private _workspaceConfigPath?;
-    /** @deprecated use `_cachedSpecs` */
-    projectTestFiles: Map<string, TestSpecification[]>;
     constructor(mode: VitestRunMode, options?: VitestOptions);
     private _onRestartListeners;
     private _onClose;
     private _onSetServer;
     private _onCancelListeners;
     private _onUserTestsRerun;
+    private _onFilterWatchedSpecification;
+    /** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
+    get invalidates(): Set<string>;
+    /** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
+    get changedTests(): Set<string>;
+    /**
+     * The global config.
+     */
+    get config(): ResolvedConfig;
+    /** @deprecated use `vitest.vite` instead */
+    get server(): ViteDevServer;
+    /**
+     * Global Vite's dev server instance.
+     */
+    get vite(): ViteDevServer;
+    /**
+     * The global test state manager.
+     * @experimental The State API is experimental and not subject to semver.
+     */
+    get state(): StateManager;
+    /**
+     * The global snapshot manager. You can access the current state on `snapshot.summary`.
+     */
+    get snapshot(): SnapshotManager;
+    /**
+     * Test results and test file stats cache. Primarily used by the sequencer to sort tests.
+     */
+    get cache(): VitestCache;
+    /** @deprecated internal */
     setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
-    provide<T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]): void;
-    getRootTestProject(): TestProject;
+    /**
+     * Provide a value to the test context. This value will be available to all tests with `inject`.
+     */
+    provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
+    /**
+     * Get global provided context.
+     */
+    getProvidedContext(): ProvidedContext;
+    /** @deprecated use `getRootProject` instead */
+    getCoreWorkspaceProject(): TestProject;
+    /**
+     * Return project that has the root (or "global") config.
+     */
+    getRootProject(): TestProject;
     /**
      * @deprecated use Reported Task API instead
      */
     getProjectByTaskId(taskId: string): TestProject;
-    getProjectByName(name?: string): TestProject;
+    getProjectByName(name: string): TestProject;
+    /**
+     * Import a file using Vite module runner. The file will be transformed by Vite and executed in a separate context.
+     * @param moduleId The ID of the module in Vite module graph
+     */
+    import<T>(moduleId: string): Promise<T>;
     private resolveWorkspaceConfigPath;
     private resolveWorkspace;
+    /**
+     * Glob test files in every project and create a TestSpecification for each file and pool.
+     * @param filters String filters to match the test files.
+     */
+    globTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
     private initCoverageProvider;
-    mergeReports(): Promise<void>;
-    collect(filters?: string[]): Promise<{
-        tests: File[];
-        errors: unknown[];
-    }>;
-    listFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
-    start(filters?: string[]): Promise<void>;
+    /**
+     * Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
+     */
+    mergeReports(directory?: string): Promise<TestRunResult>;
+    collect(filters?: string[]): Promise<TestRunResult>;
+    /** @deprecated use `getRelevantTestSpecifications` instead */
+    listFiles(filters?: string[]): Promise<TestSpecification[]>;
+    /**
+     * Returns the list of test files that match the config and filters.
+     * @param filters String filters to match the test files
+     */
+    getRelevantTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
+    /**
+     * Initialize reporters, the coverage provider, and run tests.
+     * This method can throw an error:
+     *   - `FilesNotFoundError` if no tests are found
+     *   - `GitNotFoundError` if `--related` flag is used, but git repository is not initialized
+     *   - `Error` from the user reporters
+     * @param filters String filters to match the test files
+     */
+    start(filters?: string[]): Promise<TestRunResult>;
+    /**
+     * Initialize reporters and the coverage provider. This method doesn't run any tests.
+     * If the `--watch` flag is provided, Vitest will still run changed tests even if this method was not called.
+     */
     init(): Promise<void>;
-    private getTestDependencies;
-    filterTestsBySource(specs: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
     /**
-     * @deprecated remove when vscode extension supports "getFileWorkspaceSpecs"
+     * @deprecated remove when vscode extension supports "getModuleSpecifications"
      */
     getProjectsByTestFile(file: string): WorkspaceSpec[];
-    getFileWorkspaceSpecs(file: string): TestSpecification[];
-    initializeGlobalSetup(paths: TestSpecification[]): Promise<void>;
-    runFiles(specs: TestSpecification[], allTestsRun: boolean): Promise<void>;
-    collectFiles(specs: WorkspaceSpec[]): Promise<void>;
+    /** @deprecated */
+    getFileWorkspaceSpecs(file: string): WorkspaceSpec[];
+    /**
+     * Get test specifications assosiated with the given module. If module is not a test file, an empty array is returned.
+     *
+     * **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
+     * @param moduleId The module ID to get test specifications for.
+     */
+    getModuleSpecifications(moduleId: string): TestSpecification[];
+    /**
+     * Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache alltogether.
+     */
+    clearSpecificationsCache(moduleId?: string): void;
+    /**
+     * Run tests for the given test specifications. This does not trigger `onWatcher*` events.
+     * @param specifications A list of specifications to run.
+     * @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+     */
+    runTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
+    /**
+     * Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
+     * @param specifications A list of specifications to run.
+     * @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+     */
+    rerunTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
+    private runFiles;
+    /**
+     * Collect tests in specified modules. Vitest will run the files to collect tests.
+     * @param specifications A list of specifications to run.
+     */
+    collectTests(specifications: TestSpecification[]): Promise<TestRunResult>;
+    /**
+     * Gracefully cancel the current test run. Vitest will wait until all running tests are finished before cancelling.
+     */
     cancelCurrentRun(reason: CancelReason): Promise<void>;
-    initBrowserServers(): Promise<void>;
-    rerunFiles(files?: string[], trigger?: string, allTestsRun?: boolean, resetTestNamePattern?: boolean): Promise<void>;
-    private isSuite;
-    rerunTask(id: 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 initializeGlobalSetup;
+    /**
+     * Update snapshots in specified files. If no files are provided, it will update files with failed tests and obsolete snapshots.
+     * @param files The list of files on the file system
+     */
+    updateSnapshot(files?: string[]): Promise<TestRunResult>;
+    /**
+     * Enable the mode that allows updating snapshots when running tests.
+     * This method doesn't run any tests.
+     *
+     * Every test that runs after this method is called will update snapshots.
+     * To disable the mode, call `resetSnapshotUpdate`.
+     */
+    enableSnapshotUpdate(): void;
+    /**
+     * Disable the mode that allows updating snapshots when running tests.
+     */
+    resetSnapshotUpdate(): void;
+    /**
+     * Set the global test name pattern to a regexp.
+     * This method doesn't run any tests.
+     */
+    setGlobalTestNamePattern(pattern: string | RegExp): void;
+    /**
+     * Resets the global test name pattern. This method doesn't run any tests.
+     */
+    resetGlobalTestNamePattern(): void;
     private _rerunTimer;
     private scheduleRerun;
-    getModuleProjects(filepath: string): TestProject[];
     /**
-     * Watch only the specified tests. If no tests are provided, all tests will be watched.
+     * Invalidate a file in all projects.
      */
-    watchTests(tests: string[]): void;
-    private updateLastChanged;
-    onChange: (id: string) => void;
-    onUnlink: (id: string) => void;
-    onAdd: (id: string) => Promise<void>;
-    checkUnhandledErrors(errors: unknown[]): void;
-    private unregisterWatcher;
-    private registerWatcher;
+    invalidateFile(filepath: string): void;
+    /** @deprecated use `invalidateFile` */
+    updateLastChanged(filepath: string): void;
+    private reportCoverage;
     /**
-     * @returns A value indicating whether rerun is needed (changedTests was mutated)
+     * Closes all projects and their associated resources.
+     * This can only be called once; the closing promise is cached until the server restarts.
      */
-    private handleFileChanged;
-    private reportCoverage;
     close(): Promise<void>;
     /**
-     * Close the thread pool and exit the process
+     * Closes all projects and exit the process
+     * @param force If true, the process will exit immediately after closing the projects.
      */
     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
+     * @deprecated use `globTestSpecifications` instead
+     */
+    globTestSpecs(filters?: string[]): Promise<TestSpecification[]>;
+    /**
+     * @deprecated use `globTestSpecifications` instead
+     */
+    globTestFiles(filters?: string[]): Promise<TestSpecification[]>;
+    /** @deprecated filter by `this.projects` yourself */
+    getModuleProjects(filepath: string): TestProject[];
+    /**
+     * Should the server be kept running after the tests are done.
      */
-    globTestFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
-    private ensureSpecCached;
     shouldKeepServer(): boolean;
+    /**
+     * Register a handler that will be called when the server is restarted due to a config change.
+     */
     onServerRestart(fn: OnServerRestartHandler): void;
-    onAfterSetServer(fn: OnServerRestartHandler): void;
-    onCancel(fn: (reason: CancelReason) => void): void;
-    onClose(fn: () => void): void;
+    /**
+     * Register a handler that will be called when the test run is cancelled with `vitest.cancelCurrentRun`.
+     */
+    onCancel(fn: (reason: CancelReason) => Awaitable$1<void>): void;
+    /**
+     * Register a handler that will be called when the server is closed.
+     */
+    onClose(fn: () => Awaitable$1<void>): void;
+    /**
+     * Register a handler that will be called when the tests are rerunning.
+     */
     onTestsRerun(fn: OnTestsRerunHandler): void;
+    /**
+     * Register a handler that will be called when a file is changed.
+     * This callback should return `true` of `false` indicating whether the test file needs to be rerun.
+     * @example
+     * const testsToRun = [resolve('./test.spec.ts')]
+     * vitest.onFilterWatchedSpecification(specification => testsToRun.includes(specification.moduleId))
+     */
+    onFilterWatchedSpecification(fn: (specification: TestSpecification) => boolean): void;
 }
+type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+type OnTestsRerunHandler = (testFiles: TestSpecification[]) => Promise<void> | void;
 
-export { type SerializedTestProject as $, type ApiConfig as A, type BaseCoverageOptions as B, CoverageMap as C, type DepsOptimizationOptions as D, type TypecheckConfig as E, type UserConfig as F, type ResolvedConfig as G, type ProjectConfig as H, type InlineConfig as I, type BenchmarkUserOptions as J, type VitestOptions as K, Logger as L, TestProject as M, type TestSequencer as N, type WorkspaceSpec as O, type Pool as P, TestModule as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TestProjectConfiguration as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, type ModuleDiagnostic as X, VitestPackageInstaller as Y, type ProcessPool as Z, getFilePoolName as _, type ReportContext as a, type HTMLOptions as a0, type JsonOptions$1 as a1, type JUnitOptions as a2, TestCase as a3, TestSuite as a4, type TaskOptions as a5, TestCollection as a6, type TestDiagnostic as a7, type TestResult as a8, type TestResultFailed as a9, JUnitReporter as aA, TapFlatReporter as aB, TapReporter as aC, VerboseReporter as aD, BaseReporter as aE, TestFile as aF, type FileDiagnostic as aG, ReportersMap as aH, type BuiltinReporters as aI, type BuiltinReporterOptions as aJ, type JsonAssertionResult as aK, type JsonTestResult as aL, type JsonTestResults as aM, BenchmarkReportsMap as aN, type BenchmarkBuiltinReporters as aO, type TestResultPassed as aa, type TestResultSkipped as ab, type TestSequencerConstructor as ac, TestSpecification as ad, type BrowserBuiltinProvider as ae, type BrowserCommand as af, type BrowserCommandContext as ag, type BrowserOrchestrator as ah, type BrowserProvider as ai, type BrowserProviderInitializationOptions as aj, type BrowserProviderModule as ak, type BrowserProviderOptions as al, type BrowserServer as am, type BrowserServerState as an, type BrowserServerStateContext as ao, type CDPSession as ap, type ResolvedBrowserOptions as aq, type ResolvedProjectConfig as ar, type ResolveSnapshotPathHandler as as, type ResolveSnapshotPathHandlerContext as at, BasicReporter as au, DefaultReporter as av, DotReporter as aw, GithubActionsReporter as ax, HangingProcessReporter as ay, JsonReporter as az, type CoverageProvider as b, type CoverageProviderModule as c, type CoverageV8Options as d, type UserProjectConfigFn as e, type UserProjectConfigExport as f, type VitestEnvironment as g, type RawErrsMap as h, type TscErrorInfo as i, type CollectLineNumbers as j, type CollectLines as k, type RootAndTarget as l, type Context as m, type CoverageReporter as n, type CoverageProviderName as o, type CoverageOptions as p, type CoverageIstanbulOptions as q, type CustomProviderOptions as r, type Reporter as s, type BrowserScript as t, type BrowserConfigOptions as u, type BuiltinEnvironment as v, type PoolOptions as w, type CSSModuleScopeStrategy as x, type VitestRunMode as y, type TransformModePatterns as z };
+export { type JUnitOptions as $, type ApiConfig as A, type BaseCoverageOptions as B, CoverageMap as C, type DepsOptimizationOptions as D, TestProject as E, type TestSequencer as F, TestSpecification as G, TestModule as H, type InlineConfig as I, type OnTestsRerunHandler as J, VitestPackageInstaller as K, Logger as L, type ModuleDiagnostic as M, type ProcessPool as N, type OnServerRestartHandler as O, type Pool as P, type WorkspaceSpec as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TestProjectConfiguration as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, getFilePoolName as X, type SerializedTestProject as Y, type HTMLOptions as Z, type JsonOptions$1 as _, type ReportContext as a, type TaskOptions as a0, TestCase as a1, TestCollection as a2, type TestDiagnostic as a3, type TestResult as a4, type TestResultFailed as a5, type TestResultPassed as a6, type TestResultSkipped as a7, TestSuite as a8, type TestSequencerConstructor as a9, TapFlatReporter as aA, TapReporter as aB, VerboseReporter as aC, BaseReporter as aD, TestFile as aE, type FileDiagnostic as aF, ReportersMap as aG, type BuiltinReporters as aH, type BuiltinReporterOptions as aI, type JsonAssertionResult as aJ, type JsonTestResult as aK, type JsonTestResults as aL, BenchmarkReportsMap as aM, type BenchmarkBuiltinReporters as aN, type BrowserBuiltinProvider as aa, type BrowserCommand as ab, type BrowserCommandContext as ac, type BrowserInstanceOption as ad, type BrowserOrchestrator as ae, type BrowserProvider as af, type BrowserProviderInitializationOptions as ag, type BrowserProviderModule as ah, type BrowserProviderOptions as ai, type BrowserServerState as aj, type BrowserServerStateSession as ak, type CDPSession as al, type ParentProjectBrowser as am, type ProjectBrowser as an, type ResolvedBrowserOptions as ao, type ResolvedProjectConfig as ap, type ResolveSnapshotPathHandler as aq, type ResolveSnapshotPathHandlerContext as ar, type TestRunResult as as, BasicReporter as at, DefaultReporter as au, DotReporter as av, GithubActionsReporter as aw, HangingProcessReporter as ax, JsonReporter as ay, JUnitReporter as az, type CoverageProvider as b, type CoverageProviderModule as c, type CoverageV8Options as d, type UserProjectConfigFn as e, type UserProjectConfigExport as f, type CoverageReporter as g, type CoverageProviderName as h, type CoverageOptions as i, type CoverageIstanbulOptions as j, type CustomProviderOptions as k, type Reporter as l, type BrowserScript as m, type BrowserConfigOptions as n, type BuiltinEnvironment as o, type VitestEnvironment as p, type PoolOptions as q, type CSSModuleScopeStrategy as r, type VitestRunMode as s, type TransformModePatterns as t, type TypecheckConfig as u, type UserConfig as v, type ResolvedConfig as w, type ProjectConfig as x, type BenchmarkUserOptions as y, type VitestOptions as z };