vitest 0.28.4 → 0.29.0

package/dist/node.js

@@ -1,33 +1,33 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-node-pkg.94145502.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.eb0c265c.js';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-node-pkg.88e7e848.js';
+export { V as VitestExecutor } from './chunk-runtime-mocker.a048e92d.js';
 import 'pathe';
 import './chunk-constants.797d3ebf.js';
 import 'node:url';
 import './chunk-utils-env.860d90c2.js';
 import 'std-env';
-import './chunk-integrations-coverage.48e6286b.js';
+import './chunk-integrations-coverage.e0a6acd2.js';
 import 'local-pkg';
-import 'util';
-import 'path';
-import './chunk-env-node.ffd1183b.js';
+import './chunk-env-node.affdd278.js';
 import 'node:console';
 import 'picocolors';
 import 'vite';
 import 'node:path';
 import 'node:process';
 import 'node:fs';
+import 'path';
 import 'os';
+import 'util';
 import 'stream';
 import 'events';
 import 'fs';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'vite-node/client';
 import 'vite-node/server';
-import './chunk-utils-global.442d1d33.js';
+import './chunk-utils-global.727b6d25.js';
 import '@vitest/runner/utils';
 import '@vitest/utils';
 import 'node:fs/promises';
-import './vendor-index.618ca5a1.js';
+import './vendor-index.2cbcdd1e.js';
 import 'node:buffer';
 import 'node:child_process';
 import 'child_process';
@@ -38,12 +38,13 @@ import 'source-map';
 import 'module';
 import 'acorn';
 import 'acorn-walk';
+import 'node:v8';
+import './vendor-index.783e7f3e.js';
+import './chunk-utils-base.81f83dbd.js';
 import 'node:worker_threads';
 import 'tinypool';
-import './vendor-index.783e7f3e.js';
 import 'perf_hooks';
-import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
+import './chunk-utils-tasks.b41c8284.js';
 import 'crypto';
 import 'vite-node/utils';
 import '@vitest/utils/diff';
@@ -54,5 +55,6 @@ import 'readline';
 import './vendor-index.bdee400f.js';
 import 'node:module';
 import 'node:assert';
-import 'node:v8';
 import 'node:util';
+import '@vitest/spy';
+import './chunk-runtime-rpc.971b3848.js';

package/dist/runners.d.ts

@@ -1,5 +1,5 @@
 import { VitestRunner, VitestRunnerImportSource, Suite, Test, TestContext } from '@vitest/runner';
-import { a as ResolvedConfig } from './types-aac763a5.js';
+import { a as ResolvedConfig } from './types-7cd96283.js';
 import '@vitest/expect';
 import 'vite';
 import '@vitest/runner/types';
@@ -10,12 +10,14 @@ import 'vite-node/client';
 import 'vite-node/server';
 import 'node:worker_threads';
 import 'vite-node';
+import 'source-map';
 import 'node:fs';
 
 declare class VitestTestRunner implements VitestRunner {
     config: ResolvedConfig;
     private snapshotClient;
     private workerState;
+    private __vitest_executor;
     constructor(config: ResolvedConfig);
     importFile(filepath: string, source: VitestRunnerImportSource): unknown;
     onBeforeRun(): void;
@@ -30,6 +32,7 @@ declare class VitestTestRunner implements VitestRunner {
 
 declare class NodeBenchmarkRunner implements VitestRunner {
     config: ResolvedConfig;
+    private __vitest_executor;
     constructor(config: ResolvedConfig);
     importFile(filepath: string, source: VitestRunnerImportSource): unknown;
     runSuite(suite: Suite): Promise<void>;

package/dist/runners.js

@@ -1,18 +1,226 @@
-export { N as NodeBenchmarkRunner, V as VitestTestRunner } from './runners-chunk.js';
-import '@vitest/expect';
-import './chunk-utils-import.0402c9db.js';
-import '@vitest/runner';
+import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
+import { d as getSnapshotClient, c as createExpect, a as vi, e as getBenchOptions, f as getBenchFn } from './chunk-utils-import.ec15dcad.js';
+import { g as getWorkerState } from './chunk-utils-global.727b6d25.js';
+import { g as getFullName } from './chunk-utils-tasks.b41c8284.js';
+import { updateTask } from '@vitest/runner';
+import { createDefer, getSafeTimers } from '@vitest/utils';
 import '@vitest/runner/utils';
-import '@vitest/utils';
-import './chunk-utils-global.442d1d33.js';
-import 'pathe';
-import './chunk-utils-env.860d90c2.js';
-import 'std-env';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.9c0386cc.js';
-import './chunk-snapshot-env.6457638e.js';
-import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
+import './chunk-runtime-rpc.971b3848.js';
+import 'pathe';
+import './chunk-snapshot-env.a347d647.js';
+import './chunk-utils-base.81f83dbd.js';
 import 'util';
 import '@vitest/spy';
+import './chunk-utils-env.860d90c2.js';
+import 'std-env';
+
+class VitestTestRunner {
+  constructor(config) {
+    this.config = config;
+    this.snapshotClient = getSnapshotClient();
+    this.workerState = getWorkerState();
+  }
+  importFile(filepath, source) {
+    if (source === "setup")
+      this.workerState.moduleCache.delete(filepath);
+    return this.__vitest_executor.executeId(filepath);
+  }
+  onBeforeRun() {
+    this.snapshotClient.clear();
+  }
+  async onAfterRun() {
+    await this.snapshotClient.saveCurrent();
+  }
+  onAfterRunSuite(suite) {
+    if (this.config.logHeapUsage && typeof process !== "undefined")
+      suite.result.heap = process.memoryUsage().heapUsed;
+  }
+  onAfterRunTest(test) {
+    this.snapshotClient.clearTest();
+    if (this.config.logHeapUsage && typeof process !== "undefined")
+      test.result.heap = process.memoryUsage().heapUsed;
+    this.workerState.current = void 0;
+  }
+  async onBeforeRunTest(test) {
+    if (test.mode !== "run") {
+      this.snapshotClient.skipTestSnapshots(test);
+      return;
+    }
+    clearModuleMocks(this.config);
+    await this.snapshotClient.setTest(test);
+    this.workerState.current = test;
+  }
+  onBeforeTryTest(test) {
+    var _a;
+    setState({
+      assertionCalls: 0,
+      isExpectingAssertions: false,
+      isExpectingAssertionsError: null,
+      expectedAssertionsNumber: null,
+      expectedAssertionsNumberErrorGen: null,
+      testPath: (_a = test.suite.file) == null ? void 0 : _a.filepath,
+      currentTestName: getFullName(test),
+      snapshotState: this.snapshotClient.snapshotState
+    }, globalThis[GLOBAL_EXPECT]);
+  }
+  onAfterTryTest(test) {
+    const {
+      assertionCalls,
+      expectedAssertionsNumber,
+      expectedAssertionsNumberErrorGen,
+      isExpectingAssertions,
+      isExpectingAssertionsError
+    } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
+      throw expectedAssertionsNumberErrorGen();
+    if (isExpectingAssertions === true && assertionCalls === 0)
+      throw isExpectingAssertionsError;
+  }
+  extendTestContext(context) {
+    let _expect;
+    Object.defineProperty(context, "expect", {
+      get() {
+        if (!_expect)
+          _expect = createExpect(context.meta);
+        return _expect;
+      }
+    });
+    Object.defineProperty(context, "_local", {
+      get() {
+        return _expect != null;
+      }
+    });
+    return context;
+  }
+}
+function clearModuleMocks(config) {
+  const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+  if (restoreMocks)
+    vi.restoreAllMocks();
+  else if (mockReset)
+    vi.resetAllMocks();
+  else if (clearMocks)
+    vi.clearAllMocks();
+  if (unstubEnvs)
+    vi.unstubAllEnvs();
+  if (unstubGlobals)
+    vi.unstubAllGlobals();
+}
+
+async function importTinybench() {
+  if (!globalThis.EventTarget)
+    await import('./vendor-index.534e612c.js').then(function (n) { return n.i; });
+  return await import('tinybench');
+}
+function createBenchmarkResult(name) {
+  return {
+    name,
+    rank: 0,
+    rme: 0,
+    samples: []
+  };
+}
+async function runBenchmarkSuite(suite, runner) {
+  var _a;
+  const { Task, Bench } = await importTinybench();
+  const start = performance.now();
+  const benchmarkGroup = [];
+  const benchmarkSuiteGroup = [];
+  for (const task of suite.tasks) {
+    if (task.mode !== "run")
+      continue;
+    if ((_a = task.meta) == null ? void 0 : _a.benchmark)
+      benchmarkGroup.push(task);
+    else if (task.type === "suite")
+      benchmarkSuiteGroup.push(task);
+  }
+  if (benchmarkSuiteGroup.length)
+    await Promise.all(benchmarkSuiteGroup.map((subSuite) => runBenchmarkSuite(subSuite, runner)));
+  if (benchmarkGroup.length) {
+    const defer = createDefer();
+    const benchmarkMap = {};
+    suite.result = {
+      state: "run",
+      startTime: start,
+      benchmark: createBenchmarkResult(suite.name)
+    };
+    updateTask$1(suite);
+    benchmarkGroup.forEach((benchmark, idx) => {
+      const options = getBenchOptions(benchmark);
+      const benchmarkInstance = new Bench(options);
+      const benchmarkFn = getBenchFn(benchmark);
+      benchmark.result = {
+        state: "run",
+        startTime: start,
+        benchmark: createBenchmarkResult(benchmark.name)
+      };
+      const id = idx.toString();
+      benchmarkMap[id] = benchmark;
+      const task = new Task(benchmarkInstance, id, benchmarkFn);
+      benchmark.meta.task = task;
+      updateTask$1(benchmark);
+    });
+    benchmarkGroup.forEach((benchmark) => {
+      benchmark.meta.task.addEventListener("complete", (e) => {
+        const task = e.task;
+        const _benchmark = benchmarkMap[task.name || ""];
+        if (_benchmark) {
+          const taskRes = task.result;
+          const result = _benchmark.result.benchmark;
+          Object.assign(result, taskRes);
+          updateTask$1(_benchmark);
+        }
+      });
+      benchmark.meta.task.addEventListener("error", (e) => {
+        const task = e.task;
+        const _benchmark = benchmarkMap[task.name || ""];
+        defer.reject(_benchmark ? task.result.error : e);
+      });
+    });
+    Promise.all(benchmarkGroup.map(async (benchmark) => {
+      await benchmark.meta.task.warmup();
+      const { setTimeout } = getSafeTimers();
+      return await new Promise((resolve) => setTimeout(async () => {
+        resolve(await benchmark.meta.task.run());
+      }));
+    })).then((tasks) => {
+      suite.result.duration = performance.now() - start;
+      suite.result.state = "pass";
+      tasks.sort((a, b) => a.result.mean - b.result.mean).forEach((cycle, idx) => {
+        const benchmark = benchmarkMap[cycle.name || ""];
+        benchmark.result.state = "pass";
+        if (benchmark) {
+          const result = benchmark.result.benchmark;
+          result.rank = Number(idx) + 1;
+          updateTask$1(benchmark);
+        }
+      });
+      updateTask$1(suite);
+      defer.resolve(null);
+    });
+    await defer;
+  }
+  function updateTask$1(task) {
+    updateTask(task, runner);
+  }
+}
+class NodeBenchmarkRunner {
+  constructor(config) {
+    this.config = config;
+  }
+  importFile(filepath, source) {
+    if (source === "setup")
+      getWorkerState().moduleCache.delete(filepath);
+    return this.__vitest_executor.executeId(filepath);
+  }
+  async runSuite(suite) {
+    await runBenchmarkSuite(suite, this);
+  }
+  async runTest() {
+    throw new Error("`test()` and `it()` is only available in test mode.");
+  }
+}
+
+export { NodeBenchmarkRunner, VitestTestRunner };

package/dist/{types-aac763a5.d.ts → types-7cd96283.d.ts}

@@ -1,15 +1,16 @@
 import { MatchersObject, MatcherState } from '@vitest/expect';
-import { UserConfig as UserConfig$1, ViteDevServer, CommonServerOptions, AliasOptions } from 'vite';
+import { UserConfig as UserConfig$1, ViteDevServer, CommonServerOptions, DepOptimizationConfig, AliasOptions } from 'vite';
 import { File, Test as Test$1, Suite, TaskResultPack, Task } from '@vitest/runner/types';
 import * as _vitest_runner from '@vitest/runner';
-import { Task as Task$1, File as File$1, TaskResultPack as TaskResultPack$1, Test as Test$2, TaskCustom } from '@vitest/runner';
+import { Task as Task$1, Test as Test$2, TaskCustom } from '@vitest/runner';
 import { ParsedStack, ErrorWithDiff, ChainableFunction } from '@vitest/runner/utils';
 import { Arrayable as Arrayable$1 } from '@vitest/utils';
 import { Task as Task$2, TaskResult, Bench, Options } from 'tinybench';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
 import { MessagePort } from 'node:worker_threads';
-import { RawSourceMap, ViteNodeResolveId, FetchFunction, ModuleCacheMap } from 'vite-node';
+import { RawSourceMap, FetchResult, ViteNodeResolveId, ModuleCacheMap } from 'vite-node';
+import { RawSourceMap as RawSourceMap$1 } from 'source-map';
 import { Stats } from 'node:fs';
 
 /**
@@ -252,7 +253,7 @@ declare class Typechecker {
 }
 
 type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
-interface WorkerPool {
+interface ProcessPool {
     runTests: RunWithFiles;
     close: () => Promise<void>;
 }
@@ -375,7 +376,7 @@ declare class Vitest {
     reporters: Reporter[];
     coverageProvider: CoverageProvider | null | undefined;
     logger: Logger;
-    pool: WorkerPool | undefined;
+    pool: ProcessPool | undefined;
     typechecker: Typechecker | undefined;
     vitenode: ViteNodeServer;
     invalidates: Set<string>;
@@ -417,7 +418,10 @@ declare class Vitest {
      */
     exit(force?: boolean): Promise<void>;
     report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
-    globFiles(filters: string[], include: string[], exclude: string[]): Promise<string[]>;
+    globFiles(include: string[], exclude: string[], cwd: string): Promise<string[]>;
+    private _allTestsCache;
+    globAllTestFiles(config: ResolvedConfig, cwd: string): Promise<string[]>;
+    filterFiles(testFiles: string[], filters?: string[]): string[];
     globTestFiles(filters?: string[]): Promise<string[]>;
     isTargetFile(id: string, source?: string): Promise<boolean>;
     isInSourceTestFile(code: string): boolean;
@@ -890,6 +894,87 @@ interface AcornNode {
 	type: string;
 }
 
+// Type definitions for istanbul-lib-report 3.0
+
+
+interface Node {
+    isRoot(): boolean;
+    visit(visitor: Visitor, state: any): void;
+}
+
+interface Visitor<N extends Node = Node> {
+    onStart(root: N, state: any): void;
+    onSummary(root: N, state: any): void;
+    onDetail(root: N, state: any): void;
+    onSummaryEnd(root: N, state: any): void;
+    onEnd(root: N, state: any): void;
+}
+
+// Type definitions for istanbul-reports 3.0
+
+
+interface FileOptions {
+    file: string;
+}
+
+interface ProjectOptions {
+    projectRoot: string;
+}
+
+interface ReportOptions {
+    clover: CloverOptions;
+    cobertura: CoberturaOptions;
+    'html-spa': HtmlSpaOptions;
+    html: HtmlOptions;
+    json: JsonOptions;
+    'json-summary': JsonSummaryOptions;
+    lcov: LcovOptions;
+    lcovonly: LcovOnlyOptions;
+    none: never;
+    teamcity: TeamcityOptions;
+    text: TextOptions;
+    'text-lcov': TextLcovOptions;
+    'text-summary': TextSummaryOptions;
+}
+
+interface CloverOptions extends FileOptions, ProjectOptions {}
+
+interface CoberturaOptions extends FileOptions, ProjectOptions {}
+
+interface HtmlSpaOptions extends HtmlOptions {
+    metricsToShow: Array<'lines' | 'branches' | 'functions' | 'statements'>;
+}
+interface HtmlOptions {
+    verbose: boolean;
+    skipEmpty: boolean;
+    subdir: string;
+    linkMapper: LinkMapper;
+}
+
+type JsonOptions = FileOptions;
+type JsonSummaryOptions = FileOptions;
+
+interface LcovOptions extends FileOptions, ProjectOptions {}
+interface LcovOnlyOptions extends FileOptions, ProjectOptions {}
+
+interface TeamcityOptions extends FileOptions {
+    blockName: string;
+}
+
+interface TextOptions extends FileOptions {
+    maxCols: number;
+    skipEmpty: boolean;
+    skipFull: boolean;
+}
+type TextLcovOptions = ProjectOptions;
+type TextSummaryOptions = FileOptions;
+
+interface LinkMapper {
+    getPath(node: string | Node): string;
+    relativePath(source: string | Node, target: string | Node): string;
+    assetPath(node: Node, name: string): string;
+}
+
 declare type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
 declare type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
 declare type PromisifyFn<T> = ReturnType$1<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType$1<T>>>;
@@ -950,36 +1035,44 @@ interface SnapshotSummary {
     updated: number;
 }
 
-interface WorkerContext {
-    workerId: number;
-    port: MessagePort;
-    config: ResolvedConfig;
-    files: string[];
-    invalidates?: string[];
-}
-type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
-interface AfterSuiteRunMeta {
-    coverage?: unknown;
-}
-interface WorkerRPC {
-    fetch: FetchFunction;
-    resolveId: ResolveIdFunction;
-    getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
-    onFinished: (files: File$1[], errors?: unknown[]) => void;
+interface RuntimeRPC {
+    fetch: (id: string, environment: VitestEnvironment) => Promise<FetchResult>;
+    resolveId: (id: string, importer: string | undefined, environment: VitestEnvironment) => Promise<ViteNodeResolveId | null>;
+    getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap$1 | undefined>;
+    onFinished: (files: File[], errors?: unknown[]) => void;
     onWorkerExit: (error: unknown, code?: number) => void;
     onPathsCollected: (paths: string[]) => void;
     onUserConsoleLog: (log: UserConsoleLog) => void;
     onUnhandledError: (err: unknown, type: string) => void;
-    onCollected: (files: File$1[]) => void;
+    onCollected: (files: File[]) => void;
     onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
-    onTaskUpdate: (pack: TaskResultPack$1[]) => void;
+    onTaskUpdate: (pack: TaskResultPack[]) => void;
     snapshotSaved: (snapshot: SnapshotResult) => void;
     resolveSnapshotPath: (testPath: string) => string;
 }
+interface ContextTestEnvironment {
+    name: VitestEnvironment;
+    options: EnvironmentOptions | null;
+}
+interface ContextRPC {
+    config: ResolvedConfig;
+    files: string[];
+    invalidates?: string[];
+    environment: ContextTestEnvironment;
+}
+
+interface WorkerContext extends ContextRPC {
+    workerId: number;
+    port: MessagePort;
+}
+type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+interface AfterSuiteRunMeta {
+    coverage?: unknown;
+}
 interface WorkerGlobalState {
     ctx: WorkerContext;
     config: ResolvedConfig;
-    rpc: BirpcReturn<WorkerRPC>;
+    rpc: BirpcReturn<RuntimeRPC>;
     current?: Test$2;
     filepath?: string;
     moduleCache: ModuleCacheMap;
@@ -991,7 +1084,6 @@ interface CoverageProvider {
     initialize(ctx: Vitest): Promise<void> | void;
     resolveOptions(): ResolvedCoverageOptions;
     clean(clean?: boolean): void | Promise<void>;
-    onBeforeFilesRun?(): void | Promise<void>;
     onAfterSuiteRun(meta: AfterSuiteRunMeta): void | Promise<void>;
     reportCoverage(reportContext?: ReportContext): void | Promise<void>;
     onFileTransform?(sourceCode: string, id: string, pluginCtx: TransformPluginContext): TransformResult | Promise<TransformResult>;
@@ -1005,28 +1097,39 @@ interface CoverageProviderModule {
      * Factory for creating a new coverage provider
      */
     getProvider(): CoverageProvider | Promise<CoverageProvider>;
+    /**
+     * Executed before tests are run in the worker thread.
+     */
+    startCoverage?(): unknown | Promise<unknown>;
     /**
      * Executed on after each run in the worker thread. Possible to return a payload passed to the provider
      */
     takeCoverage?(): unknown | Promise<unknown>;
+    /**
+     * Executed after all tests have been run in the worker thread.
+     */
+    stopCoverage?(): unknown | Promise<unknown>;
 }
-type CoverageReporter = 'clover' | 'cobertura' | 'html-spa' | 'html' | 'json-summary' | 'json' | 'lcov' | 'lcovonly' | 'none' | 'teamcity' | 'text-lcov' | 'text-summary' | 'text';
-type Provider = 'c8' | 'istanbul' | CoverageProviderModule | undefined;
-type CoverageOptions<T extends Provider = Provider> = T extends CoverageProviderModule ? ({
+type CoverageReporter = keyof ReportOptions;
+type CoverageReporterWithOptions<ReporterName extends CoverageReporter = CoverageReporter> = ReporterName extends CoverageReporter ? ReportOptions[ReporterName] extends never ? [ReporterName, {}] : [ReporterName, Partial<ReportOptions[ReporterName]>] : never;
+type Provider = 'c8' | 'istanbul' | 'custom' | undefined;
+type CoverageOptions<T extends Provider = Provider> = T extends 'istanbul' ? ({
     provider: T;
-} & BaseCoverageOptions) : T extends 'istanbul' ? ({
+} & CoverageIstanbulOptions) : T extends 'c8' ? ({
     provider: T;
-} & CoverageIstanbulOptions) : ({
+} & CoverageC8Options) : T extends 'custom' ? ({
+    provider: T;
+} & CustomProviderOptions) : ({
     provider?: T;
-} & CoverageC8Options);
+} & (CoverageC8Options));
 /** Fields that have default values. Internally these will always be defined. */
-type FieldsWithDefaultValues = 'enabled' | 'clean' | 'cleanOnRerun' | 'reportsDirectory' | 'exclude' | 'extension' | 'reporter';
+type FieldsWithDefaultValues = 'enabled' | 'clean' | 'cleanOnRerun' | 'reportsDirectory' | 'exclude' | 'extension';
 type ResolvedCoverageOptions<T extends Provider = Provider> = CoverageOptions<T> & Required<Pick<CoverageOptions<T>, FieldsWithDefaultValues>> & {
-    reporter: CoverageReporter[];
+    reporter: CoverageReporterWithOptions[];
 };
 interface BaseCoverageOptions {
     /**
-     * Enables coverage collection. Can be overriden using `--coverage` CLI option.
+     * Enables coverage collection. Can be overridden using `--coverage` CLI option.
      *
      * @default false
      */
@@ -1075,7 +1178,7 @@ interface BaseCoverageOptions {
      *
      * @default ['text', 'html', 'clover', 'json']
      */
-    reporter?: Arrayable<CoverageReporter>;
+    reporter?: Arrayable<CoverageReporter> | (CoverageReporter | [CoverageReporter] | CoverageReporterWithOptions)[];
     /**
      * Do not show files with 100% statement, branch, and function coverage
      *
@@ -1113,6 +1216,12 @@ interface BaseCoverageOptions {
      * @default undefined
      */
     statements?: number;
+    /**
+     * Update threshold values automatically when current coverage is higher than earlier thresholds
+     *
+     * @default false
+     */
+    thresholdAutoUpdate?: boolean;
 }
 interface CoverageIstanbulOptions extends BaseCoverageOptions {
     /**
@@ -1159,6 +1268,10 @@ interface CoverageC8Options extends BaseCoverageOptions {
      */
     100?: boolean;
 }
+interface CustomProviderOptions extends Pick<BaseCoverageOptions, FieldsWithDefaultValues> {
+    /** Name of the module or path to a file to load the custom provider from */
+    customProviderModule: string;
+}
 
 interface JSDOMOptions {
     /**
@@ -1336,6 +1449,12 @@ interface InlineConfig {
      * Handling for dependencies inlining or externalizing
      */
     deps?: {
+        /**
+         * Enable dependency optimization. This can improve the performance of your tests.
+         */
+        experimentalOptimizer?: Omit<DepOptimizationConfig, 'disabled'> & {
+            enabled: boolean;
+        };
         /**
          * Externalize means that Vite will bypass the package to native Node.
          *
@@ -1541,6 +1660,12 @@ interface InlineConfig {
      * @default true
      */
     isolate?: boolean;
+    /**
+     * Run tests inside a single thread.
+     *
+     * @default false
+     */
+    singleThread?: boolean;
     /**
      * Coverage options
      */
@@ -1828,7 +1953,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
         sequencer: TestSequencerConstructor;
         hooks: SequenceHooks;
         shuffle?: boolean;
-        seed?: number;
+        seed: number;
     };
     typecheck: TypecheckConfig;
     runner?: string;
@@ -1979,7 +2104,7 @@ declare global {
             toBeInstanceOf<E>(expected: E): void;
             toBeCalledTimes(times: number): void;
             toHaveLength(length: number): void;
-            toHaveProperty<E>(property: string | string[], value?: E): void;
+            toHaveProperty<E>(property: string | (string | number)[], value?: E): void;
             toBeCloseTo(number: number, numDigits?: number): void;
             toHaveBeenCalledTimes(times: number): void;
             toHaveBeenCalledOnce(): void;
@@ -2041,4 +2166,4 @@ type Context = RootAndTarget & {
     lastActivePath?: string;
 };
 
-export { CoverageReporter as $, ApiConfig as A, BenchmarkAPI as B, CollectLineNumbers as C, MergeInsertions as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, DeepMerge as G, MutableArray as H, InlineConfig as I, JSDOMOptions as J, Constructable as K, ModuleCache as L, MockFactoryWithHelper as M, Nullable as N, EnvironmentReturn as O, Environment as P, UserConsoleLog as Q, RuntimeConfig as R, SnapshotResult as S, TscErrorInfo as T, UserConfig as U, VitestEnvironment as V, WorkerContext as W, OnServerRestartHandler as X, CoverageProvider as Y, ReportContext as Z, CoverageProviderModule as _, ResolvedConfig as a, CoverageOptions as a0, ResolvedCoverageOptions as a1, BaseCoverageOptions as a2, CoverageIstanbulOptions as a3, CoverageC8Options as a4, BenchmarkUserOptions as a5, Benchmark as a6, BenchmarkResult as a7, BenchFunction as a8, MockFactory as a9, MockMap as aa, TestSequencer as ab, startVitest as ac, TestSequencerConstructor as ad, ModuleGraphData as b, Reporter as c, RawErrsMap as d, CollectLines as e, RootAndTarget as f, Context as g, BuiltinEnvironment as h, CSSModuleScopeStrategy as i, SequenceHooks as j, VitestRunMode as k, TypecheckConfig as l, Vitest as m, SnapshotData as n, SnapshotUpdateState as o, SnapshotStateOptions as p, SnapshotMatchOptions as q, UncheckedSnapshot as r, SnapshotSummary as s, ResolveIdFunction as t, AfterSuiteRunMeta as u, WorkerRPC as v, WorkerGlobalState as w, Awaitable as x, Arrayable as y, ArgumentsType$1 as z };
+export { ReportContext as $, ApiConfig as A, BenchmarkAPI as B, CollectLineNumbers as C, Arrayable as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, ArgumentsType$1 as G, MergeInsertions as H, InlineConfig as I, JSDOMOptions as J, DeepMerge as K, MutableArray as L, MockFactoryWithHelper as M, Nullable as N, Constructable as O, ModuleCache as P, EnvironmentReturn as Q, RuntimeConfig as R, SnapshotResult as S, TscErrorInfo as T, UserConfig as U, VitestEnvironment as V, WorkerContext as W, Environment as X, UserConsoleLog as Y, OnServerRestartHandler as Z, CoverageProvider as _, ResolvedConfig as a, CoverageProviderModule as a0, CoverageReporter as a1, CoverageOptions as a2, ResolvedCoverageOptions as a3, BaseCoverageOptions as a4, CoverageIstanbulOptions as a5, CoverageC8Options as a6, CustomProviderOptions as a7, BenchmarkUserOptions as a8, Benchmark as a9, BenchmarkResult as aa, BenchFunction as ab, MockFactory as ac, MockMap as ad, TestSequencer as ae, startVitest as af, TestSequencerConstructor as ag, HtmlOptions as ah, FileOptions as ai, CloverOptions as aj, CoberturaOptions as ak, HtmlSpaOptions as al, LcovOptions as am, LcovOnlyOptions as an, TeamcityOptions as ao, TextOptions as ap, ProjectOptions as aq, ModuleGraphData as b, Reporter as c, RawErrsMap as d, CollectLines as e, RootAndTarget as f, Context as g, BuiltinEnvironment as h, CSSModuleScopeStrategy as i, SequenceHooks as j, VitestRunMode as k, TypecheckConfig as l, RuntimeRPC as m, ContextTestEnvironment as n, ContextRPC as o, Vitest as p, SnapshotData as q, SnapshotUpdateState as r, SnapshotStateOptions as s, SnapshotMatchOptions as t, UncheckedSnapshot as u, SnapshotSummary as v, ResolveIdFunction as w, AfterSuiteRunMeta as x, WorkerGlobalState as y, Awaitable as z };