vitest 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/chunks/{reporters.d.CqR9-CDJ.d.ts → reporters.d.37tJQ2uV.d.ts}

@@ -1,13 +1,12 @@
-import { Task, CancelReason, TaskMeta, Suite, File, TestAnnotation, ImportDuration, TaskResultPack, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
-import { ParsedStack, Awaitable, TestError, SerializedError, Arrayable } from '@vitest/utils';
-import { P as ProvidedContext, U as UserConsoleLog, b as Awaitable$1, c as Arrayable$1, A as AfterSuiteRunMeta, L as LabelColor } from './environment.d.2fYMoz3o.js';
+import { CancelReason, TaskMeta, Suite, File, TestAnnotation, ImportDuration, Test, Task, TaskResultPack, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
+import { Awaitable, ParsedStack, TestError, SerializedError, Arrayable as Arrayable$1 } from '@vitest/utils';
+import { P as ProvidedContext, c as Arrayable, A as AfterSuiteRunMeta, U as UserConsoleLog, b as Awaitable$1, L as LabelColor } from './environment.d.2fYMoz3o.js';
 import { Writable } from 'node:stream';
-import { ViteDevServer, ModuleNode, TransformResult as TransformResult$1, DepOptimizationConfig, ServerOptions, UserConfig as UserConfig$1, ConfigEnv, AliasOptions } from 'vite';
-import { Console } from 'node:console';
-import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.Cawq_X_N.js';
+import { ViteDevServer, TransformResult as TransformResult$1, DepOptimizationConfig, ServerOptions, UserConfig as UserConfig$1, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
-import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.CKNVOKm0.js';
+import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.DOMmqJQx.js';
+import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d._GBBbReY.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -17,6 +16,7 @@ import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
 import { a as RuntimeCoverageProviderModule } from './coverage.d.BZtK59WP.js';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { Stats } from 'node:fs';
+import { Console } from 'node:console';
 
 type ChaiConfig = Omit<Partial<typeof chai.config>, "useProxy" | "proxyExcludedKeys">;
 
@@ -69,53 +69,6 @@ interface ConstructorOptionsOverride {
 	resources?: "usable";
 }
 
-declare class TypeCheckError extends Error {
-	message: string;
-	stacks: ParsedStack[];
-	name: string;
-	constructor(message: string, stacks: ParsedStack[]);
-}
-
-interface ErrorOptions {
-	type?: string;
-	fullStack?: boolean;
-	project?: TestProject;
-	verbose?: boolean;
-	screenshotPaths?: string[];
-	task?: Task;
-	showCodeFrame?: boolean;
-}
-type Listener = () => void;
-declare class Logger {
-	ctx: Vitest;
-	outputStream: NodeJS.WriteStream | Writable;
-	errorStream: NodeJS.WriteStream | Writable;
-	private _clearScreenPending;
-	private _highlights;
-	private cleanupListeners;
-	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): void;
-	deprecate(message: string): void;
-	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;
-	getColumns(): number;
-	onTerminalCleanup(listener: Listener): void;
-	private addCleanupListeners;
-	private registerUnhandledRejection;
-}
-
 interface BrowserProviderInitializationOptions {
 	browser: string;
 	options?: BrowserProviderOptions;
@@ -262,11 +215,6 @@ interface BrowserConfigOptions {
 	*/
 	screenshotFailures?: boolean;
 	/**
-	* Scripts injected into the tester iframe.
-	* @deprecated Will be removed in the future, use `testerHtmlPath` instead.
-	*/
-	testerScripts?: BrowserScript[];
-	/**
 	* Path to the index.html file that will be used to run tests.
 	*/
 	testerHtmlPath?: string;
@@ -296,6 +244,15 @@ interface BrowserConfigOptions {
 			comparatorOptions?: ToMatchScreenshotComparators[ComparatorName];
 		} }[keyof ToMatchScreenshotComparators] & ToMatchScreenshotOptions;
 	};
+	/**
+	* Enables tracking uncaught errors and exceptions so they can be reported by Vitest.
+	*
+	* If you need to hide certain errors, it is recommended to use [`onUnhandledError`](https://vitest.dev/config/#onunhandlederror) option instead.
+	*
+	* Disabling this will completely remove all Vitest error handlers, which can help debugging with the "Pause on exceptions" checkbox turned on.
+	* @default true
+	*/
+	trackUnhandledErrors?: boolean;
 }
 interface BrowserCommandContext {
 	testPath: string | undefined;
@@ -463,129 +420,400 @@ interface ToMatchScreenshotOptions {
 }
 interface ToMatchScreenshotComparators {}
 
-declare class ReportedTaskImplementation {
-	/**
-	* The project associated with the test or suite.
-	*/
-	readonly project: TestProject;
+type BuiltinPool = "browser" | "threads" | "forks" | "vmThreads" | "vmForks" | "typescript";
+type Pool = BuiltinPool | (string & {});
+interface PoolOptions extends Record<string, unknown> {
 	/**
-	* 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 order.
+	* 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.
 	*/
-	readonly id: string;
+	threads?: ThreadsOptions & WorkerContextOptions;
 	/**
-	* Location in the module where the test or suite is defined.
+	* 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.
 	*/
-	readonly location: {
-		line: number;
-		column: number;
-	} | undefined;
+	forks?: ForksOptions & WorkerContextOptions;
 	/**
-	* Checks if the test did not fail the suite.
-	* If the test is not finished yet or was skipped, it will return `true`.
+	* 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.
 	*/
-	ok(): boolean;
+	vmThreads?: ThreadsOptions & VmOptions;
 	/**
-	* Custom metadata that was attached to the test during its execution.
+	* 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.
 	*/
-	meta(): TaskMeta;
+	vmForks?: ForksOptions & VmOptions;
 }
-declare class TestCase extends ReportedTaskImplementation {
-	#private;
-	readonly type = "test";
-	/**
-	* Direct reference to the test module where the test or suite is defined.
-	*/
-	readonly module: TestModule;
+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;
 	/**
-	* Name of the test.
+	* Run tests inside a single thread.
+	*
+	* @default false
 	*/
-	readonly name: string;
+	singleThread?: boolean;
 	/**
-	* Options that the test was initiated with.
+	* Use Atomics to synchronize threads
+	*
+	* This can improve performance in some cases, but might cause segfault in older Node versions.
+	*
+	* @default false
 	*/
-	readonly options: TaskOptions;
+	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;
 	/**
-	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
+	* Run tests inside a single fork.
+	*
+	* @default false
 	*/
-	readonly parent: TestSuite | TestModule;
+	singleFork?: boolean;
+}
+interface ResolvedForksOptions extends ForksOptions {
+	minForks?: number;
+	maxForks?: number;
+}
+interface WorkerContextOptions {
 	/**
-	* Full name of the test including all parent suites separated with `>`.
+	* Isolate test environment by recycling `worker_threads` or `child_process` after each test
+	*
+	* @default true
 	*/
-	get fullName(): string;
+	isolate?: boolean;
 	/**
-	* Test results.
-	* - **pending**: Test was collected, but didn't finish running yet.
-	* - **passed**: Test passed successfully
-	* - **failed**: Test failed to execute
-	* - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
+	* 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
 	*/
-	result(): TestResult;
+	execArgv?: string[];
+}
+interface VmOptions {
 	/**
-	* Test annotations added via the `task.annotate` API during the test execution.
+	* Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
+	* If you see memory leaks, try to tinker this value.
 	*/
-	annotations(): ReadonlyArray<TestAnnotation>;
+	memoryLimit?: string | number;
+	/** Isolation is always enabled */
+	isolate?: true;
 	/**
-	* Useful information about the test like duration, memory usage, etc.
-	* Diagnostic is only available after the test has finished.
+	* 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
 	*/
-	diagnostic(): TestDiagnostic | undefined;
+	execArgv?: string[];
 }
-declare class TestCollection {
-	#private;
-	constructor(task: Suite | File, project: TestProject);
-	/**
-	* Returns the test or suite at a specific index.
-	*/
-	at(index: number): TestCase | TestSuite | undefined;
+
+declare class TestSpecification {
 	/**
-	* The number of tests and suites in the collection.
+	* The task ID associated with the test module.
 	*/
-	get size(): number;
+	readonly taskId: string;
 	/**
-	* Returns the collection in array form for easier manipulation.
+	* The test project that the module belongs to.
 	*/
-	array(): (TestCase | TestSuite)[];
+	readonly project: TestProject;
 	/**
-	* Filters all tests that are part of this collection and its children.
+	* The ID of the module in the Vite module graph. It is usually an absolute file path.
 	*/
-	allTests(state?: TestState): Generator<TestCase, undefined, void>;
+	readonly moduleId: string;
 	/**
-	* Filters only the tests that are part of this collection.
+	* 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.
 	*/
-	tests(state?: TestState): Generator<TestCase, undefined, void>;
+	readonly pool: Pool;
 	/**
-	* Filters only the suites that are part of this collection.
+	* Line numbers of the test locations to run.
 	*/
-	suites(): Generator<TestSuite, undefined, void>;
+	readonly testLines: number[] | undefined;
+	constructor(project: TestProject, moduleId: string, pool: Pool, testLines?: number[] | undefined);
 	/**
-	* Filters all suites that are part of this collection and its children.
+	* Test module associated with the specification.
 	*/
-	allSuites(): Generator<TestSuite, undefined, void>;
-	[Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
+	get testModule(): TestModule | undefined;
+	toJSON(): SerializedTestSpecification;
 }
 
-type ReportedHookContext = {
-	readonly name: "beforeAll" | "afterAll";
-	readonly entity: TestSuite | TestModule;
-} | {
-	readonly name: "beforeEach" | "afterEach";
-	readonly entity: TestCase;
-};
-declare abstract class SuiteImplementation extends ReportedTaskImplementation {
+declare class TestProject {
+	options?: Vitest;
 	/**
-	* Collection of suites and tests that are part of this suite.
+	* The global Vitest instance.
+	* @experimental The public Vitest API is experimental and does not follow semver.
 	*/
-	readonly children: TestCollection;
+	readonly vitest: Vitest;
 	/**
-	* Errors that happened outside of the test run during collection, like syntax errors.
+	* Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
 	*/
-	errors(): SerializedError[];
-}
-declare class TestSuite extends SuiteImplementation {
-	#private;
-	readonly type = "suite";
+	readonly globalConfig: ResolvedConfig;
+	/**
+	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
+	*/
+	browser?: ProjectBrowser;
+	/**
+	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
+	*/
+	readonly tmpDir: string;
+	/** @inetrnal */ testFilesList: string[] | null;
+	private runner;
+	private closingPromise;
+	private typecheckFilesList;
+	private _globalSetups?;
+	private _provided;
+	constructor(vitest: Vitest, options?: InitializeProjectOptions | undefined);
+	/**
+	* The unique hash of this project. This value is consistent between the reruns.
+	*
+	* It is based on the root of the project (not consistent between OS) and its name.
+	*/
+	get hash(): string;
+	// "provide" is a property, not a method to keep the context when destructed in the global setup,
+	// making it a method would be a breaking change, and can be done in Vitest 3 at minimum
+	/**
+	* 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 the provided context. The project context is merged with the global context.
+	*/
+	getProvidedContext(): ProvidedContext;
+	/**
+	* Creates a new test specification. Specifications describe how to run tests.
+	* @param moduleId The file path
+	*/
+	createSpecification(moduleId: string, locations?: number[] | undefined, pool?: string): TestSpecification;
+	toJSON(): SerializedTestProject;
+	/**
+	* Vite's dev server instance. Every workspace project has its own server.
+	*/
+	get vite(): ViteDevServer;
+	/**
+	* Resolved project configuration.
+	*/
+	get config(): ResolvedConfig;
+	/**
+	* The name of the project or an empty string if not set.
+	*/
+	get name(): string;
+	/**
+	* The color used when reporting tasks of this project.
+	*/
+	get color(): ProjectName["color"];
+	/**
+	* Serialized project configuration. This is the config that tests receive.
+	*/
+	get serializedConfig(): SerializedConfig;
+	/**
+	* Check if this is the root project. The root project is the one that has the root config.
+	*/
+	isRootProject(): boolean;
+	onTestsRerun(cb: OnTestsRerunHandler): void;
+	/**
+	* Get all files in the project that match the globs in the config and the filters.
+	* @param filters String filters to match the test files.
+	*/
+	globTestFiles(filters?: string[]): Promise<{
+		/**
+		* Test files that match the filters.
+		*/
+		testFiles: string[];
+		/**
+		* Typecheck test files that match the filters. This will be empty unless `typecheck.enabled` is `true`.
+		*/
+		typecheckTestFiles: string[];
+	}>;
+	private globAllTestFiles;
+	isBrowserEnabled(): boolean;
+	private markTestFile;
+	/**
+	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
+	*/
+	matchesTestGlob(moduleId: string, source?: () => string): boolean;
+	private isInSourceTestCode;
+	private filterFiles;
+	private _parentBrowser?;
+	/**
+	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
+	* 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>;
+	private _setHash;
+	private _serializeOverriddenConfig;
+	private clearTmpDir;
+}
+interface SerializedTestProject {
+	name: string;
+	serializedConfig: SerializedConfig;
+	context: ProvidedContext;
+}
+interface InitializeProjectOptions extends TestProjectInlineConfiguration {
+	configFile: string | false;
+}
+
+declare class ReportedTaskImplementation {
+	/**
+	* The project associated with the test or suite.
+	*/
+	readonly project: TestProject;
+	/**
+	* Unique identifier.
+	* This ID is deterministic and will be the same for the same test across multiple runs.
+	* The ID is based on the project name, module url and test order.
+	*/
+	readonly id: string;
+	/**
+	* Location in the module where the test or suite is defined.
+	*/
+	readonly location: {
+		line: number;
+		column: number;
+	} | undefined;
+	/**
+	* Checks if the test did not fail the suite.
+	* If the test is not finished yet or was skipped, it will return `true`.
+	*/
+	ok(): boolean;
+	/**
+	* Custom metadata that was attached to the test during its execution.
+	*/
+	meta(): TaskMeta;
+}
+declare class TestCase extends ReportedTaskImplementation {
+	#private;
+	readonly type = "test";
+	/**
+	* Direct reference to the test module where the test or suite is defined.
+	*/
+	readonly module: TestModule;
+	/**
+	* Name of the test.
+	*/
+	readonly name: string;
+	/**
+	* Options that the test was initiated with.
+	*/
+	readonly options: TaskOptions;
+	/**
+	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
+	*/
+	readonly parent: TestSuite | TestModule;
+	/**
+	* Full name of the test including all parent suites separated with `>`.
+	*/
+	get fullName(): string;
+	/**
+	* Test results.
+	* - **pending**: Test was collected, but didn't finish running yet.
+	* - **passed**: Test passed successfully
+	* - **failed**: Test failed to execute
+	* - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
+	*/
+	result(): TestResult;
+	/**
+	* Test annotations added via the `task.annotate` API during the test execution.
+	*/
+	annotations(): ReadonlyArray<TestAnnotation>;
+	/**
+	* Useful information about the test like duration, memory usage, etc.
+	* Diagnostic is only available after the test has finished.
+	*/
+	diagnostic(): TestDiagnostic | undefined;
+}
+declare class TestCollection {
+	#private;
+	constructor(task: Suite | File, project: TestProject);
+	/**
+	* Returns the test or suite at a specific index.
+	*/
+	at(index: number): TestCase | TestSuite | undefined;
+	/**
+	* The number of tests and suites in the collection.
+	*/
+	get size(): number;
+	/**
+	* Returns the collection in array form for easier manipulation.
+	*/
+	array(): (TestCase | TestSuite)[];
+	/**
+	* Filters all tests that are part of this collection and its children.
+	*/
+	allTests(state?: TestState): Generator<TestCase, undefined, void>;
+	/**
+	* Filters only the tests that are part of this collection.
+	*/
+	tests(state?: TestState): Generator<TestCase, undefined, void>;
+	/**
+	* Filters only the suites that are part of this collection.
+	*/
+	suites(): Generator<TestSuite, undefined, void>;
+	/**
+	* Filters all suites that are part of this collection and its children.
+	*/
+	allSuites(): Generator<TestSuite, undefined, void>;
+	[Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
+}
+
+type ReportedHookContext = {
+	readonly name: "beforeAll" | "afterAll";
+	readonly entity: TestSuite | TestModule;
+} | {
+	readonly name: "beforeEach" | "afterEach";
+	readonly entity: TestCase;
+};
+declare abstract class SuiteImplementation extends ReportedTaskImplementation {
+	/**
+	* Collection of suites and tests that are part of this suite.
+	*/
+	readonly children: TestCollection;
+	/**
+	* Errors that happened outside of the test run during collection, like syntax errors.
+	*/
+	errors(): SerializedError[];
+}
+declare class TestSuite extends SuiteImplementation {
+	#private;
+	readonly type = "suite";
 	/**
 	* Name of the test or the suite.
 	*/
@@ -772,347 +1000,395 @@ interface ModuleDiagnostic {
 	*/
 	readonly importDurations: Record<string, ImportDuration>;
 }
+declare function experimental_getRunnerTask(entity: TestCase): Test;
+declare function experimental_getRunnerTask(entity: TestSuite): Suite;
+declare function experimental_getRunnerTask(entity: TestModule): File;
+declare function experimental_getRunnerTask(entity: TestCase | TestSuite | TestModule): Suite | File | Test;
 
-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 CoverageSummaryData {
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
 }
-interface ResolvedPoolOptions extends PoolOptions {
-	threads?: ResolvedThreadsOptions & WorkerContextOptions;
-	forks?: ResolvedForksOptions & WorkerContextOptions;
-	vmThreads?: ResolvedThreadsOptions & VmOptions;
-	vmForks?: ResolvedForksOptions & VmOptions;
+
+declare class CoverageSummary {
+    constructor(data: CoverageSummary | CoverageSummaryData);
+    merge(obj: CoverageSummary): CoverageSummary;
+    toJSON(): CoverageSummaryData;
+    isEmpty(): boolean;
+    data: CoverageSummaryData;
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
 }
-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 CoverageMapData {
+    [key: string]: FileCoverage | FileCoverageData;
 }
-interface ResolvedThreadsOptions extends ThreadsOptions {
-	minThreads?: number;
-	maxThreads?: number;
+
+declare class CoverageMap {
+    constructor(data: CoverageMapData | CoverageMap);
+    addFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): void;
+    files(): string[];
+    fileCoverageFor(filename: string): FileCoverage;
+    filter(callback: (key: string) => boolean): void;
+    getCoverageSummary(): CoverageSummary;
+    merge(data: CoverageMapData | CoverageMap): void;
+    toJSON(): CoverageMapData;
+    data: CoverageMapData;
 }
-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 Location {
+    line: number;
+    column: number;
 }
-interface ResolvedForksOptions extends ForksOptions {
-	minForks?: number;
-	maxForks?: number;
+
+interface Range {
+    start: Location;
+    end: Location;
 }
-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 BranchMapping {
+    loc: Range;
+    type: string;
+    locations: Range[];
+    line: number;
 }
-interface VmOptions {
-	/**
-	* Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
-	* If you see memory leaks, try to tinker this value.
-	*/
-	memoryLimit?: string | number;
-	/** Isolation is always enabled */
-	isolate?: true;
-	/**
-	* Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
-	*
-	* See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
-	*
-	* Set to `process.execArgv` to pass all arguments of the current process.
-	*
-	* Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
-	*
-	* @default [] // no execution arguments are passed
-	*/
-	execArgv?: string[];
+
+interface FunctionMapping {
+    name: string;
+    decl: Range;
+    loc: Range;
+    line: number;
 }
 
-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 task ID associated with the test module.
-	*/
-	readonly taskId: string;
-	/**
-	* 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);
-	/**
-	* Test module associated with the specification.
-	*/
-	get testModule(): TestModule | undefined;
-	toJSON(): SerializedTestSpecification;
-	/**
-	* for backwards compatibility
-	* @deprecated
-	*/
-	[Symbol.iterator](): Generator<string | TestProject, void, unknown>;
+interface FileCoverageData {
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
 }
 
-declare class TestProject {
-	/** @deprecated */
-	path: string | number;
-	options?: Vitest;
-	/**
-	* The global Vitest instance.
-	* @experimental The public Vitest API is experimental and does not follow semver.
-	*/
-	readonly vitest: Vitest;
+interface Totals {
+    total: number;
+    covered: number;
+    skipped: number;
+    pct: number;
+}
+
+interface Coverage {
+    covered: number;
+    total: number;
+    coverage: number;
+}
+
+declare class FileCoverage implements FileCoverageData {
+    constructor(data: string | FileCoverage | FileCoverageData);
+    merge(other: FileCoverageData): void;
+    getBranchCoverageByLine(): { [line: number]: Coverage };
+    getLineCoverage(): { [line: number]: number };
+    getUncoveredLines(): number[];
+    resetHits(): void;
+    computeBranchTotals(): Totals;
+    computeSimpleTotals(): Totals;
+    toSummary(): CoverageSummary;
+    toJSON(): object;
+
+    data: FileCoverageData;
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+interface Node {
+    isRoot(): boolean;
+    visit(visitor: Visitor, state: any): void;
+}
+
+interface Visitor<N extends Node = Node> {
+    onStart(root: N, state: any): void;
+    onSummary(root: N, state: any): void;
+    onDetail(root: N, state: any): void;
+    onSummaryEnd(root: N, state: any): void;
+    onEnd(root: N, state: any): void;
+}
+
+interface FileOptions {
+    file: string;
+}
+
+interface ProjectOptions {
+    projectRoot: string;
+}
+
+interface ReportOptions {
+    clover: CloverOptions;
+    cobertura: CoberturaOptions;
+    "html-spa": HtmlSpaOptions;
+    html: HtmlOptions;
+    json: JsonOptions$1;
+    "json-summary": JsonSummaryOptions;
+    lcov: LcovOptions;
+    lcovonly: LcovOnlyOptions;
+    none: never;
+    teamcity: TeamcityOptions;
+    text: TextOptions;
+    "text-lcov": TextLcovOptions;
+    "text-summary": TextSummaryOptions;
+}
+
+interface CloverOptions extends FileOptions, ProjectOptions {}
+
+interface CoberturaOptions extends FileOptions, ProjectOptions {}
+
+interface HtmlSpaOptions extends HtmlOptions {
+    metricsToShow: Array<"lines" | "branches" | "functions" | "statements">;
+}
+interface HtmlOptions {
+    verbose: boolean;
+    skipEmpty: boolean;
+    subdir: string;
+    linkMapper: LinkMapper;
+}
+
+type JsonOptions$1 = FileOptions;
+type JsonSummaryOptions = FileOptions;
+
+interface LcovOptions extends FileOptions, ProjectOptions {}
+interface LcovOnlyOptions extends FileOptions, ProjectOptions {}
+
+interface TeamcityOptions extends FileOptions {
+    blockName: string;
+}
+
+interface TextOptions extends FileOptions {
+    maxCols: number;
+    skipEmpty: boolean;
+    skipFull: boolean;
+}
+type TextLcovOptions = ProjectOptions;
+type TextSummaryOptions = FileOptions;
+
+interface LinkMapper {
+    getPath(node: string | Node): string;
+    relativePath(source: string | Node, target: string | Node): string;
+    assetPath(node: Node, name: string): string;
+}
+
+type TransformResult = string | Partial<TransformResult$1> | undefined | null | void;
+type CoverageResults = unknown;
+interface CoverageProvider {
+	name: string;
+	/** Called when provider is being initialized before tests run */
+	initialize: (ctx: Vitest) => Promise<void> | void;
+	/** Called when setting coverage options for Vitest context (`ctx.config.coverage`) */
+	resolveOptions: () => ResolvedCoverageOptions;
+	/** Callback to clean previous reports */
+	clean: (clean?: boolean) => void | Promise<void>;
+	/** Called with coverage results after a single test file has been run */
+	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void | Promise<void>;
+	/** Callback called when test run fails */
+	onTestFailure?: () => void | Promise<void>;
+	/** Callback to generate final coverage results */
+	generateCoverage: (reportContext: ReportContext) => CoverageResults | Promise<CoverageResults>;
+	/** Callback to convert coverage results to coverage reports. Called with results returned from `generateCoverage` */
+	reportCoverage: (coverage: CoverageResults, reportContext: ReportContext) => void | Promise<void>;
+	/** Callback for `--merge-reports` options. Called with multiple coverage results generated by `generateCoverage`. */
+	mergeReports?: (coverages: CoverageResults[]) => void | Promise<void>;
+	/** Callback called for instrumenting files with coverage counters. */
+	onFileTransform?: (sourceCode: string, id: string, pluginCtx: any) => TransformResult | Promise<TransformResult>;
+	/** Callback that's called when the coverage is enabled via a programmatic `enableCoverage` API. */
+	onEnabled?: () => void | Promise<void>;
+}
+interface ReportContext {
+	/** Indicates whether all tests were run. False when only specific tests were run. */
+	allTestsRun?: boolean;
+}
+interface CoverageProviderModule extends RuntimeCoverageProviderModule {
 	/**
-	* Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
+	* Factory for creating a new coverage provider
 	*/
-	readonly globalConfig: ResolvedConfig;
+	getProvider: () => CoverageProvider | Promise<CoverageProvider>;
+}
+type CoverageReporter = keyof ReportOptions | (string & {});
+type CoverageReporterWithOptions<ReporterName extends CoverageReporter = CoverageReporter> = ReporterName extends keyof ReportOptions ? ReportOptions[ReporterName] extends never ? [ReporterName, object] : [ReporterName, Partial<ReportOptions[ReporterName]>] : [ReporterName, Record<string, unknown>];
+type CoverageProviderName = "v8" | "istanbul" | "custom" | undefined;
+type CoverageOptions<T extends CoverageProviderName = CoverageProviderName> = T extends "istanbul" ? {
+	provider: T;
+} & CoverageIstanbulOptions : T extends "v8" ? {
 	/**
-	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
+	* Provider to use for coverage collection.
+	*
+	* @default 'v8'
 	*/
-	browser?: ProjectBrowser;
-	/** @deprecated use `vitest` instead */
-	ctx: Vitest;
+	provider: T;
+} & CoverageV8Options : T extends "custom" ? {
+	provider: T;
+} & CustomProviderOptions : {
+	provider?: T;
+} & CoverageV8Options;
+/** Fields that have default values. Internally these will always be defined. */
+type FieldsWithDefaultValues = "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "exclude" | "reportOnFailure" | "allowExternal" | "processingConcurrency";
+type ResolvedCoverageOptions<T extends CoverageProviderName = CoverageProviderName> = CoverageOptions<T> & Required<Pick<CoverageOptions<T>, FieldsWithDefaultValues>> & {
+	reporter: CoverageReporterWithOptions[];
+};
+interface BaseCoverageOptions {
 	/**
-	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
+	* Enables coverage collection. Can be overridden using `--coverage` CLI option.
+	*
+	* @default false
 	*/
-	readonly tmpDir: string;
-	private runner;
-	private closingPromise;
-	private testFilesList;
-	private typecheckFilesList;
-	private _globalSetups?;
-	private _provided;
-	constructor(path: string | number, vitest: Vitest, options?: InitializeProjectOptions | undefined);
+	enabled?: boolean;
 	/**
-	* The unique hash of this project. This value is consistent between the reruns.
+	* List of files included in coverage as glob patterns.
+	* By default only files covered by tests are included.
 	*
-	* It is based on the root of the project (not consistent between OS) and its name.
+	* See [Including and excluding files from coverage report](https://vitest.dev/guide/coverage.html#including-and-excluding-files-from-coverage-report) for examples.
 	*/
-	get hash(): string;
-	// "provide" is a property, not a method to keep the context when destructed in the global setup,
-	// making it a method would be a breaking change, and can be done in Vitest 3 at minimum
+	include?: string[];
 	/**
-	* Provide a value to the test context. This value will be available to all tests with `inject`.
+	* List of files excluded from coverage as glob patterns.
+	* Files are first checked against `coverage.include`.
+	*
+	* See [Including and excluding files from coverage report](https://vitest.dev/guide/coverage.html#including-and-excluding-files-from-coverage-report) for examples.
 	*/
-	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
+	exclude?: string[];
 	/**
-	* Get the provided context. The project context is merged with the global context.
+	* Clean coverage results before running tests
+	*
+	* @default true
 	*/
-	getProvidedContext(): ProvidedContext;
+	clean?: boolean;
 	/**
-	* Creates a new test specification. Specifications describe how to run tests.
-	* @param moduleId The file path
+	* Clean coverage report on watch rerun
+	*
+	* @default true
 	*/
-	createSpecification(moduleId: string, locations?: number[] | undefined, pool?: string): TestSpecification;
-	toJSON(): SerializedTestProject;
+	cleanOnRerun?: boolean;
 	/**
-	* Vite's dev server instance. Every workspace project has its own server.
+	* Directory to write coverage report to
+	*
+	* @default './coverage'
 	*/
-	get vite(): ViteDevServer;
+	reportsDirectory?: string;
 	/**
-	* Resolved project configuration.
+	* Coverage reporters to use.
+	* See [istanbul documentation](https://istanbul.js.org/docs/advanced/alternative-reporters/) for detailed list of all reporters.
+	*
+	* @default ['text', 'html', 'clover', 'json']
 	*/
-	get config(): ResolvedConfig;
+	reporter?: Arrayable<CoverageReporter> | (CoverageReporter | [CoverageReporter] | CoverageReporterWithOptions)[];
 	/**
-	* The name of the project or an empty string if not set.
+	* Do not show files with 100% statement, branch, and function coverage
+	*
+	* @default false
 	*/
-	get name(): string;
+	skipFull?: boolean;
 	/**
-	* The color used when reporting tasks of this project.
+	* Configurations for thresholds
+	*
+	* @example
+	*
+	* ```ts
+	* {
+	*   // Thresholds for all files
+	*   functions: 95,
+	*   branches: 70,
+	*   perFile: true,
+	*   autoUpdate: true,
+	*
+	*   // Thresholds for utilities
+	*   'src/utils/**.ts': {
+	*     lines: 100,
+	*     statements: 95,
+	*   }
+	* }
+	* ```
 	*/
-	get color(): ProjectName["color"];
+	thresholds?: Thresholds | ({
+		[glob: string]: Pick<Thresholds, 100 | "statements" | "functions" | "branches" | "lines">;
+	} & Thresholds);
 	/**
-	* Serialized project configuration. This is the config that tests receive.
+	* Watermarks for statements, lines, branches and functions.
+	*
+	* Default value is `[50,80]` for each property.
 	*/
-	get serializedConfig(): SerializedConfig;
-	/** @deprecated use `vite` instead */
-	get server(): ViteDevServer;
+	watermarks?: {
+		statements?: [number, number];
+		functions?: [number, number];
+		branches?: [number, number];
+		lines?: [number, number];
+	};
 	/**
-	* Check if this is the root project. The root project is the one that has the root config.
+	* Generate coverage report even when tests fail.
+	*
+	* @default false
 	*/
-	isRootProject(): boolean;
-	/** @deprecated use `isRootProject` instead */
-	isCore(): boolean;
-	/** @deprecated use `createSpecification` instead */
-	createSpec(moduleId: string, pool: string): WorkspaceSpec;
-	/** @deprecated */
-	initializeGlobalSetup(): Promise<void>;
-	onTestsRerun(cb: OnTestsRerunHandler): void;
-	/** @deprecated */
-	teardownGlobalSetup(): Promise<void>;
-	/** @deprecated use `vitest.logger` instead */
-	get logger(): Logger;
-	// it's possible that file path was imported with different queries (?raw, ?url, etc)
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getModulesByFilepath(file: string): Set<ModuleNode>;
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getModuleById(id: string): ModuleNode | undefined;
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getSourceMapModuleById(id: string): TransformResult$1["map"] | undefined;
-	/** @deprecated use `vitest.reporters` instead */
-	get reporters(): Reporter[];
+	reportOnFailure?: boolean;
 	/**
-	* Get all files in the project that match the globs in the config and the filters.
-	* @param filters String filters to match the test files.
+	* Collect coverage of files outside the project `root`.
+	*
+	* @default false
 	*/
-	globTestFiles(filters?: string[]): Promise<{
-		/**
-		* Test files that match the filters.
-		*/
-		testFiles: string[];
-		/**
-		* Typecheck test files that match the filters. This will be empty unless `typecheck.enabled` is `true`.
-		*/
-		typecheckTestFiles: string[];
-	}>;
-	private globAllTestFiles;
-	isBrowserEnabled(): boolean;
-	private markTestFile;
-	/** @deprecated use `serializedConfig` instead */
-	getSerializableConfig(): SerializedConfig;
+	allowExternal?: boolean;
 	/**
-	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
+	* 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
 	*/
-	matchesTestGlob(moduleId: string, source?: () => string): boolean;
-	/** @deprecated use `matchesTestGlob` instead */
-	isTargetFile(id: string, source?: string): Promise<boolean>;
-	private isInSourceTestCode;
-	private filterFiles;
-	private _parentBrowser?;
+	excludeAfterRemap?: boolean;
 	/**
-	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
-	* If the resources are needed again, create a new project.
+	* Concurrency limit used when processing the coverage results.
+	* Defaults to `Math.min(20, os.availableParallelism?.() ?? os.cpus().length)`
 	*/
-	close(): Promise<void>;
+	processingConcurrency?: number;
 	/**
-	* Import a file using Vite module runner.
-	* @param moduleId The ID of the module in Vite module graph
+	* Set to array of class method names to ignore for coverage
+	*
+	* @default []
 	*/
-	import<T>(moduleId: string): Promise<T>;
-	/** @deprecated use `name` instead */
-	getName(): string;
-	/** @deprecated internal */
-	setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
-	private _setHash;
-	private _serializeOverriddenConfig;
-	private clearTmpDir;
-	/** @deprecated */
-	initBrowserProvider(): Promise<void>;
-}
-
-interface SerializedTestProject {
-	name: string;
-	serializedConfig: SerializedConfig;
-	context: ProvidedContext;
+	ignoreClassMethods?: string[];
 }
-interface InitializeProjectOptions extends TestProjectInlineConfiguration {
-	configFile: string | false;
+interface CoverageIstanbulOptions extends BaseCoverageOptions {}
+interface CoverageV8Options extends BaseCoverageOptions {}
+interface CustomProviderOptions extends Pick<BaseCoverageOptions, FieldsWithDefaultValues> {
+	/** Name of the module or path to a file to load the custom provider from */
+	customProviderModule: string;
 }
-
-/**
-* @deprecated use TestSpecification instead
-*/
-type WorkspaceSpec = TestSpecification & [project: TestProject, file: string, options: {
-	pool: Pool;
-}];
-type RunWithFiles = (files: TestSpecification[], invalidates?: string[]) => Awaitable<void>;
-interface ProcessPool {
-	name: string;
-	runTests: RunWithFiles;
-	collectTests: RunWithFiles;
-	close?: () => Awaitable<void>;
+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;
 }
-declare function getFilePoolName(project: TestProject): Pool;
 
 interface TestRunResult {
 	testModules: TestModule[];
@@ -1159,6 +1435,53 @@ declare class VitestCache {
 	static resolveCacheDir(root: string, dir?: string, projectName?: string): string;
 }
 
+declare class TypeCheckError extends Error {
+	message: string;
+	stacks: ParsedStack[];
+	name: string;
+	constructor(message: string, stacks: ParsedStack[]);
+}
+
+interface ErrorOptions {
+	type?: string;
+	fullStack?: boolean;
+	project?: TestProject;
+	verbose?: boolean;
+	screenshotPaths?: string[];
+	task?: Task;
+	showCodeFrame?: boolean;
+}
+type Listener = () => void;
+declare class Logger {
+	ctx: Vitest;
+	outputStream: NodeJS.WriteStream | Writable;
+	errorStream: NodeJS.WriteStream | Writable;
+	private _clearScreenPending;
+	private _highlights;
+	private cleanupListeners;
+	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): void;
+	deprecate(message: string): void;
+	clearHighlightCache(filename?: string): void;
+	highlight(filename: string, source: string): string;
+	printNoTestFound(filters?: string[]): void;
+	printBanner(): void;
+	printBrowserBanner(project: TestProject): void;
+	printUnhandledErrors(errors: ReadonlyArray<unknown>): void;
+	printSourceTypeErrors(errors: TypeCheckError[]): void;
+	getColumns(): number;
+	onTerminalCleanup(listener: Listener): void;
+	private addCleanupListeners;
+	private registerUnhandledRejection;
+}
+
 declare class VitestPackageInstaller {
 	isPackageExists(name: string, options?: {
 		paths?: string[];
@@ -1224,6 +1547,36 @@ declare class StateManager {
 	cancelFiles(files: string[], project: TestProject): void;
 }
 
+declare class VitestWatcher {
+	private vitest;
+	/**
+	* Modules that will be invalidated on the next run.
+	*/
+	readonly invalidates: Set<string>;
+	/**
+	* Test files that have changed and need to be rerun.
+	*/
+	readonly changedTests: Set<string>;
+	private readonly _onRerun;
+	constructor(vitest: Vitest);
+	unregisterWatcher: () => void;
+	registerWatcher(): this;
+	private scheduleRerun;
+	private getTestFilesFromWatcherTrigger;
+	onFileChange: (id: string) => void;
+	onFileDelete: (id: string) => void;
+	onFileCreate: (id: string) => void;
+	private handleSetupFile;
+	/**
+	* @returns A value indicating whether rerun is needed (changedTests was mutated)
+	*/
+	private handleFileChanged;
+}
+interface WatcherTriggerPattern {
+	pattern: RegExp;
+	testsToRun: (file: string, match: RegExpMatchArray) => string[] | string | null | undefined | void;
+}
+
 interface VitestOptions {
 	packageInstaller?: VitestPackageInstaller;
 	stdin?: NodeJS.ReadStream;
@@ -1262,16 +1615,24 @@ declare class Vitest {
 	* If projects were filtered with `--project` flag, they won't appear here.
 	*/
 	projects: TestProject[];
+	/**
+	* A watcher handler. This is not the file system watcher. The handler only
+	* exposes methods to handle changed files.
+	*
+	* If you have your own watcher, you can use these methods to replicate
+	* Vitest behaviour.
+	*/
+	readonly watcher: VitestWatcher;
 	private isFirstRun;
 	private restartsCount;
 	private readonly specifications;
-	private readonly watcher;
 	private pool;
 	private _config?;
 	private _vite?;
 	private _state?;
 	private _cache?;
 	private _snapshot?;
+	private _coverageProvider?;
 	constructor(mode: VitestRunMode, cliOptions: UserConfig, options?: VitestOptions);
 	private _onRestartListeners;
 	private _onClose;
@@ -1279,16 +1640,10 @@ declare class Vitest {
 	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.
 	*/
@@ -1306,8 +1661,9 @@ declare class Vitest {
 	* 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): Promise<void>;
+	enableCoverage(): Promise<void>;
+	disableCoverage(): void;
+	private _coverageOverrideCache;
 	/**
 	* Inject new test projects into the workspace.
 	* @param config Glob, config path or a custom config options.
@@ -1322,22 +1678,20 @@ declare class Vitest {
 	* 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;
 	/**
 	* 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>;
+	/**
+	* Creates a coverage provider if `coverage` is enabled in the config.
+	*/
+	createCoverageProvider(): Promise<CoverageProvider | null>;
 	private resolveProjects;
 	/**
 	* Glob test files in every project and create a TestSpecification for each file and pool.
@@ -1350,8 +1704,6 @@ declare class Vitest {
 	*/
 	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
@@ -1372,11 +1724,10 @@ declare class Vitest {
 	*/
 	init(): Promise<void>;
 	/**
-	* @deprecated remove when vscode extension supports "getModuleSpecifications"
+	* If there is a test run happening, returns a promise that will
+	* resolve when the test run is finished.
 	*/
-	getProjectsByTestFile(file: string): WorkspaceSpec[];
-	/** @deprecated */
-	getFileWorkspaceSpecs(file: string): WorkspaceSpec[];
+	waitForTestRunEnd(): Promise<void>;
 	/**
 	* Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
 	*
@@ -1401,6 +1752,11 @@ declare class Vitest {
 	*/
 	rerunTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
 	private runFiles;
+	experimental_parseSpecifications(specifications: TestSpecification[], options?: {
+		/** @default os.availableParallelism() */
+		concurrency?: number;
+	}): Promise<TestModule[]>;
+	experimental_parseSpecification(specification: TestSpecification): Promise<TestModule>;
 	/**
 	* Collect tests in specified modules. Vitest will run the files to collect tests.
 	* @param specifications A list of specifications to run.
@@ -1438,14 +1794,11 @@ declare class Vitest {
 	*/
 	resetGlobalTestNamePattern(): void;
 	private _rerunTimer;
-	// we can't use a single `triggerId` yet because vscode extension relies on this
 	private scheduleRerun;
 	/**
 	* Invalidate a file in all projects.
 	*/
 	invalidateFile(filepath: string): void;
-	/** @deprecated use `invalidateFile` */
-	updateLastChanged(filepath: string): void;
 	private reportCoverage;
 	/**
 	* Closes all projects and their associated resources.
@@ -1458,16 +1811,6 @@ declare class Vitest {
 	*/
 	exit(force?: boolean): Promise<void>;
 	/**
-	* @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.
 	*/
 	shouldKeepServer(): boolean;
@@ -1573,182 +1916,78 @@ interface Reporter {
 	/**
 	* Called after the hook finished running.
 	*/
-	onHookEnd?: (hook: ReportedHookContext) => Awaitable$1<void>;
-	onCoverage?: (coverage: unknown) => Awaitable$1<void>;
-}
-
-interface BaseOptions {
-	isTTY?: boolean;
-}
-declare abstract class BaseReporter implements Reporter {
-	start: number;
-	end: number;
-	watchFilters?: string[];
-	failedUnwatchedFiles: TestModule[];
-	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;
-	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, _reason: TestRunEndReason): void;
-	onTestCaseResult(testCase: TestCase): void;
-	onTestSuiteResult(testSuite: TestSuite): void;
-	onTestModuleEnd(testModule: TestModule): void;
-	private logFailedTask;
-	protected printTestModule(testModule: TestModule): void;
-	protected printTestCase(moduleState: TestModuleState, test: TestCase): void;
-	private getModuleLog;
-	protected printTestSuite(_suite: TestSuite): void;
-	protected getTestName(test: Task, separator?: string): string;
-	protected getFullName(test: Task, separator?: string): string;
-	protected formatShortError(error: TestError): string;
-	protected getTestIndentation(_test: Task): string;
-	protected printAnnotations(test: TestCase, console: "log" | "error", padding?: number): void;
-	protected getDurationPrefix(task: Task): string;
-	onWatcherStart(files?: File[], errors?: unknown[]): void;
-	onWatcherRerun(files: string[], trigger?: string): void;
-	onUserConsoleLog(log: UserConsoleLog, taskState?: TestResult["state"]): void;
-	onTestRemoved(trigger?: string): void;
-	shouldLog(log: UserConsoleLog, taskState?: TestResult["state"]): 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 DefaultReporterOptions extends BaseOptions {
-	summary?: boolean;
-}
-declare class DefaultReporter extends BaseReporter {
-	private options;
-	private summary?;
-	constructor(options?: DefaultReporterOptions);
-	onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
-	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): void;
-	onTestModuleQueued(file: TestModule): void;
-	onTestModuleCollected(module: TestModule): void;
-	onTestModuleEnd(module: TestModule): void;
-	onTestCaseReady(test: TestCase): void;
-	onTestCaseResult(test: TestCase): void;
-	onHookStart(hook: ReportedHookContext): void;
-	onHookEnd(hook: ReportedHookContext): void;
-	onInit(ctx: Vitest): void;
-}
-
-interface HTMLOptions {
-	outputFile?: string;
-}
-
-interface CoverageSummaryData {
-    lines: Totals;
-    statements: Totals;
-    branches: Totals;
-    functions: Totals;
-}
-
-declare class CoverageSummary {
-    constructor(data: CoverageSummary | CoverageSummaryData);
-    merge(obj: CoverageSummary): CoverageSummary;
-    toJSON(): CoverageSummaryData;
-    isEmpty(): boolean;
-    data: CoverageSummaryData;
-    lines: Totals;
-    statements: Totals;
-    branches: Totals;
-    functions: Totals;
-}
-
-interface CoverageMapData {
-    [key: string]: FileCoverage | FileCoverageData;
-}
-
-declare class CoverageMap {
-    constructor(data: CoverageMapData | CoverageMap);
-    addFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): void;
-    files(): string[];
-    fileCoverageFor(filename: string): FileCoverage;
-    filter(callback: (key: string) => boolean): void;
-    getCoverageSummary(): CoverageSummary;
-    merge(data: CoverageMapData | CoverageMap): void;
-    toJSON(): CoverageMapData;
-    data: CoverageMapData;
-}
-
-interface Location {
-    line: number;
-    column: number;
-}
-
-interface Range {
-    start: Location;
-    end: Location;
-}
-
-interface BranchMapping {
-    loc: Range;
-    type: string;
-    locations: Range[];
-    line: number;
-}
-
-interface FunctionMapping {
-    name: string;
-    decl: Range;
-    loc: Range;
-    line: number;
-}
-
-interface FileCoverageData {
-    path: string;
-    statementMap: { [key: string]: Range };
-    fnMap: { [key: string]: FunctionMapping };
-    branchMap: { [key: string]: BranchMapping };
-    s: { [key: string]: number };
-    f: { [key: string]: number };
-    b: { [key: string]: number[] };
+	onHookEnd?: (hook: ReportedHookContext) => Awaitable$1<void>;
+	onCoverage?: (coverage: unknown) => Awaitable$1<void>;
 }
 
-interface Totals {
-    total: number;
-    covered: number;
-    skipped: number;
-    pct: number;
+interface BaseOptions {
+	isTTY?: boolean;
 }
-
-interface Coverage {
-    covered: number;
-    total: number;
-    coverage: number;
+declare abstract class BaseReporter implements Reporter {
+	start: number;
+	end: number;
+	watchFilters?: string[];
+	failedUnwatchedFiles: TestModule[];
+	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;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, _reason: TestRunEndReason): void;
+	onTestCaseResult(testCase: TestCase): void;
+	onTestSuiteResult(testSuite: TestSuite): void;
+	onTestModuleEnd(testModule: TestModule): void;
+	private logFailedTask;
+	protected printTestModule(testModule: TestModule): void;
+	protected printTestCase(moduleState: TestModuleState, test: TestCase): void;
+	private getModuleLog;
+	protected printTestSuite(_suite: TestSuite): void;
+	protected getTestName(test: Task, separator?: string): string;
+	protected getFullName(test: Task, separator?: string): string;
+	protected formatShortError(error: TestError): string;
+	protected getTestIndentation(_test: Task): string;
+	protected printAnnotations(test: TestCase, console: "log" | "error", padding?: number): void;
+	protected getDurationPrefix(task: Task): string;
+	onWatcherStart(files?: File[], errors?: unknown[]): void;
+	onWatcherRerun(files: string[], trigger?: string): void;
+	onUserConsoleLog(log: UserConsoleLog, taskState?: TestResult["state"]): void;
+	onTestRemoved(trigger?: string): void;
+	shouldLog(log: UserConsoleLog, taskState?: TestResult["state"]): 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;
 }
 
-declare class FileCoverage implements FileCoverageData {
-    constructor(data: string | FileCoverage | FileCoverageData);
-    merge(other: FileCoverageData): void;
-    getBranchCoverageByLine(): { [line: number]: Coverage };
-    getLineCoverage(): { [line: number]: number };
-    getUncoveredLines(): number[];
-    resetHits(): void;
-    computeBranchTotals(): Totals;
-    computeSimpleTotals(): Totals;
-    toSummary(): CoverageSummary;
-    toJSON(): object;
+interface DefaultReporterOptions extends BaseOptions {
+	summary?: boolean;
+}
+declare class DefaultReporter extends BaseReporter {
+	private options;
+	private summary?;
+	constructor(options?: DefaultReporterOptions);
+	onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): void;
+	onTestModuleQueued(file: TestModule): void;
+	onTestModuleCollected(module: TestModule): void;
+	onTestModuleEnd(module: TestModule): void;
+	onTestCaseReady(test: TestCase): void;
+	onTestCaseResult(test: TestCase): void;
+	onHookStart(hook: ReportedHookContext): void;
+	onHookEnd(hook: ReportedHookContext): void;
+	onInit(ctx: Vitest): void;
+}
 
-    data: FileCoverageData;
-    path: string;
-    statementMap: { [key: string]: Range };
-    fnMap: { [key: string]: FunctionMapping };
-    branchMap: { [key: string]: BranchMapping };
-    s: { [key: string]: number };
-    f: { [key: string]: number };
-    b: { [key: string]: number[] };
+interface HTMLOptions {
+	outputFile?: string;
 }
 
 // for compatibility reasons, the reporter produces a JSON similar to the one produced by the Jest JSON reporter
@@ -1794,15 +2033,15 @@ interface JsonTestResults {
 	snapshot: SnapshotSummary;
 	coverageMap?: CoverageMap | null | undefined;
 }
-interface JsonOptions$1 {
+interface JsonOptions {
 	outputFile?: string;
 }
 declare class JsonReporter implements Reporter {
 	start: number;
 	ctx: Vitest;
-	options: JsonOptions$1;
+	options: JsonOptions;
 	coverageMap?: CoverageMap;
-	constructor(options: JsonOptions$1);
+	constructor(options: JsonOptions);
 	onInit(ctx: Vitest): void;
 	onCoverage(coverageMap: unknown): void;
 	onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
@@ -1926,391 +2165,107 @@ declare function renderTable(options: {
 	compare?: Record<Task["id"], FormattedBenchmarkResult>;
 }): string;
 
-declare class BenchmarkReporter extends DefaultReporter {
-	compare?: Parameters<typeof renderTable>[0]["compare"];
-	onInit(ctx: Vitest): Promise<void>;
-	onTaskUpdate(packs: TaskResultPack[]): void;
-	onTestSuiteResult(testSuite: TestSuite): void;
-	protected printTestModule(testModule: TestModule): void;
-	private printSuiteTable;
-	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): Promise<void>;
-}
-
-declare class VerboseBenchmarkReporter extends BenchmarkReporter {
-	protected verbose: boolean;
-}
-
-declare const BenchmarkReportsMap: {
-	default: typeof BenchmarkReporter;
-	verbose: typeof VerboseBenchmarkReporter;
-};
-type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
-
-declare const ReportersMap: {
-	default: typeof DefaultReporter;
-	blob: typeof BlobReporter;
-	verbose: typeof VerboseReporter;
-	dot: typeof DotReporter;
-	json: typeof JsonReporter;
-	tap: typeof TapReporter;
-	"tap-flat": typeof TapFlatReporter;
-	junit: typeof JUnitReporter;
-	"hanging-process": typeof HangingProcessReporter;
-	"github-actions": typeof GithubActionsReporter;
-};
-type BuiltinReporters = keyof typeof ReportersMap;
-interface BuiltinReporterOptions {
-	"default": DefaultReporterOptions;
-	"verbose": DefaultReporterOptions;
-	"dot": BaseOptions;
-	"json": JsonOptions$1;
-	"blob": BlobOptions;
-	"tap": never;
-	"tap-flat": never;
-	"junit": JUnitOptions;
-	"hanging-process": never;
-	"html": HTMLOptions;
-}
-
-interface TestSequencer {
-	/**
-	* Slicing tests into shards. Will be run before `sort`.
-	* Only run, if `shard` is defined.
-	*/
-	shard: (files: TestSpecification[]) => Awaitable$1<TestSpecification[]>;
-	sort: (files: TestSpecification[]) => Awaitable$1<TestSpecification[]>;
-}
-interface TestSequencerConstructor {
-	new (ctx: Vitest): TestSequencer;
-}
-
-interface WatcherTriggerPattern {
-	pattern: RegExp;
-	testsToRun: (file: string, match: RegExpMatchArray) => string[] | string | null | undefined | void;
-}
-
-interface BenchmarkUserOptions {
-	/**
-	* Include globs for benchmark test files
-	*
-	* @default ['**\/*.{bench,benchmark}.?(c|m)[jt]s?(x)']
-	*/
-	include?: string[];
-	/**
-	* Exclude globs for benchmark test files
-	* @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
-	*/
-	exclude?: string[];
-	/**
-	* Include globs for in-source benchmark test files
-	*
-	* @default []
-	*/
-	includeSource?: string[];
-	/**
-	* Custom reporter for output. Can contain one or more built-in report names, reporter instances,
-	* and/or paths to custom reporters
-	*
-	* @default ['default']
-	*/
-	reporters?: Arrayable<BenchmarkBuiltinReporters | Reporter>;
-	/**
-	* @deprecated Use `benchmark.outputJson` instead
-	*/
-	outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
-	/**
-	* benchmark output file to compare against
-	*/
-	compare?: string;
-	/**
-	* benchmark output file
-	*/
-	outputJson?: string;
-	/**
-	* Include `samples` array of benchmark results for API or custom reporter usages.
-	* This is disabled by default to reduce memory usage.
-	* @default false
-	*/
-	includeSamples?: boolean;
-}
-
-interface Node {
-    isRoot(): boolean;
-    visit(visitor: Visitor, state: any): void;
-}
-
-interface Visitor<N extends Node = Node> {
-    onStart(root: N, state: any): void;
-    onSummary(root: N, state: any): void;
-    onDetail(root: N, state: any): void;
-    onSummaryEnd(root: N, state: any): void;
-    onEnd(root: N, state: any): void;
-}
-
-interface FileOptions {
-    file: string;
-}
-
-interface ProjectOptions {
-    projectRoot: string;
-}
-
-interface ReportOptions {
-    clover: CloverOptions;
-    cobertura: CoberturaOptions;
-    "html-spa": HtmlSpaOptions;
-    html: HtmlOptions;
-    json: JsonOptions;
-    "json-summary": JsonSummaryOptions;
-    lcov: LcovOptions;
-    lcovonly: LcovOnlyOptions;
-    none: never;
-    teamcity: TeamcityOptions;
-    text: TextOptions;
-    "text-lcov": TextLcovOptions;
-    "text-summary": TextSummaryOptions;
-}
-
-interface CloverOptions extends FileOptions, ProjectOptions {}
-
-interface CoberturaOptions extends FileOptions, ProjectOptions {}
-
-interface HtmlSpaOptions extends HtmlOptions {
-    metricsToShow: Array<"lines" | "branches" | "functions" | "statements">;
-}
-interface HtmlOptions {
-    verbose: boolean;
-    skipEmpty: boolean;
-    subdir: string;
-    linkMapper: LinkMapper;
-}
-
-type JsonOptions = FileOptions;
-type JsonSummaryOptions = FileOptions;
-
-interface LcovOptions extends FileOptions, ProjectOptions {}
-interface LcovOnlyOptions extends FileOptions, ProjectOptions {}
-
-interface TeamcityOptions extends FileOptions {
-    blockName: string;
+declare class BenchmarkReporter extends DefaultReporter {
+	compare?: Parameters<typeof renderTable>[0]["compare"];
+	onInit(ctx: Vitest): Promise<void>;
+	onTaskUpdate(packs: TaskResultPack[]): void;
+	onTestSuiteResult(testSuite: TestSuite): void;
+	protected printTestModule(testModule: TestModule): void;
+	private printSuiteTable;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): Promise<void>;
 }
 
-interface TextOptions extends FileOptions {
-    maxCols: number;
-    skipEmpty: boolean;
-    skipFull: boolean;
+declare class VerboseBenchmarkReporter extends BenchmarkReporter {
+	protected verbose: boolean;
 }
-type TextLcovOptions = ProjectOptions;
-type TextSummaryOptions = FileOptions;
 
-interface LinkMapper {
-    getPath(node: string | Node): string;
-    relativePath(source: string | Node, target: string | Node): string;
-    assetPath(node: Node, name: string): string;
-}
+declare const BenchmarkReportsMap: {
+	default: typeof BenchmarkReporter;
+	verbose: typeof VerboseBenchmarkReporter;
+};
+type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
 
-type TransformResult = string | Partial<TransformResult$1> | undefined | null | void;
-type CoverageResults = unknown;
-interface CoverageProvider {
-	name: string;
-	/** Called when provider is being initialized before tests run */
-	initialize: (ctx: Vitest) => Promise<void> | void;
-	/** Called when setting coverage options for Vitest context (`ctx.config.coverage`) */
-	resolveOptions: () => ResolvedCoverageOptions;
-	/** Callback to clean previous reports */
-	clean: (clean?: boolean) => void | Promise<void>;
-	/** Called with coverage results after a single test file has been run */
-	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void | Promise<void>;
-	/** Callback called when test run fails */
-	onTestFailure?: () => void | Promise<void>;
-	/** Callback to generate final coverage results */
-	generateCoverage: (reportContext: ReportContext) => CoverageResults | Promise<CoverageResults>;
-	/** Callback to convert coverage results to coverage reports. Called with results returned from `generateCoverage` */
-	reportCoverage: (coverage: CoverageResults, reportContext: ReportContext) => void | Promise<void>;
-	/** Callback for `--merge-reports` options. Called with multiple coverage results generated by `generateCoverage`. */
-	mergeReports?: (coverages: CoverageResults[]) => void | Promise<void>;
-	/** Callback called for instrumenting files with coverage counters. */
-	onFileTransform?: (sourceCode: string, id: string, pluginCtx: any) => TransformResult | Promise<TransformResult>;
-}
-interface ReportContext {
-	/** Indicates whether all tests were run. False when only specific tests were run. */
-	allTestsRun?: boolean;
+declare const ReportersMap: {
+	default: typeof DefaultReporter;
+	blob: typeof BlobReporter;
+	verbose: typeof VerboseReporter;
+	dot: typeof DotReporter;
+	json: typeof JsonReporter;
+	tap: typeof TapReporter;
+	"tap-flat": typeof TapFlatReporter;
+	junit: typeof JUnitReporter;
+	"hanging-process": typeof HangingProcessReporter;
+	"github-actions": typeof GithubActionsReporter;
+};
+type BuiltinReporters = keyof typeof ReportersMap;
+interface BuiltinReporterOptions {
+	"default": DefaultReporterOptions;
+	"verbose": DefaultReporterOptions;
+	"dot": BaseOptions;
+	"json": JsonOptions;
+	"blob": BlobOptions;
+	"tap": never;
+	"tap-flat": never;
+	"junit": JUnitOptions;
+	"hanging-process": never;
+	"html": HTMLOptions;
 }
-interface CoverageProviderModule extends RuntimeCoverageProviderModule {
+
+interface TestSequencer {
 	/**
-	* Factory for creating a new coverage provider
+	* Slicing tests into shards. Will be run before `sort`.
+	* Only run, if `shard` is defined.
 	*/
-	getProvider: () => CoverageProvider | Promise<CoverageProvider>;
+	shard: (files: TestSpecification[]) => Awaitable$1<TestSpecification[]>;
+	sort: (files: TestSpecification[]) => Awaitable$1<TestSpecification[]>;
 }
-type CoverageReporter = keyof ReportOptions | (string & {});
-type CoverageReporterWithOptions<ReporterName extends CoverageReporter = CoverageReporter> = ReporterName extends keyof ReportOptions ? ReportOptions[ReporterName] extends never ? [ReporterName, object] : [ReporterName, Partial<ReportOptions[ReporterName]>] : [ReporterName, Record<string, unknown>];
-type CoverageProviderName = "v8" | "istanbul" | "custom" | undefined;
-type CoverageOptions<T extends CoverageProviderName = CoverageProviderName> = T extends "istanbul" ? {
-	provider: T;
-} & CoverageIstanbulOptions : T extends "v8" ? {
-	/**
-	* Provider to use for coverage collection.
-	*
-	* @default 'v8'
-	*/
-	provider: T;
-} & CoverageV8Options : T extends "custom" ? {
-	provider: T;
-} & CustomProviderOptions : {
-	provider?: T;
-} & CoverageV8Options;
-/** Fields that have default values. Internally these will always be defined. */
-type FieldsWithDefaultValues = "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "exclude" | "reportOnFailure" | "allowExternal" | "processingConcurrency";
-type ResolvedCoverageOptions<T extends CoverageProviderName = CoverageProviderName> = CoverageOptions<T> & Required<Pick<CoverageOptions<T>, FieldsWithDefaultValues>> & {
-	reporter: CoverageReporterWithOptions[];
-};
-interface BaseCoverageOptions {
-	/**
-	* Enables coverage collection. Can be overridden using `--coverage` CLI option.
-	*
-	* @default false
-	*/
-	enabled?: boolean;
+interface TestSequencerConstructor {
+	new (ctx: Vitest): TestSequencer;
+}
+
+interface BenchmarkUserOptions {
 	/**
-	* List of files included in coverage as glob patterns.
-	* By default only files covered by tests are included.
+	* Include globs for benchmark test files
 	*
-	* See [Including and excluding files from coverage report](https://vitest.dev/guide/coverage.html#including-and-excluding-files-from-coverage-report) for examples.
+	* @default ['**\/*.{bench,benchmark}.?(c|m)[jt]s?(x)']
 	*/
 	include?: string[];
 	/**
-	* List of files excluded from coverage as glob patterns.
-	* Files are first checked against `coverage.include`.
-	*
-	* See [Including and excluding files from coverage report](https://vitest.dev/guide/coverage.html#including-and-excluding-files-from-coverage-report) for examples.
+	* Exclude globs for benchmark test files
+	* @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
 	*/
 	exclude?: string[];
 	/**
-	* Clean coverage results before running tests
-	*
-	* @default true
-	*/
-	clean?: boolean;
-	/**
-	* Clean coverage report on watch rerun
-	*
-	* @default true
-	*/
-	cleanOnRerun?: boolean;
-	/**
-	* Directory to write coverage report to
-	*
-	* @default './coverage'
-	*/
-	reportsDirectory?: string;
-	/**
-	* Coverage reporters to use.
-	* See [istanbul documentation](https://istanbul.js.org/docs/advanced/alternative-reporters/) for detailed list of all reporters.
-	*
-	* @default ['text', 'html', 'clover', 'json']
-	*/
-	reporter?: Arrayable$1<CoverageReporter> | (CoverageReporter | [CoverageReporter] | CoverageReporterWithOptions)[];
-	/**
-	* Do not show files with 100% statement, branch, and function coverage
-	*
-	* @default false
-	*/
-	skipFull?: boolean;
-	/**
-	* Configurations for thresholds
-	*
-	* @example
-	*
-	* ```ts
-	* {
-	*   // Thresholds for all files
-	*   functions: 95,
-	*   branches: 70,
-	*   perFile: true,
-	*   autoUpdate: true,
-	*
-	*   // Thresholds for utilities
-	*   'src/utils/**.ts': {
-	*     lines: 100,
-	*     statements: 95,
-	*   }
-	* }
-	* ```
-	*/
-	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.
+	* Include globs for in-source benchmark test files
 	*
-	* @default false
+	* @default []
 	*/
-	reportOnFailure?: boolean;
+	includeSource?: string[];
 	/**
-	* Collect coverage of files outside the project `root`.
+	* Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+	* and/or paths to custom reporters
 	*
-	* @default false
+	* @default ['default']
 	*/
-	allowExternal?: boolean;
+	reporters?: Arrayable$1<BenchmarkBuiltinReporters | Reporter>;
 	/**
-	* 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
+	* @deprecated Use `benchmark.outputJson` instead
 	*/
-	excludeAfterRemap?: boolean;
+	outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
 	/**
-	* Concurrency limit used when processing the coverage results.
-	* Defaults to `Math.min(20, os.availableParallelism?.() ?? os.cpus().length)`
+	* benchmark output file to compare against
 	*/
-	processingConcurrency?: number;
+	compare?: string;
 	/**
-	* Set to array of class method names to ignore for coverage
-	*
-	* @default []
+	* benchmark output file
 	*/
-	ignoreClassMethods?: string[];
-}
-interface CoverageIstanbulOptions extends BaseCoverageOptions {}
-interface CoverageV8Options extends BaseCoverageOptions {}
-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;
+	outputJson?: string;
 	/**
-	* Update threshold values automatically when current coverage is higher than earlier thresholds
-	*
+	* Include `samples` array of benchmark results for API or custom reporter usages.
+	* This is disabled by default to reduce memory usage.
 	* @default false
 	*/
-	autoUpdate?: boolean;
-	/** Thresholds for statements */
-	statements?: number;
-	/** Thresholds for functions */
-	functions?: number;
-	/** Thresholds for branches */
-	branches?: number;
-	/** Thresholds for lines */
-	lines?: number;
+	includeSamples?: boolean;
 }
 
 type BuiltinEnvironment = "node" | "jsdom" | "happy-dom" | "edge-runtime";
@@ -2578,7 +2533,7 @@ interface InlineConfig {
 	*
 	* @default []
 	*/
-	reporters?: Arrayable$1<ReporterName | InlineReporter> | ((ReporterName | InlineReporter) | [ReporterName] | ReporterWithOptions)[];
+	reporters?: Arrayable<ReporterName | InlineReporter> | ((ReporterName | InlineReporter) | [ReporterName] | ReporterWithOptions)[];
 	/**
 	* Write test results to a file when the --reporter=json` or `--reporter=junit` option is also specified.
 	* Also definable individually per reporter by using an object instead.
@@ -3172,5 +3127,5 @@ type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
 });
 type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 
-export { CoverageMap as C, TestSuite as E, Logger as L, TestProject as T, Vitest as V, BenchmarkReporter as aA, BenchmarkReportsMap as aB, DefaultReporter as aC, DotReporter as aD, GithubActionsReporter as aE, HangingProcessReporter as aF, JsonReporter as aG, JUnitReporter as aH, ReportersMap as aI, TapFlatReporter as aJ, TapReporter as aK, VerboseBenchmarkReporter as aL, VerboseReporter as aM, BaseReporter as aN, TestSpecification as l, VitestPackageInstaller as n, getFilePoolName as p, TestCase as s, TestCollection as t, TestModule as v };
-export type { BrowserOrchestrator as $, ApiConfig as A, TestResultSkipped as B, TestState as D, TestSuiteState as F, TestSequencerConstructor as G, HTMLOptions as H, InlineConfig as I, JsonOptions$1 as J, BenchmarkUserOptions as K, ModuleDiagnostic as M, BrowserBuiltinProvider as N, OnServerRestartHandler as O, ProcessPool as P, BrowserCommand as Q, ResolvedCoverageOptions as R, SerializedTestProject as S, UserWorkspaceConfig as U, WatcherTriggerPattern as W, BrowserCommandContext as X, BrowserConfigOptions as Y, BrowserInstanceOption as Z, BrowserModuleMocker as _, TestProjectConfiguration as a, BrowserProvider as a0, BrowserProviderInitializationOptions as a1, BrowserProviderModule as a2, BrowserProviderOptions as a3, BrowserScript as a4, BrowserServerState as a5, BrowserServerStateSession as a6, CDPSession as a7, ParentProjectBrowser as a8, ProjectBrowser as a9, BenchmarkBuiltinReporters as aO, BuiltinReporterOptions as aP, BuiltinReporters as aQ, JsonAssertionResult as aR, JsonTestResult as aS, JsonTestResults as aT, ResolvedBrowserOptions as aa, ToMatchScreenshotComparators as ab, ToMatchScreenshotOptions as ac, BuiltinEnvironment as ad, CSSModuleScopeStrategy as ae, DepsOptimizationOptions as af, EnvironmentOptions as ag, Pool as ah, PoolOptions as ai, ProjectConfig as aj, ResolvedProjectConfig as ak, ResolveSnapshotPathHandler as al, ResolveSnapshotPathHandlerContext as am, TypecheckConfig as an, VitestEnvironment as ao, BaseCoverageOptions as ap, CoverageIstanbulOptions as aq, CoverageOptions as ar, CoverageProvider as as, CoverageProviderModule as at, CoverageReporter as au, CustomProviderOptions as av, TestRunResult as aw, ReportedHookContext as ax, Reporter as ay, TestRunEndReason as az, ReportContext as b, CoverageV8Options as c, UserProjectConfigFn as d, UserProjectConfigExport as e, UserConfig as f, TestProjectInlineConfiguration as g, ResolvedConfig as h, VitestRunMode as i, VitestOptions as j, TestSequencer as k, OnTestsRerunHandler as m, WorkspaceSpec as o, JUnitOptions as q, TaskOptions as r, TestDiagnostic as u, TestModuleState as w, TestResult as x, TestResultFailed as y, TestResultPassed as z };
+export { TestSuite as B, CoverageMap as C, experimental_getRunnerTask as E, Logger as L, TestProject as T, Vitest as V, DefaultReporter as aA, DotReporter as aB, GithubActionsReporter as aC, HangingProcessReporter as aD, JsonReporter as aE, JUnitReporter as aF, ReportersMap as aG, TapFlatReporter as aH, TapReporter as aI, VerboseBenchmarkReporter as aJ, VerboseReporter as aK, BaseReporter as aL, BenchmarkReporter as ay, BenchmarkReportsMap as az, TestSpecification as k, VitestPackageInstaller as n, TestCase as q, TestCollection as r, TestModule as t };
+export type { BrowserProvider as $, ApiConfig as A, TestSuiteState as D, TestSequencerConstructor as F, BenchmarkUserOptions as G, HTMLOptions as H, InlineConfig as I, JsonOptions as J, BrowserBuiltinProvider as K, ModuleDiagnostic as M, BrowserCommand as N, OnServerRestartHandler as O, Pool as P, BrowserCommandContext as Q, ResolvedCoverageOptions as R, SerializedTestProject as S, UserWorkspaceConfig as U, WatcherTriggerPattern as W, BrowserConfigOptions as X, BrowserInstanceOption as Y, BrowserModuleMocker as Z, BrowserOrchestrator as _, TestProjectConfiguration as a, BrowserProviderInitializationOptions as a0, BrowserProviderModule as a1, BrowserProviderOptions as a2, BrowserScript as a3, BrowserServerState as a4, BrowserServerStateSession as a5, CDPSession as a6, ParentProjectBrowser as a7, ProjectBrowser as a8, ResolvedBrowserOptions as a9, BenchmarkBuiltinReporters as aM, BuiltinReporterOptions as aN, BuiltinReporters as aO, JsonAssertionResult as aP, JsonTestResult as aQ, JsonTestResults as aR, ToMatchScreenshotComparators as aa, ToMatchScreenshotOptions as ab, BuiltinEnvironment as ac, CSSModuleScopeStrategy as ad, DepsOptimizationOptions as ae, EnvironmentOptions as af, PoolOptions as ag, ProjectConfig as ah, ResolvedProjectConfig as ai, ResolveSnapshotPathHandler as aj, ResolveSnapshotPathHandlerContext as ak, TypecheckConfig as al, VitestEnvironment as am, BaseCoverageOptions as an, CoverageIstanbulOptions as ao, CoverageOptions as ap, CoverageProvider as aq, CoverageProviderModule as ar, CoverageReporter as as, CustomProviderOptions as at, TestRunResult as au, ReportedHookContext as av, Reporter as aw, TestRunEndReason as ax, ReportContext as b, CoverageV8Options as c, UserProjectConfigFn as d, UserProjectConfigExport as e, UserConfig as f, TestProjectInlineConfiguration as g, ResolvedConfig as h, VitestRunMode as i, VitestOptions as j, TestSequencer as l, OnTestsRerunHandler as m, JUnitOptions as o, TaskOptions as p, TestDiagnostic as s, TestModuleState as u, TestResult as v, TestResultFailed as w, TestResultPassed as x, TestResultSkipped as y, TestState as z };