vitest 3.0.0-beta.3 → 3.0.0

package/dist/chunks/{reporters.DCiyjXOg.d.ts → reporters.Y8BYiXBN.d.ts}

@@ -1,11 +1,11 @@
 import * as _vitest_runner from '@vitest/runner';
 import { TaskMeta, Suite, File, TaskResultPack, Task, SequenceHooks, SequenceSetupFiles, CancelReason } from '@vitest/runner';
 import { b as Awaitable, U as UserConsoleLog, A as AfterSuiteRunMeta, c as Arrayable$1, f as EnvironmentOptions, P as ProvidedContext } from './environment.d8YfPkTm.js';
-import { TestError, ParsedStack, Arrayable, ErrorWithDiff, Awaitable as Awaitable$1 } from '@vitest/utils';
+import { TestError, SerializedError, ParsedStack, Arrayable, ErrorWithDiff, Awaitable as Awaitable$1 } from '@vitest/utils';
 import { Writable } from 'node:stream';
 import { TransformResult as TransformResult$1, ServerOptions, DepOptimizationConfig, AliasOptions, UserConfig as UserConfig$1, ConfigEnv, ViteDevServer, ModuleNode } from 'vite';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
-import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.BTPBhmK5.js';
+import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.BRtC-JeT.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -29,7 +29,7 @@ type SerializedTestSpecification = [
 
 declare class ReportedTaskImplementation {
     /**
-     * The project assosiacted with the test or suite.
+     * The project associated with the test or suite.
      */
     readonly project: TestProject;
     /**
@@ -75,13 +75,13 @@ declare class TestCase extends ReportedTaskImplementation {
      */
     get fullName(): string;
     /**
-     * Test results. Will be `undefined` if test is skipped, not finished yet or was just collected.
+     * Test results.
+     * - **pending**: Test was collected, but didn't finish running yet.
+     * - **passed**: Test passed successfully
+     * - **failed**: Test failed to execute
+     * - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
      */
-    result(): TestResult | undefined;
-    /**
-     * Checks if the test was skipped during collection or dynamically with `ctx.skip()`.
-     */
-    skipped(): boolean;
+    result(): TestResult;
     /**
      * Custom metadata that was attached to the test during its execution.
      */
@@ -110,11 +110,11 @@ declare class TestCollection {
     /**
      * Filters all tests that are part of this collection and its children.
      */
-    allTests(state?: TestResult['state'] | 'running'): Generator<TestCase, undefined, void>;
+    allTests(state?: TestState): Generator<TestCase, undefined, void>;
     /**
      * Filters only the tests that are part of this collection.
      */
-    tests(state?: TestResult['state'] | 'running'): Generator<TestCase, undefined, void>;
+    tests(state?: TestState): Generator<TestCase, undefined, void>;
     /**
      * Filters only the suites that are part of this collection.
      */
@@ -126,19 +126,22 @@ declare class TestCollection {
     [Symbol.iterator](): Generator<TestSuite | TestCase, undefined, void>;
 }
 
+type ReportedHookContext = {
+    readonly name: 'beforeAll' | 'afterAll';
+    readonly entity: TestSuite | TestModule;
+} | {
+    readonly name: 'beforeEach' | 'afterEach';
+    readonly entity: TestCase;
+};
 declare abstract class SuiteImplementation extends ReportedTaskImplementation {
     /**
      * Collection of suites and tests that are part of this suite.
      */
     readonly children: TestCollection;
-    /**
-     * Checks if the suite was skipped during collection.
-     */
-    skipped(): boolean;
     /**
      * Errors that happened outside of the test run during collection, like syntax errors.
      */
-    errors(): TestError[];
+    errors(): SerializedError[];
 }
 declare class TestSuite extends SuiteImplementation {
     #private;
@@ -164,6 +167,10 @@ declare class TestSuite extends SuiteImplementation {
      * This will also return `false` if suite failed during collection.
      */
     ok: () => boolean;
+    /**
+     * Checks the running state of the suite.
+     */
+    state(): TestSuiteState;
     /**
      * Full name of the suite including all parent suites separated with `>`.
      */
@@ -174,19 +181,19 @@ declare class TestModule extends SuiteImplementation {
     readonly type = "module";
     /**
      * This is usually an absolute UNIX file path.
-     * It can be a virtual id if the file is not on the disk.
-     * This value corresponds to Vite's `ModuleGraph` id.
+     * It can be a virtual ID if the file is not on the disk.
+     * This value corresponds to the ID in the Vite's module graph.
      */
     readonly moduleId: string;
+    /**
+     * Checks the running state of the test file.
+     */
+    state(): TestModuleState;
     /**
      * Checks if the module has any failed tests.
      * This will also return `false` if module failed during collection.
      */
     ok: () => boolean;
-    /**
-     * Checks if the module was skipped and didn't run.
-     */
-    skipped: () => boolean;
     /**
      * Useful information about the module like duration, memory usage, etc.
      * If the module was not executed yet, all diagnostic values will return `0`.
@@ -194,114 +201,319 @@ declare class TestModule extends SuiteImplementation {
     diagnostic(): ModuleDiagnostic;
 }
 interface TaskOptions {
-    each: boolean | undefined;
-    concurrent: boolean | undefined;
-    shuffle: boolean | undefined;
-    retry: number | undefined;
-    repeats: number | undefined;
-    mode: 'run' | 'only' | 'skip' | 'todo' | 'queued';
-}
-type TestResult = TestResultPassed | TestResultFailed | TestResultSkipped;
+    readonly each: boolean | undefined;
+    readonly fails: boolean | undefined;
+    readonly concurrent: boolean | undefined;
+    readonly shuffle: boolean | undefined;
+    readonly retry: number | undefined;
+    readonly repeats: number | undefined;
+    readonly mode: 'run' | 'only' | 'skip' | 'todo';
+}
+type TestSuiteState = 'skipped' | 'pending' | 'failed' | 'passed';
+type TestModuleState = TestSuiteState | 'queued';
+type TestState = TestResult['state'];
+type TestResult = TestResultPassed | TestResultFailed | TestResultSkipped | TestResultPending;
+interface TestResultPending {
+    /**
+     * The test was collected, but didn't finish running yet.
+     */
+    readonly state: 'pending';
+    /**
+     * Pending tests have no errors.
+     */
+    readonly errors: undefined;
+}
 interface TestResultPassed {
     /**
      * The test passed successfully.
      */
-    state: 'passed';
+    readonly state: 'passed';
     /**
      * Errors that were thrown during the test execution.
      *
      * **Note**: If test was retried successfully, errors will still be reported.
      */
-    errors: TestError[] | undefined;
+    readonly errors: ReadonlyArray<TestError> | undefined;
 }
 interface TestResultFailed {
     /**
      * The test failed to execute.
      */
-    state: 'failed';
+    readonly state: 'failed';
     /**
      * Errors that were thrown during the test execution.
      */
-    errors: TestError[];
+    readonly errors: ReadonlyArray<TestError>;
 }
 interface TestResultSkipped {
     /**
      * The test was skipped with `only` (on another test), `skip` or `todo` flag.
      * You can see which one was used in the `options.mode` option.
      */
-    state: 'skipped';
+    readonly state: 'skipped';
     /**
      * Skipped tests have no errors.
      */
-    errors: undefined;
+    readonly errors: undefined;
     /**
      * A custom note passed down to `ctx.skip(note)`.
      */
-    note: string | undefined;
+    readonly note: string | undefined;
 }
 interface TestDiagnostic {
     /**
      * If the duration of the test is above `slowTestThreshold`.
      */
-    slow: boolean;
+    readonly slow: boolean;
     /**
      * The amount of memory used by the test in bytes.
      * This value is only available if the test was executed with `logHeapUsage` flag.
      */
-    heap: number | undefined;
+    readonly heap: number | undefined;
     /**
      * The time it takes to execute the test in ms.
      */
-    duration: number;
+    readonly duration: number;
     /**
      * The time in ms when the test started.
      */
-    startTime: number;
+    readonly startTime: number;
     /**
      * The amount of times the test was retried.
      */
-    retryCount: number;
+    readonly retryCount: number;
     /**
      * The amount of times the test was repeated as configured by `repeats` option.
      * This value can be lower if the test failed during the repeat and no `retry` is configured.
      */
-    repeatCount: number;
+    readonly repeatCount: number;
     /**
      * If test passed on a second retry.
      */
-    flaky: boolean;
+    readonly flaky: boolean;
 }
 interface ModuleDiagnostic {
     /**
      * The time it takes to import and initiate an environment.
      */
-    environmentSetupDuration: number;
+    readonly environmentSetupDuration: number;
     /**
      * The time it takes Vitest to setup test harness (runner, mocks, etc.).
      */
-    prepareDuration: number;
+    readonly prepareDuration: number;
     /**
      * The time it takes to import the test module.
      * This includes importing everything in the module and executing suite callbacks.
      */
-    collectDuration: number;
+    readonly collectDuration: number;
     /**
      * The time it takes to import the setup module.
      */
-    setupDuration: number;
+    readonly setupDuration: number;
     /**
      * Accumulated duration of all tests and hooks in the module.
      */
-    duration: number;
+    readonly duration: number;
+}
+
+type BuiltinPool = 'browser' | 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript';
+type Pool = BuiltinPool | (string & {});
+interface PoolOptions extends Record<string, unknown> {
+    /**
+     * Run tests in `node:worker_threads`.
+     *
+     * Test isolation (when enabled) is done by spawning a new thread for each test file.
+     *
+     * This pool is used by default.
+     */
+    threads?: ThreadsOptions & WorkerContextOptions;
+    /**
+     * Run tests in `node:child_process` using [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
+     *
+     * Test isolation (when enabled) is done by spawning a new child process for each test file.
+     */
+    forks?: ForksOptions & WorkerContextOptions;
+    /**
+     * Run tests in isolated `node:vm`.
+     * Test files are run parallel using `node:worker_threads`.
+     *
+     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
+     */
+    vmThreads?: ThreadsOptions & VmOptions;
+    /**
+     * Run tests in isolated `node:vm`.
+     *
+     * Test files are run parallel using `node:child_process` [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
+     *
+     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
+     */
+    vmForks?: ForksOptions & VmOptions;
+}
+interface ResolvedPoolOptions extends PoolOptions {
+    threads?: ResolvedThreadsOptions & WorkerContextOptions;
+    forks?: ResolvedForksOptions & WorkerContextOptions;
+    vmThreads?: ResolvedThreadsOptions & VmOptions;
+    vmForks?: ResolvedForksOptions & VmOptions;
+}
+interface ThreadsOptions {
+    /** Minimum amount of threads to use */
+    minThreads?: number | string;
+    /** Maximum amount of threads to use */
+    maxThreads?: number | string;
+    /**
+     * Run tests inside a single thread.
+     *
+     * @default false
+     */
+    singleThread?: boolean;
+    /**
+     * Use Atomics to synchronize threads
+     *
+     * This can improve performance in some cases, but might cause segfault in older Node versions.
+     *
+     * @default false
+     */
+    useAtomics?: boolean;
+}
+interface ResolvedThreadsOptions extends ThreadsOptions {
+    minThreads?: number;
+    maxThreads?: number;
+}
+interface ForksOptions {
+    /** Minimum amount of child processes to use */
+    minForks?: number | string;
+    /** Maximum amount of child processes to use */
+    maxForks?: number | string;
+    /**
+     * Run tests inside a single fork.
+     *
+     * @default false
+     */
+    singleFork?: boolean;
+}
+interface ResolvedForksOptions extends ForksOptions {
+    minForks?: number;
+    maxForks?: number;
+}
+interface WorkerContextOptions {
+    /**
+     * Isolate test environment by recycling `worker_threads` or `child_process` after each test
+     *
+     * @default true
+     */
+    isolate?: boolean;
+    /**
+     * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
+     *
+     * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
+     *
+     * Set to `process.execArgv` to pass all arguments of the current process.
+     *
+     * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
+     *
+     * @default [] // no execution arguments are passed
+     */
+    execArgv?: string[];
+}
+interface VmOptions {
+    /**
+     * Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
+     * If you see memory leaks, try to tinker this value.
+     */
+    memoryLimit?: string | number;
+    /** Isolation is always enabled */
+    isolate?: true;
+    /**
+     * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
+     *
+     * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
+     *
+     * Set to `process.execArgv` to pass all arguments of the current process.
+     *
+     * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
+     *
+     * @default [] // no execution arguments are passed
+     */
+    execArgv?: string[];
+}
+
+declare class TestSpecification {
+    /**
+     * @deprecated use `project` instead
+     */
+    readonly 0: TestProject;
+    /**
+     * @deprecated use `moduleId` instead
+     */
+    readonly 1: string;
+    /**
+     * @deprecated use `pool` instead
+     */
+    readonly 2: {
+        pool: Pool;
+    };
+    /**
+     * The task ID associated with the test module.
+     */
+    readonly taskId: string;
+    /**
+     * The test project that the module belongs to.
+     */
+    readonly project: TestProject;
+    /**
+     * The ID of the module in the Vite module graph. It is usually an absolute file path.
+     */
+    readonly moduleId: string;
+    /**
+     * The current test pool. It's possible to have multiple pools in a single test project with `poolMatchGlob` and `typecheck.enabled`.
+     * @experimental In Vitest 4, the project will only support a single pool and this property will be removed.
+     */
+    readonly pool: Pool;
+    /**
+     * Line numbers of the test locations to run.
+     */
+    readonly testLines: number[] | undefined;
+    constructor(project: TestProject, moduleId: string, pool: Pool, testLines?: number[] | undefined);
+    /**
+     * Test module associated with the specification.
+     */
+    get testModule(): TestModule | undefined;
+    toJSON(): SerializedTestSpecification;
+    /**
+     * for backwards compatibility
+     * @deprecated
+     */
+    [Symbol.iterator](): Generator<string | TestProject, void, unknown>;
 }
 
+type TestRunEndReason = 'passed' | 'interrupted' | 'failed';
 interface Reporter {
-    onInit?: (ctx: Vitest) => void;
+    onInit?: (vitest: Vitest) => void;
+    /**
+     * Called when the project initiated the browser instance.
+     * project.browser will always be defined.
+     * @experimental
+     */
+    onBrowserInit?: (project: TestProject) => Awaitable<void>;
+    /**
+     * @deprecated use `onTestRunStart` instead
+     */
     onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+    /**
+     * @deprecated use `onTestRunStart` instead
+     */
     onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable<void>;
-    onTestModuleQueued?: (file: TestModule) => Awaitable<void>;
-    onCollected?: (files?: File[]) => Awaitable<void>;
+    /**
+     * @deprecated use `onTestModuleCollected` instead
+     */
+    onCollected?: (files: File[]) => Awaitable<void>;
+    /**
+     * @deprecated use `onTestRunEnd` instead
+     */
     onFinished?: (files: File[], errors: unknown[], coverage?: unknown) => Awaitable<void>;
+    /**
+     * @deprecated use `onTestModuleQueued`, `onTestModuleStart`, `onTestModuleEnd`, `onTestCaseReady`, `onTestCaseResult` instead
+     */
     onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
     onTestRemoved?: (trigger?: string) => Awaitable<void>;
     onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
@@ -309,6 +521,59 @@ interface Reporter {
     onServerRestart?: (reason?: string) => Awaitable<void>;
     onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
     onProcessTimeout?: () => Awaitable<void>;
+    /**
+     * Called when the new test run starts.
+     */
+    onTestRunStart?: (specifications: ReadonlyArray<TestSpecification>) => Awaitable<void>;
+    /**
+     * Called when the test run is finished.
+     */
+    onTestRunEnd?: (testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason) => Awaitable<void>;
+    /**
+     * Called when the module is enqueued for testing. The file itself is not loaded yet.
+     */
+    onTestModuleQueued?: (testModule: TestModule) => Awaitable<void>;
+    /**
+     * Called when the test file is loaded and the module is ready to run tests.
+     */
+    onTestModuleCollected?: (testModule: TestModule) => Awaitable<void>;
+    /**
+     * Called when starting to run tests of the test file
+     */
+    onTestModuleStart?: (testModule: TestModule) => Awaitable<void>;
+    /**
+     * Called when all tests of the test file have finished running.
+     */
+    onTestModuleEnd?: (testModule: TestModule) => Awaitable<void>;
+    /**
+     * Called when test case is ready to run.
+     * Called before the `beforeEach` hooks for the test are run.
+     */
+    onTestCaseReady?: (testCase: TestCase) => Awaitable<void>;
+    /**
+     * Called after the test and its hooks are finished running.
+     * The `result()` cannot be `pending`.
+     */
+    onTestCaseResult?: (testCase: TestCase) => Awaitable<void>;
+    /**
+     * Called when test suite is ready to run.
+     * Called before the `beforeAll` hooks for the test are run.
+     */
+    onTestSuiteReady?: (testSuite: TestSuite) => Awaitable<void>;
+    /**
+     * Called after the test suite and its hooks are finished running.
+     * The `state` cannot be `pending`.
+     */
+    onTestSuiteResult?: (testSuite: TestSuite) => Awaitable<void>;
+    /**
+     * Called before the hook starts to run.
+     */
+    onHookStart?: (hook: ReportedHookContext) => Awaitable<void>;
+    /**
+     * Called after the hook finished running.
+     */
+    onHookEnd?: (hook: ReportedHookContext) => Awaitable<void>;
+    onCoverage?: (coverage: unknown) => Awaitable<void>;
 }
 
 interface BaseOptions {
@@ -332,6 +597,9 @@ declare abstract class BaseReporter implements Reporter {
     relative(path: string): string;
     onFinished(files?: File[], errors?: unknown[]): void;
     onTaskUpdate(packs: TaskResultPack[]): void;
+    /**
+     * Callback invoked with a single `Task` from `onTaskUpdate`
+     */
     protected printTask(task: Task): void;
     private getDurationPrefix;
     onWatcherStart(files?: File[], errors?: unknown[]): void;
@@ -365,12 +633,17 @@ declare class DefaultReporter extends BaseReporter {
     private options;
     private summary?;
     constructor(options?: DefaultReporterOptions);
+    onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
     onTestModuleQueued(file: TestModule): void;
+    onTestModuleCollected(module: TestModule): void;
+    onTestModuleEnd(module: TestModule): void;
+    onTestCaseReady(test: TestCase): void;
+    onTestCaseResult(test: TestCase): void;
+    onHookStart(hook: ReportedHookContext): void;
+    onHookEnd(hook: ReportedHookContext): void;
     onInit(ctx: Vitest): void;
     onPathsCollected(paths?: string[]): void;
-    onTaskUpdate(packs: TaskResultPack[]): void;
-    onWatcherRerun(files: string[], trigger?: string): void;
-    onFinished(files?: File[], errors?: unknown[]): void;
+    onTestRunEnd(): void;
 }
 
 interface HTMLOptions {
@@ -384,11 +657,18 @@ declare class BasicReporter extends BaseReporter {
 }
 
 declare class DotReporter extends BaseReporter {
-    private summary?;
+    private renderer?;
+    private tests;
+    private finishedTests;
     onInit(ctx: Vitest): void;
-    onTaskUpdate(packs: TaskResultPack[]): void;
+    printTask(task: Task): void;
     onWatcherRerun(files: string[], trigger?: string): void;
     onFinished(files?: File[], errors?: unknown[]): void;
+    onTestModuleCollected(module: TestModule): void;
+    onTestCaseReady(test: TestCase): void;
+    onTestCaseResult(test: TestCase): void;
+    onTestModuleEnd(): void;
+    private createSummary;
 }
 
 declare class GithubActionsReporter implements Reporter {
@@ -624,179 +904,41 @@ declare class TapFlatReporter extends TapReporter {
 declare class VerboseReporter extends DefaultReporter {
     protected verbose: boolean;
     renderSucceed: boolean;
-    onTaskUpdate(packs: TaskResultPack[]): void;
+    printTask(task: Task): void;
 }
 
-declare class TypeCheckError extends Error {
-    message: string;
-    stacks: ParsedStack[];
-    name: string;
-    constructor(message: string, stacks: ParsedStack[]);
-}
-
-interface PrintErrorResult {
-    nearest?: ParsedStack;
-}
-
-interface Options {
-	/**
-	Show the cursor. This can be useful when a CLI accepts input from a user.
-
-	@example
-	```
-	import {createLogUpdate} from 'log-update';
-
-	// Write output but don't hide the cursor
-	const log = createLogUpdate(process.stdout, {
-		showCursor: true
-	});
-	```
-	*/
-	readonly showCursor?: boolean;
-}
-
-type LogUpdateMethods = {
-	/**
-	Clear the logged output.
-	*/
-	clear(): void;
-
-	/**
-	Persist the logged output. Useful if you want to start a new log session below the current one.
-	*/
-	done(): void;
+type FormattedBenchmarkResult = BenchmarkResult & {
+    id: string;
 };
 
-/**
-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;
+declare function renderTable(options: {
+    tasks: Task[];
+    level: number;
+    shallow?: boolean;
     showHeap: boolean;
+    columns: number;
     slowTestThreshold: number;
-    compare?: FlatBenchmarkReport;
-}
-declare function createTableRenderer(_tasks: Task[], options: TableRendererOptions): {
-    start(): /*elided*/ any;
-    update(_tasks: Task[]): /*elided*/ any;
-    stop(): /*elided*/ any;
-    clear(): void;
-};
+    compare?: Record<Task['id'], FormattedBenchmarkResult>;
+}): string;
 
-declare class TableReporter extends BaseReporter {
-    renderer?: ReturnType<typeof createTableRenderer>;
-    rendererOptions: TableRendererOptions;
-    onTestRemoved(trigger?: string): void;
-    onCollected(): Promise<void>;
+declare class BenchmarkReporter extends DefaultReporter {
+    compare?: Parameters<typeof renderTable>[0]['compare'];
+    onInit(ctx: Vitest): Promise<void>;
     onTaskUpdate(packs: TaskResultPack[]): void;
-    onFinished(files?: File[], errors?: unknown[]): Promise<void>;
-    onWatcherStart(): Promise<void>;
-    stopListRender(): void;
-    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
-    onUserConsoleLog(log: UserConsoleLog): void;
+    printTask(task: Task): void;
+    onFinished(files?: _vitest_runner.File[], errors?: unknown[]): Promise<void>;
 }
-interface FlatBenchmarkReport {
-    [id: string]: FormattedBenchmarkResult;
+
+declare class VerboseBenchmarkReporter extends BenchmarkReporter {
+    protected verbose: boolean;
 }
-type FormattedBenchmarkResult = BenchmarkResult & {
-    id: string;
-};
 
 declare const BenchmarkReportsMap: {
-    default: typeof TableReporter;
-    verbose: typeof VerboseReporter;
+    default: typeof BenchmarkReporter;
+    verbose: typeof VerboseBenchmarkReporter;
 };
 type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
 
-/**
- * @deprecated Use `TestModule` instead
- */
-declare const TestFile: typeof TestModule;
-
-/**
- * @deprecated Use `ModuleDiagnostic` instead
- */
-type FileDiagnostic = ModuleDiagnostic;
-
 declare const ReportersMap: {
     default: typeof DefaultReporter;
     basic: typeof BasicReporter;
@@ -825,169 +967,53 @@ interface BuiltinReporterOptions {
     'html': HTMLOptions;
 }
 
-type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
-
-type BuiltinPool = 'browser' | 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript';
-type Pool = BuiltinPool | (string & {});
-interface PoolOptions extends Record<string, unknown> {
-    /**
-     * Run tests in `node:worker_threads`.
-     *
-     * Test isolation (when enabled) is done by spawning a new thread for each test file.
-     *
-     * This pool is used by default.
-     */
-    threads?: ThreadsOptions & WorkerContextOptions;
-    /**
-     * Run tests in `node:child_process` using [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
-     *
-     * Test isolation (when enabled) is done by spawning a new child process for each test file.
-     */
-    forks?: ForksOptions & WorkerContextOptions;
-    /**
-     * Run tests in isolated `node:vm`.
-     * Test files are run parallel using `node:worker_threads`.
-     *
-     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
-     */
-    vmThreads?: ThreadsOptions & VmOptions;
-    /**
-     * Run tests in isolated `node:vm`.
-     *
-     * Test files are run parallel using `node:child_process` [`fork()`](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
-     *
-     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
-     */
-    vmForks?: ForksOptions & VmOptions;
-}
-interface ResolvedPoolOptions extends PoolOptions {
-    threads?: ResolvedThreadsOptions & WorkerContextOptions;
-    forks?: ResolvedForksOptions & WorkerContextOptions;
-    vmThreads?: ResolvedThreadsOptions & VmOptions;
-    vmForks?: ResolvedForksOptions & VmOptions;
-}
-interface ThreadsOptions {
-    /** Minimum amount of threads to use */
-    minThreads?: number | string;
-    /** Maximum amount of threads to use */
-    maxThreads?: number | string;
-    /**
-     * Run tests inside a single thread.
-     *
-     * @default false
-     */
-    singleThread?: boolean;
-    /**
-     * Use Atomics to synchronize threads
-     *
-     * This can improve performance in some cases, but might cause segfault in older Node versions.
-     *
-     * @default false
-     */
-    useAtomics?: boolean;
-}
-interface ResolvedThreadsOptions extends ThreadsOptions {
-    minThreads?: number;
-    maxThreads?: number;
-}
-interface ForksOptions {
-    /** Minimum amount of child processes to use */
-    minForks?: number | string;
-    /** Maximum amount of child processes to use */
-    maxForks?: number | string;
-    /**
-     * Run tests inside a single fork.
-     *
-     * @default false
-     */
-    singleFork?: boolean;
-}
-interface ResolvedForksOptions extends ForksOptions {
-    minForks?: number;
-    maxForks?: number;
+declare class TypeCheckError extends Error {
+    message: string;
+    stacks: ParsedStack[];
+    name: string;
+    constructor(message: string, stacks: ParsedStack[]);
 }
-interface WorkerContextOptions {
-    /**
-     * Isolate test environment by recycling `worker_threads` or `child_process` after each test
-     *
-     * @default true
-     */
-    isolate?: boolean;
-    /**
-     * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
-     *
-     * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
-     *
-     * Set to `process.execArgv` to pass all arguments of the current process.
-     *
-     * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
-     *
-     * @default [] // no execution arguments are passed
-     */
-    execArgv?: string[];
+
+interface ErrorOptions {
+    type?: string;
+    fullStack?: boolean;
+    project?: TestProject;
+    verbose?: boolean;
+    screenshotPaths?: string[];
+    task?: Task;
+    showCodeFrame?: boolean;
 }
-interface VmOptions {
-    /**
-     * Specifies the memory limit for `worker_thread` or `child_process` before they are recycled.
-     * If you see memory leaks, try to tinker this value.
-     */
-    memoryLimit?: string | number;
-    /** Isolation is always enabled */
-    isolate?: true;
-    /**
-     * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
-     *
-     * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
-     *
-     * Set to `process.execArgv` to pass all arguments of the current process.
-     *
-     * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
-     *
-     * @default [] // no execution arguments are passed
-     */
-    execArgv?: string[];
+type Listener = () => void;
+declare class Logger {
+    ctx: Vitest;
+    outputStream: NodeJS.WriteStream | Writable;
+    errorStream: NodeJS.WriteStream | Writable;
+    private _clearScreenPending;
+    private _highlights;
+    private cleanupListeners;
+    console: Console;
+    constructor(ctx: Vitest, outputStream?: NodeJS.WriteStream | Writable, errorStream?: NodeJS.WriteStream | Writable);
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    clearFullScreen(message?: string): void;
+    clearScreen(message: string, force?: boolean): void;
+    private _clearScreen;
+    printError(err: unknown, options?: ErrorOptions): void;
+    clearHighlightCache(filename?: string): void;
+    highlight(filename: string, source: string): string;
+    printNoTestFound(filters?: string[]): void;
+    printBanner(): void;
+    printBrowserBanner(project: TestProject): void;
+    printUnhandledErrors(errors: unknown[]): void;
+    printSourceTypeErrors(errors: TypeCheckError[]): void;
+    getColumns(): number;
+    onTerminalCleanup(listener: Listener): void;
+    private addCleanupListeners;
+    private registerUnhandledRejection;
 }
 
-declare class TestSpecification {
-    /**
-     * @deprecated use `project` instead
-     */
-    readonly 0: TestProject;
-    /**
-     * @deprecated use `moduleId` instead
-     */
-    readonly 1: string;
-    /**
-     * @deprecated use `pool` instead
-     */
-    readonly 2: {
-        pool: Pool;
-    };
-    /**
-     * The test project that the module belongs to.
-     */
-    readonly project: TestProject;
-    /**
-     * The ID of the module in the Vite module graph. It is usually an absolute file path.
-     */
-    readonly moduleId: string;
-    /**
-     * The current test pool. It's possible to have multiple pools in a single test project with `poolMatchGlob` and `typecheck.enabled`.
-     * @experimental In Vitest 4, the project will only support a single pool and this property will be removed.
-     */
-    readonly pool: Pool;
-    /**
-     * Line numbers of the test locations to run.
-     */
-    readonly testLines: number[] | undefined;
-    constructor(project: TestProject, moduleId: string, pool: Pool, testLines?: number[] | undefined);
-    toJSON(): SerializedTestSpecification;
-    /**
-     * for backwards compatibility
-     * @deprecated
-     */
-    [Symbol.iterator](): Generator<string | TestProject, void, unknown>;
-}
+type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
 
 interface TestSequencer {
     /**
@@ -2021,7 +2047,7 @@ interface InlineConfig {
     /**
      * 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.
+     * However, disabling such interception might help when you want to debug a code with normal synchronous terminal console logging.
      *
      * This option has no effect on browser pool since Vitest preserves original logging on browser devtools.
      *
@@ -2043,7 +2069,7 @@ interface InlineConfig {
 }
 interface TypecheckConfig {
     /**
-     * Run typechecking tests alongisde regular tests.
+     * Run typechecking tests alongside regular tests.
      */
     enabled?: boolean;
     /**
@@ -2272,7 +2298,7 @@ interface BrowserConfigOptions {
     enabled?: boolean;
     /**
      * Name of the browser
-     * @deprecated use `configs` instead. if both are defined, this will filter `configs` by name.
+     * @deprecated use `instances` instead. if both are defined, this will filter `instances` by name.
      */
     name?: string;
     /**
@@ -2294,7 +2320,7 @@ interface BrowserConfigOptions {
      *
      * @example
      * { playwright: { launch: { devtools: true } }
-     * @deprecated use `configs` instead
+     * @deprecated use `instances` instead
      */
     providerOptions?: BrowserProviderOptions;
     /**
@@ -2505,7 +2531,6 @@ declare class TestProject {
     private typecheckFilesList;
     private _globalSetups?;
     private _provided;
-    private _vite?;
     constructor(
     /** @deprecated */
     path: string | number, vitest: Vitest, options?: InitializeProjectOptions | undefined);
@@ -2593,6 +2618,8 @@ declare class TestProject {
     isTargetFile(id: string, source?: string): Promise<boolean>;
     private isInSourceTestCode;
     private filterFiles;
+    private _parentBrowser?;
+    private _parent?;
     /**
      * 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.
@@ -2607,7 +2634,7 @@ declare class TestProject {
     getName(): string;
     /** @deprecated internal */
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
-    private _serializeOverridenConfig;
+    private _serializeOverriddenConfig;
     private clearTmpDir;
     /** @deprecated */
     initBrowserProvider(): Promise<void>;
@@ -2620,7 +2647,6 @@ interface SerializedTestProject {
 }
 interface InitializeProjectOptions extends UserWorkspaceConfig {
     configFile: string | false;
-    extends?: string;
 }
 
 /**
@@ -2710,7 +2736,7 @@ declare class StateManager {
     taskFileMap: WeakMap<Task, File>;
     errorsSet: Set<unknown>;
     processTimeoutCauses: Set<string>;
-    reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
+    reportedTasksMap: WeakMap<Task, TestCase | TestSuite | TestModule>;
     catchError(err: unknown, type: string): void;
     clearErrors(): void;
     getUnhandledErrors(): unknown[];
@@ -2728,7 +2754,7 @@ declare class StateManager {
     collectFiles(project: TestProject, files?: File[]): void;
     clearFiles(project: TestProject, paths?: string[]): void;
     updateId(task: Task, project: TestProject): void;
-    getReportedEntity(task: Task): TestModule | TestCase | TestSuite | undefined;
+    getReportedEntity(task: Task): TestCase | TestSuite | TestModule | undefined;
     updateTasks(packs: TaskResultPack[]): void;
     updateUserLog(log: UserConsoleLog): void;
     getCountOfFailedTests(): number;
@@ -2885,14 +2911,14 @@ declare class Vitest {
     /** @deprecated */
     getFileWorkspaceSpecs(file: string): WorkspaceSpec[];
     /**
-     * Get test specifications assosiated with the given module. If module is not a test file, an empty array is returned.
+     * Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
      *
      * **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
      * @param moduleId The module ID to get test specifications for.
      */
     getModuleSpecifications(moduleId: string): TestSpecification[];
     /**
-     * Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache alltogether.
+     * Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache altogether.
      */
     clearSpecificationsCache(moduleId?: string): void;
     /**
@@ -3005,4 +3031,4 @@ declare class Vitest {
 type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
 type OnTestsRerunHandler = (testFiles: TestSpecification[]) => Promise<void> | void;
 
-export { type JUnitOptions as $, type ApiConfig as A, type BaseCoverageOptions as B, CoverageMap as C, type DepsOptimizationOptions as D, TestProject as E, type TestSequencer as F, TestSpecification as G, TestModule as H, type InlineConfig as I, type OnTestsRerunHandler as J, VitestPackageInstaller as K, Logger as L, type ModuleDiagnostic as M, type ProcessPool as N, type OnServerRestartHandler as O, type Pool as P, type WorkspaceSpec as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TestProjectConfiguration as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, getFilePoolName as X, type SerializedTestProject as Y, type HTMLOptions as Z, type JsonOptions$1 as _, type ReportContext as a, type TaskOptions as a0, TestCase as a1, TestCollection as a2, type TestDiagnostic as a3, type TestResult as a4, type TestResultFailed as a5, type TestResultPassed as a6, type TestResultSkipped as a7, TestSuite as a8, type TestSequencerConstructor as a9, TapFlatReporter as aA, TapReporter as aB, VerboseReporter as aC, BaseReporter as aD, TestFile as aE, type FileDiagnostic as aF, ReportersMap as aG, type BuiltinReporters as aH, type BuiltinReporterOptions as aI, type JsonAssertionResult as aJ, type JsonTestResult as aK, type JsonTestResults as aL, BenchmarkReportsMap as aM, type BenchmarkBuiltinReporters as aN, type BrowserBuiltinProvider as aa, type BrowserCommand as ab, type BrowserCommandContext as ac, type BrowserInstanceOption as ad, type BrowserOrchestrator as ae, type BrowserProvider as af, type BrowserProviderInitializationOptions as ag, type BrowserProviderModule as ah, type BrowserProviderOptions as ai, type BrowserServerState as aj, type BrowserServerStateSession as ak, type CDPSession as al, type ParentProjectBrowser as am, type ProjectBrowser as an, type ResolvedBrowserOptions as ao, type ResolvedProjectConfig as ap, type ResolveSnapshotPathHandler as aq, type ResolveSnapshotPathHandlerContext as ar, type TestRunResult as as, BasicReporter as at, DefaultReporter as au, DotReporter as av, GithubActionsReporter as aw, HangingProcessReporter as ax, JsonReporter as ay, JUnitReporter as az, type CoverageProvider as b, type CoverageProviderModule as c, type CoverageV8Options as d, type UserProjectConfigFn as e, type UserProjectConfigExport as f, type CoverageReporter as g, type CoverageProviderName as h, type CoverageOptions as i, type CoverageIstanbulOptions as j, type CustomProviderOptions as k, type Reporter as l, type BrowserScript as m, type BrowserConfigOptions as n, type BuiltinEnvironment as o, type VitestEnvironment as p, type PoolOptions as q, type CSSModuleScopeStrategy as r, type VitestRunMode as s, type TransformModePatterns as t, type TypecheckConfig as u, type UserConfig as v, type ResolvedConfig as w, type ProjectConfig as x, type BenchmarkUserOptions as y, type VitestOptions as z };
+export { type JUnitOptions as $, type ApiConfig as A, type BaseCoverageOptions as B, CoverageMap as C, type DepsOptimizationOptions as D, TestProject as E, type TestSequencer as F, TestSpecification as G, TestModule as H, type InlineConfig as I, type OnTestsRerunHandler as J, VitestPackageInstaller as K, Logger as L, type ModuleDiagnostic as M, type ProcessPool as N, type OnServerRestartHandler as O, type Pool as P, type WorkspaceSpec as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TestProjectConfiguration as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, getFilePoolName as X, type SerializedTestProject as Y, type HTMLOptions as Z, type JsonOptions$1 as _, type ReportContext as a, type TaskOptions as a0, TestCase as a1, TestCollection as a2, type TestDiagnostic as a3, type TestModuleState as a4, type TestResult as a5, type TestResultFailed as a6, type TestResultPassed as a7, type TestResultSkipped as a8, type TestState as a9, BenchmarkReportsMap as aA, DefaultReporter as aB, DotReporter as aC, GithubActionsReporter as aD, HangingProcessReporter as aE, JsonReporter as aF, JUnitReporter as aG, ReportersMap as aH, TapFlatReporter as aI, TapReporter as aJ, VerboseBenchmarkReporter as aK, VerboseReporter as aL, BaseReporter as aM, type BenchmarkBuiltinReporters as aN, type BuiltinReporterOptions as aO, type BuiltinReporters as aP, type JsonAssertionResult as aQ, type JsonTestResult as aR, type JsonTestResults as aS, TestSuite as aa, type TestSuiteState as ab, type TestSequencerConstructor as ac, type BrowserBuiltinProvider as ad, type BrowserCommand as ae, type BrowserCommandContext as af, type BrowserInstanceOption as ag, type BrowserOrchestrator as ah, type BrowserProvider as ai, type BrowserProviderInitializationOptions as aj, type BrowserProviderModule as ak, type BrowserProviderOptions as al, type BrowserServerState as am, type BrowserServerStateSession as an, type CDPSession as ao, type ParentProjectBrowser as ap, type ProjectBrowser as aq, type ResolvedBrowserOptions as ar, type ResolvedProjectConfig as as, type ResolveSnapshotPathHandler as at, type ResolveSnapshotPathHandlerContext as au, type TestRunResult as av, type ReportedHookContext as aw, type TestRunEndReason as ax, BasicReporter as ay, BenchmarkReporter as az, type CoverageProvider as b, type CoverageProviderModule as c, type CoverageV8Options as d, type UserProjectConfigFn as e, type UserProjectConfigExport as f, type CoverageReporter as g, type CoverageProviderName as h, type CoverageOptions as i, type CoverageIstanbulOptions as j, type CustomProviderOptions as k, type Reporter as l, type BrowserScript as m, type BrowserConfigOptions as n, type BuiltinEnvironment as o, type VitestEnvironment as p, type PoolOptions as q, type CSSModuleScopeStrategy as r, type VitestRunMode as s, type TransformModePatterns as t, type TypecheckConfig as u, type UserConfig as v, type ResolvedConfig as w, type ProjectConfig as x, type BenchmarkUserOptions as y, type VitestOptions as z };