vitest 4.0.0-beta.17 → 4.0.0-beta.19

package/dist/chunks/{reporters.d.DAyr7w3M.d.ts → reporters.d.C6nGyY9_.d.ts}

@@ -1,13 +1,13 @@
-import { CancelReason, TaskMeta, Suite, File, TestAnnotation, ImportDuration, Test, Task, TaskResultPack, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
-import { Awaitable, ParsedStack, TestError, SerializedError, Arrayable } from '@vitest/utils';
-import { P as ProvidedContext, A as AfterSuiteRunMeta, U as UserConsoleLog, L as LabelColor } from './worker.d.DSgBAZPX.js';
+import { TaskMeta, Suite, File, TestAnnotation, ImportDuration, Test, Task, TaskResultPack, FileSpecification, CancelReason, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
+import { TestError, SerializedError, Arrayable, ParsedStack, Awaitable } from '@vitest/utils';
+import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, C as ContextRPC, L as LabelColor } from './worker.d.BFk-vvBU.js';
 import { Writable } from 'node:stream';
-import { Plugin, ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
+import { TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { BrowserCommands } from 'vitest/browser';
-import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.C4PpNy7v.js';
-import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.CCG7W26I.js';
+import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.u2CUDWwS.js';
+import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.B9iJzZyn.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -70,922 +70,269 @@ interface ConstructorOptionsOverride {
 	resources?: "usable";
 }
 
-interface CDPSession {
-	send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
-	on: (event: string, listener: (...args: unknown[]) => void) => void;
-	once: (event: string, listener: (...args: unknown[]) => void) => void;
-	off: (event: string, listener: (...args: unknown[]) => void) => void;
-}
-interface BrowserModuleMocker {
-	register: (sessionId: string, module: MockedModule) => Promise<void>;
-	delete: (sessionId: string, url: string) => Promise<void>;
-	clear: (sessionId: string) => Promise<void>;
-}
-interface BrowserProviderOption<Options extends object = object> {
-	name: string;
-	supportedBrowser?: ReadonlyArray<string>;
-	options: Options;
-	providerFactory: (project: TestProject) => BrowserProvider;
-	serverFactory: BrowserServerFactory;
-}
-interface BrowserServerOptions {
-	project: TestProject;
-	coveragePlugin: () => Plugin;
-	mocksPlugins: (options: {
-		filter: (id: string) => boolean;
-	}) => Plugin[];
-	metaEnvReplacer: () => Plugin;
-}
-interface BrowserServerFactory {
-	(otpions: BrowserServerOptions): Promise<ParentProjectBrowser>;
-}
-interface BrowserProvider {
-	name: string;
-	mocker?: BrowserModuleMocker;
-	readonly initScripts?: string[];
+declare class ReportedTaskImplementation {
 	/**
-	* @experimental opt-in into file parallelisation
+	* The project associated with the test or suite.
 	*/
-	supportsParallelism: boolean;
-	getCommandsContext: (sessionId: string) => Record<string, unknown>;
-	openPage: (sessionId: string, url: string) => Promise<void>;
-	getCDPSession?: (sessionId: string) => Promise<CDPSession>;
-	close: () => Awaitable<void>;
-}
-type BrowserBuiltinProvider = "webdriverio" | "playwright" | "preview";
-interface _BrowserNames {}
-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"> {
+	readonly project: TestProject;
 	/**
-	* Name of the browser
+	* 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.
 	*/
-	browser: keyof _BrowserNames extends never ? string : _BrowserNames[keyof _BrowserNames];
-	name?: string;
-	provider?: BrowserProviderOption;
-}
-interface BrowserConfigOptions {
+	readonly id: string;
 	/**
-	* if running tests in the browser should be the default
-	*
-	* @default false
+	* Location in the module where the test or suite is defined.
 	*/
-	enabled?: boolean;
+	readonly location: {
+		line: number;
+		column: number;
+	} | undefined;
 	/**
-	* Configurations for different browser setups
+	* Checks if the test did not fail the suite.
+	* If the test is not finished yet or was skipped, it will return `true`.
 	*/
-	instances?: BrowserInstanceOption[];
+	ok(): boolean;
 	/**
-	* Browser provider
-	* @example
-	* ```ts
-	* import { playwright } from '@vitest/browser-playwright'
-	* export default defineConfig({
-	*   test: {
-	*     browser: {
-	*       provider: playwright(),
-	*     },
-	*   },
-	* })
-	* ```
+	* Custom metadata that was attached to the test during its execution.
 	*/
-	provider?: BrowserProviderOption;
+	meta(): TaskMeta;
+}
+declare class TestCase extends ReportedTaskImplementation {
+	#private;
+	readonly type = "test";
 	/**
-	* enable headless mode
-	*
-	* @default process.env.CI
+	* Direct reference to the test module where the test or suite is defined.
 	*/
-	headless?: boolean;
+	readonly module: TestModule;
 	/**
-	* Serve API options.
-	*
-	* The default port is 63315.
+	* Name of the test.
 	*/
-	api?: ApiConfig | number;
+	readonly name: string;
 	/**
-	* Isolate test environment after each test
-	*
-	* @default true
+	* Options that the test was initiated with.
 	*/
-	isolate?: boolean;
+	readonly options: TaskOptions;
 	/**
-	* Run test files in parallel if provider supports this option
-	* This option only has effect in headless mode (enabled in CI by default)
-	*
-	* @default // Same as "test.fileParallelism"
+	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
 	*/
-	fileParallelism?: boolean;
+	readonly parent: TestSuite | TestModule;
 	/**
-	* Show Vitest UI
-	*
-	* @default !process.env.CI
+	* Full name of the test including all parent suites separated with `>`.
 	*/
-	ui?: boolean;
+	get fullName(): string;
 	/**
-	* Default viewport size
+	* 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()`.
 	*/
-	viewport?: {
-		/**
-		* Width of the viewport
-		* @default 414
-		*/
-		width: number;
-		/**
-		* Height of the viewport
-		* @default 896
-		*/
-		height: number;
-	};
+	result(): TestResult;
 	/**
-	* Locator options
+	* Test annotations added via the `task.annotate` API during the test execution.
 	*/
-	locators?: {
-		/**
-		* Attribute used to locate elements by test id
-		* @default 'data-testid'
-		*/
-		testIdAttribute?: string;
-	};
+	annotations(): ReadonlyArray<TestAnnotation>;
 	/**
-	* Generate traces that can be viewed on https://trace.playwright.dev/
-	*
-	* This option is supported only by **playwright** provider.
+	* Useful information about the test like duration, memory usage, etc.
+	* Diagnostic is only available after the test has finished.
 	*/
-	trace?: BrowserTraceViewMode | {
-		mode: BrowserTraceViewMode;
-		/**
-		* The directory where all traces will be stored. By default, Vitest
-		* stores all traces in `__traces__` folder close to the test file.
-		*/
-		tracesDir?: string;
-		/**
-		* Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.
-		* @default true
-		*/
-		screenshots?: boolean;
-		/**
-		* If this option is true tracing will
-		* - capture DOM snapshot on every action
-		* - record network activity
-		* @default true
-		*/
-		snapshots?: boolean;
-	};
+	diagnostic(): TestDiagnostic | undefined;
+}
+declare class TestCollection {
+	#private;
+	constructor(task: Suite | File, project: TestProject);
 	/**
-	* Directory where screenshots will be saved when page.screenshot() is called
-	* If not set, all screenshots are saved to __screenshots__ directory in the same folder as the test file.
-	* If this is set, it will be resolved relative to the project root.
-	* @default __screenshots__
+	* Returns the test or suite at a specific index.
 	*/
-	screenshotDirectory?: string;
+	at(index: number): TestCase | TestSuite | undefined;
 	/**
-	* Should Vitest take screenshots if the test fails
-	* @default !browser.ui
+	* The number of tests and suites in the collection.
 	*/
-	screenshotFailures?: boolean;
+	get size(): number;
 	/**
-	* Path to the index.html file that will be used to run tests.
+	* Returns the collection in array form for easier manipulation.
 	*/
-	testerHtmlPath?: string;
+	array(): (TestCase | TestSuite)[];
 	/**
-	* Scripts injected into the main window.
+	* Filters all tests that are part of this collection and its children.
 	*/
-	orchestratorScripts?: BrowserScript[];
+	allTests(state?: TestState): Generator<TestCase, undefined, void>;
 	/**
-	* Commands that will be executed on the server
-	* via the browser `import("vitest/browser").commands` API.
-	* @see {@link https://vitest.dev/guide/browser/commands}
+	* Filters only the tests that are part of this collection.
 	*/
-	commands?: Record<string, BrowserCommand<any>>;
+	tests(state?: TestState): Generator<TestCase, undefined, void>;
 	/**
-	* Timeout for connecting to the browser
-	* @default 30000
+	* Filters only the suites that are part of this collection.
 	*/
-	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;
-	};
+	suites(): Generator<TestSuite, undefined, void>;
 	/**
-	* 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
+	* Filters all suites that are part of this collection and its children.
 	*/
-	trackUnhandledErrors?: boolean;
+	allSuites(): Generator<TestSuite, undefined, void>;
+	[Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
 }
-interface BrowserCommandContext {
-	testPath: string | undefined;
-	provider: BrowserProvider;
-	project: TestProject;
-	sessionId: string;
-	triggerCommand: <K extends keyof BrowserCommands>(name: K, ...args: Parameters<BrowserCommands[K]>) => ReturnType<BrowserCommands[K]>;
+
+type ReportedHookContext = {
+	readonly name: "beforeAll" | "afterAll";
+	readonly entity: TestSuite | TestModule;
+} | {
+	readonly name: "beforeEach" | "afterEach";
+	readonly entity: TestCase;
+};
+declare abstract class SuiteImplementation extends ReportedTaskImplementation {
+	/**
+	* Collection of suites and tests that are part of this suite.
+	*/
+	readonly children: TestCollection;
+	/**
+	* Errors that happened outside of the test run during collection, like syntax errors.
+	*/
+	errors(): SerializedError[];
 }
-interface BrowserServerStateSession {
-	project: TestProject;
-	connected: () => void;
-	fail: (v: Error) => void;
-}
-interface BrowserOrchestrator {
-	cleanupTesters: () => Promise<void>;
-	createTesters: (options: BrowserTesterOptions) => Promise<void>;
-	onCancel: (reason: CancelReason) => Promise<void>;
-	$close: () => void;
-}
-interface BrowserServerState {
-	orchestrators: Map<string, BrowserOrchestrator>;
-}
-interface ParentProjectBrowser {
-	spawn: (project: TestProject) => ProjectBrowser;
-	vite: ViteDevServer;
-}
-interface ProjectBrowser {
-	vite: ViteDevServer;
-	state: BrowserServerState;
-	provider: BrowserProvider;
-	close: () => Promise<void>;
-	initBrowserProvider: (project: TestProject) => Promise<void>;
-	parseStacktrace: (stack: string) => ParsedStack[];
-	parseErrorStacktrace: (error: TestError, options?: StackTraceParserOptions) => ParsedStack[];
-	registerCommand: <K extends keyof BrowserCommands>(name: K, cb: BrowserCommand<Parameters<BrowserCommands[K]>, ReturnType<BrowserCommands[K]>>) => void;
-	triggerCommand: <K extends keyof BrowserCommands>(name: K, context: BrowserCommandContext, ...args: Parameters<BrowserCommands[K]>) => ReturnType<BrowserCommands[K]>;
-}
-interface BrowserCommand<
-	Payload extends unknown[] = [],
-	ReturnValue = any
-> {
-	(context: BrowserCommandContext, ...payload: Payload): Awaitable<ReturnValue>;
-}
-interface BrowserScript {
-	/**
-	* If "content" is provided and type is "module", this will be its identifier.
-	*
-	* If you are using TypeScript, you can add `.ts` extension here for example.
-	* @default `injected-${index}.js`
-	*/
-	id?: string;
+declare class TestSuite extends SuiteImplementation {
+	#private;
+	readonly type = "suite";
 	/**
-	* JavaScript content to be injected. This string is processed by Vite plugins if type is "module".
-	*
-	* You can use `id` to give Vite a hint about the file extension.
+	* Name of the test or the suite.
 	*/
-	content?: string;
+	readonly name: string;
 	/**
-	* Path to the script. This value is resolved by Vite so it can be a node module or a file path.
+	* Direct reference to the test module where the test or suite is defined.
 	*/
-	src?: string;
+	readonly module: TestModule;
 	/**
-	* If the script should be loaded asynchronously.
+	* Parent suite. If suite was called directly inside the module, the parent will be the module itself.
 	*/
-	async?: boolean;
+	readonly parent: TestSuite | TestModule;
 	/**
-	* Script type.
-	* @default 'module'
+	* Options that suite was initiated with.
 	*/
-	type?: string;
-}
-interface ResolvedBrowserOptions extends BrowserConfigOptions {
-	name: string;
-	enabled: boolean;
-	headless: boolean;
-	isolate: boolean;
-	fileParallelism: boolean;
-	api: ApiConfig;
-	ui: boolean;
-	viewport: {
-		width: number;
-		height: number;
-	};
-	screenshotFailures: boolean;
-	locators: {
-		testIdAttribute: string;
-	};
-	trace: {
-		mode: BrowserTraceViewMode;
-		tracesDir?: string;
-		screenshots?: boolean;
-		snapshots?: boolean;
-	};
-}
-type ToMatchScreenshotResolvePath = (data: {
+	readonly options: TaskOptions;
 	/**
-	* 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"
+	* Checks if the suite has any failed tests.
+	* This will also return `false` if suite failed during collection.
 	*/
-	arg: string;
+	ok: () => boolean;
 	/**
-	* 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.
+	* The meta information attached to the suite during its collection or execution.
 	*/
-	ext: string;
+	meta: () => TaskMeta;
 	/**
-	* The instance's browser name.
+	* Checks the running state of the suite.
 	*/
-	browserName: string;
+	state(): TestSuiteState;
 	/**
-	* The value of {@linkcode process.platform}.
+	* Full name of the suite including all parent suites separated with `>`.
 	*/
-	platform: NodeJS.Platform;
+	get fullName(): string;
+}
+declare class TestModule extends SuiteImplementation {
+	readonly location: undefined;
+	readonly type = "module";
 	/**
-	* The value provided to
-	* {@linkcode https://vitest.dev/guide/browser/config#browser-screenshotdirectory|browser.screenshotDirectory},
-	* if none is provided, its default value.
+	* 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.
 	*/
-	screenshotDirectory: string;
+	readonly moduleId: string;
 	/**
-	* Absolute path to the project's
-	* {@linkcode https://vitest.dev/config/#root|root}.
+	* Module id relative to the project. This is the same as `task.name`.
 	*/
-	root: string;
+	readonly relativeModuleId: string;
 	/**
-	* Path to the test file, relative to the project's
-	* {@linkcode https://vitest.dev/config/#root|root}.
+	* Checks the running state of the test file.
 	*/
-	testFileDirectory: string;
+	state(): TestModuleState;
 	/**
-	* The test's filename.
+	* Checks if the module has any failed tests.
+	* This will also return `false` if module failed during collection.
 	*/
-	testFileName: string;
+	ok: () => boolean;
 	/**
-	* The {@linkcode https://vitest.dev/api/#test|test}'s name, including
-	* parent {@linkcode https://vitest.dev/api/#describe|describe}, sanitized.
+	* The meta information attached to the module during its collection or execution.
 	*/
-	testName: string;
+	meta: () => TaskMeta;
 	/**
-	* The value provided to
-	* {@linkcode https://vitest.dev/config/#attachmentsdir|attachmentsDir},
-	* if none is provided, its default value.
+	* Useful information about the module like duration, memory usage, etc.
+	* If the module was not executed yet, all diagnostic values will return `0`.
 	*/
-	attachmentsDir: string;
-}) => string;
-interface ToMatchScreenshotOptions {
+	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 {
 	/**
-	* Overrides default reference screenshot path.
-	*
-	* @default `${root}/${testFileDirectory}/${screenshotDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}`
+	* The test was collected, but didn't finish running yet.
 	*/
-	resolveScreenshotPath?: ToMatchScreenshotResolvePath;
+	readonly state: "pending";
 	/**
-	* Overrides default screenshot path used for diffs.
-	*
-	* @default `${root}/${attachmentsDir}/${testFileDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}`
+	* Pending tests have no errors.
 	*/
-	resolveDiffPath?: ToMatchScreenshotResolvePath;
+	readonly errors: undefined;
 }
-interface ToMatchScreenshotComparators {}
-
-type BuiltinPool = "browser" | "threads" | "forks" | "vmThreads" | "vmForks" | "typescript";
-type Pool = BuiltinPool | (string & {});
-interface PoolOptions extends Record<string, unknown> {
+interface TestResultPassed {
 	/**
-	* 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.
+	* The test passed successfully.
 	*/
-	threads?: ThreadsOptions & WorkerContextOptions;
+	readonly state: "passed";
 	/**
-	* Run tests in `node:child_process` using [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
+	* Errors that were thrown during the test execution.
 	*
-	* Test isolation (when enabled) is done by spawning a new child process for each test file.
+	* **Note**: If test was retried successfully, errors will still be reported.
 	*/
-	forks?: ForksOptions & WorkerContextOptions;
+	readonly errors: ReadonlyArray<TestError> | undefined;
+}
+interface TestResultFailed {
 	/**
-	* 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.
+	* The test failed to execute.
 	*/
-	vmThreads?: ThreadsOptions & VmOptions;
+	readonly state: "failed";
 	/**
-	* 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.
+	* Errors that were thrown during the test execution.
 	*/
-	vmForks?: ForksOptions & VmOptions;
-}
-interface ResolvedPoolOptions extends PoolOptions {
-	threads?: ResolvedThreadsOptions & WorkerContextOptions;
-	forks?: ResolvedForksOptions & WorkerContextOptions;
-	vmThreads?: ResolvedThreadsOptions & VmOptions;
-	vmForks?: ResolvedForksOptions & VmOptions;
+	readonly errors: ReadonlyArray<TestError>;
 }
-interface ThreadsOptions {
-	/** Maximum amount of threads to use */
-	maxThreads?: number | string;
+interface TestResultSkipped {
 	/**
-	* Run tests inside a single thread.
-	*
-	* @default false
+	* 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.
 	*/
-	singleThread?: boolean;
+	readonly state: "skipped";
 	/**
-	* Use Atomics to synchronize threads
-	*
-	* This can improve performance in some cases, but might cause segfault in older Node versions.
-	*
-	* @default false
+	* Skipped tests have no errors.
 	*/
-	useAtomics?: boolean;
-}
-interface ResolvedThreadsOptions extends ThreadsOptions {
-	maxThreads?: number;
-}
-interface ForksOptions {
-	/** Maximum amount of child processes to use */
-	maxForks?: number | string;
+	readonly errors: undefined;
 	/**
-	* Run tests inside a single fork.
-	*
-	* @default false
+	* A custom note passed down to `ctx.skip(note)`.
 	*/
-	singleFork?: boolean;
-}
-interface ResolvedForksOptions extends ForksOptions {
-	maxForks?: number;
+	readonly note: string | undefined;
 }
-interface WorkerContextOptions {
+interface TestDiagnostic {
 	/**
-	* Isolate test environment by recycling `worker_threads` or `child_process` after each test
-	*
-	* @default true
+	* If the duration of the test is above `slowTestThreshold`.
 	*/
-	isolate?: boolean;
+	readonly slow: boolean;
 	/**
-	* Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
-	*
-	* See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
-	*
-	* Set to `process.execArgv` to pass all arguments of the current process.
-	*
-	* Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
-	*
-	* @default [] // no execution arguments are passed
+	* The amount of memory used by the test in bytes.
+	* This value is only available if the test was executed with `logHeapUsage` flag.
 	*/
-	execArgv?: string[];
-}
-interface VmOptions {
+	readonly heap: number | undefined;
 	/**
-	* Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
-	* If you see memory leaks, try to tinker this value.
+	* The time it takes to execute the test in ms.
 	*/
-	memoryLimit?: string | number;
-	/** Isolation is always enabled */
-	isolate?: true;
-	/**
-	* Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
-	*
-	* See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
-	*
-	* Set to `process.execArgv` to pass all arguments of the current process.
-	*
-	* Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
-	*
-	* @default [] // no execution arguments are passed
-	*/
-	execArgv?: string[];
-}
-
-declare class TestSpecification {
-	/**
-	* The task ID associated with the test module.
-	*/
-	readonly taskId: string;
-	/**
-	* The test project that the module belongs to.
-	*/
-	readonly project: TestProject;
-	/**
-	* The ID of the module in the Vite module graph. It is usually an absolute file path.
-	*/
-	readonly moduleId: string;
-	/**
-	* The current test pool. It's possible to have multiple pools in a single test project with `poolMatchGlob` and `typecheck.enabled`.
-	* @experimental In Vitest 4, the project will only support a single pool and this property will be removed.
-	*/
-	readonly pool: Pool;
-	/**
-	* Line numbers of the test locations to run.
-	*/
-	readonly testLines: number[] | undefined;
-	constructor(project: TestProject, moduleId: string, pool: Pool, testLines?: number[] | undefined);
-	/**
-	* Test module associated with the specification.
-	*/
-	get testModule(): TestModule | undefined;
-	toJSON(): SerializedTestSpecification;
-}
-
-declare class TestProject {
-	options?: InitializeProjectOptions | undefined;
-	/**
-	* The global Vitest instance.
-	* @experimental The public Vitest API is experimental and does not follow semver.
-	*/
-	readonly vitest: Vitest;
-	/**
-	* Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
-	*/
-	readonly globalConfig: ResolvedConfig;
-	/**
-	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
-	*/
-	browser?: ProjectBrowser;
-	/**
-	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
-	*/
-	readonly tmpDir: string;
-	/** @inetrnal */ testFilesList: string[] | null;
-	private runner;
-	private closingPromise;
-	private typecheckFilesList;
-	private _globalSetups?;
-	private _provided;
-	constructor(vitest: Vitest, options?: InitializeProjectOptions | undefined);
-	/**
-	* The unique hash of this project. This value is consistent between the reruns.
-	*
-	* It is based on the root of the project (not consistent between OS) and its name.
-	*/
-	get hash(): string;
-	/**
-	* Provide a value to the test context. This value will be available to all tests with `inject`.
-	*/
-	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
-	/**
-	* Get the provided context. The project context is merged with the global context.
-	*/
-	getProvidedContext(): ProvidedContext;
-	/**
-	* Creates a new test specification. Specifications describe how to run tests.
-	* @param moduleId The file path
-	*/
-	createSpecification(moduleId: string, locations?: number[] | undefined, pool?: string): TestSpecification;
-	toJSON(): SerializedTestProject;
-	/**
-	* Vite's dev server instance. Every workspace project has its own server.
-	*/
-	get vite(): ViteDevServer;
-	/**
-	* Resolved project configuration.
-	*/
-	get config(): ResolvedConfig;
-	/**
-	* The name of the project or an empty string if not set.
-	*/
-	get name(): string;
-	/**
-	* The color used when reporting tasks of this project.
-	*/
-	get color(): ProjectName["color"];
-	/**
-	* Serialized project configuration. This is the config that tests receive.
-	*/
-	get serializedConfig(): SerializedConfig;
-	/**
-	* Check if this is the root project. The root project is the one that has the root config.
-	*/
-	isRootProject(): boolean;
-	onTestsRerun(cb: OnTestsRerunHandler): void;
-	/**
-	* Get all files in the project that match the globs in the config and the filters.
-	* @param filters String filters to match the test files.
-	*/
-	globTestFiles(filters?: string[]): Promise<{
-		/**
-		* Test files that match the filters.
-		*/
-		testFiles: string[];
-		/**
-		* Typecheck test files that match the filters. This will be empty unless `typecheck.enabled` is `true`.
-		*/
-		typecheckTestFiles: string[];
-	}>;
-	private globAllTestFiles;
-	isBrowserEnabled(): boolean;
-	private markTestFile;
-	/**
-	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
-	*/
-	matchesTestGlob(moduleId: string, source?: () => string): boolean;
-	private isInSourceTestCode;
-	private filterFiles;
-	private _parentBrowser?;
-	/**
-	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
-	* If the resources are needed again, create a new project.
-	*/
-	close(): Promise<void>;
-	/**
-	* Import a file using Vite module runner.
-	* @param moduleId The ID of the module in Vite module graph
-	*/
-	import<T>(moduleId: string): Promise<T>;
-	private _setHash;
-	private _serializeOverriddenConfig;
-	private clearTmpDir;
-}
-interface SerializedTestProject {
-	name: string;
-	serializedConfig: SerializedConfig;
-	context: ProvidedContext;
-}
-interface InitializeProjectOptions extends TestProjectInlineConfiguration {
-	configFile: string | false;
-}
-
-declare class ReportedTaskImplementation {
-	/**
-	* The project associated with the test or suite.
-	*/
-	readonly project: TestProject;
-	/**
-	* Unique identifier.
-	* This ID is deterministic and will be the same for the same test across multiple runs.
-	* The ID is based on the project name, module url and test order.
-	*/
-	readonly id: string;
-	/**
-	* Location in the module where the test or suite is defined.
-	*/
-	readonly location: {
-		line: number;
-		column: number;
-	} | undefined;
-	/**
-	* Checks if the test did not fail the suite.
-	* If the test is not finished yet or was skipped, it will return `true`.
-	*/
-	ok(): boolean;
-	/**
-	* Custom metadata that was attached to the test during its execution.
-	*/
-	meta(): TaskMeta;
-}
-declare class TestCase extends ReportedTaskImplementation {
-	#private;
-	readonly type = "test";
-	/**
-	* Direct reference to the test module where the test or suite is defined.
-	*/
-	readonly module: TestModule;
-	/**
-	* Name of the test.
-	*/
-	readonly name: string;
-	/**
-	* Options that the test was initiated with.
-	*/
-	readonly options: TaskOptions;
-	/**
-	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
-	*/
-	readonly parent: TestSuite | TestModule;
-	/**
-	* Full name of the test including all parent suites separated with `>`.
-	*/
-	get fullName(): string;
-	/**
-	* Test results.
-	* - **pending**: Test was collected, but didn't finish running yet.
-	* - **passed**: Test passed successfully
-	* - **failed**: Test failed to execute
-	* - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
-	*/
-	result(): TestResult;
-	/**
-	* Test annotations added via the `task.annotate` API during the test execution.
-	*/
-	annotations(): ReadonlyArray<TestAnnotation>;
-	/**
-	* Useful information about the test like duration, memory usage, etc.
-	* Diagnostic is only available after the test has finished.
-	*/
-	diagnostic(): TestDiagnostic | undefined;
-}
-declare class TestCollection {
-	#private;
-	constructor(task: Suite | File, project: TestProject);
-	/**
-	* Returns the test or suite at a specific index.
-	*/
-	at(index: number): TestCase | TestSuite | undefined;
-	/**
-	* The number of tests and suites in the collection.
-	*/
-	get size(): number;
-	/**
-	* Returns the collection in array form for easier manipulation.
-	*/
-	array(): (TestCase | TestSuite)[];
-	/**
-	* Filters all tests that are part of this collection and its children.
-	*/
-	allTests(state?: TestState): Generator<TestCase, undefined, void>;
-	/**
-	* Filters only the tests that are part of this collection.
-	*/
-	tests(state?: TestState): Generator<TestCase, undefined, void>;
-	/**
-	* Filters only the suites that are part of this collection.
-	*/
-	suites(): Generator<TestSuite, undefined, void>;
-	/**
-	* Filters all suites that are part of this collection and its children.
-	*/
-	allSuites(): Generator<TestSuite, undefined, void>;
-	[Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
-}
-
-type ReportedHookContext = {
-	readonly name: "beforeAll" | "afterAll";
-	readonly entity: TestSuite | TestModule;
-} | {
-	readonly name: "beforeEach" | "afterEach";
-	readonly entity: TestCase;
-};
-declare abstract class SuiteImplementation extends ReportedTaskImplementation {
-	/**
-	* Collection of suites and tests that are part of this suite.
-	*/
-	readonly children: TestCollection;
-	/**
-	* Errors that happened outside of the test run during collection, like syntax errors.
-	*/
-	errors(): SerializedError[];
-}
-declare class TestSuite extends SuiteImplementation {
-	#private;
-	readonly type = "suite";
-	/**
-	* Name of the test or the suite.
-	*/
-	readonly name: string;
-	/**
-	* Direct reference to the test module where the test or suite is defined.
-	*/
-	readonly module: TestModule;
-	/**
-	* Parent suite. If suite was called directly inside the module, the parent will be the module itself.
-	*/
-	readonly parent: TestSuite | TestModule;
-	/**
-	* Options that suite was initiated with.
-	*/
-	readonly options: TaskOptions;
-	/**
-	* Checks if the suite has any failed tests.
-	* This will also return `false` if suite failed during collection.
-	*/
-	ok: () => boolean;
-	/**
-	* The meta information attached to the suite during its collection or execution.
-	*/
-	meta: () => TaskMeta;
-	/**
-	* Checks the running state of the suite.
-	*/
-	state(): TestSuiteState;
-	/**
-	* Full name of the suite including all parent suites separated with `>`.
-	*/
-	get fullName(): string;
-}
-declare class TestModule extends SuiteImplementation {
-	readonly location: undefined;
-	readonly type = "module";
-	/**
-	* 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 moduleId: string;
-	/**
-	* Module id relative to the project. This is the same as `task.name`.
-	*/
-	readonly relativeModuleId: string;
-	/**
-	* Checks the running state of the test file.
-	*/
-	state(): TestModuleState;
-	/**
-	* Checks if the module has any failed tests.
-	* This will also return `false` if module failed during collection.
-	*/
-	ok: () => boolean;
-	/**
-	* The meta information attached to the module during its collection or execution.
-	*/
-	meta: () => TaskMeta;
-	/**
-	* Useful information about the module like duration, memory usage, etc.
-	* If the module was not executed yet, all diagnostic values will return `0`.
-	*/
-	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 {
-	/**
-	* The test was collected, but didn't finish running yet.
-	*/
-	readonly state: "pending";
-	/**
-	* Pending tests have no errors.
-	*/
-	readonly errors: undefined;
-}
-interface TestResultPassed {
-	/**
-	* The test passed successfully.
-	*/
-	readonly state: "passed";
-	/**
-	* Errors that were thrown during the test execution.
-	*
-	* **Note**: If test was retried successfully, errors will still be reported.
-	*/
-	readonly errors: ReadonlyArray<TestError> | undefined;
-}
-interface TestResultFailed {
-	/**
-	* The test failed to execute.
-	*/
-	readonly state: "failed";
-	/**
-	* Errors that were thrown during the test execution.
-	*/
-	readonly errors: ReadonlyArray<TestError>;
-}
-interface TestResultSkipped {
-	/**
-	* 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.
-	*/
-	readonly state: "skipped";
-	/**
-	* Skipped tests have no errors.
-	*/
-	readonly errors: undefined;
-	/**
-	* A custom note passed down to `ctx.skip(note)`.
-	*/
-	readonly note: string | undefined;
-}
-interface TestDiagnostic {
-	/**
-	* 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;
+	readonly duration: number;
 	/**
 	* The time in ms when the test started.
 	*/
@@ -1041,6 +388,36 @@ 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;
 
+declare class TestSpecification {
+	/**
+	* The task ID associated with the test module.
+	*/
+	readonly taskId: string;
+	/**
+	* The test project that the module belongs to.
+	*/
+	readonly project: TestProject;
+	/**
+	* The ID of the module in the Vite module graph. It is usually an absolute file path.
+	*/
+	readonly moduleId: string;
+	/**
+	* The current test pool. It's possible to have multiple pools in a single test project with `poolMatchGlob` and `typecheck.enabled`.
+	* @experimental In Vitest 4, the project will only support a single pool and this property will be removed.
+	*/
+	readonly pool: Pool;
+	/**
+	* Line numbers of the test locations to run.
+	*/
+	readonly testLines: number[] | undefined;
+	constructor(project: TestProject, moduleId: string, pool: Pool, testLines?: number[] | undefined);
+	/**
+	* Test module associated with the specification.
+	*/
+	get testModule(): TestModule | undefined;
+	toJSON(): SerializedTestSpecification;
+}
+
 interface CoverageSummaryData {
     lines: Totals;
     statements: Totals;
@@ -1526,6 +903,80 @@ declare class VitestPackageInstaller {
 	ensureInstalled(dependency: string, root: string, version?: string): Promise<boolean>;
 }
 
+type TestRunEndReason = "passed" | "interrupted" | "failed";
+interface Reporter {
+	onInit?: (vitest: Vitest) => void;
+	/**
+	* Called when the project initiated the browser instance.
+	* project.browser will always be defined.
+	* @experimental
+	*/
+	onBrowserInit?: (project: TestProject) => Awaitable<void>;
+	onTestRemoved?: (trigger?: string) => Awaitable<void>;
+	onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
+	onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
+	onServerRestart?: (reason?: string) => Awaitable<void>;
+	onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
+	onProcessTimeout?: () => Awaitable<void>;
+	/**
+	* Called when the new test run starts.
+	*/
+	onTestRunStart?: (specifications: ReadonlyArray<TestSpecification>) => Awaitable<void>;
+	/**
+	* Called when the test run is finished.
+	*/
+	onTestRunEnd?: (testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason) => Awaitable<void>;
+	/**
+	* Called when the module is enqueued for testing. The file itself is not loaded yet.
+	*/
+	onTestModuleQueued?: (testModule: TestModule) => Awaitable<void>;
+	/**
+	* Called when the test file is loaded and the module is ready to run tests.
+	*/
+	onTestModuleCollected?: (testModule: TestModule) => Awaitable<void>;
+	/**
+	* Called when starting to run tests of the test file
+	*/
+	onTestModuleStart?: (testModule: TestModule) => Awaitable<void>;
+	/**
+	* Called when all tests of the test file have finished running.
+	*/
+	onTestModuleEnd?: (testModule: TestModule) => Awaitable<void>;
+	/**
+	* Called when test case is ready to run.
+	* Called before the `beforeEach` hooks for the test are run.
+	*/
+	onTestCaseReady?: (testCase: TestCase) => Awaitable<void>;
+	/**
+	* Called after the test and its hooks are finished running.
+	* The `result()` cannot be `pending`.
+	*/
+	onTestCaseResult?: (testCase: TestCase) => Awaitable<void>;
+	/**
+	* Called when annotation is added via the `task.annotate` API.
+	*/
+	onTestCaseAnnotate?: (testCase: TestCase, annotation: TestAnnotation) => Awaitable<void>;
+	/**
+	* Called when test suite is ready to run.
+	* Called before the `beforeAll` hooks for the test are run.
+	*/
+	onTestSuiteReady?: (testSuite: TestSuite) => Awaitable<void>;
+	/**
+	* Called after the test suite and its hooks are finished running.
+	* The `state` cannot be `pending`.
+	*/
+	onTestSuiteResult?: (testSuite: TestSuite) => Awaitable<void>;
+	/**
+	* Called before the hook starts to run.
+	*/
+	onHookStart?: (hook: ReportedHookContext) => Awaitable<void>;
+	/**
+	* Called after the hook finished running.
+	*/
+	onHookEnd?: (hook: ReportedHookContext) => Awaitable<void>;
+	onCoverage?: (coverage: unknown) => Awaitable<void>;
+}
+
 interface BlobOptions {
 	outputFile?: string;
 }
@@ -1552,10 +1003,19 @@ declare class StateManager {
 	idMap: Map<string, Task>;
 	taskFileMap: WeakMap<Task, File>;
 	errorsSet: Set<unknown>;
-	processTimeoutCauses: Set<string>;
 	reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
 	blobs?: MergedBlobs;
 	transformTime: number;
+	metadata: Record<string, {
+		externalized: Record<string, string>;
+		duration: Record<string, number[]>;
+		tmps: Record<string, string>;
+		dumpDir?: string;
+		outline?: {
+			externalized: number;
+			inlined: number;
+		};
+	}>;
 	onUnhandledError?: OnUnhandledErrorCallback;
 	constructor(options: {
 		onUnhandledError?: OnUnhandledErrorCallback;
@@ -1563,8 +1023,6 @@ declare class StateManager {
 	catchError(error: unknown, type: string): void;
 	clearErrors(): void;
 	getUnhandledErrors(): unknown[];
-	addProcessTimeoutCause(cause: string): void;
-	getProcessTimeoutCauses(): string[];
 	getPaths(): string[];
 	/**
 	* Return files that were running or collected.
@@ -1582,389 +1040,890 @@ declare class StateManager {
 	updateTasks(packs: TaskResultPack[]): void;
 	updateUserLog(log: UserConsoleLog): void;
 	getCountOfFailedTests(): number;
-	cancelFiles(files: string[], project: TestProject): void;
+	cancelFiles(files: FileSpecification[], project: TestProject): void;
 }
 
 declare class VitestWatcher {
 	private vitest;
 	/**
-	* Modules that will be invalidated on the next run.
+	* 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;
+	stdout?: NodeJS.WriteStream | Writable;
+	stderr?: NodeJS.WriteStream | Writable;
+}
+declare class Vitest {
+	readonly mode: VitestRunMode;
+	/**
+	* Current Vitest version.
+	* @example '2.0.0'
+	*/
+	readonly version: string;
+	static readonly version: string;
+	/**
+	* The logger instance used to log messages. It's recommended to use this logger instead of `console`.
+	* It's possible to override stdout and stderr streams when initiating Vitest.
+	* @example
+	* new Vitest('test', {
+	*   stdout: new Writable(),
+	* })
+	*/
+	readonly logger: Logger;
+	/**
+	* The package installer instance used to install Vitest packages.
+	* @example
+	* await vitest.packageInstaller.ensureInstalled('@vitest/browser', process.cwd())
+	*/
+	readonly packageInstaller: VitestPackageInstaller;
+	/**
+	* A path to the built Vitest directory. This is usually a folder in `node_modules`.
+	*/
+	readonly distPath: string;
+	/**
+	* A list of projects that are currently running.
+	* If projects were filtered with `--project` flag, they won't appear here.
+	*/
+	projects: TestProject[];
+	/**
+	* 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 pool;
+	private _config?;
+	private _vite?;
+	private _state?;
+	private _cache?;
+	private _snapshot?;
+	private _coverageProvider?;
+	constructor(mode: VitestRunMode, cliOptions: UserConfig, options?: VitestOptions);
+	private _onRestartListeners;
+	private _onClose;
+	private _onSetServer;
+	private _onCancelListeners;
+	private _onUserTestsRerun;
+	private _onFilterWatchedSpecification;
+	/**
+	* The global config.
+	*/
+	get config(): ResolvedConfig;
+	/**
+	* Global Vite's dev server instance.
+	*/
+	get vite(): ViteDevServer;
+	/**
+	* The global test state manager.
+	* @experimental The State API is experimental and not subject to semver.
+	*/
+	get state(): StateManager;
+	/**
+	* The global snapshot manager. You can access the current state on `snapshot.summary`.
+	*/
+	get snapshot(): SnapshotManager;
+	/**
+	* Test results and test file stats cache. Primarily used by the sequencer to sort tests.
+	*/
+	get cache(): VitestCache;
+	enableCoverage(): Promise<void>;
+	disableCoverage(): void;
+	private _coverageOverrideCache;
+	/**
+	* Inject new test projects into the workspace.
+	* @param config Glob, config path or a custom config options.
+	* @returns An array of new test projects. Can be empty if the name was filtered out.
+	*/
+	private injectTestProject;
+	/**
+	* Provide a value to the test context. This value will be available to all tests with `inject`.
+	*/
+	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
+	/**
+	* Get global provided context.
+	*/
+	getProvidedContext(): ProvidedContext;
+	/**
+	* Return project that has the root (or "global") config.
+	*/
+	getRootProject(): TestProject;
+	getProjectByName(name: string): TestProject;
+	/**
+	* Import a file using Vite module runner. The file will be transformed by Vite and executed in a separate context.
+	* @param moduleId The ID of the module in Vite module graph
+	*/
+	import<T>(moduleId: string): Promise<T>;
+	/**
+	* Creates a coverage provider if `coverage` is enabled in the config.
+	*/
+	createCoverageProvider(): Promise<CoverageProvider | null>;
+	private resolveProjects;
+	/**
+	* Glob test files in every project and create a TestSpecification for each file and pool.
+	* @param filters String filters to match the test files.
+	*/
+	globTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
+	private initCoverageProvider;
+	/**
+	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
+	*/
+	mergeReports(directory?: string): Promise<TestRunResult>;
+	/**
+	* Returns the seed, if tests are running in a random order.
+	*/
+	getSeed(): number | null;
+	collect(filters?: string[]): Promise<TestRunResult>;
+	/**
+	* Returns the list of test files that match the config and filters.
+	* @param filters String filters to match the test files
+	*/
+	getRelevantTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
+	/**
+	* Initialize reporters, the coverage provider, and run tests.
+	* This method can throw an error:
+	*   - `FilesNotFoundError` if no tests are found
+	*   - `GitNotFoundError` if `--related` flag is used, but git repository is not initialized
+	*   - `Error` from the user reporters
+	* @param filters String filters to match the test files
+	*/
+	start(filters?: string[]): Promise<TestRunResult>;
+	/**
+	* Initialize reporters and the coverage provider. This method doesn't run any tests.
+	* If the `--watch` flag is provided, Vitest will still run changed tests even if this method was not called.
+	*/
+	init(): Promise<void>;
+	/**
+	* If there is a test run happening, returns a promise that will
+	* resolve when the test run is finished.
+	*/
+	waitForTestRunEnd(): Promise<void>;
+	/**
+	* Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
+	*
+	* **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
+	* @param moduleId The module ID to get test specifications for.
+	*/
+	getModuleSpecifications(moduleId: string): TestSpecification[];
+	/**
+	* Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache altogether.
+	*/
+	clearSpecificationsCache(moduleId?: string): void;
+	/**
+	* Run tests for the given test specifications. This does not trigger `onWatcher*` events.
+	* @param specifications A list of specifications to run.
+	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+	*/
+	runTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
+	/**
+	* Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
+	* @param specifications A list of specifications to run.
+	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+	*/
+	rerunTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
+	private runFiles;
+	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.
+	*/
+	collectTests(specifications: TestSpecification[]): Promise<TestRunResult>;
+	/**
+	* Gracefully cancel the current test run. Vitest will wait until all running tests are finished before cancelling.
+	*/
+	cancelCurrentRun(reason: CancelReason): Promise<void>;
+	private initializeGlobalSetup;
+	/**
+	* Update snapshots in specified files. If no files are provided, it will update files with failed tests and obsolete snapshots.
+	* @param files The list of files on the file system
+	*/
+	updateSnapshot(files?: string[]): Promise<TestRunResult>;
+	/**
+	* Enable the mode that allows updating snapshots when running tests.
+	* This method doesn't run any tests.
+	*
+	* Every test that runs after this method is called will update snapshots.
+	* To disable the mode, call `resetSnapshotUpdate`.
+	*/
+	enableSnapshotUpdate(): void;
+	/**
+	* Disable the mode that allows updating snapshots when running tests.
+	*/
+	resetSnapshotUpdate(): void;
+	/**
+	* Set the global test name pattern to a regexp.
+	* This method doesn't run any tests.
 	*/
-	readonly invalidates: Set<string>;
+	setGlobalTestNamePattern(pattern: string | RegExp): void;
 	/**
-	* Test files that have changed and need to be rerun.
+	* Returns the regexp used for the global test name pattern.
 	*/
-	readonly changedTests: Set<string>;
-	private readonly _onRerun;
-	constructor(vitest: Vitest);
-	unregisterWatcher: () => void;
-	registerWatcher(): this;
+	getGlobalTestNamePattern(): RegExp | undefined;
+	/**
+	* Resets the global test name pattern. This method doesn't run any tests.
+	*/
+	resetGlobalTestNamePattern(): void;
+	private _rerunTimer;
 	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)
+	* Invalidate a file in all projects.
 	*/
-	private handleFileChanged;
-}
-interface WatcherTriggerPattern {
-	pattern: RegExp;
-	testsToRun: (file: string, match: RegExpMatchArray) => string[] | string | null | undefined | void;
-}
-
-interface VitestOptions {
-	packageInstaller?: VitestPackageInstaller;
-	stdin?: NodeJS.ReadStream;
-	stdout?: NodeJS.WriteStream | Writable;
-	stderr?: NodeJS.WriteStream | Writable;
-}
-declare class Vitest {
-	readonly mode: VitestRunMode;
+	invalidateFile(filepath: string): void;
+	private reportCoverage;
 	/**
-	* Current Vitest version.
-	* @example '2.0.0'
+	* Closes all projects and their associated resources.
+	* This can only be called once; the closing promise is cached until the server restarts.
 	*/
-	readonly version: string;
-	static readonly version: string;
+	close(): Promise<void>;
 	/**
-	* The logger instance used to log messages. It's recommended to use this logger instead of `console`.
-	* It's possible to override stdout and stderr streams when initiating Vitest.
-	* @example
-	* new Vitest('test', {
-	*   stdout: new Writable(),
-	* })
+	* Closes all projects and exit the process
+	* @param force If true, the process will exit immediately after closing the projects.
 	*/
-	readonly logger: Logger;
+	exit(force?: boolean): Promise<void>;
 	/**
-	* The package installer instance used to install Vitest packages.
-	* @example
-	* await vitest.packageInstaller.ensureInstalled('@vitest/browser', process.cwd())
+	* Should the server be kept running after the tests are done.
 	*/
-	readonly packageInstaller: VitestPackageInstaller;
+	shouldKeepServer(): boolean;
 	/**
-	* A path to the built Vitest directory. This is usually a folder in `node_modules`.
+	* Register a handler that will be called when the server is restarted due to a config change.
 	*/
-	readonly distPath: string;
+	onServerRestart(fn: OnServerRestartHandler): void;
 	/**
-	* A list of projects that are currently running.
-	* If projects were filtered with `--project` flag, they won't appear here.
+	* Register a handler that will be called when the test run is cancelled with `vitest.cancelCurrentRun`.
 	*/
-	projects: TestProject[];
+	onCancel(fn: (reason: CancelReason) => Awaitable<void>): void;
 	/**
-	* 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.
+	* Register a handler that will be called when the server is closed.
 	*/
-	readonly watcher: VitestWatcher;
-	private isFirstRun;
-	private restartsCount;
-	private readonly specifications;
-	private pool;
-	private _config?;
-	private _vite?;
-	private _state?;
-	private _cache?;
-	private _snapshot?;
-	private _coverageProvider?;
-	constructor(mode: VitestRunMode, cliOptions: UserConfig, options?: VitestOptions);
-	private _onRestartListeners;
-	private _onClose;
-	private _onSetServer;
-	private _onCancelListeners;
-	private _onUserTestsRerun;
-	private _onFilterWatchedSpecification;
+	onClose(fn: () => Awaitable<void>): void;
 	/**
-	* The global config.
+	* Register a handler that will be called when the tests are rerunning.
 	*/
-	get config(): ResolvedConfig;
+	onTestsRerun(fn: OnTestsRerunHandler): void;
 	/**
-	* Global Vite's dev server instance.
+	* Register a handler that will be called when a file is changed.
+	* This callback should return `true` of `false` indicating whether the test file needs to be rerun.
+	* @example
+	* const testsToRun = [resolve('./test.spec.ts')]
+	* vitest.onFilterWatchedSpecification(specification => testsToRun.includes(specification.moduleId))
 	*/
-	get vite(): ViteDevServer;
+	onFilterWatchedSpecification(fn: (specification: TestSpecification) => boolean): void;
 	/**
-	* The global test state manager.
-	* @experimental The State API is experimental and not subject to semver.
+	* Check if the project with a given name should be included.
 	*/
-	get state(): StateManager;
+	matchesProjectFilter(name: string): boolean;
+}
+type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+type OnTestsRerunHandler = (testFiles: TestSpecification[]) => Promise<void> | void;
+
+interface CDPSession {
+	send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
+	on: (event: string, listener: (...args: unknown[]) => void) => void;
+	once: (event: string, listener: (...args: unknown[]) => void) => void;
+	off: (event: string, listener: (...args: unknown[]) => void) => void;
+}
+interface BrowserModuleMocker {
+	register: (sessionId: string, module: MockedModule) => Promise<void>;
+	delete: (sessionId: string, url: string) => Promise<void>;
+	clear: (sessionId: string) => Promise<void>;
+}
+interface BrowserProviderOption<Options extends object = object> {
+	name: string;
+	supportedBrowser?: ReadonlyArray<string>;
+	options: Options;
+	providerFactory: (project: TestProject) => BrowserProvider;
+	serverFactory: BrowserServerFactory;
+}
+interface BrowserServerOptions {
+	project: TestProject;
+	coveragePlugin: () => Plugin;
+	mocksPlugins: (options: {
+		filter: (id: string) => boolean;
+	}) => Plugin[];
+	metaEnvReplacer: () => Plugin;
+}
+interface BrowserServerFactory {
+	(otpions: BrowserServerOptions): Promise<ParentProjectBrowser>;
+}
+interface BrowserProvider {
+	name: string;
+	mocker?: BrowserModuleMocker;
+	readonly initScripts?: string[];
 	/**
-	* The global snapshot manager. You can access the current state on `snapshot.summary`.
+	* @experimental opt-in into file parallelisation
 	*/
-	get snapshot(): SnapshotManager;
+	supportsParallelism: boolean;
+	getCommandsContext: (sessionId: string) => Record<string, unknown>;
+	openPage: (sessionId: string, url: string) => Promise<void>;
+	getCDPSession?: (sessionId: string) => Promise<CDPSession>;
+	close: () => Awaitable<void>;
+}
+type BrowserBuiltinProvider = "webdriverio" | "playwright" | "preview";
+interface _BrowserNames {}
+type UnsupportedProperties = "browser" | "typecheck" | "alias" | "sequence" | "root" | "pool" | "runner" | "api" | "deps" | "environment" | "environmentOptions" | "server" | "benchmark" | "name";
+interface BrowserInstanceOption extends Omit<ProjectConfig, UnsupportedProperties>, Pick<BrowserConfigOptions, "headless" | "locators" | "viewport" | "testerHtmlPath" | "screenshotDirectory" | "screenshotFailures"> {
 	/**
-	* Test results and test file stats cache. Primarily used by the sequencer to sort tests.
+	* Name of the browser
 	*/
-	get cache(): VitestCache;
-	enableCoverage(): Promise<void>;
-	disableCoverage(): void;
-	private _coverageOverrideCache;
+	browser: keyof _BrowserNames extends never ? string : _BrowserNames[keyof _BrowserNames];
+	name?: string;
+	provider?: BrowserProviderOption;
+}
+interface BrowserConfigOptions {
 	/**
-	* Inject new test projects into the workspace.
-	* @param config Glob, config path or a custom config options.
-	* @returns An array of new test projects. Can be empty if the name was filtered out.
+	* if running tests in the browser should be the default
+	*
+	* @default false
 	*/
-	private injectTestProject;
+	enabled?: boolean;
 	/**
-	* Provide a value to the test context. This value will be available to all tests with `inject`.
+	* Configurations for different browser setups
 	*/
-	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
+	instances?: BrowserInstanceOption[];
 	/**
-	* Get global provided context.
+	* Browser provider
+	* @example
+	* ```ts
+	* import { playwright } from '@vitest/browser-playwright'
+	* export default defineConfig({
+	*   test: {
+	*     browser: {
+	*       provider: playwright(),
+	*     },
+	*   },
+	* })
+	* ```
 	*/
-	getProvidedContext(): ProvidedContext;
+	provider?: BrowserProviderOption;
 	/**
-	* Return project that has the root (or "global") config.
+	* enable headless mode
+	*
+	* @default process.env.CI
 	*/
-	getRootProject(): TestProject;
-	getProjectByName(name: string): TestProject;
+	headless?: boolean;
 	/**
-	* 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
+	* Serve API options.
+	*
+	* The default port is 63315.
 	*/
-	import<T>(moduleId: string): Promise<T>;
+	api?: ApiConfig | number;
 	/**
-	* Creates a coverage provider if `coverage` is enabled in the config.
+	* Isolate test environment after each test
+	*
+	* @default true
 	*/
-	createCoverageProvider(): Promise<CoverageProvider | null>;
-	private resolveProjects;
+	isolate?: boolean;
+	/**
+	* Run test files in parallel if provider supports this option
+	* This option only has effect in headless mode (enabled in CI by default)
+	*
+	* @default // Same as "test.fileParallelism"
+	*/
+	fileParallelism?: boolean;
+	/**
+	* Show Vitest UI
+	*
+	* @default !process.env.CI
+	*/
+	ui?: boolean;
+	/**
+	* Default viewport size
+	*/
+	viewport?: {
+		/**
+		* Width of the viewport
+		* @default 414
+		*/
+		width: number;
+		/**
+		* Height of the viewport
+		* @default 896
+		*/
+		height: number;
+	};
+	/**
+	* Locator options
+	*/
+	locators?: {
+		/**
+		* Attribute used to locate elements by test id
+		* @default 'data-testid'
+		*/
+		testIdAttribute?: string;
+	};
 	/**
-	* Glob test files in every project and create a TestSpecification for each file and pool.
-	* @param filters String filters to match the test files.
+	* Generate traces that can be viewed on https://trace.playwright.dev/
+	*
+	* This option is supported only by **playwright** provider.
 	*/
-	globTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
-	private initCoverageProvider;
+	trace?: BrowserTraceViewMode | {
+		mode: BrowserTraceViewMode;
+		/**
+		* The directory where all traces will be stored. By default, Vitest
+		* stores all traces in `__traces__` folder close to the test file.
+		*/
+		tracesDir?: string;
+		/**
+		* Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.
+		* @default true
+		*/
+		screenshots?: boolean;
+		/**
+		* If this option is true tracing will
+		* - capture DOM snapshot on every action
+		* - record network activity
+		* @default true
+		*/
+		snapshots?: boolean;
+	};
 	/**
-	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
+	* Directory where screenshots will be saved when page.screenshot() is called
+	* If not set, all screenshots are saved to __screenshots__ directory in the same folder as the test file.
+	* If this is set, it will be resolved relative to the project root.
+	* @default __screenshots__
 	*/
-	mergeReports(directory?: string): Promise<TestRunResult>;
+	screenshotDirectory?: string;
 	/**
-	* Returns the seed, if tests are running in a random order.
+	* Should Vitest take screenshots if the test fails
+	* @default !browser.ui
 	*/
-	getSeed(): number | null;
-	collect(filters?: string[]): Promise<TestRunResult>;
+	screenshotFailures?: boolean;
 	/**
-	* Returns the list of test files that match the config and filters.
-	* @param filters String filters to match the test files
+	* Path to the index.html file that will be used to run tests.
 	*/
-	getRelevantTestSpecifications(filters?: string[]): Promise<TestSpecification[]>;
+	testerHtmlPath?: string;
 	/**
-	* Initialize reporters, the coverage provider, and run tests.
-	* This method can throw an error:
-	*   - `FilesNotFoundError` if no tests are found
-	*   - `GitNotFoundError` if `--related` flag is used, but git repository is not initialized
-	*   - `Error` from the user reporters
-	* @param filters String filters to match the test files
+	* Scripts injected into the main window.
 	*/
-	start(filters?: string[]): Promise<TestRunResult>;
+	orchestratorScripts?: BrowserScript[];
 	/**
-	* Initialize reporters and the coverage provider. This method doesn't run any tests.
-	* If the `--watch` flag is provided, Vitest will still run changed tests even if this method was not called.
+	* Commands that will be executed on the server
+	* via the browser `import("vitest/browser").commands` API.
+	* @see {@link https://vitest.dev/guide/browser/commands}
 	*/
-	init(): Promise<void>;
+	commands?: Record<string, BrowserCommand<any>>;
 	/**
-	* If there is a test run happening, returns a promise that will
-	* resolve when the test run is finished.
+	* Timeout for connecting to the browser
+	* @default 30000
 	*/
-	waitForTestRunEnd(): Promise<void>;
+	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;
+	};
 	/**
-	* Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
+	* Enables tracking uncaught errors and exceptions so they can be reported by Vitest.
 	*
-	* **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
-	* @param moduleId The module ID to get test specifications for.
+	* 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
 	*/
-	getModuleSpecifications(moduleId: string): TestSpecification[];
+	trackUnhandledErrors?: boolean;
+}
+interface BrowserCommandContext {
+	testPath: string | undefined;
+	provider: BrowserProvider;
+	project: TestProject;
+	sessionId: string;
+	triggerCommand: <K extends keyof BrowserCommands>(name: K, ...args: Parameters<BrowserCommands[K]>) => ReturnType<BrowserCommands[K]>;
+}
+interface BrowserServerStateSession {
+	project: TestProject;
+	connected: () => void;
+	fail: (v: Error) => void;
+}
+interface BrowserOrchestrator {
+	cleanupTesters: () => Promise<void>;
+	createTesters: (options: BrowserTesterOptions) => Promise<void>;
+	onCancel: (reason: CancelReason) => Promise<void>;
+	$close: () => void;
+}
+interface BrowserServerState {
+	orchestrators: Map<string, BrowserOrchestrator>;
+}
+interface ParentProjectBrowser {
+	spawn: (project: TestProject) => ProjectBrowser;
+	vite: ViteDevServer;
+}
+interface ProjectBrowser {
+	vite: ViteDevServer;
+	state: BrowserServerState;
+	provider: BrowserProvider;
+	close: () => Promise<void>;
+	initBrowserProvider: (project: TestProject) => Promise<void>;
+	parseStacktrace: (stack: string) => ParsedStack[];
+	parseErrorStacktrace: (error: TestError, options?: StackTraceParserOptions) => ParsedStack[];
+	registerCommand: <K extends keyof BrowserCommands>(name: K, cb: BrowserCommand<Parameters<BrowserCommands[K]>, ReturnType<BrowserCommands[K]>>) => void;
+	triggerCommand: <K extends keyof BrowserCommands>(name: K, context: BrowserCommandContext, ...args: Parameters<BrowserCommands[K]>) => ReturnType<BrowserCommands[K]>;
+}
+interface BrowserCommand<
+	Payload extends unknown[] = [],
+	ReturnValue = any
+> {
+	(context: BrowserCommandContext, ...payload: Payload): Awaitable<ReturnValue>;
+}
+interface BrowserScript {
 	/**
-	* Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache altogether.
+	* If "content" is provided and type is "module", this will be its identifier.
+	*
+	* If you are using TypeScript, you can add `.ts` extension here for example.
+	* @default `injected-${index}.js`
 	*/
-	clearSpecificationsCache(moduleId?: string): void;
+	id?: string;
 	/**
-	* Run tests for the given test specifications. This does not trigger `onWatcher*` events.
-	* @param specifications A list of specifications to run.
-	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+	* JavaScript content to be injected. This string is processed by Vite plugins if type is "module".
+	*
+	* You can use `id` to give Vite a hint about the file extension.
 	*/
-	runTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
+	content?: string;
 	/**
-	* Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
-	* @param specifications A list of specifications to run.
-	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+	* Path to the script. This value is resolved by Vite so it can be a node module or a file path.
 	*/
-	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>;
+	src?: string;
 	/**
-	* Collect tests in specified modules. Vitest will run the files to collect tests.
-	* @param specifications A list of specifications to run.
+	* If the script should be loaded asynchronously.
 	*/
-	collectTests(specifications: TestSpecification[]): Promise<TestRunResult>;
+	async?: boolean;
 	/**
-	* Gracefully cancel the current test run. Vitest will wait until all running tests are finished before cancelling.
+	* Script type.
+	* @default 'module'
 	*/
-	cancelCurrentRun(reason: CancelReason): Promise<void>;
-	private initializeGlobalSetup;
+	type?: string;
+}
+interface ResolvedBrowserOptions extends BrowserConfigOptions {
+	name: string;
+	enabled: boolean;
+	headless: boolean;
+	isolate: boolean;
+	fileParallelism: boolean;
+	api: ApiConfig;
+	ui: boolean;
+	viewport: {
+		width: number;
+		height: number;
+	};
+	screenshotFailures: boolean;
+	locators: {
+		testIdAttribute: string;
+	};
+	trace: {
+		mode: BrowserTraceViewMode;
+		tracesDir?: string;
+		screenshots?: boolean;
+		snapshots?: boolean;
+	};
+}
+type ToMatchScreenshotResolvePath = (data: {
 	/**
-	* Update snapshots in specified files. If no files are provided, it will update files with failed tests and obsolete snapshots.
-	* @param files The list of files on the file system
+	* 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"
 	*/
-	updateSnapshot(files?: string[]): Promise<TestRunResult>;
+	arg: string;
 	/**
-	* Enable the mode that allows updating snapshots when running tests.
-	* This method doesn't run any tests.
+	* Screenshot extension, with leading dot.
 	*
-	* Every test that runs after this method is called will update snapshots.
-	* To disable the mode, call `resetSnapshotUpdate`.
+	* This can be set through the arguments passed to `toMatchScreenshot`, but
+	* the value will fall back to `'.png'` if an unsupported extension is used.
 	*/
-	enableSnapshotUpdate(): void;
+	ext: string;
 	/**
-	* Disable the mode that allows updating snapshots when running tests.
+	* The instance's browser name.
 	*/
-	resetSnapshotUpdate(): void;
+	browserName: string;
 	/**
-	* Set the global test name pattern to a regexp.
-	* This method doesn't run any tests.
+	* The value of {@linkcode process.platform}.
 	*/
-	setGlobalTestNamePattern(pattern: string | RegExp): void;
+	platform: NodeJS.Platform;
 	/**
-	* Returns the regexp used for the global test name pattern.
+	* The value provided to
+	* {@linkcode https://vitest.dev/guide/browser/config#browser-screenshotdirectory|browser.screenshotDirectory},
+	* if none is provided, its default value.
 	*/
-	getGlobalTestNamePattern(): RegExp | undefined;
+	screenshotDirectory: string;
 	/**
-	* Resets the global test name pattern. This method doesn't run any tests.
-	*/
-	resetGlobalTestNamePattern(): void;
-	private _rerunTimer;
-	private scheduleRerun;
+	* Absolute path to the project's
+	* {@linkcode https://vitest.dev/config/#root|root}.
+	*/
+	root: string;
 	/**
-	* Invalidate a file in all projects.
+	* Path to the test file, relative to the project's
+	* {@linkcode https://vitest.dev/config/#root|root}.
 	*/
-	invalidateFile(filepath: string): void;
-	private reportCoverage;
+	testFileDirectory: string;
 	/**
-	* Closes all projects and their associated resources.
-	* This can only be called once; the closing promise is cached until the server restarts.
+	* The test's filename.
 	*/
-	close(): Promise<void>;
+	testFileName: string;
 	/**
-	* Closes all projects and exit the process
-	* @param force If true, the process will exit immediately after closing the projects.
+	* The {@linkcode https://vitest.dev/api/#test|test}'s name, including
+	* parent {@linkcode https://vitest.dev/api/#describe|describe}, sanitized.
 	*/
-	exit(force?: boolean): Promise<void>;
+	testName: string;
 	/**
-	* Should the server be kept running after the tests are done.
+	* The value provided to
+	* {@linkcode https://vitest.dev/config/#attachmentsdir|attachmentsDir},
+	* if none is provided, its default value.
 	*/
-	shouldKeepServer(): boolean;
+	attachmentsDir: string;
+}) => string;
+interface ToMatchScreenshotOptions {
 	/**
-	* Register a handler that will be called when the server is restarted due to a config change.
+	* Overrides default reference screenshot path.
+	*
+	* @default `${root}/${testFileDirectory}/${screenshotDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}`
 	*/
-	onServerRestart(fn: OnServerRestartHandler): void;
+	resolveScreenshotPath?: ToMatchScreenshotResolvePath;
 	/**
-	* Register a handler that will be called when the test run is cancelled with `vitest.cancelCurrentRun`.
+	* Overrides default screenshot path used for diffs.
+	*
+	* @default `${root}/${attachmentsDir}/${testFileDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}`
 	*/
-	onCancel(fn: (reason: CancelReason) => Awaitable<void>): void;
+	resolveDiffPath?: ToMatchScreenshotResolvePath;
+}
+interface ToMatchScreenshotComparators {}
+
+declare class TestProject {
+	options?: InitializeProjectOptions | undefined;
 	/**
-	* Register a handler that will be called when the server is closed.
+	* The global Vitest instance.
 	*/
-	onClose(fn: () => Awaitable<void>): void;
+	readonly vitest: Vitest;
 	/**
-	* Register a handler that will be called when the tests are rerunning.
+	* Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
 	*/
-	onTestsRerun(fn: OnTestsRerunHandler): void;
+	readonly globalConfig: ResolvedConfig;
 	/**
-	* Register a handler that will be called when a file is changed.
-	* This callback should return `true` of `false` indicating whether the test file needs to be rerun.
-	* @example
-	* const testsToRun = [resolve('./test.spec.ts')]
-	* vitest.onFilterWatchedSpecification(specification => testsToRun.includes(specification.moduleId))
+	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
 	*/
-	onFilterWatchedSpecification(fn: (specification: TestSpecification) => boolean): void;
+	browser?: ProjectBrowser;
 	/**
-	* Check if the project with a given name should be included.
+	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
 	*/
-	matchesProjectFilter(name: string): boolean;
-}
-type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
-type OnTestsRerunHandler = (testFiles: TestSpecification[]) => Promise<void> | void;
-
-type TestRunEndReason = "passed" | "interrupted" | "failed";
-interface Reporter {
-	onInit?: (vitest: Vitest) => void;
+	readonly tmpDir: string;
+	/** @inetrnal */ testFilesList: string[] | null;
+	private runner;
+	private closingPromise;
+	private typecheckFilesList;
+	private _globalSetups?;
+	private _provided;
+	constructor(vitest: Vitest, options?: InitializeProjectOptions | undefined);
 	/**
-	* Called when the project initiated the browser instance.
-	* project.browser will always be defined.
-	* @experimental
+	* 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.
 	*/
-	onBrowserInit?: (project: TestProject) => Awaitable<void>;
-	onTestRemoved?: (trigger?: string) => Awaitable<void>;
-	onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
-	onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
-	onServerRestart?: (reason?: string) => Awaitable<void>;
-	onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
-	onProcessTimeout?: () => Awaitable<void>;
+	get hash(): string;
 	/**
-	* Called when the new test run starts.
+	* Provide a value to the test context. This value will be available to all tests with `inject`.
 	*/
-	onTestRunStart?: (specifications: ReadonlyArray<TestSpecification>) => Awaitable<void>;
+	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
 	/**
-	* Called when the test run is finished.
+	* Get the provided context. The project context is merged with the global context.
 	*/
-	onTestRunEnd?: (testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason) => Awaitable<void>;
+	getProvidedContext(): ProvidedContext;
 	/**
-	* Called when the module is enqueued for testing. The file itself is not loaded yet.
+	* Creates a new test specification. Specifications describe how to run tests.
+	* @param moduleId The file path
 	*/
-	onTestModuleQueued?: (testModule: TestModule) => Awaitable<void>;
+	createSpecification(moduleId: string, locations?: number[] | undefined, pool?: string): TestSpecification;
+	toJSON(): SerializedTestProject;
 	/**
-	* Called when the test file is loaded and the module is ready to run tests.
+	* Vite's dev server instance. Every workspace project has its own server.
 	*/
-	onTestModuleCollected?: (testModule: TestModule) => Awaitable<void>;
+	get vite(): ViteDevServer;
 	/**
-	* Called when starting to run tests of the test file
+	* Resolved project configuration.
 	*/
-	onTestModuleStart?: (testModule: TestModule) => Awaitable<void>;
+	get config(): ResolvedConfig;
 	/**
-	* Called when all tests of the test file have finished running.
+	* The name of the project or an empty string if not set.
 	*/
-	onTestModuleEnd?: (testModule: TestModule) => Awaitable<void>;
+	get name(): string;
 	/**
-	* Called when test case is ready to run.
-	* Called before the `beforeEach` hooks for the test are run.
+	* The color used when reporting tasks of this project.
 	*/
-	onTestCaseReady?: (testCase: TestCase) => Awaitable<void>;
+	get color(): ProjectName["color"];
 	/**
-	* Called after the test and its hooks are finished running.
-	* The `result()` cannot be `pending`.
+	* Serialized project configuration. This is the config that tests receive.
 	*/
-	onTestCaseResult?: (testCase: TestCase) => Awaitable<void>;
+	get serializedConfig(): SerializedConfig;
 	/**
-	* Called when annotation is added via the `task.annotate` API.
+	* Check if this is the root project. The root project is the one that has the root config.
 	*/
-	onTestCaseAnnotate?: (testCase: TestCase, annotation: TestAnnotation) => Awaitable<void>;
+	isRootProject(): boolean;
+	onTestsRerun(cb: OnTestsRerunHandler): void;
 	/**
-	* Called when test suite is ready to run.
-	* Called before the `beforeAll` hooks for the test are run.
+	* 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.
 	*/
-	onTestSuiteReady?: (testSuite: TestSuite) => Awaitable<void>;
+	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;
 	/**
-	* Called after the test suite and its hooks are finished running.
-	* The `state` cannot be `pending`.
+	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
 	*/
-	onTestSuiteResult?: (testSuite: TestSuite) => Awaitable<void>;
+	matchesTestGlob(moduleId: string, source?: () => string): boolean;
+	private isInSourceTestCode;
+	private filterFiles;
+	private _parentBrowser?;
 	/**
-	* Called before the hook starts to run.
+	* 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.
 	*/
-	onHookStart?: (hook: ReportedHookContext) => Awaitable<void>;
+	close(): Promise<void>;
 	/**
-	* Called after the hook finished running.
+	* Import a file using Vite module runner.
+	* @param moduleId The ID of the module in Vite module graph
 	*/
-	onHookEnd?: (hook: ReportedHookContext) => Awaitable<void>;
-	onCoverage?: (coverage: unknown) => Awaitable<void>;
+	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;
+}
+
+interface PoolRunnerInitializer {
+	readonly name: string;
+	createPoolWorker: (options: PoolOptions) => PoolWorker;
 }
+interface PoolOptions {
+	distPath: string;
+	project: TestProject;
+	method: "run" | "collect";
+	cacheFs?: boolean;
+	environment: string;
+	execArgv: string[];
+	env: Record<string, string>;
+}
+interface PoolWorker {
+	readonly name: string;
+	readonly execArgv: string[];
+	readonly env: Record<string, string>;
+	readonly reportMemory?: boolean;
+	readonly cacheFs?: boolean;
+	on: (event: string, callback: (arg: any) => void) => void;
+	off: (event: string, callback: (arg: any) => void) => void;
+	send: (message: WorkerRequest) => void;
+	deserialize: (data: unknown) => unknown;
+	start: () => Promise<void>;
+	stop: () => Promise<void>;
+}
+interface PoolTask {
+	worker: "forks" | "threads" | "vmForks" | "vmThreads" | (string & {});
+	project: TestProject;
+	isolate: boolean;
+	env: Record<string, string>;
+	execArgv: string[];
+	context: ContextRPC;
+	memoryLimit: number | null;
+}
+type WorkerRequest = {
+	__vitest_worker_request__: true;
+} & ({
+	type: "start";
+	options: {
+		reportMemory: boolean;
+	};
+} | {
+	type: "stop";
+} | {
+	type: "run";
+	context: ContextRPC;
+	poolId: number;
+} | {
+	type: "collect";
+	context: ContextRPC;
+	poolId: number;
+} | {
+	type: "cancel";
+});
+type WorkerResponse = {
+	__vitest_worker_response__: true;
+} & ({
+	type: "started";
+} | {
+	type: "stopped";
+	error?: unknown;
+} | {
+	type: "testfileFinished";
+	usedMemory?: number;
+	error?: unknown;
+});
 
 interface BaseOptions {
 	isTTY?: boolean;
@@ -2034,6 +1993,22 @@ declare class DefaultReporter extends BaseReporter {
 	onInit(ctx: Vitest): void;
 }
 
+interface GithubActionsReporterOptions {
+	onWritePath?: (path: string) => string;
+	/**
+	* @default true
+	*/
+	displayAnnotations?: boolean;
+}
+declare class GithubActionsReporter implements Reporter {
+	ctx: Vitest;
+	options: GithubActionsReporterOptions;
+	constructor(options?: GithubActionsReporterOptions);
+	onInit(ctx: Vitest): void;
+	onTestCaseAnnotate(testCase: TestCase, annotation: TestAnnotation): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>): void;
+}
+
 interface HTMLOptions {
 	outputFile?: string;
 }
@@ -2151,18 +2126,6 @@ declare class DotReporter extends BaseReporter {
 	private createSummary;
 }
 
-interface GithubActionsReporterOptions {
-	onWritePath?: (path: string) => string;
-}
-declare class GithubActionsReporter implements Reporter {
-	ctx: Vitest;
-	options: GithubActionsReporterOptions;
-	constructor(options?: GithubActionsReporterOptions);
-	onInit(ctx: Vitest): void;
-	onTestCaseAnnotate(testCase: TestCase, annotation: TestAnnotation): void;
-	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>): void;
-}
-
 declare class HangingProcessReporter implements Reporter {
 	whyRunning: (() => void) | undefined;
 	onInit(): void;
@@ -2256,6 +2219,7 @@ interface BuiltinReporterOptions {
 	"junit": JUnitOptions;
 	"hanging-process": never;
 	"html": HTMLOptions;
+	"github-actions": GithubActionsReporterOptions;
 }
 
 interface TestSequencer {
@@ -2317,7 +2281,6 @@ interface BenchmarkUserOptions {
 
 type BuiltinEnvironment = "node" | "jsdom" | "happy-dom" | "edge-runtime";
 type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
-
 type CSSModuleScopeStrategy = "stable" | "scoped" | "non-scoped";
 type ApiConfig = Pick<ServerOptions, "port" | "strictPort" | "host" | "middlewareMode">;
 interface EnvironmentOptions {
@@ -2454,6 +2417,8 @@ interface ResolveSnapshotPathHandlerContext {
 	config: SerializedConfig;
 }
 type ResolveSnapshotPathHandler = (testPath: string, snapExtension: string, context: ResolveSnapshotPathHandlerContext) => string;
+type BuiltinPool = "browser" | "threads" | "forks" | "vmThreads" | "vmForks" | "typescript";
+type Pool = BuiltinPool | (string & {});
 interface InlineConfig {
 	/**
 	* Name of the project. Will be used to display in the reporter.
@@ -2489,6 +2454,23 @@ interface InlineConfig {
 	deps?: DepsOptions;
 	server?: {
 		deps?: ServerDepsOptions;
+		debug?: {
+			/**
+			* The folder where Vitest stores the contents of transformed
+			* test files that can be inspected manually.
+			*
+			* If `true`, Vitest dumps the files in `.vitest-dump` folder relative to the root of the project.
+			*
+			* You can also use `VITEST_DEBUG_DUMP` env variable to enable this.
+			*/
+			dump?: string | true;
+			/**
+			* If dump is enabled, should Vitest load the files from there instead of transforming them.
+			*
+			* You can also use `VITEST_DEBUG_LOAD_DUMP` env variable to enable this.
+			*/
+			load?: boolean;
+		};
 	};
 	/**
 	* Base directory to scan for the test files
@@ -2519,25 +2501,38 @@ interface InlineConfig {
 	/**
 	* 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.
+	* Disabling this option improves performance if your code doesn't rely on side effects.
 	*
 	* @default true
 	*/
 	isolate?: boolean;
 	/**
-	* Pool used to run tests in.
+	* Pass additional arguments to `node` process when spawning the worker.
 	*
-	* Supports 'threads', 'forks', 'vmThreads'
+	* See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
 	*
-	* @default 'forks'
+	* Set to `process.execArgv` to pass all arguments of the current process.
+	*
+	* Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
+	*
+	* @default [] // no execution arguments are passed
+	*/
+	execArgv?: string[];
+	/**
+	* Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
+	* If you see memory leaks, try to tinker this value.
 	*/
-	pool?: Exclude<Pool, "browser">;
+	vmMemoryLimit?: string | number;
 	/**
-	* Pool options
+	* Pool used to run tests in.
+	*
+	* Supports 'threads', 'forks', 'vmThreads', 'vmForks'
+	*
+	* @default 'forks'
 	*/
-	poolOptions?: PoolOptions;
+	pool?: Exclude<Pool, "browser"> | PoolRunnerInitializer;
 	/**
-	* Maximum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.maxThreads`/`poolOptions.forks.maxForks` has higher priority.
+	* Maximum number or percentage of workers to run tests in.
 	*/
 	maxWorkers?: number | string;
 	/**
@@ -2683,7 +2678,6 @@ interface InlineConfig {
 	ui?: boolean;
 	/**
 	* options for test in a browser environment
-	* @experimental
 	*
 	* @default false
 	*/
@@ -2824,14 +2818,14 @@ interface InlineConfig {
 	* Debug tests by opening `node:inspector` in worker / child process.
 	* Provides similar experience as `--inspect` Node CLI argument.
 	*
-	* Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
+	* Requires `fileParallelism: false`.
 	*/
 	inspect?: boolean | string;
 	/**
 	* Debug tests by opening `node:inspector` in worker / child process and wait for debugger to connect.
 	* Provides similar experience as `--inspect-brk` Node CLI argument.
 	*
-	* Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
+	* Requires `fileParallelism: false`.
 	*/
 	inspectBrk?: boolean | string;
 	/**
@@ -3065,7 +3059,7 @@ interface UserConfig extends InlineConfig {
 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"> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config" | "filters" | "browser" | "coverage" | "testNamePattern" | "related" | "api" | "reporters" | "resolveSnapshotPath" | "benchmark" | "shard" | "cache" | "sequence" | "typecheck" | "runner" | "pool" | "cliExclude" | "diff" | "setupFiles" | "snapshotEnvironment" | "bail" | "name" | "vmMemoryLimit"> {
 	mode: VitestRunMode;
 	name: ProjectName["label"];
 	color?: ProjectName["color"];
@@ -3082,7 +3076,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config"
 	snapshotOptions: SnapshotStateOptions;
 	browser: ResolvedBrowserOptions;
 	pool: Pool;
-	poolOptions?: ResolvedPoolOptions;
+	poolRunner?: PoolRunnerInitializer;
 	reporters: (InlineReporter | ReporterWithOptions)[];
 	defines: Record<string, any>;
 	api: ApiConfig & {
@@ -3115,8 +3109,10 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config"
 	};
 	runner?: string;
 	maxWorkers: number;
+	vmMemoryLimit?: UserConfig["vmMemoryLimit"];
+	dumpDir?: string;
 }
-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";
+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" | "watchTriggerPatterns";
 interface ServerDepsOptions {
 	/**
 	* Externalize means that Vite will bpass the package to native Node.
@@ -3141,15 +3137,11 @@ interface ServerDepsOptions {
 	*/
 	fallbackCJS?: boolean;
 }
-type ProjectConfig = Omit<InlineConfig, NonProjectOptions | "sequencer" | "deps" | "poolOptions"> & {
+type ProjectConfig = Omit<InlineConfig, NonProjectOptions | "sequencer" | "deps"> & {
 	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">;
-	};
+	fileParallelism?: boolean;
 };
 type ResolvedProjectConfig = Omit<ResolvedConfig, Exclude<NonProjectOptions, "coverage" | "watch">>;
 interface UserWorkspaceConfig extends UserConfig$1 {
@@ -3167,5 +3159,5 @@ type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
 });
 type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 
-export { TestSuite as B, CoverageMap as C, experimental_getRunnerTask 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 k, VitestPackageInstaller as n, TestCase as q, TestCollection as r, TestModule as t };
-export type { BrowserOrchestrator 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, _BrowserNames as _, TestProjectConfiguration as a, BrowserProvider as a0, BrowserProviderOption as a1, BrowserScript as a2, BrowserServerFactory as a3, BrowserServerOptions 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, ToMatchScreenshotComparators as ab, ToMatchScreenshotOptions as ac, BuiltinEnvironment as ad, CSSModuleScopeStrategy as ae, DepsOptimizationOptions as af, EnvironmentOptions as ag, PoolOptions as ah, ProjectConfig as ai, ResolvedProjectConfig as aj, ResolveSnapshotPathHandler as ak, ResolveSnapshotPathHandlerContext 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 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 };
+export { CoverageMap as C, TestSuite as K, Logger as L, experimental_getRunnerTask as Q, TestProject as T, Vitest as V, BenchmarkReporter as aE, BenchmarkReportsMap as aF, DefaultReporter as aG, DotReporter as aH, GithubActionsReporter as aI, HangingProcessReporter as aJ, JsonReporter as aK, JUnitReporter as aL, ReportersMap as aM, TapFlatReporter as aN, TapReporter as aO, VerboseBenchmarkReporter as aP, VerboseReporter as aQ, BaseReporter as aR, TestSpecification as k, VitestPackageInstaller as p, TestCase as v, TestCollection as w, TestModule as y };
+export type { BrowserCommand as $, ApiConfig as A, TestResult as B, TestResultFailed as D, TestResultPassed as E, TestResultSkipped as F, TestState as G, HTMLOptions as H, InlineConfig as I, JsonOptions as J, ModuleDiagnostic as M, TestSuiteState as N, OnServerRestartHandler as O, PoolWorker as P, ResolvedCoverageOptions as R, SerializedTestProject as S, UserWorkspaceConfig as U, WatcherTriggerPattern as W, TestSequencerConstructor as X, BenchmarkUserOptions as Y, BrowserBuiltinProvider as Z, _BrowserNames as _, TestProjectConfiguration as a, BrowserCommandContext as a0, BrowserConfigOptions as a1, BrowserInstanceOption as a2, BrowserModuleMocker as a3, BrowserOrchestrator as a4, BrowserProvider as a5, BrowserProviderOption as a6, BrowserScript as a7, BrowserServerFactory as a8, BrowserServerOptions as a9, TestRunResult as aA, ReportedHookContext as aB, Reporter as aC, TestRunEndReason as aD, BenchmarkBuiltinReporters as aS, BuiltinReporterOptions as aT, BuiltinReporters as aU, JsonAssertionResult as aV, JsonTestResult as aW, JsonTestResults as aX, BrowserServerState as aa, BrowserServerStateSession as ab, CDPSession as ac, ParentProjectBrowser as ad, ProjectBrowser as ae, ResolvedBrowserOptions as af, ToMatchScreenshotComparators as ag, ToMatchScreenshotOptions as ah, BuiltinEnvironment as ai, CSSModuleScopeStrategy as aj, DepsOptimizationOptions as ak, EnvironmentOptions as al, Pool as am, ProjectConfig as an, ResolvedProjectConfig as ao, ResolveSnapshotPathHandler as ap, ResolveSnapshotPathHandlerContext as aq, TypecheckConfig as ar, VitestEnvironment as as, BaseCoverageOptions as at, CoverageIstanbulOptions as au, CoverageOptions as av, CoverageProvider as aw, CoverageProviderModule as ax, CoverageReporter as ay, CustomProviderOptions as az, ReportContext as b, CoverageV8Options as c, UserProjectConfigFn as d, UserProjectConfigExport as e, UserConfig as f, TestProjectInlineConfiguration as g, ResolvedConfig as h, VitestRunMode as i, VitestOptions as j, PoolOptions as l, WorkerRequest as m, TestSequencer as n, OnTestsRerunHandler as o, PoolRunnerInitializer as q, PoolTask as r, WorkerResponse as s, JUnitOptions as t, TaskOptions as u, TestDiagnostic as x, TestModuleState as z };