vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/chunks/{reporters.d.DxZg19fy.d.ts → reporters.d.CVzhsTvK.d.ts}

@@ -1,23 +1,22 @@
-import { Task, CancelReason, TaskMeta, Suite, File, TestAnnotation, ImportDuration, TaskResultPack, TaskEventPack, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
-import { P as ProvidedContext, U as UserConsoleLog, b as Awaitable$1, c as Arrayable$1, A as AfterSuiteRunMeta, L as LabelColor } from './environment.d.CUq4cUgQ.js';
-import { ParsedStack, Awaitable, TestError, SerializedError, Arrayable } from '@vitest/utils';
+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.BsToaxti.js';
 import { Writable } from 'node:stream';
-import { ViteDevServer, ModuleNode, TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
-import { Console } from 'node:console';
-import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.q8Z0P0q1.js';
+import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, 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.HJdfX-8k.js';
+import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.Dx7DO_Ce.js';
+import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.B_LthbQq.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 { chai } from '@vitest/expect';
 import { happyDomTypes, jsdomTypes } from 'vitest/optional-types.js';
-import { B as BenchmarkResult } from './benchmark.d.BwvBVTda.js';
-import { a as RuntimeCoverageProviderModule } from './coverage.d.S9RMNXIe.js';
+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">;
 
@@ -70,57 +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;
-}
 interface CDPSession {
 	send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
 	on: (event: string, listener: (...args: unknown[]) => void) => void;
@@ -132,6 +80,11 @@ interface BrowserModuleMocker {
 	delete: (sessionId: string, url: string) => Promise<void>;
 	clear: (sessionId: string) => Promise<void>;
 }
+interface BrowserProviderOption {
+	name: string;
+	supportedBrowser?: ReadonlyArray<string>;
+	factory: (project: TestProject) => BrowserProvider;
+}
 interface BrowserProvider {
 	name: string;
 	mocker?: BrowserModuleMocker;
@@ -139,21 +92,14 @@ interface BrowserProvider {
 	* @experimental opt-in into file parallelisation
 	*/
 	supportsParallelism: boolean;
-	getSupportedBrowsers: () => readonly string[];
 	getCommandsContext: (sessionId: string) => Record<string, unknown>;
-	openPage: (sessionId: string, url: string, beforeNavigate?: () => Promise<void>) => Promise<void>;
+	openPage: (sessionId: string, url: string) => Promise<void>;
 	getCDPSession?: (sessionId: string) => Promise<CDPSession>;
 	close: () => Awaitable<void>;
-	// eslint-disable-next-line ts/method-signature-style -- we want to allow extended options
-	initialize(ctx: TestProject, options: BrowserProviderInitializationOptions): Awaitable<void>;
 }
-interface BrowserProviderModule {
-	new (): BrowserProvider;
-}
-interface BrowserProviderOptions {}
 type BrowserBuiltinProvider = "webdriverio" | "playwright" | "preview";
-type UnsupportedProperties = "browser" | "typecheck" | "alias" | "sequence" | "root" | "pool" | "poolOptions" | "runner" | "api" | "deps" | "testTransformMode" | "poolMatchGlobs" | "environmentMatchGlobs" | "environment" | "environmentOptions" | "server" | "benchmark" | "name";
-interface BrowserInstanceOption extends BrowserProviderOptions, Omit<ProjectConfig, UnsupportedProperties>, Pick<BrowserConfigOptions, "headless" | "locators" | "viewport" | "testerHtmlPath" | "screenshotDirectory" | "screenshotFailures"> {
+type UnsupportedProperties = "browser" | "typecheck" | "alias" | "sequence" | "root" | "pool" | "poolOptions" | "runner" | "api" | "deps" | "environment" | "environmentOptions" | "server" | "benchmark" | "name";
+interface BrowserInstanceOption extends Omit<ProjectConfig, UnsupportedProperties>, Pick<BrowserConfigOptions, "headless" | "locators" | "viewport" | "testerHtmlPath" | "screenshotDirectory" | "screenshotFailures" | "provider"> {
 	/**
 	* Name of the browser
 	*/
@@ -168,32 +114,13 @@ interface BrowserConfigOptions {
 	*/
 	enabled?: boolean;
 	/**
-	* Name of the browser
-	* @deprecated use `instances` instead. if both are defined, this will filter `instances` by name.
-	*/
-	name?: string;
-	/**
 	* Configurations for different browser setups
 	*/
-	instances?: BrowserInstanceOption[];
+	instances: BrowserInstanceOption[];
 	/**
 	* Browser provider
-	*
-	* @default 'preview'
-	*/
-	provider?: BrowserBuiltinProvider | (string & {});
-	/**
-	* Options that are passed down to a browser provider.
-	* To support type hinting, add one of the types to your tsconfig.json "compilerOptions.types" field:
-	*
-	* - for webdriverio: `@vitest/browser/providers/webdriverio`
-	* - for playwright: `@vitest/browser/providers/playwright`
-	*
-	* @example
-	* { playwright: { launch: { devtools: true } }
-	* @deprecated use `instances` instead
 	*/
-	providerOptions?: BrowserProviderOptions;
+	provider?: BrowserProviderOption;
 	/**
 	* enable headless mode
 	*
@@ -233,12 +160,12 @@ interface BrowserConfigOptions {
 		* Width of the viewport
 		* @default 414
 		*/
-		width: number
+		width: number;
 		/**
 		* Height of the viewport
 		* @default 896
 		*/
-		height: number
+		height: number;
 	};
 	/**
 	* Locator options
@@ -248,7 +175,7 @@ interface BrowserConfigOptions {
 		* Attribute used to locate elements by test id
 		* @default 'data-testid'
 		*/
-		testIdAttribute?: string
+		testIdAttribute?: string;
 	};
 	/**
 	* Directory where screenshots will be saved when page.screenshot() is called
@@ -263,11 +190,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;
@@ -286,13 +208,31 @@ interface BrowserConfigOptions {
 	* @default 30000
 	*/
 	connectTimeout?: number;
+	expect?: {
+		toMatchScreenshot?: { [ComparatorName in keyof ToMatchScreenshotComparators] : {
+			/**
+			* The name of the comparator to use for visual diffing.
+			*
+			* @defaultValue `'pixelmatch'`
+			*/
+			comparatorName?: ComparatorName;
+			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;
 	provider: BrowserProvider;
 	project: TestProject;
-	/** @deprecated use `sessionId` instead */
-	contextId: string;
 	sessionId: string;
 }
 interface BrowserServerStateSession {
@@ -354,7 +294,6 @@ interface BrowserScript {
 }
 interface ResolvedBrowserOptions extends BrowserConfigOptions {
 	name: string;
-	providerOptions?: BrowserProviderOptions;
 	enabled: boolean;
 	headless: boolean;
 	isolate: boolean;
@@ -362,665 +301,1065 @@ interface ResolvedBrowserOptions extends BrowserConfigOptions {
 	api: ApiConfig;
 	ui: boolean;
 	viewport: {
-		width: number
-		height: number
+		width: number;
+		height: number;
 	};
 	screenshotFailures: boolean;
 	locators: {
-		testIdAttribute: string
+		testIdAttribute: string;
 	};
 }
-
-declare class ReportedTaskImplementation {
-	/**
-	* The project associated with the test or suite.
-	*/
-	readonly project: TestProject;
+type ToMatchScreenshotResolvePath = (data: {
 	/**
-	* 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.
+	* Path **without** extension, sanitized and relative to the test file.
+	*
+	* This comes from the arguments passed to `toMatchScreenshot`; if called
+	* without arguments this will be the auto-generated name.
+	*
+	* @example
+	* test('calls `onClick`', () => {
+	*   expect(locator).toMatchScreenshot()
+	*   // arg = "calls-onclick-1"
+	* })
+	*
+	* @example
+	* expect(locator).toMatchScreenshot('foo/bar/baz.png')
+	* // arg = "foo/bar/baz"
+	*
+	* @example
+	* expect(locator).toMatchScreenshot('../foo/bar/baz.png')
+	* // arg = "foo/bar/baz"
 	*/
-	readonly id: string;
+	arg: string;
 	/**
-	* Location in the module where the test or suite is defined.
+	* Screenshot extension, with leading dot.
+	*
+	* This can be set through the arguments passed to `toMatchScreenshot`, but
+	* the value will fall back to `'.png'` if an unsupported extension is used.
 	*/
-	readonly location: {
-		line: number
-		column: number
-	} | undefined;
+	ext: string;
 	/**
-	* Checks if the test did not fail the suite.
-	* If the test is not finished yet or was skipped, it will return `true`.
+	* The instance's browser name.
 	*/
-	ok(): boolean;
+	browserName: string;
 	/**
-	* Custom metadata that was attached to the test during its execution.
+	* The value of {@linkcode process.platform}.
 	*/
-	meta(): TaskMeta;
-}
-declare class TestCase extends ReportedTaskImplementation {
-	#private;
-	readonly type = "test";
+	platform: NodeJS.Platform;
 	/**
-	* Direct reference to the test module where the test or suite is defined.
+	* The value provided to
+	* {@linkcode https://vitest.dev/guide/browser/config#browser-screenshotdirectory|browser.screenshotDirectory},
+	* if none is provided, its default value.
 	*/
-	readonly module: TestModule;
+	screenshotDirectory: string;
 	/**
-	* Name of the test.
+	* Absolute path to the project's
+	* {@linkcode https://vitest.dev/config/#root|root}.
 	*/
-	readonly name: string;
+	root: string;
 	/**
-	* Options that the test was initiated with.
+	* Path to the test file, relative to the project's
+	* {@linkcode https://vitest.dev/config/#root|root}.
 	*/
-	readonly options: TaskOptions;
+	testFileDirectory: string;
 	/**
-	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
+	* The test's filename.
 	*/
-	readonly parent: TestSuite | TestModule;
+	testFileName: string;
 	/**
-	* Full name of the test including all parent suites separated with `>`.
+	* The {@linkcode https://vitest.dev/api/#test|test}'s name, including
+	* parent {@linkcode https://vitest.dev/api/#describe|describe}, sanitized.
 	*/
-	get fullName(): string;
+	testName: 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()`.
+	* The value provided to
+	* {@linkcode https://vitest.dev/config/#attachmentsdir|attachmentsDir},
+	* if none is provided, its default value.
 	*/
-	result(): TestResult;
+	attachmentsDir: string;
+}) => string;
+interface ToMatchScreenshotOptions {
 	/**
-	* Test annotations added via the `task.annotate` API during the test execution.
+	* Overrides default reference screenshot path.
+	*
+	* @default `${root}/${testFileDirectory}/${screenshotDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}`
 	*/
-	annotations(): ReadonlyArray<TestAnnotation>;
+	resolveScreenshotPath?: ToMatchScreenshotResolvePath;
 	/**
-	* Useful information about the test like duration, memory usage, etc.
-	* Diagnostic is only available after the test has finished.
+	* Overrides default screenshot path used for diffs.
+	*
+	* @default `${root}/${attachmentsDir}/${testFileDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}`
 	*/
-	diagnostic(): TestDiagnostic | undefined;
+	resolveDiffPath?: ToMatchScreenshotResolvePath;
 }
-declare class TestCollection {
-	#private;
-	constructor(task: Suite | File, project: TestProject);
+interface ToMatchScreenshotComparators {}
+
+type BuiltinPool = "browser" | "threads" | "forks" | "vmThreads" | "vmForks" | "typescript";
+type Pool = BuiltinPool | (string & {});
+interface PoolOptions extends Record<string, unknown> {
 	/**
-	* Returns the test or suite at a specific index.
+	* 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.
 	*/
-	at(index: number): TestCase | TestSuite | undefined;
+	threads?: ThreadsOptions & WorkerContextOptions;
 	/**
-	* The number of tests and suites in the collection.
+	* 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.
 	*/
-	get size(): number;
+	forks?: ForksOptions & WorkerContextOptions;
 	/**
-	* Returns the collection in array form for easier manipulation.
+	* 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.
 	*/
-	array(): (TestCase | TestSuite)[];
+	vmThreads?: ThreadsOptions & VmOptions;
 	/**
-	* Filters all tests that are part of this collection and its children.
+	* 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.
 	*/
-	allTests(state?: TestState): Generator<TestCase, undefined, void>;
+	vmForks?: ForksOptions & VmOptions;
+}
+interface ResolvedPoolOptions extends PoolOptions {
+	threads?: ResolvedThreadsOptions & WorkerContextOptions;
+	forks?: ResolvedForksOptions & WorkerContextOptions;
+	vmThreads?: ResolvedThreadsOptions & VmOptions;
+	vmForks?: ResolvedForksOptions & VmOptions;
+}
+interface ThreadsOptions {
+	/** Maximum amount of threads to use */
+	maxThreads?: number | string;
 	/**
-	* Filters only the tests that are part of this collection.
+	* Run tests inside a single thread.
+	*
+	* @default false
 	*/
-	tests(state?: TestState): Generator<TestCase, undefined, void>;
+	singleThread?: boolean;
 	/**
-	* Filters only the suites that are part of this collection.
+	* Use Atomics to synchronize threads
+	*
+	* This can improve performance in some cases, but might cause segfault in older Node versions.
+	*
+	* @default false
 	*/
-	suites(): Generator<TestSuite, undefined, void>;
+	useAtomics?: boolean;
+}
+interface ResolvedThreadsOptions extends ThreadsOptions {
+	maxThreads?: number;
+}
+interface ForksOptions {
+	/** Maximum amount of child processes to use */
+	maxForks?: number | string;
 	/**
-	* Filters all suites that are part of this collection and its children.
+	* Run tests inside a single fork.
+	*
+	* @default false
 	*/
-	allSuites(): Generator<TestSuite, undefined, void>;
-	[Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
+	singleFork?: boolean;
 }
-
-type ReportedHookContext = {
-	readonly name: "beforeAll" | "afterAll"
-	readonly entity: TestSuite | TestModule
-} | {
-	readonly name: "beforeEach" | "afterEach"
-	readonly entity: TestCase
-};
-declare abstract class SuiteImplementation extends ReportedTaskImplementation {
+interface ResolvedForksOptions extends ForksOptions {
+	maxForks?: number;
+}
+interface WorkerContextOptions {
 	/**
-	* Collection of suites and tests that are part of this suite.
+	* Isolate test environment by recycling `worker_threads` or `child_process` after each test
+	*
+	* @default true
 	*/
-	readonly children: TestCollection;
+	isolate?: boolean;
 	/**
-	* Errors that happened outside of the test run during collection, like syntax errors.
+	* 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
 	*/
-	errors(): SerializedError[];
+	execArgv?: string[];
 }
-declare class TestSuite extends SuiteImplementation {
-	#private;
-	readonly type = "suite";
+interface VmOptions {
 	/**
-	* Name of the test or the suite.
+	* Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
+	* If you see memory leaks, try to tinker this value.
 	*/
-	readonly name: string;
+	memoryLimit?: string | number;
+	/** Isolation is always enabled */
+	isolate?: true;
 	/**
-	* Direct reference to the test module where the test or suite is defined.
+	* 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
 	*/
-	readonly module: TestModule;
+	execArgv?: string[];
+}
+
+declare class TestSpecification {
 	/**
-	* Parent suite. If suite was called directly inside the module, the parent will be the module itself.
+	* The task ID associated with the test module.
 	*/
-	readonly parent: TestSuite | TestModule;
+	readonly taskId: string;
 	/**
-	* Options that suite was initiated with.
+	* The test project that the module belongs to.
 	*/
-	readonly options: TaskOptions;
+	readonly project: TestProject;
 	/**
-	* Checks if the suite has any failed tests.
-	* This will also return `false` if suite failed during collection.
+	* The ID of the module in the Vite module graph. It is usually an absolute file path.
 	*/
-	ok: () => boolean;
+	readonly moduleId: string;
 	/**
-	* The meta information attached to the suite during its collection or execution.
+	* 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.
 	*/
-	meta: () => TaskMeta;
+	readonly pool: Pool;
 	/**
-	* Checks the running state of the suite.
+	* Line numbers of the test locations to run.
 	*/
-	state(): TestSuiteState;
+	readonly testLines: number[] | undefined;
+	constructor(project: TestProject, moduleId: string, pool: Pool, testLines?: number[] | undefined);
 	/**
-	* Full name of the suite including all parent suites separated with `>`.
+	* Test module associated with the specification.
 	*/
-	get fullName(): string;
+	get testModule(): TestModule | undefined;
+	toJSON(): SerializedTestSpecification;
 }
-declare class TestModule extends SuiteImplementation {
-	readonly location: undefined;
-	readonly type = "module";
+
+declare class TestProject {
+	options?: InitializeProjectOptions | undefined;
 	/**
-	* This is usually an absolute UNIX file path.
-	* It can be a virtual ID if the file is not on the disk.
-	* This value corresponds to the ID in the Vite's module graph.
+	* The global Vitest instance.
+	* @experimental The public Vitest API is experimental and does not follow semver.
 	*/
-	readonly moduleId: string;
+	readonly vitest: Vitest;
 	/**
-	* Checks the running state of the test file.
+	* Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
 	*/
-	state(): TestModuleState;
+	readonly globalConfig: ResolvedConfig;
 	/**
-	* Checks if the module has any failed tests.
-	* This will also return `false` if module failed during collection.
+	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
 	*/
-	ok: () => boolean;
+	browser?: ProjectBrowser;
 	/**
-	* The meta information attached to the module during its collection or execution.
+	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
 	*/
-	meta: () => TaskMeta;
+	readonly tmpDir: string;
+	/** @inetrnal */ testFilesList: string[] | null;
+	private runner;
+	private closingPromise;
+	private typecheckFilesList;
+	private _globalSetups?;
+	private _provided;
+	constructor(vitest: Vitest, options?: InitializeProjectOptions | undefined);
 	/**
-	* Useful information about the module like duration, memory usage, etc.
-	* If the module was not executed yet, all diagnostic values will return `0`.
+	* 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.
 	*/
-	diagnostic(): ModuleDiagnostic;
-}
-interface TaskOptions {
-	readonly each: boolean | undefined;
-	readonly fails: boolean | undefined;
-	readonly concurrent: boolean | undefined;
-	readonly shuffle: boolean | undefined;
-	readonly retry: number | undefined;
-	readonly repeats: number | undefined;
-	readonly mode: "run" | "only" | "skip" | "todo";
-}
-type TestSuiteState = "skipped" | "pending" | "failed" | "passed";
-type TestModuleState = TestSuiteState | "queued";
-type TestState = TestResult["state"];
-type TestResult = TestResultPassed | TestResultFailed | TestResultSkipped | TestResultPending;
-interface TestResultPending {
+	get hash(): string;
 	/**
-	* The test was collected, but didn't finish running yet.
+	* Provide a value to the test context. This value will be available to all tests with `inject`.
 	*/
-	readonly state: "pending";
+	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
 	/**
-	* Pending tests have no errors.
+	* Get the provided context. The project context is merged with the global context.
 	*/
-	readonly errors: undefined;
-}
-interface TestResultPassed {
+	getProvidedContext(): ProvidedContext;
 	/**
-	* The test passed successfully.
+	* Creates a new test specification. Specifications describe how to run tests.
+	* @param moduleId The file path
 	*/
-	readonly state: "passed";
+	createSpecification(moduleId: string, locations?: number[] | undefined, pool?: string): TestSpecification;
+	toJSON(): SerializedTestProject;
 	/**
-	* Errors that were thrown during the test execution.
-	*
-	* **Note**: If test was retried successfully, errors will still be reported.
+	* Vite's dev server instance. Every workspace project has its own server.
 	*/
-	readonly errors: ReadonlyArray<TestError> | undefined;
-}
-interface TestResultFailed {
+	get vite(): ViteDevServer;
 	/**
-	* The test failed to execute.
+	* Resolved project configuration.
 	*/
-	readonly state: "failed";
+	get config(): ResolvedConfig;
 	/**
-	* Errors that were thrown during the test execution.
+	* The name of the project or an empty string if not set.
 	*/
-	readonly errors: ReadonlyArray<TestError>;
-}
-interface TestResultSkipped {
+	get name(): string;
 	/**
-	* 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.
+	* The color used when reporting tasks of this project.
 	*/
-	readonly state: "skipped";
+	get color(): ProjectName["color"];
 	/**
-	* Skipped tests have no errors.
+	* Serialized project configuration. This is the config that tests receive.
 	*/
-	readonly errors: undefined;
+	get serializedConfig(): SerializedConfig;
 	/**
-	* A custom note passed down to `ctx.skip(note)`.
+	* Check if this is the root project. The root project is the one that has the root config.
 	*/
-	readonly note: string | undefined;
-}
-interface TestDiagnostic {
+	isRootProject(): boolean;
+	onTestsRerun(cb: OnTestsRerunHandler): void;
 	/**
-	* If the duration of the test is above `slowTestThreshold`.
+	* 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.
 	*/
-	readonly slow: boolean;
+	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;
 	/**
-	* The amount of memory used by the test in bytes.
-	* This value is only available if the test was executed with `logHeapUsage` flag.
+	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
 	*/
-	readonly heap: number | undefined;
+	matchesTestGlob(moduleId: string, source?: () => string): boolean;
+	private isInSourceTestCode;
+	private filterFiles;
+	private _parentBrowser?;
 	/**
-	* The time it takes to execute the test in ms.
+	* 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.
 	*/
-	readonly duration: number;
+	close(): Promise<void>;
 	/**
-	* The time in ms when the test started.
+	* Import a file using Vite module runner.
+	* @param moduleId The ID of the module in Vite module graph
 	*/
-	readonly startTime: number;
+	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 amount of times the test was retried.
+	* The project associated with the test or suite.
 	*/
-	readonly retryCount: number;
+	readonly project: TestProject;
 	/**
-	* The amount of times the test was repeated as configured by `repeats` option.
-	* This value can be lower if the test failed during the repeat and no `retry` is configured.
+	* 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 repeatCount: number;
+	readonly id: string;
 	/**
-	* If test passed on a second retry.
+	* Location in the module where the test or suite is defined.
 	*/
-	readonly flaky: boolean;
-}
-interface ModuleDiagnostic {
+	readonly location: {
+		line: number;
+		column: number;
+	} | undefined;
 	/**
-	* The time it takes to import and initiate an environment.
+	* Checks if the test did not fail the suite.
+	* If the test is not finished yet or was skipped, it will return `true`.
 	*/
-	readonly environmentSetupDuration: number;
+	ok(): boolean;
 	/**
-	* The time it takes Vitest to setup test harness (runner, mocks, etc.).
+	* Custom metadata that was attached to the test during its execution.
 	*/
-	readonly prepareDuration: number;
+	meta(): TaskMeta;
+}
+declare class TestCase extends ReportedTaskImplementation {
+	#private;
+	readonly type = "test";
 	/**
-	* The time it takes to import the test module.
-	* This includes importing everything in the module and executing suite callbacks.
+	* Direct reference to the test module where the test or suite is defined.
 	*/
-	readonly collectDuration: number;
+	readonly module: TestModule;
 	/**
-	* The time it takes to import the setup module.
+	* Name of the test.
 	*/
-	readonly setupDuration: number;
+	readonly name: string;
 	/**
-	* Accumulated duration of all tests and hooks in the module.
+	* Options that the test was initiated with.
 	*/
-	readonly duration: number;
+	readonly options: TaskOptions;
 	/**
-	* The amount of memory used by the test module in bytes.
-	* This value is only available if the test was executed with `logHeapUsage` flag.
+	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
 	*/
-	readonly heap: number | undefined;
+	readonly parent: TestSuite | TestModule;
 	/**
-	* The time spent importing every non-externalized dependency that Vitest has processed.
+	* Full name of the test including all parent suites separated with `>`.
 	*/
-	readonly importDurations: Record<string, ImportDuration>;
-}
-
-type BuiltinPool = "browser" | "threads" | "forks" | "vmThreads" | "vmForks" | "typescript";
-type Pool = BuiltinPool | (string & {});
-interface PoolOptions extends Record<string, unknown> {
+	get fullName(): string;
 	/**
-	* 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.
+	* 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()`.
 	*/
-	threads?: ThreadsOptions & WorkerContextOptions;
+	result(): TestResult;
 	/**
-	* 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.
+	* Test annotations added via the `task.annotate` API during the test execution.
 	*/
-	forks?: ForksOptions & WorkerContextOptions;
+	annotations(): ReadonlyArray<TestAnnotation>;
 	/**
-	* 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.
+	* Useful information about the test like duration, memory usage, etc.
+	* Diagnostic is only available after the test has finished.
 	*/
-	vmForks?: ForksOptions & VmOptions;
-}
-interface ResolvedPoolOptions extends PoolOptions {
-	threads?: ResolvedThreadsOptions & WorkerContextOptions;
-	forks?: ResolvedForksOptions & WorkerContextOptions;
-	vmThreads?: ResolvedThreadsOptions & VmOptions;
-	vmForks?: ResolvedForksOptions & VmOptions;
+	diagnostic(): TestDiagnostic | undefined;
 }
-interface ThreadsOptions {
-	/** Minimum amount of threads to use */
-	minThreads?: number | string;
-	/** Maximum amount of threads to use */
-	maxThreads?: number | string;
+declare class TestCollection {
+	#private;
+	constructor(task: Suite | File, project: TestProject);
 	/**
-	* Run tests inside a single thread.
-	*
-	* @default false
+	* Returns the test or suite at a specific index.
 	*/
-	singleThread?: boolean;
+	at(index: number): TestCase | TestSuite | undefined;
 	/**
-	* Use Atomics to synchronize threads
-	*
-	* This can improve performance in some cases, but might cause segfault in older Node versions.
-	*
-	* @default false
+	* The number of tests and suites in the collection.
 	*/
-	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;
+	get size(): number;
 	/**
-	* Run tests inside a single fork.
-	*
-	* @default false
+	* Returns the collection in array form for easier manipulation.
 	*/
-	singleFork?: boolean;
-}
-interface ResolvedForksOptions extends ForksOptions {
-	minForks?: number;
-	maxForks?: number;
-}
-interface WorkerContextOptions {
+	array(): (TestCase | TestSuite)[];
 	/**
-	* Isolate test environment by recycling `worker_threads` or `child_process` after each test
-	*
-	* @default true
+	* Filters all tests that are part of this collection and its children.
 	*/
-	isolate?: boolean;
+	allTests(state?: TestState): Generator<TestCase, undefined, void>;
 	/**
-	* 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
+	* Filters only the tests that are part of this collection.
 	*/
-	execArgv?: string[];
-}
-interface VmOptions {
+	tests(state?: TestState): Generator<TestCase, undefined, void>;
 	/**
-	* Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
-	* If you see memory leaks, try to tinker this value.
+	* Filters only the suites that are part of this collection.
 	*/
-	memoryLimit?: string | number;
-	/** Isolation is always enabled */
-	isolate?: true;
+	suites(): Generator<TestSuite, undefined, void>;
 	/**
-	* 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
+	* Filters all suites that are part of this collection and its children.
 	*/
-	execArgv?: string[];
+	allSuites(): Generator<TestSuite, undefined, void>;
+	[Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
 }
 
-declare class TestSpecification {
+type ReportedHookContext = {
+	readonly name: "beforeAll" | "afterAll";
+	readonly entity: TestSuite | TestModule;
+} | {
+	readonly name: "beforeEach" | "afterEach";
+	readonly entity: TestCase;
+};
+declare abstract class SuiteImplementation extends ReportedTaskImplementation {
 	/**
-	* @deprecated use `project` instead
+	* Collection of suites and tests that are part of this suite.
 	*/
-	readonly 0: TestProject;
+	readonly children: TestCollection;
 	/**
-	* @deprecated use `moduleId` instead
+	* Errors that happened outside of the test run during collection, like syntax errors.
 	*/
-	readonly 1: string;
+	errors(): SerializedError[];
+}
+declare class TestSuite extends SuiteImplementation {
+	#private;
+	readonly type = "suite";
 	/**
-	* @deprecated use `pool` instead
+	* Name of the test or the suite.
 	*/
-	readonly 2: {
-		pool: Pool
-	};
+	readonly name: string;
 	/**
-	* The task ID associated with the test module.
+	* Direct reference to the test module where the test or suite is defined.
 	*/
-	readonly taskId: string;
+	readonly module: TestModule;
 	/**
-	* The test project that the module belongs to.
+	* Parent suite. If suite was called directly inside the module, the parent will be the module itself.
 	*/
-	readonly project: TestProject;
+	readonly parent: TestSuite | TestModule;
 	/**
-	* The ID of the module in the Vite module graph. It is usually an absolute file path.
+	* Options that suite was initiated with.
 	*/
-	readonly moduleId: string;
+	readonly options: TaskOptions;
 	/**
-	* 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.
+	* Checks if the suite has any failed tests.
+	* This will also return `false` if suite failed during collection.
 	*/
-	readonly pool: Pool;
+	ok: () => boolean;
 	/**
-	* Line numbers of the test locations to run.
+	* The meta information attached to the suite during its collection or execution.
 	*/
-	readonly testLines: number[] | undefined;
-	constructor(project: TestProject, moduleId: string, pool: Pool, testLines?: number[] | undefined);
+	meta: () => TaskMeta;
 	/**
-	* Test module associated with the specification.
+	* Checks the running state of the suite.
 	*/
-	get testModule(): TestModule | undefined;
-	toJSON(): SerializedTestSpecification;
+	state(): TestSuiteState;
 	/**
-	* for backwards compatibility
-	* @deprecated
+	* Full name of the suite including all parent suites separated with `>`.
 	*/
-	[Symbol.iterator](): Generator<string | TestProject, void, unknown>;
+	get fullName(): string;
 }
-
-declare class TestProject {
-	/** @deprecated */
-	path: string | number;
-	options?: InitializeProjectOptions | undefined;
+declare class TestModule extends SuiteImplementation {
+	readonly location: undefined;
+	readonly type = "module";
 	/**
-	* The global Vitest instance.
-	* @experimental The public Vitest API is experimental and does not follow semver.
+	* This is usually an absolute UNIX file path.
+	* It can be a virtual ID if the file is not on the disk.
+	* This value corresponds to the ID in the Vite's module graph.
 	*/
-	readonly vitest: Vitest;
+	readonly moduleId: string;
 	/**
-	* Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
+	* Module id relative to the project. This is the same as `task.name`.
 	*/
-	readonly globalConfig: ResolvedConfig;
+	readonly relativeModuleId: string;
 	/**
-	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
+	* Checks the running state of the test file.
 	*/
-	browser?: ProjectBrowser;
-	/** @deprecated use `vitest` instead */
-	ctx: Vitest;
+	state(): TestModuleState;
 	/**
-	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
+	* Checks if the module has any failed tests.
+	* This will also return `false` if module failed during collection.
 	*/
-	readonly tmpDir: string;
-	private runner;
-	private closingPromise;
-	private testFilesList;
-	private typecheckFilesList;
-	private _globalSetups?;
-	private _provided;
-	constructor(path: string | number, vitest: Vitest, options?: InitializeProjectOptions | undefined);
+	ok: () => boolean;
 	/**
-	* 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.
+	* The meta information attached to the module during its collection or execution.
 	*/
-	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
+	meta: () => TaskMeta;
 	/**
-	* Provide a value to the test context. This value will be available to all tests with `inject`.
+	* Useful information about the module like duration, memory usage, etc.
+	* If the module was not executed yet, all diagnostic values will return `0`.
 	*/
-	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
+	diagnostic(): ModuleDiagnostic;
+}
+interface TaskOptions {
+	readonly each: boolean | undefined;
+	readonly fails: boolean | undefined;
+	readonly concurrent: boolean | undefined;
+	readonly shuffle: boolean | undefined;
+	readonly retry: number | undefined;
+	readonly repeats: number | undefined;
+	readonly mode: "run" | "only" | "skip" | "todo";
+}
+type TestSuiteState = "skipped" | "pending" | "failed" | "passed";
+type TestModuleState = TestSuiteState | "queued";
+type TestState = TestResult["state"];
+type TestResult = TestResultPassed | TestResultFailed | TestResultSkipped | TestResultPending;
+interface TestResultPending {
 	/**
-	* Get the provided context. The project context is merged with the global context.
+	* The test was collected, but didn't finish running yet.
 	*/
-	getProvidedContext(): ProvidedContext;
+	readonly state: "pending";
 	/**
-	* Creates a new test specification. Specifications describe how to run tests.
-	* @param moduleId The file path
+	* Pending tests have no errors.
 	*/
-	createSpecification(moduleId: string, locations?: number[] | undefined, pool?: string): TestSpecification;
-	toJSON(): SerializedTestProject;
+	readonly errors: undefined;
+}
+interface TestResultPassed {
 	/**
-	* Vite's dev server instance. Every workspace project has its own server.
+	* The test passed successfully.
 	*/
-	get vite(): ViteDevServer;
+	readonly state: "passed";
 	/**
-	* Resolved project configuration.
+	* Errors that were thrown during the test execution.
+	*
+	* **Note**: If test was retried successfully, errors will still be reported.
 	*/
-	get config(): ResolvedConfig;
+	readonly errors: ReadonlyArray<TestError> | undefined;
+}
+interface TestResultFailed {
 	/**
-	* The name of the project or an empty string if not set.
+	* The test failed to execute.
 	*/
-	get name(): string;
+	readonly state: "failed";
 	/**
-	* The color used when reporting tasks of this project.
+	* Errors that were thrown during the test execution.
 	*/
-	get color(): ProjectName["color"];
+	readonly errors: ReadonlyArray<TestError>;
+}
+interface TestResultSkipped {
 	/**
-	* Serialized project configuration. This is the config that tests receive.
+	* 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.
 	*/
-	get serializedConfig(): SerializedConfig;
-	/** @deprecated use `vite` instead */
-	get server(): ViteDevServer;
+	readonly state: "skipped";
 	/**
-	* Check if this is the root project. The root project is the one that has the root config.
+	* Skipped tests have no errors.
 	*/
-	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[];
+	readonly errors: undefined;
 	/**
-	* 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.
+	* A custom note passed down to `ctx.skip(note)`.
 	*/
-	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;
+	readonly note: string | undefined;
+}
+interface TestDiagnostic {
 	/**
-	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
+	* If the duration of the test is above `slowTestThreshold`.
+	*/
+	readonly slow: boolean;
+	/**
+	* The amount of memory used by the test in bytes.
+	* This value is only available if the test was executed with `logHeapUsage` flag.
+	*/
+	readonly heap: number | undefined;
+	/**
+	* The time it takes to execute the test in ms.
+	*/
+	readonly duration: number;
+	/**
+	* The time in ms when the test started.
+	*/
+	readonly startTime: number;
+	/**
+	* The amount of times the test was retried.
+	*/
+	readonly retryCount: number;
+	/**
+	* The amount of times the test was repeated as configured by `repeats` option.
+	* This value can be lower if the test failed during the repeat and no `retry` is configured.
+	*/
+	readonly repeatCount: number;
+	/**
+	* If test passed on a second retry.
+	*/
+	readonly flaky: boolean;
+}
+interface ModuleDiagnostic {
+	/**
+	* The time it takes to import and initiate an environment.
+	*/
+	readonly environmentSetupDuration: number;
+	/**
+	* The time it takes Vitest to setup test harness (runner, mocks, etc.).
+	*/
+	readonly prepareDuration: number;
+	/**
+	* The time it takes to import the test module.
+	* This includes importing everything in the module and executing suite callbacks.
+	*/
+	readonly collectDuration: number;
+	/**
+	* The time it takes to import the setup module.
+	*/
+	readonly setupDuration: number;
+	/**
+	* Accumulated duration of all tests and hooks in the module.
+	*/
+	readonly duration: number;
+	/**
+	* The amount of memory used by the test module in bytes.
+	* This value is only available if the test was executed with `logHeapUsage` flag.
+	*/
+	readonly heap: number | undefined;
+	/**
+	* The time spent importing every non-externalized dependency that Vitest has processed.
+	*/
+	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;
+
+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[] };
+}
+
+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 {
+	/**
+	* Factory for creating a new coverage provider
+	*/
+	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" ? {
+	/**
+	* 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;
+	/**
+	* List of files included in coverage as glob patterns.
+	* By default only files covered by tests are included.
+	*
+	* See [Including and excluding files from coverage report](https://vitest.dev/guide/coverage.html#including-and-excluding-files-from-coverage-report) for examples.
+	*/
+	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?: 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<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.
+	*
+	* @default false
+	*/
+	reportOnFailure?: boolean;
+	/**
+	* Collect coverage of files outside the project `root`.
+	*
+	* @default false
+	*/
+	allowExternal?: boolean;
+	/**
+	* Apply exclusions again after coverage has been remapped to original sources.
+	* This is useful when your source files are transpiled and may contain source maps
+	* of non-source files.
+	*
+	* Use this option when you are seeing files that show up in report even if they
+	* match your `coverage.exclude` patterns.
+	*
+	* @default false
 	*/
-	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
+	* Also can accept a function to format the new threshold values
+	*
+	* @default false
+	*/
+	autoUpdate?: boolean | ((newThreshold: number) => number);
+	/** 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, file: string): Pool;
 
 interface TestRunResult {
 	testModules: TestModule[];
@@ -1062,14 +1401,61 @@ declare class VitestCache {
 	constructor(version: string);
 	getFileTestResults(key: string): SuiteResultCache | undefined;
 	getFileStats(key: string): {
-		size: number
+		size: number;
 	} | undefined;
 	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[]
+		paths?: string[];
 	}): boolean;
 	ensureInstalled(dependency: string, root: string, version?: string): Promise<boolean>;
 }
@@ -1081,9 +1467,11 @@ declare class BlobReporter implements Reporter {
 	start: number;
 	ctx: Vitest;
 	options: BlobOptions;
+	coverage: unknown | undefined;
 	constructor(options: BlobOptions);
 	onInit(ctx: Vitest): void;
-	onFinished(files: File[] | undefined, errors: unknown[] | undefined, coverage: unknown): Promise<void>;
+	onCoverage(coverage: unknown): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>): Promise<void>;
 }
 interface MergedBlobs {
 	files: File[];
@@ -1101,7 +1489,12 @@ declare class StateManager {
 	processTimeoutCauses: Set<string>;
 	reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
 	blobs?: MergedBlobs;
-	catchError(err: unknown, type: string): void;
+	transformTime: number;
+	onUnhandledError?: OnUnhandledErrorCallback;
+	constructor(options: {
+		onUnhandledError?: OnUnhandledErrorCallback;
+	});
+	catchError(error: unknown, type: string): void;
 	clearErrors(): void;
 	getUnhandledErrors(): unknown[];
 	addProcessTimeoutCause(cause: string): void;
@@ -1125,6 +1518,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;
@@ -1163,17 +1586,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 _workspaceConfigPath?;
+	private _coverageProvider?;
 	constructor(mode: VitestRunMode, cliOptions: UserConfig, options?: VitestOptions);
 	private _onRestartListeners;
 	private _onClose;
@@ -1181,16 +1611,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.
 	*/
@@ -1208,8 +1632,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.
@@ -1224,23 +1649,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>;
-	private resolveWorkspaceConfigPath;
+	/**
+	* 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.
@@ -1253,8 +1675,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
@@ -1275,11 +1695,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.
 	*
@@ -1304,6 +1723,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.
@@ -1337,18 +1761,19 @@ declare class Vitest {
 	*/
 	setGlobalTestNamePattern(pattern: string | RegExp): void;
 	/**
+	* Returns the regexp used for the global test name pattern.
+	*/
+	getGlobalTestNamePattern(): RegExp | undefined;
+	/**
 	* Resets the global test name pattern. This method doesn't run any tests.
 	*/
 	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.
@@ -1361,16 +1786,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;
@@ -1415,26 +1830,6 @@ interface Reporter {
 	* @experimental
 	*/
 	onBrowserInit?: (project: TestProject) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestRunStart` instead
-	*/
-	onPathsCollected?: (paths?: string[]) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestRunStart` instead
-	*/
-	onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestModuleCollected` instead
-	*/
-	onCollected?: (files: File[]) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestRunEnd` instead
-	*/
-	onFinished?: (files: File[], errors: unknown[], coverage?: unknown) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestModuleQueued`, `onTestModuleStart`, `onTestModuleEnd`, `onTestCaseReady`, `onTestCaseResult` instead
-	*/
-	onTaskUpdate?: (packs: TaskResultPack[], events: TaskEventPack[]) => Awaitable$1<void>;
 	onTestRemoved?: (trigger?: string) => Awaitable$1<void>;
 	onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable$1<void>;
 	onWatcherRerun?: (files: string[], trigger?: string) => Awaitable$1<void>;
@@ -1510,173 +1905,68 @@ declare abstract class BaseReporter implements Reporter {
 	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;
-	onFinished(files?: File[], errors?: unknown[]): 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;
-	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;
-	onTestRunEnd(): 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[] };
+	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(testSuite: TestSuite): void;
+	protected getTestName(test: Task, _separator?: string): string;
+	protected getFullName(test: Task, separator?: string): string;
+	protected getTestIndentation(test: Task): string;
+	protected printAnnotations(test: TestCase, console: "log" | "error", padding?: number): void;
+	protected getEntityPrefix(entity: TestCase | TestModule | TestSuite): string;
+	protected getTestCaseSuffix(testCase: TestCase): string;
+	protected getStateSymbol(test: TestCase | TestModule | TestSuite): string;
+	private getDurationPrefix;
+	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 Totals {
-    total: number;
-    covered: number;
-    skipped: number;
-    pct: number;
+interface DefaultReporterOptions extends BaseOptions {
+	summary?: boolean;
 }
-
-interface Coverage {
-    covered: number;
-    total: number;
-    coverage: number;
+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;
 }
 
-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 HTMLOptions {
+	outputFile?: string;
 }
 
-// for compatibility reasons, the reporter produces a JSON similar to the one produced by the Jest JSON reporter
-// the following types are extracted from the Jest repository (and simplified)
-// the commented-out fields are the missing ones
 type Status = "passed" | "failed" | "skipped" | "pending" | "todo" | "disabled";
 type Milliseconds = number;
 interface Callsite {
@@ -1717,17 +2007,18 @@ 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;
-	constructor(options: JsonOptions$1);
+	options: JsonOptions;
+	coverageMap?: CoverageMap;
+	constructor(options: JsonOptions);
 	onInit(ctx: Vitest): void;
-	protected logTasks(files: File[], coverageMap?: CoverageMap | null): Promise<void>;
-	onFinished(files?: File[], _errors?: unknown[], coverageMap?: unknown): Promise<void>;
+	onCoverage(coverageMap: unknown): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
 	/**
 	* Writes the report to an output file if specified in the config,
 	* or logs it to the console otherwise.
@@ -1742,8 +2033,6 @@ interface ClassnameTemplateVariables {
 }
 interface JUnitOptions {
 	outputFile?: string;
-	/** @deprecated Use `classnameTemplate` instead. */
-	classname?: string;
 	/**
 	* Template for the classname attribute. Can be either a string or a function. The string can contain placeholders {filename} and {filepath}.
 	*/
@@ -1773,7 +2062,7 @@ declare class JUnitReporter implements Reporter {
 	writeElement(name: string, attrs: Record<string, any>, children: () => Promise<void>): Promise<void>;
 	writeLogs(task: Task, type: "err" | "out"): Promise<void>;
 	writeTasks(tasks: Task[], filename: string): Promise<void>;
-	onFinished(files?: File[]): Promise<void>;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
 }
 
 declare class DotReporter extends BaseReporter {
@@ -1781,10 +2070,9 @@ declare class DotReporter extends BaseReporter {
 	private tests;
 	private finishedTests;
 	onInit(ctx: Vitest): void;
-	// Ignore default logging of base reporter
 	printTestModule(): void;
 	onWatcherRerun(files: string[], trigger?: string): void;
-	onFinished(files?: File[], errors?: unknown[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): void;
 	onTestModuleCollected(module: TestModule): void;
 	onTestCaseReady(test: TestCase): void;
 	onTestCaseResult(test: TestCase): void;
@@ -1801,7 +2089,7 @@ declare class GithubActionsReporter implements Reporter {
 	constructor(options?: GithubActionsReporterOptions);
 	onInit(ctx: Vitest): void;
 	onTestCaseAnnotate(testCase: TestCase, annotation: TestAnnotation): void;
-	onFinished(files?: File[], errors?: unknown[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>): void;
 }
 
 declare class HangingProcessReporter implements Reporter {
@@ -1817,37 +2105,38 @@ declare class TapReporter implements Reporter {
 	static getComment(task: Task): string;
 	private logErrorDetails;
 	protected logTasks(tasks: Task[]): void;
-	onFinished(files?: File[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): void;
 }
 
 declare class TapFlatReporter extends TapReporter {
 	onInit(ctx: Vitest): void;
-	onFinished(files?: File[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): void;
+}
+
+declare class TreeReporter extends DefaultReporter {
+	protected verbose: boolean;
+	renderSucceed: boolean;
 }
 
 declare class VerboseReporter extends DefaultReporter {
 	protected verbose: boolean;
 	renderSucceed: boolean;
-	printTestModule(module: TestModule): void;
+	printTestModule(_module: TestModule): void;
 	onTestCaseResult(test: TestCase): void;
-	protected printTestSuite(testSuite: TestSuite): void;
-	protected getTestName(test: Task): string;
-	protected getTestIndentation(test: Task): string;
-	protected formatShortError(): string;
 }
 
 type FormattedBenchmarkResult = BenchmarkResult & {
-	id: string
+	id: string;
 };
 
 declare function renderTable(options: {
-	tasks: Task[]
-	level: number
-	shallow?: boolean
-	showHeap: boolean
-	columns: number
-	slowTestThreshold: number
-	compare?: Record<Task["id"], FormattedBenchmarkResult>
+	tasks: Task[];
+	level: number;
+	shallow?: boolean;
+	showHeap: boolean;
+	columns: number;
+	slowTestThreshold: number;
+	compare?: Record<Task["id"], FormattedBenchmarkResult>;
 }): string;
 
 declare class BenchmarkReporter extends DefaultReporter {
@@ -1857,7 +2146,7 @@ declare class BenchmarkReporter extends DefaultReporter {
 	onTestSuiteResult(testSuite: TestSuite): void;
 	protected printTestModule(testModule: TestModule): void;
 	private printSuiteTable;
-	onFinished(files?: File[], errors?: unknown[]): Promise<void>;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): Promise<void>;
 }
 
 declare class VerboseBenchmarkReporter extends BenchmarkReporter {
@@ -1865,380 +2154,97 @@ declare class VerboseBenchmarkReporter extends BenchmarkReporter {
 }
 
 declare const BenchmarkReportsMap: {
-	default: typeof BenchmarkReporter
-	verbose: typeof VerboseBenchmarkReporter
+	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
+	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;
+	tree: typeof TreeReporter;
+	"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;
-}
-
-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>;
-}
-interface ReportContext {
-	/** Indicates whether all tests were run. False when only specific tests were run. */
-	allTestsRun?: boolean;
+interface BuiltinReporterOptions {
+	"default": DefaultReporterOptions;
+	"verbose": DefaultReporterOptions;
+	"dot": BaseOptions;
+	"tree": 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";
-// Record is used, so user can get intellisense for builtin environments, but still allow custom environments
 type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
 
 type CSSModuleScopeStrategy = "stable" | "scoped" | "non-scoped";
@@ -2284,12 +2290,12 @@ interface SequenceOptions {
 		* earlier if you enable this option.
 		* @default false
 		*/
-		files?: boolean
+		files?: boolean;
 		/**
 		* Should tests run in random order.
 		* @default false
 		*/
-		tests?: boolean
+		tests?: boolean;
 	};
 	/**
 	* Should tests run in parallel.
@@ -2318,33 +2324,13 @@ interface SequenceOptions {
 	hooks?: SequenceHooks;
 }
 type DepsOptimizationOptions = Omit<DepOptimizationConfig, "disabled" | "noDiscovery"> & {
-	enabled?: boolean
+	enabled?: boolean;
 };
-interface TransformModePatterns {
-	/**
-	* Use SSR transform pipeline for all modules inside specified tests.
-	* Vite plugins will receive `ssr: true` flag when processing those files.
-	*
-	* @default tests with node or edge environment
-	*/
-	ssr?: string[];
-	/**
-	* First do a normal transform pipeline (targeting browser),
-	* then then do a SSR rewrite to run the code in Node.
-	* Vite plugins will receive `ssr: false` flag when processing those files.
-	*
-	* @default tests with jsdom or happy-dom environment
-	*/
-	web?: string[];
-}
 interface DepsOptions {
 	/**
 	* Enable dependency optimization. This can improve the performance of your tests.
 	*/
-	optimizer?: {
-		web?: DepsOptimizationOptions
-		ssr?: DepsOptimizationOptions
-	};
+	optimizer?: Partial<Record<"client" | "ssr" | ({} & string), DepsOptimizationOptions>>;
 	web?: {
 		/**
 		* Should Vitest process assets (.png, .svg, .jpg, etc) files and resolve them like Vite does in the browser.
@@ -2355,7 +2341,7 @@ interface DepsOptions {
 		*
 		* @default true
 		*/
-		transformAssets?: boolean
+		transformAssets?: boolean;
 		/**
 		* Should Vitest process CSS (.css, .scss, .sass, etc) files and resolve them like Vite does in the browser.
 		*
@@ -2365,7 +2351,7 @@ interface DepsOptions {
 		*
 		* @default true
 		*/
-		transformCss?: boolean
+		transformCss?: boolean;
 		/**
 		* Regexp pattern to match external files that should be transformed.
 		*
@@ -2375,46 +2361,15 @@ interface DepsOptions {
 		*
 		* @default []
 		*/
-		transformGlobPattern?: RegExp | RegExp[]
+		transformGlobPattern?: RegExp | RegExp[];
 	};
 	/**
-	* Externalize means that Vite will bypass the package to native Node.
-	*
-	* Externalized dependencies will not be applied Vite's transformers and resolvers.
-	* And does not support HMR on reload.
-	*
-	* Typically, packages under `node_modules` are externalized.
-	*
-	* @deprecated If you rely on vite-node directly, use `server.deps.external` instead. Otherwise, consider using `deps.optimizer.{web,ssr}.exclude`.
-	*/
-	external?: (string | RegExp)[];
-	/**
-	* Vite will process inlined modules.
-	*
-	* This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
-	*
-	* If `true`, every dependency will be inlined
-	*
-	* @deprecated If you rely on vite-node directly, use `server.deps.inline` instead. Otherwise, consider using `deps.optimizer.{web,ssr}.include`.
-	*/
-	inline?: (string | RegExp)[] | true;
-	/**
 	* Interpret CJS module's default as named exports
 	*
 	* @default true
 	*/
 	interopDefault?: boolean;
 	/**
-	* When a dependency is a valid ESM package, try to guess the cjs version based on the path.
-	* This will significantly improve the performance in huge repo, but might potentially
-	* cause some misalignment if a package have different logic in ESM and CJS mode.
-	*
-	* @default false
-	*
-	* @deprecated Use `server.deps.fallbackCJS` instead.
-	*/
-	fallbackCJS?: boolean;
-	/**
 	* A list of directories relative to the config file that should be treated as module directories.
 	*
 	* @default ['node_modules']
@@ -2461,10 +2416,9 @@ interface InlineConfig {
 	*
 	*/
 	deps?: DepsOptions;
-	/**
-	* Vite-node server options
-	*/
-	server?: Omit<ViteNodeServerOptions, "transformMode">;
+	server?: {
+		deps?: ServerDepsOptions;
+	};
 	/**
 	* Base directory to scan for the test files
 	*
@@ -2492,23 +2446,6 @@ interface InlineConfig {
 	*/
 	environmentOptions?: EnvironmentOptions;
 	/**
-	* Automatically assign environment based on globs. The first match will be used.
-	* This has effect only when running tests inside Node.js.
-	*
-	* Format: [glob, environment-name]
-	*
-	* @deprecated use [`projects`](https://vitest.dev/config/#projects) instead
-	* @default []
-	* @example [
-	*   // all tests in tests/dom will run in jsdom
-	*   ['tests/dom/**', 'jsdom'],
-	*   // all tests in tests/ with .edge.test.ts will run in edge-runtime
-	*   ['**\/*.edge.test.ts', 'edge-runtime'],
-	*   // ...
-	* ]
-	*/
-	environmentMatchGlobs?: [string, VitestEnvironment][];
-	/**
 	* Run tests in an isolated environment. This option has no effect on vmThreads pool.
 	*
 	* Disabling this option might improve performance if your code doesn't rely on side effects.
@@ -2533,41 +2470,17 @@ interface InlineConfig {
 	*/
 	maxWorkers?: number | string;
 	/**
-	* Minimum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.minThreads`/`poolOptions.forks.minForks` has higher priority.
-	*/
-	minWorkers?: number | string;
-	/**
 	* Should all test files run in parallel. Doesn't affect tests running in the same file.
-	* Setting this to `false` will override `maxWorkers` and `minWorkers` options to `1`.
+	* Setting this to `false` will override `maxWorkers` option to `1`.
 	*
 	* @default true
 	*/
 	fileParallelism?: boolean;
 	/**
-	* Automatically assign pool based on globs. The first match will be used.
-	*
-	* Format: [glob, pool-name]
-	*
-	* @deprecated use [`projects`](https://vitest.dev/config/#projects) instead
-	* @default []
-	* @example [
-	*   // all tests in "forks" directory will run using "poolOptions.forks" API
-	*   ['tests/forks/**', 'forks'],
-	*   // all other tests will run based on "poolOptions.threads" option, if you didn't specify other globs
-	*   // ...
-	* ]
-	*/
-	poolMatchGlobs?: [string, Exclude<Pool, "browser">][];
-	/**
 	* Options for projects
 	*/
 	projects?: TestProjectConfiguration[];
 	/**
-	* Path to a workspace configuration file
-	* @deprecated use `projects` instead
-	*/
-	workspace?: string | TestProjectConfiguration[];
-	/**
 	* Update snapshot
 	*
 	* @default false
@@ -2591,7 +2504,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.
@@ -2638,7 +2551,7 @@ interface InlineConfig {
 	*/
 	globalSetup?: string | string[];
 	/**
-	* Glob patter of file paths that will trigger the whole suite rerun
+	* Glob pattern of file paths that will trigger the whole suite rerun
 	*
 	* Useful if you are testing calling CLI commands
 	*
@@ -2717,13 +2630,11 @@ interface InlineConfig {
 	*/
 	uiBase?: string;
 	/**
-	* Determine the transform method for all modules imported inside a test that matches the glob pattern.
-	*/
-	testTransformMode?: TransformModePatterns;
-	/**
 	* Format options for snapshot testing.
 	*/
-	snapshotFormat?: Omit<PrettyFormatOptions, "plugins">;
+	snapshotFormat?: Omit<PrettyFormatOptions, "plugins" | "compareKeys"> & {
+		compareKeys?: null | undefined;
+	};
 	/**
 	* Path to a module which has a default export of diff config.
 	*/
@@ -2776,6 +2687,10 @@ interface InlineConfig {
 	*/
 	onStackTrace?: (error: TestError, frame: ParsedStack) => boolean | void;
 	/**
+	* A callback that can return `false` to ignore an unhandled error
+	*/
+	onUnhandledError?: OnUnhandledErrorCallback;
+	/**
 	* Indicates if CSS files should be processed.
 	*
 	* When excluded, the CSS files will be replaced with empty strings to bypass the subsequent processing.
@@ -2783,11 +2698,11 @@ interface InlineConfig {
 	* @default { include: [], modules: { classNameStrategy: false } }
 	*/
 	css?: boolean | {
-		include?: RegExp | RegExp[]
-		exclude?: RegExp | RegExp[]
+		include?: RegExp | RegExp[];
+		exclude?: RegExp | RegExp[];
 		modules?: {
-			classNameStrategy?: CSSModuleScopeStrategy
-		}
+			classNameStrategy?: CSSModuleScopeStrategy;
+		};
 	};
 	/**
 	* A number of tests that are allowed to run at the same time marked with `test.concurrent`.
@@ -2802,7 +2717,7 @@ interface InlineConfig {
 		/**
 		* @deprecated Use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir\/vitest".
 		*/
-		dir: string
+		dir: string;
 	};
 	/**
 	* Options for configuring the order of running tests.
@@ -2855,19 +2770,19 @@ interface InlineConfig {
 		/**
 		* Enable inspector
 		*/
-		enabled?: boolean
+		enabled?: boolean;
 		/**
 		* Port to run inspector on
 		*/
-		port?: number
+		port?: number;
 		/**
 		* Host to run inspector on
 		*/
-		host?: string
+		host?: string;
 		/**
 		* Wait for debugger to connect before running tests
 		*/
-		waitForDebugger?: boolean
+		waitForDebugger?: boolean;
 	};
 	/**
 	* Define variables that will be returned from `inject` in the test environment.
@@ -2896,7 +2811,7 @@ interface InlineConfig {
 		/**
 		* Throw an error if tests don't have any expect() assertions.
 		*/
-		requireAssertions?: boolean
+		requireAssertions?: boolean;
 		/**
 		* Default options for expect.poll()
 		*/
@@ -2905,13 +2820,13 @@ interface InlineConfig {
 			* Timeout in milliseconds
 			* @default 1000
 			*/
-			timeout?: number
+			timeout?: number;
 			/**
 			* Polling interval in milliseconds
 			* @default 50
 			*/
-			interval?: number
-		}
+			interval?: number;
+		};
 	};
 	/**
 	* Modify default Chai config. Vitest uses Chai for `expect` and `assert` matches.
@@ -3021,7 +2936,7 @@ interface UserConfig extends InlineConfig {
 	*
 	* Vitest will only run tests if it's called programmatically or the test file changes.
 	*
-	* CLI file filters will be ignored.
+	* If CLI file filters are passed, standalone mode is ignored.
 	*/
 	standalone?: boolean;
 	/**
@@ -3076,6 +2991,9 @@ interface UserConfig extends InlineConfig {
 	*/
 	mergeReports?: string;
 }
+type OnUnhandledErrorCallback = (error: (TestError | Error) & {
+	type: string;
+}) => boolean | void;
 interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config" | "filters" | "browser" | "coverage" | "testNamePattern" | "related" | "api" | "reporters" | "resolveSnapshotPath" | "benchmark" | "shard" | "cache" | "sequence" | "typecheck" | "runner" | "poolOptions" | "pool" | "cliExclude" | "diff" | "setupFiles" | "snapshotEnvironment" | "bail" | "name"> {
 	mode: VitestRunMode;
 	name: ProjectName["label"];
@@ -3097,53 +3015,75 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config"
 	reporters: (InlineReporter | ReporterWithOptions)[];
 	defines: Record<string, any>;
 	api: ApiConfig & {
-		token: string
+		token: string;
 	};
 	cliExclude?: string[];
 	project: string[];
 	benchmark?: Required<Omit<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">> & Pick<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">;
 	shard?: {
-		index: number
-		count: number
+		index: number;
+		count: number;
 	};
 	cache: {
 		/**
 		* @deprecated
 		*/
-		dir: string
+		dir: string;
 	} | false;
 	sequence: {
-		sequencer: TestSequencerConstructor
-		hooks: SequenceHooks
-		setupFiles: SequenceSetupFiles
-		shuffle?: boolean
-		concurrent?: boolean
-		seed: number
-		groupOrder: number
+		sequencer: TestSequencerConstructor;
+		hooks: SequenceHooks;
+		setupFiles: SequenceSetupFiles;
+		shuffle?: boolean;
+		concurrent?: boolean;
+		seed: number;
+		groupOrder: number;
 	};
 	typecheck: Omit<TypecheckConfig, "enabled"> & {
-		enabled: boolean
+		enabled: boolean;
 	};
 	runner?: string;
 	maxWorkers: number;
-	minWorkers: number;
 }
-type NonProjectOptions = "shard" | "watch" | "run" | "cache" | "update" | "reporters" | "outputFile" | "teardownTimeout" | "silent" | "forceRerunTriggers" | "testNamePattern" | "ui" | "open" | "uiBase" | "snapshotFormat" | "resolveSnapshotPath" | "passWithNoTests" | "onConsoleLog" | "onStackTrace" | "dangerouslyIgnoreUnhandledErrors" | "slowTestThreshold" | "inspect" | "inspectBrk" | "coverage" | "maxWorkers" | "minWorkers" | "fileParallelism" | "workspace" | "watchTriggerPatterns";
+type NonProjectOptions = "shard" | "watch" | "run" | "cache" | "update" | "reporters" | "outputFile" | "teardownTimeout" | "silent" | "forceRerunTriggers" | "testNamePattern" | "ui" | "open" | "uiBase" | "snapshotFormat" | "resolveSnapshotPath" | "passWithNoTests" | "onConsoleLog" | "onStackTrace" | "dangerouslyIgnoreUnhandledErrors" | "slowTestThreshold" | "inspect" | "inspectBrk" | "coverage" | "maxWorkers" | "fileParallelism" | "watchTriggerPatterns";
+interface ServerDepsOptions {
+	/**
+	* Externalize means that Vite will bpass the package to native Node.
+	*
+	* Externalized dependencies will not be applied Vite's transformers and resolvers.
+	* And does not support HMR on reload.
+	*
+	* Typically, packages under `node_modules` are externalized.
+	*/
+	external?: (string | RegExp)[];
+	/**
+	* Vite will process inlined modules.
+	*
+	* This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
+	*
+	* If `true`, every dependency will be inlined
+	*/
+	inline?: (string | RegExp)[] | true;
+	/**
+	* Try to guess the CJS version of a package when it's invalid ESM
+	* @default false
+	*/
+	fallbackCJS?: boolean;
+}
 type ProjectConfig = Omit<InlineConfig, NonProjectOptions | "sequencer" | "deps" | "poolOptions"> & {
-	mode?: string
-	sequencer?: Omit<SequenceOptions, "sequencer" | "seed">
-	deps?: Omit<DepsOptions, "moduleDirectories">
+	mode?: string;
+	sequencer?: Omit<SequenceOptions, "sequencer" | "seed">;
+	deps?: Omit<DepsOptions, "moduleDirectories">;
 	poolOptions?: {
-		threads?: Pick<NonNullable<PoolOptions["threads"]>, "singleThread" | "isolate">
-		vmThreads?: Pick<NonNullable<PoolOptions["vmThreads"]>, "singleThread">
-		forks?: Pick<NonNullable<PoolOptions["forks"]>, "singleFork" | "isolate">
-	}
+		threads?: Pick<NonNullable<PoolOptions["threads"]>, "singleThread" | "isolate">;
+		vmThreads?: Pick<NonNullable<PoolOptions["vmThreads"]>, "singleThread">;
+		forks?: Pick<NonNullable<PoolOptions["forks"]>, "singleFork" | "isolate">;
+	};
 };
 type ResolvedProjectConfig = Omit<ResolvedConfig, Exclude<NonProjectOptions, "coverage" | "watch">>;
 interface UserWorkspaceConfig extends UserConfig$1 {
 	test?: ProjectConfig;
 }
-// TODO: remove types when "workspace" support is removed
 type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
 type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
@@ -3152,9 +3092,9 @@ type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
 	* If `true`, the project will inherit all options from the root config.
 	* @example '../vite.config.ts'
 	*/
-	extends?: string | true
+	extends?: string | true;
 });
 type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 
-export { CoverageMap as C, TestSuite as E, Logger as L, TestProject as T, Vitest as V, BenchmarkReportsMap as aA, DefaultReporter as aB, DotReporter as aC, GithubActionsReporter as aD, HangingProcessReporter as aE, JsonReporter as aF, JUnitReporter as aG, ReportersMap as aH, TapFlatReporter as aI, TapReporter as aJ, VerboseBenchmarkReporter as aK, VerboseReporter as aL, BaseReporter as aM, BenchmarkReporter as az, 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 aN, BuiltinReporterOptions as aO, BuiltinReporters as aP, JsonAssertionResult as aQ, JsonTestResult as aR, JsonTestResults as aS, ResolvedBrowserOptions as aa, BuiltinEnvironment as ab, CSSModuleScopeStrategy as ac, DepsOptimizationOptions as ad, EnvironmentOptions as ae, Pool as af, PoolOptions as ag, ProjectConfig as ah, ResolvedProjectConfig as ai, ResolveSnapshotPathHandler as aj, ResolveSnapshotPathHandlerContext as ak, TransformModePatterns as al, TypecheckConfig as am, VitestEnvironment as an, BaseCoverageOptions as ao, CoverageIstanbulOptions as ap, CoverageOptions as aq, CoverageProvider as ar, CoverageProviderModule as as, CoverageReporter as at, CustomProviderOptions as au, TestRunResult as av, ReportedHookContext as aw, Reporter as ax, TestRunEndReason as ay, 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, GithubActionsReporter as aA, HangingProcessReporter as aB, JsonReporter as aC, JUnitReporter as aD, ReportersMap as aE, TapFlatReporter as aF, TapReporter as aG, VerboseBenchmarkReporter as aH, VerboseReporter as aI, BaseReporter as aJ, BenchmarkReporter as aw, BenchmarkReportsMap as ax, DefaultReporter as ay, DotReporter 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, BrowserProviderOption as a0, BrowserScript as a1, BrowserServerState as a2, BrowserServerStateSession as a3, CDPSession as a4, ParentProjectBrowser as a5, ProjectBrowser as a6, ResolvedBrowserOptions as a7, ToMatchScreenshotComparators as a8, ToMatchScreenshotOptions as a9, BenchmarkBuiltinReporters as aK, BuiltinReporterOptions as aL, BuiltinReporters as aM, JsonAssertionResult as aN, JsonTestResult as aO, JsonTestResults as aP, BuiltinEnvironment as aa, CSSModuleScopeStrategy as ab, DepsOptimizationOptions as ac, EnvironmentOptions as ad, PoolOptions as ae, ProjectConfig as af, ResolvedProjectConfig as ag, ResolveSnapshotPathHandler as ah, ResolveSnapshotPathHandlerContext as ai, TypecheckConfig as aj, VitestEnvironment as ak, BaseCoverageOptions as al, CoverageIstanbulOptions as am, CoverageOptions as an, CoverageProvider as ao, CoverageProviderModule as ap, CoverageReporter as aq, CustomProviderOptions as ar, TestRunResult as as, ReportedHookContext as at, Reporter as au, TestRunEndReason as av, 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 };