vitest 2.2.0-beta.2 → 3.0.0-beta.2

package/dist/chunks/{reporters.F9D2idOT.d.ts → reporters.DTtxC3KQ.d.ts}

@@ -1,19 +1,17 @@
 import * as _vitest_runner from '@vitest/runner';
-import { File, TaskResultPack, Task, Test, Custom, 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, d as ArgumentsType, O as OnServerRestartHandler, h as OnTestsRerunHandler } from './environment.CT0jpO-1.js';
+import { File, TaskResultPack, Task, 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 } 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.CPguQ7J1.js';
+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,6 +23,7 @@ type SerializedTestSpecification = [
     file: string,
     options: {
         pool: string;
+        testLines?: number[] | undefined;
     }
 ];
 
@@ -109,11 +108,6 @@ interface HTMLOptions {
 }
 
 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 +115,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 +125,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 | Custom;
     readonly type = "test";
     /**
      * Direct reference to the test module where the test or suite is defined.
@@ -157,20 +150,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 | Custom, 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 +176,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 +207,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 +239,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 +258,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`.
@@ -299,8 +306,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 +315,7 @@ interface TestResultSkipped {
      */
     errors: undefined;
     /**
-     * A custom note.
+     * A custom note passed down to `ctx.skip(note)`.
      */
     note: string | undefined;
 }
@@ -374,248 +381,12 @@ declare class BasicReporter extends BaseReporter {
     reportSummary(files: File[], errors: unknown[]): 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;
-}
-
-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;
-    project?: TestProject;
-    verbose?: boolean;
-    screenshotPaths?: string[];
-    task?: Task;
-    showCodeFrame?: boolean;
-}
-declare class Logger {
-    ctx: Vitest;
-    outputStream: NodeJS.WriteStream | Writable;
-    errorStream: NodeJS.WriteStream | Writable;
-    logUpdate: ReturnType<typeof createLogUpdate>;
-    private _clearScreenPending;
-    private _highlights;
-    console: Console;
-    constructor(ctx: Vitest, outputStream?: NodeJS.WriteStream | Writable, errorStream?: NodeJS.WriteStream | Writable);
-    log(...args: any[]): void;
-    error(...args: any[]): void;
-    warn(...args: any[]): void;
-    clearFullScreen(message?: string): void;
-    clearScreen(message: string, force?: boolean): void;
-    private _clearScreen;
-    printError(err: unknown, options?: ErrorOptions): PrintErrorResult | undefined;
-    clearHighlightCache(filename?: string): void;
-    highlight(filename: string, source: string): string;
-    printNoTestFound(filters?: string[]): void;
-    printBanner(): void;
-    printBrowserBanner(project: TestProject): void;
-    printUnhandledErrors(errors: unknown[]): void;
-    printSourceTypeErrors(errors: TypeCheckError[]): void;
-    private registerUnhandledRejection;
-}
-
-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>;
-    onTaskUpdate(): void;
-    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;
+    private summary?;
+    onInit(ctx: Vitest): void;
+    onTaskUpdate(packs: TaskResultPack[]): void;
+    onWatcherRerun(files: string[], trigger?: string): void;
+    onFinished(files?: File[], errors?: unknown[]): void;
 }
 
 declare class GithubActionsReporter implements Reporter {
@@ -854,6 +625,127 @@ declare class VerboseReporter extends DefaultReporter {
     onTaskUpdate(packs: TaskResultPack[]): void;
 }
 
+declare class TypeCheckError extends Error {
+    message: string;
+    stacks: ParsedStack[];
+    name: string;
+    constructor(message: string, stacks: ParsedStack[]);
+}
+
+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;
+    project?: TestProject;
+    verbose?: boolean;
+    screenshotPaths?: string[];
+    task?: Task;
+    showCodeFrame?: boolean;
+}
+declare class Logger {
+    ctx: Vitest;
+    outputStream: NodeJS.WriteStream | Writable;
+    errorStream: NodeJS.WriteStream | Writable;
+    logUpdate: ReturnType<typeof createLogUpdate>;
+    private _clearScreenPending;
+    private _highlights;
+    console: Console;
+    constructor(ctx: Vitest, outputStream?: NodeJS.WriteStream | Writable, errorStream?: NodeJS.WriteStream | Writable);
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    clearFullScreen(message?: string): void;
+    clearScreen(message: string, force?: boolean): void;
+    private _clearScreen;
+    printError(err: unknown, options?: ErrorOptions): PrintErrorResult | undefined;
+    clearHighlightCache(filename?: string): void;
+    highlight(filename: string, source: string): string;
+    printNoTestFound(filters?: string[]): void;
+    printBanner(): void;
+    printBrowserBanner(project: TestProject): void;
+    printUnhandledErrors(errors: unknown[]): void;
+    printSourceTypeErrors(errors: TypeCheckError[]): void;
+    private registerUnhandledRejection;
+}
+
 interface TableRendererOptions {
     renderSucceed?: boolean;
     logger: Logger;
@@ -862,9 +754,9 @@ interface TableRendererOptions {
     compare?: FlatBenchmarkReport;
 }
 declare function createTableRenderer(_tasks: Task[], options: TableRendererOptions): {
-    start(): any;
-    update(_tasks: Task[]): any;
-    stop(): any;
+    start(): /*elided*/ any;
+    update(_tasks: Task[]): /*elided*/ any;
+    stop(): /*elided*/ any;
     clear(): void;
 };
 
@@ -931,15 +823,177 @@ interface BuiltinReporterOptions {
     'html': HTMLOptions;
 }
 
-type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
-
+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;
@@ -1100,7 +1154,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
      */
@@ -1108,7 +1164,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>];
@@ -1297,127 +1355,6 @@ interface Thresholds {
     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;
-    /**
-     * 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[];
-}
-
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
 
@@ -1656,6 +1593,7 @@ interface InlineConfig {
      *
      * Format: [glob, environment-name]
      *
+     * @deprecated use [`workspace`](https://vitest.dev/config/#environmentmatchglobs) instead
      * @default []
      * @example [
      *   // all tests in tests/dom will run in jsdom
@@ -1706,6 +1644,7 @@ interface InlineConfig {
      *
      * Format: [glob, pool-name]
      *
+     * @deprecated use [`workspace`](https://vitest.dev/config/#poolmatchglobs) instead
      * @default []
      * @example [
      *   // all tests in "forks" directory will run using "poolOptions.forks" API
@@ -1718,7 +1657,7 @@ interface InlineConfig {
     /**
      * Path to a workspace configuration file
      */
-    workspace?: string;
+    workspace?: string | TestProjectConfiguration[];
     /**
      * Update snapshot
      *
@@ -2275,9 +2214,10 @@ type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig
 type TestProjectConfiguration = string | (UserProjectConfigExport & {
     /**
      * Relative path to the extendable config. All other options will be merged with this config.
+     * If `true`, the project will inherit all options from the root config.
      * @example '../vite.config.ts'
      */
-    extends?: string;
+    extends?: string | true;
 });
 /** @deprecated use `TestProjectConfiguration` instead */
 type WorkspaceProjectConfiguration = TestProjectConfiguration;
@@ -2508,33 +2448,6 @@ 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;
-    constructor(project: TestProject, moduleId: string, pool: Pool);
-    toJSON(): SerializedTestSpecification;
-    /**
-     * for backwards compatibility
-     * @deprecated
-     */
-    [Symbol.iterator](): Generator<string | TestProject, void, unknown>;
-}
-
 declare class TestProject {
     /** @deprecated */
     path: string | number;
@@ -2559,9 +2472,7 @@ declare class TestProject {
      * 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;
@@ -2577,7 +2488,7 @@ declare class 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;
+    provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
     /**
      * Get the provided context. The project context is merged with the global context.
      */
@@ -2586,7 +2497,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): 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.
@@ -2616,6 +2529,7 @@ declare class TestProject {
     createSpec(moduleId: string, pool: string): WorkspaceSpec;
     /** @deprecated */
     initializeGlobalSetup(): Promise<void>;
+    onTestsRerun(cb: OnTestsRerunHandler): void;
     /** @deprecated */
     teardownGlobalSetup(): Promise<void>;
     /** @deprecated use `vitest.logger` instead */
@@ -2644,12 +2558,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;
@@ -2659,6 +2574,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 */
@@ -2675,7 +2595,7 @@ interface SerializedTestProject {
     context: ProvidedContext;
 }
 interface InitializeProjectOptions extends UserWorkspaceConfig {
-    workspaceConfigPath: string;
+    configFile: string | false;
     extends?: string;
 }
 
@@ -2698,7 +2618,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;
@@ -2707,6 +2627,11 @@ interface ProcessPool {
 }
 declare function getFilePoolName(project: TestProject, file: string): Pool;
 
+interface TestRunResult {
+    testModules: TestModule[];
+    unhandledErrors: unknown[];
+}
+
 interface SuiteResultCache {
     failed: boolean;
     duration: number;
@@ -2731,7 +2656,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;
 }
@@ -2794,122 +2719,261 @@ 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[]>;
-    /** @private */
-    _browserLastPort: number;
     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;
-    private getWorkspaceConfigPath;
+    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;
+    /**
+     * 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, 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 BrowserBuiltinProvider as aa, type BrowserCommand as ab, type BrowserCommandContext as ac, type BrowserOrchestrator as ad, type BrowserProvider as ae, type BrowserProviderInitializationOptions as af, type BrowserProviderModule as ag, type BrowserProviderOptions as ah, type BrowserServer as ai, type BrowserServerState as aj, type BrowserServerStateContext as ak, type CDPSession as al, type ResolvedBrowserOptions as am, type ResolvedProjectConfig as an, type ResolveSnapshotPathHandler as ao, type ResolveSnapshotPathHandlerContext as ap, type TestRunResult 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 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 };