vitest 2.2.0-beta.1 → 3.0.0-beta.1

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

@@ -1,20 +1,19 @@
 import * as _vitest_runner from '@vitest/runner';
-import { File, TaskResultPack, Task, Test, Suite, CancelReason, Custom, TaskMeta, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
-import { b as Awaitable, U as UserConsoleLog, P as ProvidedContext, A as AfterSuiteRunMeta, c as Arrayable$1, f as EnvironmentOptions, d as ArgumentsType, O as OnServerRestartHandler, h as OnTestsRerunHandler } from './environment.CT0jpO-1.js';
+import { File, TaskResultPack, Task, Test, TaskMeta, Suite, SequenceHooks, SequenceSetupFiles, CancelReason } from '@vitest/runner';
+import { b as Awaitable, U as UserConsoleLog, A as AfterSuiteRunMeta, c as Arrayable$1, f as EnvironmentOptions, P as ProvidedContext, h as OnTestsRerunHandler, d as ArgumentsType, O as OnServerRestartHandler } from './environment.CT0jpO-1.js';
 import { Writable } from 'node:stream';
-import * as vite from 'vite';
-import { ViteDevServer, TransformResult as TransformResult$1, ServerOptions, DepOptimizationConfig, AliasOptions, UserConfig as UserConfig$1, ConfigEnv } from 'vite';
-import { ParsedStack, Awaitable as Awaitable$1, ErrorWithDiff, TestError, Arrayable } from '@vitest/utils';
-import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.CPguQ7J1.js';
+import { TransformResult as TransformResult$1, ServerOptions, DepOptimizationConfig, AliasOptions, UserConfig as UserConfig$1, ConfigEnv, ViteDevServer, ModuleNode } from 'vite';
+import { TestError, ParsedStack, Arrayable, ErrorWithDiff, Awaitable as Awaitable$1 } from '@vitest/utils';
+import { RawSourceMap, ViteNodeServerOptions } from 'vite-node';
+import { StackTraceParserOptions } from '@vitest/utils/source-map';
+import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.BTPBhmK5.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { RawSourceMap, ViteNodeServerOptions } from 'vite-node';
 import * as chai from 'chai';
-import { StackTraceParserOptions } from '@vitest/utils/source-map';
+import { B as BenchmarkResult } from './benchmark.CFFwLv-O.js';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { B as BenchmarkResult } from './benchmark.geERunq4.js';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { Stats } from 'node:fs';
 
@@ -29,8 +28,6 @@ type SerializedTestSpecification = [
     }
 ];
 
-type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
-
 interface Reporter {
     onInit?: (ctx: Vitest) => void;
     onPathsCollected?: (paths?: string[]) => Awaitable<void>;
@@ -56,12 +53,10 @@ declare abstract class BaseReporter implements Reporter {
     failedUnwatchedFiles: Task[];
     isTTY: boolean;
     ctx: Vitest;
+    renderSucceed: boolean;
     protected verbose: boolean;
     private _filesInWatchMode;
     private _timeStart;
-    private _lastRunTimeout;
-    private _lastRunTimer;
-    private _lastRunCount;
     constructor(options?: BaseOptions);
     onInit(ctx: Vitest): void;
     log(...messages: any): void;
@@ -72,7 +67,6 @@ declare abstract class BaseReporter implements Reporter {
     protected printTask(task: Task): void;
     private getDurationPrefix;
     onWatcherStart(files?: File[], errors?: unknown[]): void;
-    private resetLastRunLog;
     onWatcherRerun(files: string[], trigger?: string): void;
     onUserConsoleLog(log: UserConsoleLog): void;
     onTestRemoved(trigger?: string): void;
@@ -85,642 +79,149 @@ declare abstract class BaseReporter implements Reporter {
     private printTaskErrors;
 }
 
-interface ParsedFile extends File {
-    start: number;
-    end: number;
-}
-interface ParsedTest extends Test {
-    start: number;
-    end: number;
-}
-interface ParsedSuite extends Suite {
-    start: number;
-    end: number;
-}
-interface LocalCallDefinition {
-    start: number;
-    end: number;
-    name: string;
-    type: 'suite' | 'test';
-    mode: 'run' | 'skip' | 'only' | 'todo';
-    task: ParsedSuite | ParsedFile | ParsedTest;
+interface BlobOptions {
+    outputFile?: string;
 }
-interface FileInformation {
-    file: File;
-    filepath: string;
-    parsed: string;
-    map: RawSourceMap | null;
-    definitions: LocalCallDefinition[];
+declare class BlobReporter implements Reporter {
+    ctx: Vitest;
+    options: BlobOptions;
+    constructor(options: BlobOptions);
+    onInit(ctx: Vitest): void;
+    onFinished(files: File[] | undefined, errors: unknown[] | undefined, coverage: unknown): Promise<void>;
 }
 
-type RawErrsMap = Map<string, TscErrorInfo[]>;
-interface TscErrorInfo {
-    filePath: string;
-    errCode: number;
-    errMsg: string;
-    line: number;
-    column: number;
-}
-interface CollectLineNumbers {
-    target: number;
-    next: number;
-    prev?: number;
+interface DefaultReporterOptions extends BaseOptions {
+    summary?: boolean;
 }
-type CollectLines = {
-    [key in keyof CollectLineNumbers]: string;
-};
-interface RootAndTarget {
-    root: string;
-    targetAbsPath: string;
+declare class DefaultReporter extends BaseReporter {
+    private options;
+    private summary?;
+    constructor(options?: DefaultReporterOptions);
+    onInit(ctx: Vitest): void;
+    onPathsCollected(paths?: string[]): void;
+    onTaskUpdate(packs: TaskResultPack[]): void;
+    onWatcherRerun(files: string[], trigger?: string): void;
+    onFinished(files?: File[], errors?: unknown[]): void;
 }
-type Context = RootAndTarget & {
-    rawErrsMap: RawErrsMap;
-    openedDirs: Set<string>;
-    lastActivePath?: string;
-};
 
-declare class TypeCheckError extends Error {
-    message: string;
-    stacks: ParsedStack[];
-    name: string;
-    constructor(message: string, stacks: ParsedStack[]);
+interface HTMLOptions {
+    outputFile?: string;
 }
-interface TypecheckResults {
-    files: File[];
-    sourceErrors: TypeCheckError[];
-    time: number;
+
+declare class ReportedTaskImplementation {
+    /**
+     * Task instance.
+     * @experimental Public runner task API is experimental and does not follow semver.
+     */
+    readonly task: Task;
+    /**
+     * The project assosiacted with the test or suite.
+     */
+    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 position.
+     */
+    readonly id: string;
+    /**
+     * Location in the module where the test or suite is defined.
+     */
+    readonly location: {
+        line: number;
+        column: number;
+    } | undefined;
+    protected constructor(task: Task, project: TestProject);
+    /**
+     * Creates a new reported task instance and stores it in the project's state for future use.
+     */
+    static register(task: Task, project: TestProject): TestCase | TestSuite | TestModule;
 }
-type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>;
-declare class Typechecker {
-    protected ctx: WorkspaceProject;
-    private _onParseStart?;
-    private _onParseEnd?;
-    private _onWatcherRerun?;
-    private _result;
-    private _startTime;
-    private _output;
-    private _tests;
-    private tempConfigPath?;
-    private allowJs?;
-    private process?;
-    protected files: string[];
-    constructor(ctx: WorkspaceProject);
-    setFiles(files: string[]): void;
-    onParseStart(fn: Callback): void;
-    onParseEnd(fn: Callback<[TypecheckResults]>): void;
-    onWatcherRerun(fn: Callback): void;
-    protected collectFileTests(filepath: string): Promise<FileInformation | null>;
-    protected getFiles(): string[];
-    collectTests(): Promise<Record<string, FileInformation>>;
-    protected markPassed(file: File): void;
-    protected prepareResults(output: string): Promise<{
-        files: File[];
-        sourceErrors: TypeCheckError[];
-        time: number;
-    }>;
-    protected parseTscLikeOutput(output: string): Promise<Map<string, {
-        error: TypeCheckError;
-        originalError: TscErrorInfo;
-    }[]>>;
-    clear(): Promise<void>;
-    stop(): Promise<void>;
-    protected ensurePackageInstalled(ctx: Vitest, checker: string): Promise<void>;
-    prepare(): Promise<void>;
-    getExitCode(): number | false;
-    getOutput(): string;
-    start(): Promise<void>;
-    getResult(): TypecheckResults;
-    getTestFiles(): File[];
-    getTestPacks(): TaskResultPack[];
+declare class TestCase extends ReportedTaskImplementation {
+    #private;
+    readonly task: Test;
+    readonly type = "test";
+    /**
+     * Direct reference to the test module where the test or suite is defined.
+     */
+    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;
+    protected constructor(task: Test, project: TestProject);
+    /**
+     * Full name of the test including all parent suites separated with `>`.
+     */
+    get fullName(): string;
+    /**
+     * Test results. Will be `undefined` if test is not finished yet or was just collected.
+     */
+    result(): TestResult | undefined;
+    /**
+     * Checks if the test did not fail the suite.
+     * If the test is not finished yet or was skipped, it will return `true`.
+     */
+    ok(): boolean;
+    /**
+     * Custom metadata that was attached to the test during its execution.
+     */
+    meta(): TaskMeta;
+    /**
+     * Useful information about the test like duration, memory usage, etc.
+     * Diagnostic is only available after the test has finished.
+     */
+    diagnostic(): TestDiagnostic | undefined;
 }
-
-interface PrintErrorResult {
-    nearest?: ParsedStack;
+declare class TestCollection {
+    #private;
+    constructor(task: Suite | File, project: TestProject);
+    /**
+     * Returns the test or suite at a specific index in the array.
+     */
+    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?: TestResult['state'] | 'running'): Generator<TestCase, undefined, void>;
+    /**
+     * Filters only the tests that are part of this collection.
+     */
+    tests(state?: TestResult['state'] | 'running'): 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>;
 }
 
-interface Options {
-	/**
-	Show the cursor. This can be useful when a CLI accepts input from a user.
-
-	@example
-	```
-	import {createLogUpdate} from 'log-update';
-
-	// Write output but don't hide the cursor
-	const log = createLogUpdate(process.stdout, {
-		showCursor: true
-	});
-	```
-	*/
-	readonly showCursor?: boolean;
-}
-
-type LogUpdateMethods = {
-	/**
-	Clear the logged output.
-	*/
-	clear(): void;
-
-	/**
-	Persist the logged output. Useful if you want to start a new log session below the current one.
-	*/
-	done(): void;
-};
-
-/**
-Log to `stdout` by overwriting the previous output in the terminal.
-
-@param text - The text to log to `stdout`.
-
-@example
-```
-import logUpdate from 'log-update';
-
-const frames = ['-', '\\', '|', '/'];
-let index = 0;
-
-setInterval(() => {
-	const frame = frames[index = ++index % frames.length];
-
-	logUpdate(
-`
-		♥♥
-${frame} unicorns ${frame}
-		♥♥
-`
-	);
-}, 80);
-```
-*/
-declare const logUpdate: ((...text: string[]) => void) & LogUpdateMethods;
-
-
-/**
-Get a `logUpdate` method that logs to the specified stream.
-
-@param stream - The stream to log to.
-
-@example
-```
-import {createLogUpdate} from 'log-update';
-
-// Write output but don't hide the cursor
-const log = createLogUpdate(process.stdout);
-```
-*/
-declare function createLogUpdate(
-	stream: NodeJS.WritableStream,
-	options?: Options
-): typeof logUpdate;
-
-interface ErrorOptions {
-    type?: string;
-    fullStack?: boolean;
-    project?: WorkspaceProject;
-    verbose?: boolean;
-    screenshotPaths?: string[];
-    task?: Task;
-    showCodeFrame?: boolean;
-}
-declare class Logger {
-    ctx: Vitest;
-    outputStream: NodeJS.WriteStream | Writable;
-    errorStream: NodeJS.WriteStream | Writable;
-    logUpdate: ReturnType<typeof createLogUpdate>;
-    private _clearScreenPending;
-    private _highlights;
-    console: Console;
-    constructor(ctx: Vitest, outputStream?: NodeJS.WriteStream | Writable, errorStream?: NodeJS.WriteStream | Writable);
-    log(...args: any[]): void;
-    error(...args: any[]): void;
-    warn(...args: any[]): void;
-    clearFullScreen(message?: string): void;
-    clearScreen(message: string, force?: boolean): void;
-    private _clearScreen;
-    printError(err: unknown, options?: ErrorOptions): PrintErrorResult | undefined;
-    clearHighlightCache(filename?: string): void;
-    highlight(filename: string, source: string): string;
-    printNoTestFound(filters?: string[]): void;
-    printBanner(): void;
-    printBrowserBanner(project: WorkspaceProject): void;
-    printUnhandledErrors(errors: unknown[]): void;
-    printSourceTypeErrors(errors: TypeCheckError[]): void;
-    private registerUnhandledRejection;
-}
-
-interface BrowserProviderInitializationOptions {
-    browser: string;
-    options?: BrowserProviderOptions;
-}
-interface CDPSession {
-    send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
-    on: (event: string, listener: (...args: unknown[]) => void) => void;
-    once: (event: string, listener: (...args: unknown[]) => void) => void;
-    off: (event: string, listener: (...args: unknown[]) => void) => void;
-}
-interface BrowserProvider {
-    name: string;
-    /**
-     * @experimental opt-in into file parallelisation
-     */
-    supportsParallelism: boolean;
-    getSupportedBrowsers: () => readonly string[];
-    beforeCommand?: (command: string, args: unknown[]) => Awaitable$1<void>;
-    afterCommand?: (command: string, args: unknown[]) => Awaitable$1<void>;
-    getCommandsContext: (contextId: string) => Record<string, unknown>;
-    openPage: (contextId: string, url: string, beforeNavigate?: () => Promise<void>) => Promise<void>;
-    getCDPSession?: (contextId: string) => Promise<CDPSession>;
-    close: () => Awaitable$1<void>;
-    initialize(ctx: WorkspaceProject, options: BrowserProviderInitializationOptions): Awaitable$1<void>;
-}
-interface BrowserProviderModule {
-    new (): BrowserProvider;
-}
-interface BrowserProviderOptions {
-}
-type BrowserBuiltinProvider = 'webdriverio' | 'playwright' | 'preview';
-interface BrowserConfigOptions {
-    /**
-     * if running tests in the browser should be the default
-     *
-     * @default false
-     */
-    enabled?: boolean;
-    /**
-     * Name of the browser
-     */
-    name: string;
-    /**
-     * Browser provider
-     *
-     * @default 'preview'
-     */
-    provider?: BrowserBuiltinProvider | (string & {});
-    /**
-     * Options that are passed down to a browser provider.
-     * To support type hinting, add one of the types to your tsconfig.json "compilerOptions.types" field:
-     *
-     * - for webdriverio: `@vitest/browser/providers/webdriverio`
-     * - for playwright: `@vitest/browser/providers/playwright`
-     *
-     * @example
-     * { playwright: { launch: { devtools: true } }
-     */
-    providerOptions?: BrowserProviderOptions;
-    /**
-     * enable headless mode
-     *
-     * @default process.env.CI
-     */
-    headless?: boolean;
-    /**
-     * Serve API options.
-     *
-     * The default port is 63315.
-     */
-    api?: ApiConfig | number;
-    /**
-     * Isolate test environment after each test
-     *
-     * @default true
-     */
-    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;
-    };
-    /**
-     * 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__
-     */
-    screenshotDirectory?: string;
-    /**
-     * Should Vitest take screenshots if the test fails
-     * @default !browser.ui
-     */
-    screenshotFailures?: boolean;
-    /**
-     * Scripts injected into the tester iframe.
-     * @deprecated Will be removed in the future, use `testerHtmlPath` instead.
-     */
-    testerScripts?: BrowserScript[];
-    /**
-     * Path to the index.html file that will be used to run tests.
-     */
-    testerHtmlPath?: string;
-    /**
-     * Scripts injected into the main window.
-     */
-    orchestratorScripts?: BrowserScript[];
-    /**
-     * Commands that will be executed on the server
-     * via the browser `import("@vitest/browser/context").commands` API.
-     * @see {@link https://vitest.dev/guide/browser/commands}
-     */
-    commands?: Record<string, BrowserCommand<any>>;
-}
-interface BrowserCommandContext {
-    testPath: string | undefined;
-    provider: BrowserProvider;
-    project: WorkspaceProject;
-    contextId: string;
-}
-interface BrowserServerStateContext {
-    files: string[];
-    method: 'run' | 'collect';
-    resolve: () => void;
-    reject: (v: unknown) => void;
-}
-interface BrowserOrchestrator {
-    createTesters: (files: string[]) => Promise<void>;
-    onCancel: (reason: CancelReason) => Promise<void>;
-    $close: () => void;
-}
-interface BrowserServerState {
-    orchestrators: Map<string, BrowserOrchestrator>;
-    getContext: (contextId: string) => BrowserServerStateContext | undefined;
-    createAsyncContext: (method: 'collect' | 'run', contextId: string, files: string[]) => Promise<void>;
-}
-interface BrowserServer {
-    vite: ViteDevServer;
-    state: BrowserServerState;
-    provider: BrowserProvider;
-    close: () => Promise<void>;
-    initBrowserProvider: () => Promise<void>;
-    parseStacktrace: (stack: string) => ParsedStack[];
-    parseErrorStacktrace: (error: ErrorWithDiff, options?: StackTraceParserOptions) => ParsedStack[];
-}
-interface BrowserCommand<Payload extends unknown[]> {
-    (context: BrowserCommandContext, ...payload: Payload): Awaitable$1<any>;
-}
-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;
-    /**
-     * 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.
-     */
-    content?: string;
-    /**
-     * Path to the script. This value is resolved by Vite so it can be a node module or a file path.
-     */
-    src?: string;
-    /**
-     * If the script should be loaded asynchronously.
-     */
-    async?: boolean;
-    /**
-     * Script type.
-     * @default 'module'
-     */
-    type?: string;
-}
-interface ResolvedBrowserOptions extends BrowserConfigOptions {
-    enabled: boolean;
-    headless: boolean;
-    isolate: boolean;
-    fileParallelism: boolean;
-    api: ApiConfig;
-    ui: boolean;
-    viewport: {
-        width: number;
-        height: number;
-    };
-    screenshotFailures: boolean;
-    locators: {
-        testIdAttribute: string;
-    };
-}
-
-interface InitializeProjectOptions extends UserWorkspaceConfig {
-    workspaceConfigPath: string;
-    extends?: string;
-}
-declare class WorkspaceProject {
-    path: string | number;
-    ctx: Vitest;
-    options?: InitializeProjectOptions | undefined;
-    configOverride: Partial<ResolvedConfig> | undefined;
-    config: ResolvedConfig;
-    server: ViteDevServer;
-    vitenode: ViteNodeServer;
-    runner: ViteNodeRunner;
-    browser?: BrowserServer;
-    typechecker?: Typechecker;
-    closingPromise: Promise<unknown> | undefined;
-    testFilesList: string[] | null;
-    typecheckFilesList: string[] | null;
-    testProject: TestProject;
-    readonly id: string;
-    readonly tmpDir: string;
-    private _globalSetups;
-    private _provided;
-    constructor(path: string | number, ctx: Vitest, options?: InitializeProjectOptions | undefined);
-    getName(): string;
-    isCore(): boolean;
-    provide<T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]): void;
-    getProvidedContext(): ProvidedContext;
-    createSpec(moduleId: string, pool: string): WorkspaceSpec;
-    initializeGlobalSetup(): Promise<void>;
-    teardownGlobalSetup(): Promise<void>;
-    get logger(): Logger;
-    getModulesByFilepath(file: string): Set<vite.ModuleNode>;
-    getModuleById(id: string): vite.ModuleNode | undefined;
-    getSourceMapModuleById(id: string): TransformResult$1['map'] | undefined;
-    get reporters(): Reporter[];
-    globTestFiles(filters?: string[]): Promise<{
-        testFiles: string[];
-        typecheckTestFiles: string[];
-    }>;
-    globAllTestFiles(include: string[], exclude: string[], includeSource: string[] | undefined, cwd: string): Promise<string[]>;
-    isTestFile(id: string): boolean | null;
-    isTypecheckFile(id: string): boolean | null;
-    globFiles(include: string[], exclude: string[], cwd: string): Promise<string[]>;
-    isTargetFile(id: string, source?: string): Promise<boolean>;
-    isInSourceTestFile(code: string): boolean;
-    filterFiles(testFiles: string[], filters: string[], dir: string): string[];
-    initBrowserServer(): Promise<void>;
-    static createBasicProject(ctx: Vitest): WorkspaceProject;
-    static createCoreProject(ctx: Vitest): Promise<WorkspaceProject>;
-    setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
-    isBrowserEnabled(): boolean;
-    getSerializableConfig(): SerializedConfig;
-    close(): Promise<unknown>;
-    private clearTmpDir;
-    initBrowserProvider(): Promise<void>;
-}
-
-interface BlobOptions {
-    outputFile?: string;
-}
-declare class BlobReporter implements Reporter {
-    ctx: Vitest;
-    options: BlobOptions;
-    constructor(options: BlobOptions);
-    onInit(ctx: Vitest): void;
-    onFinished(files: File[] | undefined, errors: unknown[] | undefined, coverage: unknown): Promise<void>;
-}
-
-interface HTMLOptions {
-    outputFile?: string;
-}
-
-declare class ReportedTaskImplementation {
-    /**
-     * Task instance.
-     * @experimental Public runner task API is experimental and does not follow semver.
-     */
-    readonly task: Task;
-    /**
-     * The project assosiacted with the test or suite.
-     */
-    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 position.
-     */
-    readonly id: string;
-    /**
-     * Location in the module where the test or suite is defined.
-     */
-    readonly location: {
-        line: number;
-        column: number;
-    } | undefined;
-    protected constructor(task: Task, project: WorkspaceProject);
-    /**
-     * Creates a new reported task instance and stores it in the project's state for future use.
-     */
-    static register(task: Task, project: WorkspaceProject): TestCase | TestSuite | TestModule;
-}
-declare class TestCase extends ReportedTaskImplementation {
-    #private;
-    readonly task: Test | Custom;
-    readonly type = "test";
-    /**
-     * Direct reference to the test module where the test or suite is defined.
-     */
-    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;
-    protected constructor(task: Test | Custom, project: WorkspaceProject);
-    /**
-     * Full name of the test including all parent suites separated with `>`.
-     */
-    get fullName(): string;
-    /**
-     * Test results. Will be `undefined` if test is not finished yet or was just collected.
-     */
-    result(): TestResult | undefined;
-    /**
-     * Checks if the test did not fail the suite.
-     * If the test is not finished yet or was skipped, it will return `true`.
-     */
-    ok(): boolean;
-    /**
-     * Custom metadata that was attached to the test during its execution.
-     */
-    meta(): TaskMeta;
-    /**
-     * 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: WorkspaceProject);
-    /**
-     * Returns the test or suite at a specific index in the array.
-     */
-    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?: TestResult['state'] | 'running'): Generator<TestCase, undefined, void>;
-    /**
-     * Filters only the tests that are part of this collection.
-     */
-    tests(state?: TestResult['state'] | 'running'): 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>;
-}
-
-declare abstract class SuiteImplementation extends ReportedTaskImplementation {
-    readonly task: Suite | File;
-    /**
-     * Collection of suites and tests that are part of this suite.
-     */
-    readonly children: TestCollection;
-    protected constructor(task: Suite | File, project: WorkspaceProject);
+declare abstract class SuiteImplementation extends ReportedTaskImplementation {
+    readonly task: Suite | File;
+    /**
+     * Collection of suites and tests that are part of this suite.
+     */
+    readonly children: TestCollection;
+    protected constructor(task: Suite | File, project: TestProject);
 }
 declare class TestSuite extends SuiteImplementation {
     #private;
@@ -742,7 +243,7 @@ declare class TestSuite extends SuiteImplementation {
      * Options that suite was initiated with.
      */
     readonly options: TaskOptions;
-    protected constructor(task: Suite, project: WorkspaceProject);
+    protected constructor(task: Suite, project: TestProject);
     /**
      * Full name of the suite including all parent suites separated with `>`.
      */
@@ -758,7 +259,7 @@ declare class TestModule extends SuiteImplementation {
      * This value corresponds to Vite's `ModuleGraph` id.
      */
     readonly moduleId: string;
-    protected constructor(task: File, project: WorkspaceProject);
+    protected constructor(task: File, project: TestProject);
     /**
      * Useful information about the module like duration, memory usage, etc.
      * If the module was not executed yet, all diagnostic values will return `0`.
@@ -869,55 +370,16 @@ interface ModuleDiagnostic {
 
 declare class BasicReporter extends BaseReporter {
     constructor();
+    onInit(ctx: Vitest): void;
     reportSummary(files: File[], errors: unknown[]): void;
 }
 
-interface ListRendererOptions {
-    renderSucceed?: boolean;
-    logger: Logger;
-    showHeap: boolean;
-    slowTestThreshold: number;
-    mode: VitestRunMode;
-}
-declare function createListRenderer(_tasks: Task[], options: ListRendererOptions): {
-    start(): any;
-    update(_tasks: Task[]): any;
-    stop(): any;
-    clear(): void;
-};
-
-declare class DefaultReporter extends BaseReporter {
-    renderer?: ReturnType<typeof createListRenderer>;
-    rendererOptions: ListRendererOptions;
-    private renderSucceedDefault?;
-    onPathsCollected(paths?: string[]): void;
-    onTestRemoved(trigger?: string): Promise<void>;
-    onCollected(): void;
-    onFinished(files?: _vitest_runner.File[], errors?: unknown[]): void;
-    onWatcherStart(files?: _vitest_runner.File[], errors?: unknown[]): Promise<void>;
-    stopListRender(): void;
-    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
-    onUserConsoleLog(log: UserConsoleLog): void;
-}
-
-interface DotRendererOptions {
-    logger: Logger;
-}
-declare function createDotRenderer(_tasks: Task[], options: DotRendererOptions): {
-    start(): any;
-    update(_tasks: Task[]): any;
-    stop(): Promise<any>;
-    clear(): void;
-};
-
 declare class DotReporter extends BaseReporter {
-    renderer?: ReturnType<typeof createDotRenderer>;
-    onCollected(): void;
-    onFinished(files?: _vitest_runner.File[], errors?: unknown[]): Promise<void>;
-    onWatcherStart(): Promise<void>;
-    stopListRender(): Promise<void>;
-    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
-    onUserConsoleLog(log: UserConsoleLog): void;
+    private summary?;
+    onInit(ctx: Vitest): void;
+    onTaskUpdate(packs: TaskResultPack[]): void;
+    onWatcherRerun(files: string[], trigger?: string): void;
+    onFinished(files?: File[], errors?: unknown[]): void;
 }
 
 declare class GithubActionsReporter implements Reporter {
@@ -1095,9 +557,18 @@ declare class JsonReporter implements Reporter {
     writeReport(report: string): Promise<void>;
 }
 
+interface ClassnameTemplateVariables {
+    filename: string;
+    filepath: string;
+}
 interface JUnitOptions {
     outputFile?: string;
+    /** @deprecated Use `classnameTemplate` instead. */
     classname?: string;
+    /**
+     * Template for the classname attribute. Can be either a string or a function. The string can contain placeholders {filename} and {filepath}.
+     */
+    classnameTemplate?: string | ((classnameVariables: ClassnameTemplateVariables) => string);
     suiteName?: string;
     /**
      * Write <system-out> and <system-err> for console output
@@ -1143,10 +614,233 @@ declare class TapFlatReporter extends TapReporter {
 
 declare class VerboseReporter extends DefaultReporter {
     protected verbose: boolean;
-    constructor();
+    renderSucceed: boolean;
     onTaskUpdate(packs: TaskResultPack[]): void;
 }
 
+interface ParsedFile extends File {
+    start: number;
+    end: number;
+}
+interface ParsedTest extends Test {
+    start: number;
+    end: number;
+}
+interface ParsedSuite extends Suite {
+    start: number;
+    end: number;
+}
+interface LocalCallDefinition {
+    start: number;
+    end: number;
+    name: string;
+    type: 'suite' | 'test';
+    mode: 'run' | 'skip' | 'only' | 'todo';
+    task: ParsedSuite | ParsedFile | ParsedTest;
+}
+interface FileInformation {
+    file: File;
+    filepath: string;
+    parsed: string;
+    map: RawSourceMap | null;
+    definitions: LocalCallDefinition[];
+}
+
+type RawErrsMap = Map<string, TscErrorInfo[]>;
+interface TscErrorInfo {
+    filePath: string;
+    errCode: number;
+    errMsg: string;
+    line: number;
+    column: number;
+}
+interface CollectLineNumbers {
+    target: number;
+    next: number;
+    prev?: number;
+}
+type CollectLines = {
+    [key in keyof CollectLineNumbers]: string;
+};
+interface RootAndTarget {
+    root: string;
+    targetAbsPath: string;
+}
+type Context = RootAndTarget & {
+    rawErrsMap: RawErrsMap;
+    openedDirs: Set<string>;
+    lastActivePath?: string;
+};
+
+declare class TypeCheckError extends Error {
+    message: string;
+    stacks: ParsedStack[];
+    name: string;
+    constructor(message: string, stacks: ParsedStack[]);
+}
+interface TypecheckResults {
+    files: File[];
+    sourceErrors: TypeCheckError[];
+    time: number;
+}
+type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>;
+declare class Typechecker {
+    protected ctx: TestProject;
+    private _onParseStart?;
+    private _onParseEnd?;
+    private _onWatcherRerun?;
+    private _result;
+    private _startTime;
+    private _output;
+    private _tests;
+    private tempConfigPath?;
+    private allowJs?;
+    private process?;
+    protected files: string[];
+    constructor(ctx: TestProject);
+    setFiles(files: string[]): void;
+    onParseStart(fn: Callback): void;
+    onParseEnd(fn: Callback<[TypecheckResults]>): void;
+    onWatcherRerun(fn: Callback): void;
+    protected collectFileTests(filepath: string): Promise<FileInformation | null>;
+    protected getFiles(): string[];
+    collectTests(): Promise<Record<string, FileInformation>>;
+    protected markPassed(file: File): void;
+    protected prepareResults(output: string): Promise<{
+        files: File[];
+        sourceErrors: TypeCheckError[];
+        time: number;
+    }>;
+    protected parseTscLikeOutput(output: string): Promise<Map<string, {
+        error: TypeCheckError;
+        originalError: TscErrorInfo;
+    }[]>>;
+    clear(): Promise<void>;
+    stop(): Promise<void>;
+    protected ensurePackageInstalled(ctx: Vitest, checker: string): Promise<void>;
+    prepare(): Promise<void>;
+    getExitCode(): number | false;
+    getOutput(): string;
+    start(): Promise<void>;
+    getResult(): TypecheckResults;
+    getTestFiles(): File[];
+    getTestPacks(): TaskResultPack[];
+}
+
+interface PrintErrorResult {
+    nearest?: ParsedStack;
+}
+
+interface Options {
+	/**
+	Show the cursor. This can be useful when a CLI accepts input from a user.
+
+	@example
+	```
+	import {createLogUpdate} from 'log-update';
+
+	// Write output but don't hide the cursor
+	const log = createLogUpdate(process.stdout, {
+		showCursor: true
+	});
+	```
+	*/
+	readonly showCursor?: boolean;
+}
+
+type LogUpdateMethods = {
+	/**
+	Clear the logged output.
+	*/
+	clear(): void;
+
+	/**
+	Persist the logged output. Useful if you want to start a new log session below the current one.
+	*/
+	done(): void;
+};
+
+/**
+Log to `stdout` by overwriting the previous output in the terminal.
+
+@param text - The text to log to `stdout`.
+
+@example
+```
+import logUpdate from 'log-update';
+
+const frames = ['-', '\\', '|', '/'];
+let index = 0;
+
+setInterval(() => {
+	const frame = frames[index = ++index % frames.length];
+
+	logUpdate(
+`
+		♥♥
+${frame} unicorns ${frame}
+		♥♥
+`
+	);
+}, 80);
+```
+*/
+declare const logUpdate: ((...text: string[]) => void) & LogUpdateMethods;
+
+
+/**
+Get a `logUpdate` method that logs to the specified stream.
+
+@param stream - The stream to log to.
+
+@example
+```
+import {createLogUpdate} from 'log-update';
+
+// Write output but don't hide the cursor
+const log = createLogUpdate(process.stdout);
+```
+*/
+declare function createLogUpdate(
+	stream: NodeJS.WritableStream,
+	options?: Options
+): typeof logUpdate;
+
+interface ErrorOptions {
+    type?: string;
+    fullStack?: boolean;
+    project?: TestProject;
+    verbose?: boolean;
+    screenshotPaths?: string[];
+    task?: Task;
+    showCodeFrame?: boolean;
+}
+declare class Logger {
+    ctx: Vitest;
+    outputStream: NodeJS.WriteStream | Writable;
+    errorStream: NodeJS.WriteStream | Writable;
+    logUpdate: ReturnType<typeof createLogUpdate>;
+    private _clearScreenPending;
+    private _highlights;
+    console: Console;
+    constructor(ctx: Vitest, outputStream?: NodeJS.WriteStream | Writable, errorStream?: NodeJS.WriteStream | Writable);
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    clearFullScreen(message?: string): void;
+    clearScreen(message: string, force?: boolean): void;
+    private _clearScreen;
+    printError(err: unknown, options?: ErrorOptions): PrintErrorResult | undefined;
+    clearHighlightCache(filename?: string): void;
+    highlight(filename: string, source: string): string;
+    printNoTestFound(filters?: string[]): void;
+    printBanner(): void;
+    printBrowserBanner(project: TestProject): void;
+    printUnhandledErrors(errors: unknown[]): void;
+    printSourceTypeErrors(errors: TypeCheckError[]): void;
+    private registerUnhandledRejection;
+}
+
 interface TableRendererOptions {
     renderSucceed?: boolean;
     logger: Logger;
@@ -1155,9 +849,9 @@ interface TableRendererOptions {
     compare?: FlatBenchmarkReport;
 }
 declare function createTableRenderer(_tasks: Task[], options: TableRendererOptions): {
-    start(): any;
-    update(_tasks: Task[]): any;
-    stop(): any;
+    start(): /*elided*/ any;
+    update(_tasks: Task[]): /*elided*/ any;
+    stop(): /*elided*/ any;
     clear(): void;
 };
 
@@ -1211,9 +905,9 @@ declare const ReportersMap: {
 };
 type BuiltinReporters = keyof typeof ReportersMap;
 interface BuiltinReporterOptions {
-    'default': BaseOptions;
+    'default': DefaultReporterOptions;
     'basic': BaseOptions;
-    'verbose': never;
+    'verbose': DefaultReporterOptions;
     'dot': BaseOptions;
     'json': JsonOptions$1;
     'blob': BlobOptions;
@@ -1224,6 +918,8 @@ interface BuiltinReporterOptions {
     'html': HTMLOptions;
 }
 
+type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
+
 interface TestSequencer {
     /**
      * Slicing tests into shards. Will be run before `sort`.
@@ -1899,751 +1595,1081 @@ interface InlineConfig {
      * Exclude globs for test files
      * @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
      */
-    exclude?: string[];
+    exclude?: string[];
+    /**
+     * Include globs for in-source test files
+     *
+     * @default []
+     */
+    includeSource?: string[];
+    /**
+     * Handling for dependencies inlining or externalizing
+     *
+     */
+    deps?: DepsOptions;
+    /**
+     * Vite-node server options
+     */
+    server?: Omit<ViteNodeServerOptions, 'transformMode'>;
+    /**
+     * Base directory to scan for the test files
+     *
+     * @default `config.root`
+     */
+    dir?: string;
+    /**
+     * Register apis globally
+     *
+     * @default false
+     */
+    globals?: boolean;
+    /**
+     * Running environment
+     *
+     * Supports 'node', 'jsdom', 'happy-dom', 'edge-runtime'
+     *
+     * If used unsupported string, will try to load the package `vitest-environment-${env}`
+     *
+     * @default 'node'
+     */
+    environment?: VitestEnvironment;
+    /**
+     * Environment options.
+     */
+    environmentOptions?: EnvironmentOptions;
+    /**
+     * Automatically assign environment based on globs. The first match will be used.
+     * This has effect only when running tests inside Node.js.
+     *
+     * Format: [glob, environment-name]
+     *
+     * @deprecated use [`workspace`](https://vitest.dev/config/#environmentmatchglobs) instead
+     * @default []
+     * @example [
+     *   // all tests in tests/dom will run in jsdom
+     *   ['tests/dom/**', 'jsdom'],
+     *   // all tests in tests/ with .edge.test.ts will run in edge-runtime
+     *   ['**\/*.edge.test.ts', 'edge-runtime'],
+     *   // ...
+     * ]
+     */
+    environmentMatchGlobs?: [string, VitestEnvironment][];
+    /**
+     * Run tests in an isolated environment. This option has no effect on vmThreads pool.
+     *
+     * Disabling this option might improve performance if your code doesn't rely on side effects.
+     *
+     * @default true
+     */
+    isolate?: boolean;
+    /**
+     * Pool used to run tests in.
+     *
+     * Supports 'threads', 'forks', 'vmThreads'
+     *
+     * @default 'forks'
+     */
+    pool?: Exclude<Pool, 'browser'>;
+    /**
+     * Pool options
+     */
+    poolOptions?: PoolOptions;
+    /**
+     * Maximum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.maxThreads`/`poolOptions.forks.maxForks` has higher priority.
+     */
+    maxWorkers?: number | string;
+    /**
+     * Minimum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.minThreads`/`poolOptions.forks.minForks` has higher priority.
+     */
+    minWorkers?: number | string;
+    /**
+     * Should all test files run in parallel. Doesn't affect tests running in the same file.
+     * Setting this to `false` will override `maxWorkers` and `minWorkers` options to `1`.
+     *
+     * @default true
+     */
+    fileParallelism?: boolean;
+    /**
+     * Automatically assign pool based on globs. The first match will be used.
+     *
+     * Format: [glob, pool-name]
+     *
+     * @deprecated use [`workspace`](https://vitest.dev/config/#poolmatchglobs) instead
+     * @default []
+     * @example [
+     *   // all tests in "forks" directory will run using "poolOptions.forks" API
+     *   ['tests/forks/**', 'forks'],
+     *   // all other tests will run based on "poolOptions.threads" option, if you didn't specify other globs
+     *   // ...
+     * ]
+     */
+    poolMatchGlobs?: [string, Exclude<Pool, 'browser'>][];
+    /**
+     * Path to a workspace configuration file
+     */
+    workspace?: string | TestProjectConfiguration[];
+    /**
+     * Update snapshot
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Watch mode
+     *
+     * @default !process.env.CI
+     */
+    watch?: boolean;
+    /**
+     * Project root
+     *
+     * @default process.cwd()
+     */
+    root?: string;
+    /**
+     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+     * and/or paths to custom reporters.
+     *
+     * @default []
+     */
+    reporters?: Arrayable$1<ReporterName | InlineReporter> | ((ReporterName | InlineReporter) | [ReporterName] | ReporterWithOptions)[];
+    /**
+     * Write test results to a file when the --reporter=json` or `--reporter=junit` option is also specified.
+     * Also definable individually per reporter by using an object instead.
+     */
+    outputFile?: string | (Partial<Record<BuiltinReporters, string>> & Record<string, string>);
+    /**
+     * Default timeout of a test in milliseconds
+     *
+     * @default 5000
+     */
+    testTimeout?: number;
+    /**
+     * Default timeout of a hook in milliseconds
+     *
+     * @default 10000
+     */
+    hookTimeout?: number;
+    /**
+     * Default timeout to wait for close when Vitest shuts down, in milliseconds
+     *
+     * @default 10000
+     */
+    teardownTimeout?: number;
+    /**
+     * Silent mode
+     *
+     * @default false
+     */
+    silent?: boolean;
+    /**
+     * Hide logs for skipped tests
+     *
+     * @default false
+     */
+    hideSkippedTests?: boolean;
+    /**
+     * Path to setup files
+     */
+    setupFiles?: string | string[];
+    /**
+     * Path to global setup files
+     */
+    globalSetup?: string | string[];
+    /**
+     * Glob patter of file paths that will trigger the whole suite rerun
+     *
+     * Useful if you are testing calling CLI commands
+     *
+     * @default ['**\/package.json/**', '**\/{vitest,vite}.config.*\/**']
+     */
+    forceRerunTriggers?: string[];
+    /**
+     * Coverage options
+     */
+    coverage?: CoverageOptions;
+    /**
+     * run test names with the specified pattern
+     */
+    testNamePattern?: string | RegExp;
+    /**
+     * Will call `.mockClear()` on all spies before each test
+     * @default false
+     */
+    clearMocks?: boolean;
+    /**
+     * Will call `.mockReset()` on all spies before each test
+     * @default false
+     */
+    mockReset?: boolean;
+    /**
+     * Will call `.mockRestore()` on all spies before each test
+     * @default false
+     */
+    restoreMocks?: boolean;
+    /**
+     * Will restore all global stubs to their original values before each test
+     * @default false
+     */
+    unstubGlobals?: boolean;
+    /**
+     * Will restore all env stubs to their original values before each test
+     * @default false
+     */
+    unstubEnvs?: boolean;
+    /**
+     * Serve API options.
+     *
+     * When set to true, the default port is 51204.
+     *
+     * @default false
+     */
+    api?: boolean | number | ApiConfig;
+    /**
+     * Enable Vitest UI
+     *
+     * @default false
+     */
+    ui?: boolean;
+    /**
+     * options for test in a browser environment
+     * @experimental
+     *
+     * @default false
+     */
+    browser?: BrowserConfigOptions;
+    /**
+     * Open UI automatically.
+     *
+     * @default !process.env.CI
+     */
+    open?: boolean;
     /**
-     * Include globs for in-source test files
+     * Base url for the UI
      *
-     * @default []
+     * @default '/__vitest__/'
      */
-    includeSource?: string[];
+    uiBase?: string;
     /**
-     * Handling for dependencies inlining or externalizing
-     *
+     * Determine the transform method for all modules imported inside a test that matches the glob pattern.
      */
-    deps?: DepsOptions;
+    testTransformMode?: TransformModePatterns;
     /**
-     * Vite-node server options
+     * Format options for snapshot testing.
      */
-    server?: Omit<ViteNodeServerOptions, 'transformMode'>;
+    snapshotFormat?: Omit<PrettyFormatOptions, 'plugins'>;
     /**
-     * Base directory to scan for the test files
-     *
-     * @default `config.root`
+     * Path to a module which has a default export of diff config.
      */
-    dir?: string;
+    diff?: string | SerializedDiffOptions;
     /**
-     * Register apis globally
-     *
-     * @default false
+     * Paths to snapshot serializer modules.
      */
-    globals?: boolean;
+    snapshotSerializers?: string[];
     /**
-     * Running environment
-     *
-     * Supports 'node', 'jsdom', 'happy-dom', 'edge-runtime'
-     *
-     * If used unsupported string, will try to load the package `vitest-environment-${env}`
-     *
-     * @default 'node'
+     * Resolve custom snapshot path
      */
-    environment?: VitestEnvironment;
+    resolveSnapshotPath?: ResolveSnapshotPathHandler;
     /**
-     * Environment options.
+     * Path to a custom snapshot environment module that has a default export of `SnapshotEnvironment` object.
      */
-    environmentOptions?: EnvironmentOptions;
+    snapshotEnvironment?: string;
     /**
-     * Automatically assign environment based on globs. The first match will be used.
-     * This has effect only when running tests inside Node.js.
-     *
-     * Format: [glob, environment-name]
-     *
-     * @default []
-     * @example [
-     *   // all tests in tests/dom will run in jsdom
-     *   ['tests/dom/**', 'jsdom'],
-     *   // all tests in tests/ with .edge.test.ts will run in edge-runtime
-     *   ['**\/*.edge.test.ts', 'edge-runtime'],
-     *   // ...
-     * ]
+     * Pass with no tests
      */
-    environmentMatchGlobs?: [string, VitestEnvironment][];
+    passWithNoTests?: boolean;
     /**
-     * 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.
+     * Allow tests and suites that are marked as only
      *
-     * @default true
+     * @default !process.env.CI
      */
-    isolate?: boolean;
+    allowOnly?: boolean;
     /**
-     * Pool used to run tests in.
-     *
-     * Supports 'threads', 'forks', 'vmThreads'
-     *
-     * @default 'forks'
+     * Show heap usage after each test. Useful for debugging memory leaks.
      */
-    pool?: Exclude<Pool, 'browser'>;
+    logHeapUsage?: boolean;
     /**
-     * Pool options
+     * Custom environment variables assigned to `process.env` before running tests.
      */
-    poolOptions?: PoolOptions;
+    env?: Partial<NodeJS.ProcessEnv>;
     /**
-     * Maximum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.maxThreads`/`poolOptions.forks.maxForks` has higher priority.
+     * Options for @sinon/fake-timers
      */
-    maxWorkers?: number | string;
+    fakeTimers?: FakeTimerInstallOpts;
     /**
-     * Minimum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.minThreads`/`poolOptions.forks.minForks` has higher priority.
+     * Custom handler for console.log in tests.
+     *
+     * Return `false` to ignore the log.
      */
-    minWorkers?: number | string;
+    onConsoleLog?: (log: string, type: 'stdout' | 'stderr') => boolean | void;
     /**
-     * Should all test files run in parallel. Doesn't affect tests running in the same file.
-     * Setting this to `false` will override `maxWorkers` and `minWorkers` options to `1`.
+     * Enable stack trace filtering. If absent, all stack trace frames
+     * will be shown.
      *
-     * @default true
+     * Return `false` to omit the frame.
      */
-    fileParallelism?: boolean;
+    onStackTrace?: (error: ErrorWithDiff, frame: ParsedStack) => boolean | void;
     /**
-     * Automatically assign pool based on globs. The first match will be used.
+     * Indicates if CSS files should be processed.
      *
-     * Format: [glob, pool-name]
+     * When excluded, the CSS files will be replaced with empty strings to bypass the subsequent processing.
      *
-     * @default []
-     * @example [
-     *   // all tests in "forks" directory will run using "poolOptions.forks" API
-     *   ['tests/forks/**', 'forks'],
-     *   // all other tests will run based on "poolOptions.threads" option, if you didn't specify other globs
-     *   // ...
-     * ]
+     * @default { include: [], modules: { classNameStrategy: false } }
      */
-    poolMatchGlobs?: [string, Exclude<Pool, 'browser'>][];
+    css?: boolean | {
+        include?: RegExp | RegExp[];
+        exclude?: RegExp | RegExp[];
+        modules?: {
+            classNameStrategy?: CSSModuleScopeStrategy;
+        };
+    };
     /**
-     * Path to a workspace configuration file
+     * A number of tests that are allowed to run at the same time marked with `test.concurrent`.
+     * @default 5
      */
-    workspace?: string;
+    maxConcurrency?: number;
     /**
-     * Update snapshot
-     *
-     * @default false
+     * Options for configuring cache policy.
+     * @default { dir: 'node_modules/.vite/vitest' }
      */
-    update?: boolean;
+    cache?: false | {
+        /**
+         * @deprecated Use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir\/vitest".
+         */
+        dir: string;
+    };
     /**
-     * Watch mode
-     *
-     * @default !process.env.CI
+     * Options for configuring the order of running tests.
      */
-    watch?: boolean;
+    sequence?: SequenceOptions;
     /**
-     * Project root
-     *
-     * @default process.cwd()
+     * Specifies an `Object`, or an `Array` of `Object`,
+     * which defines aliases used to replace values in `import` or `require` statements.
+     * Will be merged with the default aliases inside `resolve.alias`.
      */
-    root?: string;
+    alias?: AliasOptions;
     /**
-     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
-     * and/or paths to custom reporters.
+     * Ignore any unhandled errors that occur
      *
-     * @default []
+     * @default false
      */
-    reporters?: Arrayable$1<ReporterName | InlineReporter> | ((ReporterName | InlineReporter) | [ReporterName] | ReporterWithOptions)[];
+    dangerouslyIgnoreUnhandledErrors?: boolean;
     /**
-     * Write test results to a file when the --reporter=json` or `--reporter=junit` option is also specified.
-     * Also definable individually per reporter by using an object instead.
+     * Options for configuring typechecking test environment.
      */
-    outputFile?: string | (Partial<Record<BuiltinReporters, string>> & Record<string, string>);
+    typecheck?: Partial<TypecheckConfig>;
     /**
-     * Default timeout of a test in milliseconds
+     * The number of milliseconds after which a test is considered slow and reported as such in the results.
      *
-     * @default 5000
+     * @default 300
      */
-    testTimeout?: number;
+    slowTestThreshold?: number;
     /**
-     * Default timeout of a hook in milliseconds
-     *
-     * @default 10000
+     * Path to a custom test runner.
      */
-    hookTimeout?: number;
+    runner?: string;
     /**
-     * Default timeout to wait for close when Vitest shuts down, in milliseconds
+     * Debug tests by opening `node:inspector` in worker / child process.
+     * Provides similar experience as `--inspect` Node CLI argument.
      *
-     * @default 10000
+     * Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
      */
-    teardownTimeout?: number;
+    inspect?: boolean | string;
     /**
-     * Silent mode
+     * 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.
      *
-     * @default false
+     * Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
      */
-    silent?: boolean;
+    inspectBrk?: boolean | string;
     /**
-     * Hide logs for skipped tests
-     *
-     * @default false
+     * Inspector options. If `--inspect` or `--inspect-brk` is enabled, these options will be passed to the inspector.
      */
-    hideSkippedTests?: boolean;
+    inspector?: {
+        /**
+         * Enable inspector
+         */
+        enabled?: boolean;
+        /**
+         * Port to run inspector on
+         */
+        port?: number;
+        /**
+         * Host to run inspector on
+         */
+        host?: string;
+        /**
+         * Wait for debugger to connect before running tests
+         */
+        waitForDebugger?: boolean;
+    };
     /**
-     * Path to setup files
+     * Define variables that will be returned from `inject` in the test environment.
+     * @example
+     * ```ts
+     * // vitest.config.ts
+     * export default defineConfig({
+     *   test: {
+     *     provide: {
+     *       someKey: 'someValue'
+     *     }
+     *   }
+     * })
+     * ```
+     * ```ts
+     * // test file
+     * import { inject } from 'vitest'
+     * const value = inject('someKey') // 'someValue'
+     * ```
      */
-    setupFiles?: string | string[];
+    provide?: Partial<ProvidedContext>;
     /**
-     * Path to global setup files
+     * Configuration options for expect() matches.
      */
-    globalSetup?: string | string[];
+    expect?: {
+        /**
+         * Throw an error if tests don't have any expect() assertions.
+         */
+        requireAssertions?: boolean;
+        /**
+         * Default options for expect.poll()
+         */
+        poll?: {
+            /**
+             * Timeout in milliseconds
+             * @default 1000
+             */
+            timeout?: number;
+            /**
+             * Polling interval in milliseconds
+             * @default 50
+             */
+            interval?: number;
+        };
+    };
+    /**
+     * Modify default Chai config. Vitest uses Chai for `expect` and `assert` matches.
+     * https://github.com/chaijs/chai/blob/4.x.x/lib/chai/config.js
+     */
+    chaiConfig?: ChaiConfig;
     /**
-     * Glob patter of file paths that will trigger the whole suite rerun
-     *
-     * Useful if you are testing calling CLI commands
-     *
-     * @default ['**\/package.json/**', '**\/{vitest,vite}.config.*\/**']
+     * Stop test execution when given number of tests have failed.
      */
-    forceRerunTriggers?: string[];
+    bail?: number;
     /**
-     * Coverage options
+     * Retry the test specific number of times if it fails.
+     *
+     * @default 0
      */
-    coverage?: CoverageOptions;
+    retry?: number;
     /**
-     * run test names with the specified pattern
+     * Show full diff when snapshot fails instead of a patch.
      */
-    testNamePattern?: string | RegExp;
+    expandSnapshotDiff?: boolean;
     /**
-     * Will call `.mockClear()` on all spies before each test
+     * By default, Vitest automatically intercepts console logging during tests for extra formatting of test file, test title, etc...
+     * This is also required for console log preview on Vitest UI.
+     * However, disabling such interception might help when you want to debug a code with normal synchronus terminal console logging.
+     *
+     * This option has no effect on browser pool since Vitest preserves original logging on browser devtools.
+     *
      * @default false
      */
-    clearMocks?: boolean;
+    disableConsoleIntercept?: boolean;
     /**
-     * Will call `.mockReset()` on all spies before each test
+     * Always print console stack traces.
+     *
      * @default false
      */
-    mockReset?: boolean;
+    printConsoleTrace?: boolean;
     /**
-     * Will call `.mockRestore()` on all spies before each test
+     * Include "location" property inside the test definition
+     *
      * @default false
      */
-    restoreMocks?: boolean;
+    includeTaskLocation?: boolean;
+}
+interface TypecheckConfig {
     /**
-     * Will restore all global stubs to their original values before each test
-     * @default false
+     * Run typechecking tests alongisde regular tests.
      */
-    unstubGlobals?: boolean;
+    enabled?: boolean;
     /**
-     * Will restore all env stubs to their original values before each test
-     * @default false
+     * When typechecking is enabled, only run typechecking tests.
      */
-    unstubEnvs?: boolean;
+    only?: boolean;
     /**
-     * Serve API options.
-     *
-     * When set to true, the default port is 51204.
+     * What tools to use for type checking.
      *
-     * @default false
+     * @default 'tsc'
      */
-    api?: boolean | number | ApiConfig;
+    checker: 'tsc' | 'vue-tsc' | (string & Record<never, never>);
     /**
-     * Enable Vitest UI
+     * Pattern for files that should be treated as test files
      *
-     * @default false
+     * @default ['**\/*.{test,spec}-d.?(c|m)[jt]s?(x)']
      */
-    ui?: boolean;
+    include: string[];
     /**
-     * options for test in a browser environment
-     * @experimental
+     * Pattern for files that should not be treated as test files
      *
-     * @default false
+     * @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
      */
-    browser?: BrowserConfigOptions;
+    exclude: string[];
     /**
-     * Open UI automatically.
-     *
-     * @default !process.env.CI
+     * Check JS files that have `@ts-check` comment.
+     * If you have it enabled in tsconfig, this will not overwrite it.
      */
-    open?: boolean;
+    allowJs?: boolean;
     /**
-     * Base url for the UI
-     *
-     * @default '/__vitest__/'
+     * Do not fail, if Vitest found errors outside the test files.
      */
-    uiBase?: string;
+    ignoreSourceErrors?: boolean;
     /**
-     * Determine the transform method for all modules imported inside a test that matches the glob pattern.
+     * Path to tsconfig, relative to the project root.
      */
-    testTransformMode?: TransformModePatterns;
+    tsconfig?: string;
+}
+interface UserConfig extends InlineConfig {
     /**
-     * Format options for snapshot testing.
+     * Path to the config file.
+     *
+     * Default resolving to `vitest.config.*`, `vite.config.*`
+     *
+     * Setting to `false` will disable config resolving.
      */
-    snapshotFormat?: Omit<PrettyFormatOptions, 'plugins'>;
+    config?: string | false | undefined;
     /**
-     * Path to a module which has a default export of diff config.
+     * Do not run tests when Vitest starts.
+     *
+     * Vitest will only run tests if it's called programmatically or the test file changes.
+     *
+     * CLI file filters will be ignored.
      */
-    diff?: string | SerializedDiffOptions;
+    standalone?: boolean;
     /**
-     * Paths to snapshot serializer modules.
+     * Use happy-dom
      */
-    snapshotSerializers?: string[];
+    dom?: boolean;
     /**
-     * Resolve custom snapshot path
+     * Run tests that cover a list of source files
      */
-    resolveSnapshotPath?: ResolveSnapshotPathHandler;
+    related?: string[] | string;
     /**
-     * Path to a custom snapshot environment module that has a default export of `SnapshotEnvironment` object.
+     * Overrides Vite mode
+     * @default 'test'
      */
-    snapshotEnvironment?: string;
+    mode?: string;
     /**
-     * Pass with no tests
+     * Runs tests that are affected by the changes in the repository, or between specified branch or commit hash
+     * Requires initialized git repository
+     * @default false
      */
-    passWithNoTests?: boolean;
+    changed?: boolean | string;
     /**
-     * Allow tests and suites that are marked as only
-     *
-     * @default !process.env.CI
+     * Test suite shard to execute in a format of <index>/<count>.
+     * Will divide tests into a `count` numbers, and run only the `indexed` part.
+     * Cannot be used with enabled watch.
+     * @example --shard=2/3
      */
-    allowOnly?: boolean;
+    shard?: string;
     /**
-     * Show heap usage after each test. Useful for debugging memory leaks.
+     * Name of the project or projects to run.
      */
-    logHeapUsage?: boolean;
+    project?: string | string[];
     /**
-     * Custom environment variables assigned to `process.env` before running tests.
+     * Additional exclude patterns
      */
-    env?: Partial<NodeJS.ProcessEnv>;
+    cliExclude?: string[];
     /**
-     * Options for @sinon/fake-timers
+     * Override vite config's clearScreen from cli
      */
-    fakeTimers?: FakeTimerInstallOpts;
+    clearScreen?: boolean;
     /**
-     * Custom handler for console.log in tests.
-     *
-     * Return `false` to ignore the log.
+     * benchmark.compare option exposed at the top level for cli
      */
-    onConsoleLog?: (log: string, type: 'stdout' | 'stderr') => boolean | void;
+    compare?: string;
     /**
-     * Enable stack trace filtering. If absent, all stack trace frames
-     * will be shown.
-     *
-     * Return `false` to omit the frame.
+     * benchmark.outputJson option exposed at the top level for cli
      */
-    onStackTrace?: (error: ErrorWithDiff, frame: ParsedStack) => boolean | void;
+    outputJson?: string;
     /**
-     * Indicates if CSS files should be processed.
-     *
-     * When excluded, the CSS files will be replaced with empty strings to bypass the subsequent processing.
-     *
-     * @default { include: [], modules: { classNameStrategy: false } }
+     * Directory of blob reports to merge
+     * @default '.vitest-reports'
      */
-    css?: boolean | {
-        include?: RegExp | RegExp[];
-        exclude?: RegExp | RegExp[];
-        modules?: {
-            classNameStrategy?: CSSModuleScopeStrategy;
-        };
+    mergeReports?: string;
+}
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'browser' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck' | 'runner' | 'poolOptions' | 'pool' | 'cliExclude' | 'diff' | 'setupFiles' | 'snapshotEnvironment' | 'bail'> {
+    mode: VitestRunMode;
+    base?: string;
+    diff?: string | SerializedDiffOptions;
+    bail?: number;
+    setupFiles: string[];
+    snapshotEnvironment?: string;
+    config?: string;
+    filters?: string[];
+    testNamePattern?: RegExp;
+    related?: string[];
+    coverage: ResolvedCoverageOptions;
+    snapshotOptions: SnapshotStateOptions;
+    browser: ResolvedBrowserOptions;
+    pool: Pool;
+    poolOptions?: ResolvedPoolOptions;
+    reporters: (InlineReporter | ReporterWithOptions)[];
+    defines: Record<string, any>;
+    api?: ApiConfig;
+    cliExclude?: string[];
+    benchmark?: Required<Omit<BenchmarkUserOptions, 'outputFile' | 'compare' | 'outputJson'>> & Pick<BenchmarkUserOptions, 'outputFile' | 'compare' | 'outputJson'>;
+    shard?: {
+        index: number;
+        count: number;
+    };
+    cache: {
+        /**
+         * @deprecated
+         */
+        dir: string;
+    } | false;
+    sequence: {
+        sequencer: TestSequencerConstructor;
+        hooks: SequenceHooks;
+        setupFiles: SequenceSetupFiles;
+        shuffle?: boolean;
+        concurrent?: boolean;
+        seed: number;
+    };
+    typecheck: Omit<TypecheckConfig, 'enabled'> & {
+        enabled: boolean;
+    };
+    runner?: string;
+    maxWorkers: number;
+    minWorkers: number;
+}
+type NonProjectOptions = 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'teardownTimeout' | 'silent' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'onStackTrace' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'coverage' | 'maxWorkers' | 'minWorkers' | 'fileParallelism';
+type ProjectConfig = Omit<UserConfig, NonProjectOptions | 'sequencer' | 'deps' | 'poolOptions'> & {
+    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'>;
     };
+};
+type ResolvedProjectConfig = Omit<ResolvedConfig, Exclude<NonProjectOptions, 'coverage' | 'watch'>>;
+interface UserWorkspaceConfig extends UserConfig$1 {
+    test?: ProjectConfig;
+}
+type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
+type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
+type TestProjectConfiguration = string | (UserProjectConfigExport & {
     /**
-     * A number of tests that are allowed to run at the same time marked with `test.concurrent`.
-     * @default 5
+     * Relative path to the extendable config. All other options will be merged with this config.
+     * If `true`, the project will inherit all options from the root config.
+     * @example '../vite.config.ts'
      */
-    maxConcurrency?: number;
+    extends?: string | true;
+});
+/** @deprecated use `TestProjectConfiguration` instead */
+type WorkspaceProjectConfiguration = TestProjectConfiguration;
+
+interface BrowserProviderInitializationOptions {
+    browser: string;
+    options?: BrowserProviderOptions;
+}
+interface CDPSession {
+    send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
+    on: (event: string, listener: (...args: unknown[]) => void) => void;
+    once: (event: string, listener: (...args: unknown[]) => void) => void;
+    off: (event: string, listener: (...args: unknown[]) => void) => void;
+}
+interface BrowserProvider {
+    name: string;
+    /**
+     * @experimental opt-in into file parallelisation
+     */
+    supportsParallelism: boolean;
+    getSupportedBrowsers: () => readonly string[];
+    beforeCommand?: (command: string, args: unknown[]) => Awaitable$1<void>;
+    afterCommand?: (command: string, args: unknown[]) => Awaitable$1<void>;
+    getCommandsContext: (contextId: string) => Record<string, unknown>;
+    openPage: (contextId: string, url: string, beforeNavigate?: () => Promise<void>) => Promise<void>;
+    getCDPSession?: (contextId: string) => Promise<CDPSession>;
+    close: () => Awaitable$1<void>;
+    initialize(ctx: TestProject, options: BrowserProviderInitializationOptions): Awaitable$1<void>;
+}
+interface BrowserProviderModule {
+    new (): BrowserProvider;
+}
+interface BrowserProviderOptions {
+}
+type BrowserBuiltinProvider = 'webdriverio' | 'playwright' | 'preview';
+interface BrowserConfigOptions {
     /**
-     * Options for configuring cache policy.
-     * @default { dir: 'node_modules/.vite/vitest' }
+     * if running tests in the browser should be the default
+     *
+     * @default false
      */
-    cache?: false | {
-        /**
-         * @deprecated Use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir\/vitest".
-         */
-        dir: string;
-    };
+    enabled?: boolean;
     /**
-     * Options for configuring the order of running tests.
+     * Name of the browser
      */
-    sequence?: SequenceOptions;
+    name: string;
     /**
-     * Specifies an `Object`, or an `Array` of `Object`,
-     * which defines aliases used to replace values in `import` or `require` statements.
-     * Will be merged with the default aliases inside `resolve.alias`.
+     * Browser provider
+     *
+     * @default 'preview'
      */
-    alias?: AliasOptions;
+    provider?: BrowserBuiltinProvider | (string & {});
     /**
-     * Ignore any unhandled errors that occur
+     * Options that are passed down to a browser provider.
+     * To support type hinting, add one of the types to your tsconfig.json "compilerOptions.types" field:
      *
-     * @default false
+     * - for webdriverio: `@vitest/browser/providers/webdriverio`
+     * - for playwright: `@vitest/browser/providers/playwright`
+     *
+     * @example
+     * { playwright: { launch: { devtools: true } }
      */
-    dangerouslyIgnoreUnhandledErrors?: boolean;
+    providerOptions?: BrowserProviderOptions;
     /**
-     * Options for configuring typechecking test environment.
+     * enable headless mode
+     *
+     * @default process.env.CI
      */
-    typecheck?: Partial<TypecheckConfig>;
+    headless?: boolean;
     /**
-     * The number of milliseconds after which a test is considered slow and reported as such in the results.
+     * Serve API options.
      *
-     * @default 300
+     * The default port is 63315.
      */
-    slowTestThreshold?: number;
+    api?: ApiConfig | number;
     /**
-     * Path to a custom test runner.
+     * Isolate test environment after each test
+     *
+     * @default true
      */
-    runner?: string;
+    isolate?: boolean;
     /**
-     * Debug tests by opening `node:inspector` in worker / child process.
-     * Provides similar experience as `--inspect` Node CLI argument.
+     * Run test files in parallel if provider supports this option
+     * This option only has effect in headless mode (enabled in CI by default)
      *
-     * Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
+     * @default // Same as "test.fileParallelism"
      */
-    inspect?: boolean | string;
+    fileParallelism?: boolean;
     /**
-     * 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.
+     * Show Vitest UI
      *
-     * Requires `poolOptions.threads.singleThread: true` OR `poolOptions.forks.singleFork: true`.
+     * @default !process.env.CI
      */
-    inspectBrk?: boolean | string;
+    ui?: boolean;
     /**
-     * Inspector options. If `--inspect` or `--inspect-brk` is enabled, these options will be passed to the inspector.
+     * Default viewport size
      */
-    inspector?: {
-        /**
-         * Enable inspector
-         */
-        enabled?: boolean;
-        /**
-         * Port to run inspector on
-         */
-        port?: number;
+    viewport?: {
         /**
-         * Host to run inspector on
+         * Width of the viewport
+         * @default 414
          */
-        host?: string;
+        width: number;
         /**
-         * Wait for debugger to connect before running tests
+         * Height of the viewport
+         * @default 896
          */
-        waitForDebugger?: boolean;
+        height: number;
     };
     /**
-     * Define variables that will be returned from `inject` in the test environment.
-     * @example
-     * ```ts
-     * // vitest.config.ts
-     * export default defineConfig({
-     *   test: {
-     *     provide: {
-     *       someKey: 'someValue'
-     *     }
-     *   }
-     * })
-     * ```
-     * ```ts
-     * // test file
-     * import { inject } from 'vitest'
-     * const value = inject('someKey') // 'someValue'
-     * ```
-     */
-    provide?: Partial<ProvidedContext>;
-    /**
-     * Configuration options for expect() matches.
+     * Locator options
      */
-    expect?: {
-        /**
-         * Throw an error if tests don't have any expect() assertions.
-         */
-        requireAssertions?: boolean;
+    locators?: {
         /**
-         * Default options for expect.poll()
+         * Attribute used to locate elements by test id
+         * @default 'data-testid'
          */
-        poll?: {
-            /**
-             * Timeout in milliseconds
-             * @default 1000
-             */
-            timeout?: number;
-            /**
-             * Polling interval in milliseconds
-             * @default 50
-             */
-            interval?: number;
-        };
+        testIdAttribute?: string;
     };
     /**
-     * Modify default Chai config. Vitest uses Chai for `expect` and `assert` matches.
-     * https://github.com/chaijs/chai/blob/4.x.x/lib/chai/config.js
-     */
-    chaiConfig?: ChaiConfig;
-    /**
-     * Stop test execution when given number of tests have failed.
+     * 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__
      */
-    bail?: number;
+    screenshotDirectory?: string;
     /**
-     * Retry the test specific number of times if it fails.
-     *
-     * @default 0
+     * Should Vitest take screenshots if the test fails
+     * @default !browser.ui
      */
-    retry?: number;
+    screenshotFailures?: boolean;
     /**
-     * Show full diff when snapshot fails instead of a patch.
+     * Scripts injected into the tester iframe.
+     * @deprecated Will be removed in the future, use `testerHtmlPath` instead.
      */
-    expandSnapshotDiff?: boolean;
+    testerScripts?: BrowserScript[];
     /**
-     * By default, Vitest automatically intercepts console logging during tests for extra formatting of test file, test title, etc...
-     * This is also required for console log preview on Vitest UI.
-     * However, disabling such interception might help when you want to debug a code with normal synchronus terminal console logging.
-     *
-     * This option has no effect on browser pool since Vitest preserves original logging on browser devtools.
-     *
-     * @default false
+     * Path to the index.html file that will be used to run tests.
      */
-    disableConsoleIntercept?: boolean;
+    testerHtmlPath?: string;
     /**
-     * Always print console stack traces.
-     *
-     * @default false
+     * Scripts injected into the main window.
      */
-    printConsoleTrace?: boolean;
+    orchestratorScripts?: BrowserScript[];
     /**
-     * Include "location" property inside the test definition
-     *
-     * @default false
+     * Commands that will be executed on the server
+     * via the browser `import("@vitest/browser/context").commands` API.
+     * @see {@link https://vitest.dev/guide/browser/commands}
      */
-    includeTaskLocation?: boolean;
+    commands?: Record<string, BrowserCommand<any>>;
 }
-interface TypecheckConfig {
-    /**
-     * Run typechecking tests alongisde regular tests.
-     */
-    enabled?: boolean;
-    /**
-     * When typechecking is enabled, only run typechecking tests.
-     */
-    only?: boolean;
-    /**
-     * What tools to use for type checking.
-     *
-     * @default 'tsc'
-     */
-    checker: 'tsc' | 'vue-tsc' | (string & Record<never, never>);
-    /**
-     * Pattern for files that should be treated as test files
-     *
-     * @default ['**\/*.{test,spec}-d.?(c|m)[jt]s?(x)']
-     */
-    include: string[];
-    /**
-     * Pattern for files that should not be treated as test files
-     *
-     * @default ['**\/node_modules/**', '**\/dist/**', '**\/cypress/**', '**\/.{idea,git,cache,output,temp}/**', '**\/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
-     */
-    exclude: string[];
-    /**
-     * Check JS files that have `@ts-check` comment.
-     * If you have it enabled in tsconfig, this will not overwrite it.
-     */
-    allowJs?: boolean;
-    /**
-     * Do not fail, if Vitest found errors outside the test files.
-     */
-    ignoreSourceErrors?: boolean;
-    /**
-     * Path to tsconfig, relative to the project root.
-     */
-    tsconfig?: string;
+interface BrowserCommandContext {
+    testPath: string | undefined;
+    provider: BrowserProvider;
+    project: TestProject;
+    contextId: string;
+}
+interface BrowserServerStateContext {
+    files: string[];
+    method: 'run' | 'collect';
+    resolve: () => void;
+    reject: (v: unknown) => void;
+}
+interface BrowserOrchestrator {
+    createTesters: (files: string[]) => Promise<void>;
+    onCancel: (reason: CancelReason) => Promise<void>;
+    $close: () => void;
+}
+interface BrowserServerState {
+    orchestrators: Map<string, BrowserOrchestrator>;
+    getContext: (contextId: string) => BrowserServerStateContext | undefined;
+    createAsyncContext: (method: 'collect' | 'run', contextId: string, files: string[]) => Promise<void>;
 }
-interface UserConfig extends InlineConfig {
+interface BrowserServer {
+    vite: ViteDevServer;
+    state: BrowserServerState;
+    provider: BrowserProvider;
+    close: () => Promise<void>;
+    initBrowserProvider: () => Promise<void>;
+    parseStacktrace: (stack: string) => ParsedStack[];
+    parseErrorStacktrace: (error: ErrorWithDiff, options?: StackTraceParserOptions) => ParsedStack[];
+}
+interface BrowserCommand<Payload extends unknown[]> {
+    (context: BrowserCommandContext, ...payload: Payload): Awaitable$1<any>;
+}
+interface BrowserScript {
     /**
-     * Path to the config file.
-     *
-     * Default resolving to `vitest.config.*`, `vite.config.*`
+     * If "content" is provided and type is "module", this will be its identifier.
      *
-     * Setting to `false` will disable config resolving.
+     * If you are using TypeScript, you can add `.ts` extension here for example.
+     * @default `injected-${index}.js`
      */
-    config?: string | false | undefined;
+    id?: string;
     /**
-     * Do not run tests when Vitest starts.
-     *
-     * Vitest will only run tests if it's called programmatically or the test file changes.
+     * JavaScript content to be injected. This string is processed by Vite plugins if type is "module".
      *
-     * CLI file filters will be ignored.
+     * You can use `id` to give Vite a hint about the file extension.
      */
-    standalone?: boolean;
+    content?: string;
     /**
-     * Use happy-dom
+     * Path to the script. This value is resolved by Vite so it can be a node module or a file path.
      */
-    dom?: boolean;
+    src?: string;
     /**
-     * Run tests that cover a list of source files
+     * If the script should be loaded asynchronously.
      */
-    related?: string[] | string;
+    async?: boolean;
     /**
-     * Overrides Vite mode
-     * @default 'test'
+     * Script type.
+     * @default 'module'
      */
-    mode?: string;
+    type?: string;
+}
+interface ResolvedBrowserOptions extends BrowserConfigOptions {
+    enabled: boolean;
+    headless: boolean;
+    isolate: boolean;
+    fileParallelism: boolean;
+    api: ApiConfig;
+    ui: boolean;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    screenshotFailures: boolean;
+    locators: {
+        testIdAttribute: string;
+    };
+}
+
+declare class TestSpecification {
     /**
-     * Runs tests that are affected by the changes in the repository, or between specified branch or commit hash
-     * Requires initialized git repository
-     * @default false
+     * @deprecated use `project` instead
      */
-    changed?: boolean | string;
+    readonly 0: TestProject;
     /**
-     * Test suite shard to execute in a format of <index>/<count>.
-     * Will divide tests into a `count` numbers, and run only the `indexed` part.
-     * Cannot be used with enabled watch.
-     * @example --shard=2/3
+     * @deprecated use `moduleId` instead
      */
-    shard?: string;
+    readonly 1: string;
     /**
-     * Name of the project or projects to run.
+     * @deprecated use `pool` instead
      */
-    project?: string | string[];
+    readonly 2: {
+        pool: Pool;
+    };
+    readonly project: TestProject;
+    readonly moduleId: string;
+    readonly pool: Pool;
+    /** @private */
+    readonly testLocations: number[] | undefined;
+    constructor(project: TestProject, moduleId: string, pool: Pool, testLocations?: number[] | undefined);
+    toJSON(): SerializedTestSpecification;
     /**
-     * Additional exclude patterns
+     * for backwards compatibility
+     * @deprecated
      */
-    cliExclude?: string[];
+    [Symbol.iterator](): Generator<string | TestProject, void, unknown>;
+}
+
+declare class TestProject {
+    /** @deprecated */
+    path: string | number;
+    /** @deprecated */
+    options?: InitializeProjectOptions | undefined;
     /**
-     * Override vite config's clearScreen from cli
+     * The global Vitest instance.
+     * @experimental The public Vitest API is experimental and does not follow semver.
      */
-    clearScreen?: boolean;
+    readonly vitest: Vitest;
     /**
-     * benchmark.compare option exposed at the top level for cli
+     * Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
      */
-    compare?: string;
+    readonly globalConfig: ResolvedConfig;
     /**
-     * benchmark.outputJson option exposed at the top level for cli
+     * Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
      */
-    outputJson?: string;
+    browser?: BrowserServer;
+    /** @deprecated use `vitest` instead */
+    ctx: Vitest;
     /**
-     * Directory of blob reports to merge
-     * @default '.vitest-reports'
+     * Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
      */
-    mergeReports?: string;
-}
-interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'browser' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck' | 'runner' | 'poolOptions' | 'pool' | 'cliExclude' | 'diff' | 'setupFiles' | 'snapshotEnvironment' | 'bail'> {
-    mode: VitestRunMode;
-    base?: string;
-    diff?: string | SerializedDiffOptions;
-    bail?: number;
-    setupFiles: string[];
-    snapshotEnvironment?: string;
-    config?: string;
-    filters?: string[];
-    testNamePattern?: RegExp;
-    related?: string[];
-    coverage: ResolvedCoverageOptions;
-    snapshotOptions: SnapshotStateOptions;
-    browser: ResolvedBrowserOptions;
-    pool: Pool;
-    poolOptions?: ResolvedPoolOptions;
-    reporters: (InlineReporter | ReporterWithOptions)[];
-    defines: Record<string, any>;
-    api?: ApiConfig;
-    cliExclude?: string[];
-    benchmark?: Required<Omit<BenchmarkUserOptions, 'outputFile' | 'compare' | 'outputJson'>> & Pick<BenchmarkUserOptions, 'outputFile' | 'compare' | 'outputJson'>;
-    shard?: {
-        index: number;
-        count: number;
-    };
-    cache: {
-        /**
-         * @deprecated
-         */
-        dir: string;
-    } | false;
-    sequence: {
-        sequencer: TestSequencerConstructor;
-        hooks: SequenceHooks;
-        setupFiles: SequenceSetupFiles;
-        shuffle?: boolean;
-        concurrent?: boolean;
-        seed: number;
-    };
-    typecheck: Omit<TypecheckConfig, 'enabled'> & {
-        enabled: boolean;
-    };
-    runner?: string;
-    maxWorkers: number;
-    minWorkers: number;
-}
-type NonProjectOptions = 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'teardownTimeout' | 'silent' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'onStackTrace' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'coverage' | 'maxWorkers' | 'minWorkers' | 'fileParallelism';
-type ProjectConfig = Omit<UserConfig, NonProjectOptions | 'sequencer' | 'deps' | 'poolOptions'> & {
-    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'>;
-    };
-};
-type ResolvedProjectConfig = Omit<ResolvedConfig, NonProjectOptions>;
-interface UserWorkspaceConfig extends UserConfig$1 {
-    test?: ProjectConfig;
-}
-type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
-type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
-type WorkspaceProjectConfiguration = string | (UserProjectConfigExport & {
+    readonly tmpDir: string;
+    vitenode: ViteNodeServer;
+    runner: ViteNodeRunner;
+    typechecker?: Typechecker;
+    private closingPromise;
+    private testFilesList;
+    private typecheckFilesList;
+    private _globalSetups?;
+    private _provided;
+    private _config?;
+    private _vite?;
+    constructor(
+    /** @deprecated */
+    path: string | number, vitest: Vitest, 
+    /** @deprecated */
+    options?: InitializeProjectOptions | undefined);
     /**
-     * Relative path to the extendable config. All other options will be merged with this config.
-     * @example '../vite.config.ts'
+     * Provide a value to the test context. This value will be available to all tests with `inject`.
      */
-    extends?: string;
-});
-
-declare class TestProject {
+    provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
     /**
-     * The global vitest instance.
-     * @experimental The public Vitest API is experimental and does not follow semver.
+     * Get the provided context. The project context is merged with the global context.
      */
-    readonly vitest: Vitest;
+    getProvidedContext(): ProvidedContext;
     /**
-     * The workspace project this test project is associated with.
-     * @experimental The public Vitest API is experimental and does not follow semver.
+     * Creates a new test specification. Specifications describe how to run tests.
+     * @param moduleId The file path
      */
-    readonly workspaceProject: WorkspaceProject;
+    createSpecification(moduleId: string, pool?: string, testLocations?: number[] | undefined): TestSpecification;
+    toJSON(): SerializedTestProject;
     /**
      * Vite's dev server instance. Every workspace project has its own server.
      */
-    readonly vite: ViteDevServer;
+    get vite(): ViteDevServer;
     /**
      * Resolved project configuration.
      */
-    readonly config: ResolvedProjectConfig;
-    /**
-     * Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
-     */
-    readonly globalConfig: ResolvedConfig;
+    get config(): ResolvedConfig;
     /**
      * The name of the project or an empty string if not set.
      */
-    readonly name: string;
-    constructor(workspaceProject: WorkspaceProject);
+    get name(): string;
     /**
      * Serialized project configuration. This is the config that tests receive.
      */
     get serializedConfig(): SerializedConfig;
+    /** @deprecated use `vite` instead */
+    get server(): ViteDevServer;
     /**
-     * Custom context provided to the project.
+     * Check if this is the root project. The root project is the one that has the root config.
      */
-    context(): ProvidedContext;
+    isRootProject(): boolean;
+    /** @deprecated use `isRootProject` instead */
+    isCore(): boolean;
+    /** @deprecated use `createSpecification` instead */
+    createSpec(moduleId: string, pool: string): WorkspaceSpec;
+    /** @deprecated */
+    initializeGlobalSetup(): Promise<void>;
+    onTestsRerun(cb: OnTestsRerunHandler): void;
+    /** @deprecated */
+    teardownGlobalSetup(): Promise<void>;
+    /** @deprecated use `vitest.logger` instead */
+    get logger(): Logger;
+    /** @deprecated use `.vite` or `.browser.vite` directly */
+    getModulesByFilepath(file: string): Set<ModuleNode>;
+    /** @deprecated use `.vite` or `.browser.vite` directly */
+    getModuleById(id: string): ModuleNode | undefined;
+    /** @deprecated use `.vite` or `.browser.vite` directly */
+    getSourceMapModuleById(id: string): TransformResult$1['map'] | undefined;
+    /** @deprecated use `vitest.reporters` instead */
+    get reporters(): Reporter[];
     /**
-     * Provide a custom serializable context to the project. This context will be available for tests once they 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.
      */
-    provide<T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]): void;
-    toJSON(): SerializedTestProject;
+    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;
+    /** @deprecated use `serializedConfig` instead */
+    getSerializableConfig(): SerializedConfig;
+    /**
+     * Test if a file matches the test globs. This does the actual glob matching unlike `isTestFile`.
+     */
+    matchesTestGlob(filepath: string, source?: string): boolean;
+    /** @deprecated use `matchesTestGlob` instead */
+    isTargetFile(id: string, source?: string): Promise<boolean>;
+    private isInSourceTestCode;
+    private filterFiles;
+    /**
+     * 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>;
+    /** @deprecated use `name` instead */
+    getName(): string;
+    /** @deprecated internal */
+    setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
+    private _serializeOverridenConfig;
+    private clearTmpDir;
+    /** @deprecated */
+    initBrowserProvider(): Promise<void>;
 }
+
 interface SerializedTestProject {
     name: string;
     serializedConfig: SerializedConfig;
     context: ProvidedContext;
 }
-
-declare class TestSpecification {
-    /**
-     * @deprecated use `project` instead
-     */
-    readonly 0: WorkspaceProject;
-    /**
-     * @deprecated use `moduleId` instead
-     */
-    readonly 1: string;
-    /**
-     * @deprecated use `pool` instead
-     */
-    readonly 2: {
-        pool: Pool;
-    };
-    readonly project: TestProject;
-    readonly moduleId: string;
-    readonly pool: Pool;
-    constructor(workspaceProject: WorkspaceProject, moduleId: string, pool: Pool);
-    toJSON(): SerializedTestSpecification;
-    /**
-     * for backwards compatibility
-     * @deprecated
-     */
-    [Symbol.iterator](): Generator<string | WorkspaceProject, void, unknown>;
+interface InitializeProjectOptions extends UserWorkspaceConfig {
+    configFile: string | false;
+    extends?: string;
 }
 
 /**
@@ -2653,7 +2679,7 @@ type WorkspaceSpec = TestSpecification & [
     /**
      * @deprecated use spec.project instead
      */
-    project: WorkspaceProject,
+    project: TestProject,
     /**
      * @deprecated use spec.moduleId instead
      */
@@ -2672,7 +2698,7 @@ interface ProcessPool {
     collectTests: RunWithFiles;
     close?: () => Awaitable$1<void>;
 }
-declare function getFilePoolName(project: WorkspaceProject, file: string): Pool;
+declare function getFilePoolName(project: TestProject, file: string): Pool;
 
 interface SuiteResultCache {
     failed: boolean;
@@ -2739,17 +2765,18 @@ declare class StateManager {
      * Return files that were running or collected.
      */
     getFiles(keys?: string[]): File[];
+    getTestModules(keys?: string[]): TestModule[];
     getFilepaths(): string[];
     getFailedFilepaths(): string[];
     collectPaths(paths?: string[]): void;
-    collectFiles(project: WorkspaceProject, files?: File[]): void;
-    clearFiles(project: WorkspaceProject, paths?: string[]): void;
-    updateId(task: Task, project: WorkspaceProject): void;
+    collectFiles(project: TestProject, files?: File[]): void;
+    clearFiles(project: TestProject, paths?: string[]): void;
+    updateId(task: Task, project: TestProject): void;
     getReportedEntity(task: Task): TestCase | TestSuite | TestModule | undefined;
     updateTasks(packs: TaskResultPack[]): void;
     updateUserLog(log: UserConsoleLog): void;
     getCountOfFailedTests(): number;
-    cancelFiles(files: string[], project: WorkspaceProject): void;
+    cancelFiles(files: string[], project: TestProject): void;
 }
 
 interface VitestOptions {
@@ -2783,17 +2810,14 @@ declare class Vitest {
     restartsCount: number;
     runner: ViteNodeRunner;
     packageInstaller: VitestPackageInstaller;
-    private coreWorkspaceProject;
     /** @private */
-    resolvedProjects: WorkspaceProject[];
-    projects: WorkspaceProject[];
+    resolvedProjects: TestProject[];
+    projects: TestProject[];
     distPath: string;
     private _cachedSpecs;
     private _workspaceConfigPath?;
     /** @deprecated use `_cachedSpecs` */
-    projectTestFiles: Map<string, WorkspaceSpec[]>;
-    /** @private */
-    _browserLastPort: number;
+    projectTestFiles: Map<string, TestSpecification[]>;
     constructor(mode: VitestRunMode, options?: VitestOptions);
     private _onRestartListeners;
     private _onClose;
@@ -2802,21 +2826,13 @@ declare class Vitest {
     private _onUserTestsRerun;
     setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
     provide<T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]): void;
-    /**
-     * @deprecated internal, use `_createCoreProject` instead
-     */
-    createCoreProject(): Promise<WorkspaceProject>;
-    /**
-     * @internal
-     */
-    _createCoreProject(): Promise<WorkspaceProject>;
-    getCoreWorkspaceProject(): WorkspaceProject;
+    getRootTestProject(): TestProject;
     /**
      * @deprecated use Reported Task API instead
      */
-    getProjectByTaskId(taskId: string): WorkspaceProject;
-    getProjectByName(name?: string): WorkspaceProject;
-    private getWorkspaceConfigPath;
+    getProjectByTaskId(taskId: string): TestProject;
+    getProjectByName(name?: string): TestProject;
+    private resolveWorkspaceConfigPath;
     private resolveWorkspace;
     private initCoverageProvider;
     mergeReports(): Promise<void>;
@@ -2833,13 +2849,15 @@ declare class Vitest {
      * @deprecated remove when vscode extension supports "getFileWorkspaceSpecs"
      */
     getProjectsByTestFile(file: string): WorkspaceSpec[];
-    getFileWorkspaceSpecs(file: string): WorkspaceSpec[];
+    getFileWorkspaceSpecs(file: string): TestSpecification[];
     initializeGlobalSetup(paths: TestSpecification[]): Promise<void>;
     runFiles(specs: TestSpecification[], allTestsRun: boolean): Promise<void>;
     collectFiles(specs: WorkspaceSpec[]): Promise<void>;
     cancelCurrentRun(reason: CancelReason): Promise<void>;
     initBrowserServers(): Promise<void>;
-    rerunFiles(files?: string[], trigger?: string, allTestsRun?: boolean): Promise<void>;
+    rerunFiles(files?: string[], trigger?: string, allTestsRun?: boolean, resetTestNamePattern?: boolean): Promise<void>;
+    private isSuite;
+    rerunTask(id: string): Promise<void>;
     changeProjectName(pattern: string): Promise<void>;
     changeNamePattern(pattern: string, files?: string[], trigger?: string): Promise<void>;
     changeFilenamePattern(pattern: string, files?: string[]): Promise<void>;
@@ -2847,7 +2865,7 @@ declare class Vitest {
     updateSnapshot(files?: string[]): Promise<void>;
     private _rerunTimer;
     private scheduleRerun;
-    getModuleProjects(filepath: string): WorkspaceProject[];
+    getModuleProjects(filepath: string): TestProject[];
     /**
      * Watch only the specified tests. If no tests are provided, all tests will be watched.
      */
@@ -2873,7 +2891,7 @@ declare class Vitest {
     getTestFilepaths(): Promise<string[]>;
     globTestSpecs(filters?: string[]): Promise<WorkspaceSpec[]>;
     /**
-     * @deprecated use globTestSpecs instead
+     * @deprecated use `globTestSpecs` instead
      */
     globTestFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
     private ensureSpecCached;
@@ -2885,4 +2903,4 @@ declare class Vitest {
     onTestsRerun(fn: OnTestsRerunHandler): void;
 }
 
-export { type SerializedTestProject as $, type ApiConfig as A, type BaseCoverageOptions as B, CoverageMap as C, type DepsOptimizationOptions as D, type UserConfig as E, type ResolvedConfig as F, type ProjectConfig as G, type BenchmarkUserOptions as H, type InlineConfig as I, type VitestOptions as J, WorkspaceProject as K, Logger as L, type TestSequencer as M, type WorkspaceSpec as N, TestModule as O, type Pool as P, type ModuleDiagnostic as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TscErrorInfo as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, VitestPackageInstaller as X, type ProcessPool as Y, getFilePoolName as Z, TestProject as _, type ReportContext as a, type HTMLOptions as a0, type JsonOptions$1 as a1, type JUnitOptions as a2, TestCase as a3, TestSuite as a4, type TaskOptions as a5, TestCollection as a6, type TestDiagnostic as a7, type TestResult as a8, type TestResultFailed as a9, JUnitReporter as aA, TapFlatReporter as aB, TapReporter as aC, VerboseReporter as aD, BaseReporter as aE, TestFile as aF, type FileDiagnostic as aG, ReportersMap as aH, type BuiltinReporters as aI, type BuiltinReporterOptions as aJ, type JsonAssertionResult as aK, type JsonTestResult as aL, type JsonTestResults as aM, BenchmarkReportsMap as aN, type BenchmarkBuiltinReporters as aO, type TestResultPassed as aa, type TestResultSkipped as ab, type TestSequencerConstructor as ac, TestSpecification as ad, type BrowserBuiltinProvider as ae, type BrowserCommand as af, type BrowserCommandContext as ag, type BrowserOrchestrator as ah, type BrowserProvider as ai, type BrowserProviderInitializationOptions as aj, type BrowserProviderModule as ak, type BrowserProviderOptions as al, type BrowserServer as am, type BrowserServerState as an, type BrowserServerStateContext as ao, type CDPSession as ap, type ResolvedBrowserOptions as aq, type ResolvedProjectConfig as ar, type ResolveSnapshotPathHandler as as, type ResolveSnapshotPathHandlerContext as at, BasicReporter as au, DefaultReporter as av, DotReporter as aw, GithubActionsReporter as ax, HangingProcessReporter as ay, JsonReporter as az, type CoverageProvider as b, type CoverageProviderModule as c, type CoverageV8Options as d, type UserProjectConfigFn as e, type UserProjectConfigExport as f, type VitestEnvironment as g, type RawErrsMap as h, type CollectLineNumbers as i, type CollectLines as j, type RootAndTarget as k, type Context as l, type CoverageReporter as m, type CoverageProviderName as n, type CoverageOptions as o, type CoverageIstanbulOptions as p, type CustomProviderOptions as q, type Reporter as r, type BrowserScript as s, type BrowserConfigOptions as t, type BuiltinEnvironment as u, type PoolOptions as v, type CSSModuleScopeStrategy as w, type VitestRunMode as x, type TransformModePatterns as y, type TypecheckConfig as z };
+export { type SerializedTestProject as $, type ApiConfig as A, type BaseCoverageOptions as B, CoverageMap as C, type DepsOptimizationOptions as D, type TypecheckConfig as E, type UserConfig as F, type ResolvedConfig as G, type ProjectConfig as H, type InlineConfig as I, type BenchmarkUserOptions as J, type VitestOptions as K, Logger as L, TestProject as M, type TestSequencer as N, type WorkspaceSpec as O, type Pool as P, TestModule as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TestProjectConfiguration as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, type ModuleDiagnostic as X, VitestPackageInstaller as Y, type ProcessPool as Z, getFilePoolName as _, type ReportContext as a, type HTMLOptions as a0, type JsonOptions$1 as a1, type JUnitOptions as a2, TestCase as a3, TestSuite as a4, type TaskOptions as a5, TestCollection as a6, type TestDiagnostic as a7, type TestResult as a8, type TestResultFailed as a9, JUnitReporter as aA, TapFlatReporter as aB, TapReporter as aC, VerboseReporter as aD, BaseReporter as aE, TestFile as aF, type FileDiagnostic as aG, ReportersMap as aH, type BuiltinReporters as aI, type BuiltinReporterOptions as aJ, type JsonAssertionResult as aK, type JsonTestResult as aL, type JsonTestResults as aM, BenchmarkReportsMap as aN, type BenchmarkBuiltinReporters as aO, type TestResultPassed as aa, type TestResultSkipped as ab, type TestSequencerConstructor as ac, TestSpecification as ad, type BrowserBuiltinProvider as ae, type BrowserCommand as af, type BrowserCommandContext as ag, type BrowserOrchestrator as ah, type BrowserProvider as ai, type BrowserProviderInitializationOptions as aj, type BrowserProviderModule as ak, type BrowserProviderOptions as al, type BrowserServer as am, type BrowserServerState as an, type BrowserServerStateContext as ao, type CDPSession as ap, type ResolvedBrowserOptions as aq, type ResolvedProjectConfig as ar, type ResolveSnapshotPathHandler as as, type ResolveSnapshotPathHandlerContext as at, BasicReporter as au, DefaultReporter as av, DotReporter as aw, GithubActionsReporter as ax, HangingProcessReporter as ay, JsonReporter as az, type CoverageProvider as b, type CoverageProviderModule as c, type CoverageV8Options as d, type UserProjectConfigFn as e, type UserProjectConfigExport as f, type VitestEnvironment as g, type RawErrsMap as h, type TscErrorInfo as i, type CollectLineNumbers as j, type CollectLines as k, type RootAndTarget as l, type Context as m, type CoverageReporter as n, type CoverageProviderName as o, type CoverageOptions as p, type CoverageIstanbulOptions as q, type CustomProviderOptions as r, type Reporter as s, type BrowserScript as t, type BrowserConfigOptions as u, type BuiltinEnvironment as v, type PoolOptions as w, type CSSModuleScopeStrategy as x, type VitestRunMode as y, type TransformModePatterns as z };