vitest 4.1.5 → 5.0.0-beta.2

package/dist/chunks/{vm.DVLYObm9.js → vm.2okbRRME.js}

@@ -1,17 +1,17 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import vm, { isContext, runInContext } from 'node:vm';
 import { dirname, basename, extname, normalize, resolve } from 'pathe';
-import { l as loadEnvironment, a as listenForErrors, e as emitModuleRunner } from './init.D98-gwRW.js';
+import { l as loadEnvironment, a as listenForErrors, e as emitModuleRunner } from './init.BVd7SaCA.js';
 import { distDir } from '../path.js';
-import { createCustomConsole } from './console.3WNpx0tS.js';
-import fs from 'node:fs';
+import { createCustomConsole } from './console.B3IRP8fX.js';
+import fs__default from 'node:fs';
 import { createRequire, Module, isBuiltin } from 'node:module';
 import { toArray, splitFileAndPostfix, isBareImport } from '@vitest/utils/helpers';
 import { findNearestPackageData } from '@vitest/utils/resolver';
 import { dirname as dirname$1 } from 'node:path';
 import { CSS_LANGS_RE, KNOWN_ASSET_RE } from '@vitest/utils/constants';
 import { getDefaultRequestStubs } from '../module-evaluator.js';
-import { s as startVitestModuleRunner, V as VITEST_VM_CONTEXT_SYMBOL, c as createNodeImportMeta } from './startVitestModuleRunner.bRl2_oI_.js';
+import { s as startVitestModuleRunner, V as VITEST_VM_CONTEXT_SYMBOL, c as createNodeImportMeta } from './index.CbgUM9E5.js';
 import { p as provideWorkerState } from './utils.BX5Fg8C4.js';
 
 function interopCommonJsModule(interopDefault, mod) {
@@ -551,7 +551,7 @@ class ViteExecutor {
 	};
 }
 
-const { existsSync } = fs;
+const { existsSync } = fs__default;
 // always defined when we use vm pool
 const nativeResolve = import.meta.resolve;
 // TODO: improve Node.js strict mode support in #2854
@@ -675,7 +675,7 @@ class ExternalModulesExecutor {
 	}
 }
 
-const { promises, readFileSync } = fs;
+const { promises, readFileSync } = fs__default;
 class FileMap {
 	fsCache = /* @__PURE__ */ new Map();
 	fsBufferCache = /* @__PURE__ */ new Map();

package/dist/chunks/{worker.d.ZpHpO4yb.d.ts → worker.d.Bu1kXGw4.d.ts}

@@ -1,8 +1,8 @@
 import { FileSpecification, Task, CancelReason } from '@vitest/runner';
 import { EvaluatedModules } from 'vite/module-runner';
-import { S as SerializedConfig } from './config.d.A1h_Y6Jt.js';
+import { a as SerializedConfig } from './config.d.D91DHYaD.js';
 import { E as Environment } from './environment.d.CrsxCzP1.js';
-import { R as RuntimeRPC, a as RunnerRPC } from './rpc.d.B_8sPU0w.js';
+import { a as RuntimeRPC, R as RunnerRPC } from './rpc.d.7JZuxZ8u.js';
 
 //#region src/messages.d.ts
 declare const TYPE_REQUEST: "q";
@@ -252,4 +252,4 @@ interface WorkerGlobalState {
 	onFilterStackTrace?: (trace: string) => string;
 }
 
-export type { BirpcOptions as B, ContextRPC as C, TestExecutionMethod as T, WorkerGlobalState as W, WorkerSetupContext as a, BirpcReturn as b, ContextTestEnvironment as c, WorkerExecuteContext as d, WorkerTestEnvironment as e };
+export type { BirpcReturn as B, ContextRPC as C, TestExecutionMethod as T, WorkerGlobalState as W, ContextTestEnvironment as a, WorkerExecuteContext as b, WorkerTestEnvironment as c, WorkerSetupContext as d, BirpcOptions as e };

package/dist/cli.js

@@ -1,11 +1,11 @@
-import { c as createCLI } from './chunks/cac.DJJmV0dT.js';
+import { c as createCLI } from './chunks/cac.8N4bOkkB.js';
 import '@vitest/utils/helpers';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
-import './chunks/constants.CPYnjOGj.js';
+import './chunks/constants.-juJ8b_4.js';
 import 'node:assert';
 
 createCLI().parse();

package/dist/config.cjs

@@ -39,7 +39,8 @@ const coverageConfigDefaults = {
 		functions: [50, 80],
 		branches: [50, 80],
 		lines: [50, 80]
-	}
+	},
+	autoAttachSubprocess: false
 };
 const fakeTimersDefaults = {
 	loopLimit: 1e4,
@@ -61,7 +62,7 @@ const configDefaults = Object.freeze({
 	teardownTimeout: 1e4,
 	forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
 	update: false,
-	reporters: [],
+	reporters: [stdEnv.isAgent ? "minimal" : "default", ...process.env.GITHUB_ACTIONS === "true" ? ["github-actions"] : []],
 	silent: false,
 	hideSkippedTests: false,
 	api: false,
@@ -79,6 +80,7 @@ const configDefaults = Object.freeze({
 		exclude: defaultExclude
 	},
 	slowTestThreshold: 300,
+	taskTitleValueFormatTruncate: 40,
 	disableConsoleIntercept: false,
 	detectAsyncLeaks: false
 });

package/dist/config.d.ts

@@ -1,33 +1,35 @@
 import { HookHandler, UserConfig, ConfigEnv } from 'vite';
 export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { I as InlineConfig, C as CoverageOptions, F as FieldsWithDefaultValues, U as UserWorkspaceConfig, b as UserProjectConfigFn, c as UserProjectConfigExport } from './chunks/reporters.d.CEnv6XRv.js';
-export { a as TestProjectConfiguration, d as TestProjectInlineConfiguration, e as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.CEnv6XRv.js';
-import { V as VitestPluginContext } from './chunks/plugin.d.BM2TCi12.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d.A1h_Y6Jt.js';
+import { a4 as InlineConfig, aW as VitestPluginContext, N as CoverageOptions, a$ as FieldsWithDefaultValues, aR as UserWorkspaceConfig, b0 as UserProjectConfigFn, b1 as UserProjectConfigExport } from './chunks/plugin.d.cIKZEZ16.js';
+export { b2 as TestProjectConfiguration, b3 as TestProjectInlineConfiguration, U as TestUserConfig, aX as WatcherTriggerPattern } from './chunks/plugin.d.cIKZEZ16.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.D91DHYaD.js';
+import './chunks/browser.d.BUhkKcDl.js';
 export { TestTagDefinition } from '@vitest/runner';
 import '@vitest/utils';
-import './chunks/traces.d.D2T_R8rx.js';
 import 'node:stream';
-import './chunks/browser.d.BcoexmFG.js';
-import './chunks/worker.d.ZpHpO4yb.js';
-import 'vite/module-runner';
-import './chunks/environment.d.CrsxCzP1.js';
-import './chunks/rpc.d.B_8sPU0w.js';
-import '@vitest/snapshot';
+import './chunks/general.d.DFAHgpC2.js';
 import '@vitest/pretty-format';
+import './chunks/environment.d-DOJxxZV9.d.DOJxxZV9.js';
+import 'node:fs/promises';
+import '@vitest/runner/types';
 import '@vitest/utils/diff';
-import '@vitest/expect';
+import 'chai';
 import 'vitest/optional-types.js';
-import './chunks/benchmark.d.DAaHLpsq.js';
-import '@vitest/runner/utils';
-import 'tinybench';
+import './chunks/worker.d.Bu1kXGw4.js';
+import 'vite/module-runner';
+import './chunks/environment.d.CrsxCzP1.js';
+import './chunks/rpc.d.7JZuxZ8u.js';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
 import 'vitest/browser';
-import './chunks/coverage.d.BZtK59WP.js';
-import '@vitest/snapshot/manager';
+import './chunks/coverage.d.g2xbl2sP.js';
 import 'node:console';
 import 'node:fs';
+import '@vitest/spy';
+import 'tinyrainbow';
+import '@vitest/utils/display';
+import '@vitest/runner/utils';
+import 'tinybench';
 
 type VitestInlineConfig = InlineConfig;
 declare module "vite" {
@@ -63,7 +65,7 @@ declare const configDefaults: Readonly<{
 	teardownTimeout: number;
 	forceRerunTriggers: string[];
 	update: boolean;
-	reporters: never[];
+	reporters: string[];
 	silent: boolean;
 	hideSkippedTests: boolean;
 	api: boolean;
@@ -83,6 +85,7 @@ declare const configDefaults: Readonly<{
 		exclude: string[];
 	};
 	slowTestThreshold: number;
+	taskTitleValueFormatTruncate: number;
 	disableConsoleIntercept: boolean;
 	detectAsyncLeaks: boolean;
 }>;

package/dist/config.js

@@ -1,6 +1,6 @@
-export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.9aQKnqFk.js';
+export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.szbHWQun.js';
 export { mergeConfig } from 'vite';
-export { d as defaultBrowserPort } from './chunks/constants.CPYnjOGj.js';
+export { d as defaultBrowserPort } from './chunks/constants.-juJ8b_4.js';
 import 'node:os';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';

package/dist/index.d.ts

@@ -1,36 +1,37 @@
-import { M as ModuleDefinitionDurationsDiagnostic, U as UntrackedModuleDefinitionDiagnostic, S as SerializedTestSpecification, a as ModuleDefinitionDiagnostic, b as ModuleDefinitionLocation, c as SourceModuleDiagnostic, d as SourceModuleLocations } from './chunks/browser.d.BcoexmFG.js';
-export { B as BrowserTesterOptions } from './chunks/browser.d.BcoexmFG.js';
-import './chunks/global.d.DVsSRdQ5.js';
-import { File, TestAnnotation, TestArtifact, TaskResultPack, TaskEventPack, Test, TaskPopulated } from '@vitest/runner';
-export { CancelReason, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteOptions, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestAnnotationArtifact, TestArtifact, TestArtifactBase, TestArtifactLocation, TestArtifactRegistry, TestAttachment, TestContext, TestFunction, TestOptions, VitestRunnerConfig as TestRunnerConfig, TestTags, VitestRunner as VitestTestRunner, afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
+import { M as ModuleDefinitionDurationsDiagnostic, U as UntrackedModuleDefinitionDiagnostic, S as SerializedTestSpecification, E as ExpectStatic, a as MatcherState, b as SyncExpectationResult, A as AsyncExpectationResult, c as ExpectationResult, B as BenchFunction, d as BenchmarkAPI, e as ModuleDefinitionDiagnostic, f as ModuleDefinitionLocation, g as SourceModuleDiagnostic, h as SourceModuleLocations } from './chunks/browser.d.BUhkKcDl.js';
+export { i as Assertion, j as AsymmetricMatchersContaining, k as Benchmark, l as BenchmarkResult, m as BrowserTesterOptions, D as DeeplyAllowMatchers, J as JestAssertion, R as Matcher, n as Matchers, o as MatchersObject } from './chunks/browser.d.BUhkKcDl.js';
+import './chunks/global.d.DhbKSQoV.js';
+import { File, TestAnnotation, TestArtifact, TaskResultPack, TaskEventPack, Test, TaskPopulated, VitestRunner, VitestRunnerImportSource, Suite, Task, CancelReason, TestContext, ImportDuration, createTaskCollector, getCurrentSuite, getCurrentTest, getHooks, getFn } from '@vitest/runner';
+export { CancelReason, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteOptions, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestAnnotationArtifact, TestArtifact, TestArtifactBase, TestArtifactLocation, TestArtifactRegistry, TestAttachment, TestContext, TestFunction, TestOptions, VitestRunnerConfig as TestRunnerConfig, TestTagDefinition, TestTags, VitestRunner as VitestTestRunner, afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
 import { Awaitable } from '@vitest/utils';
 export { ParsedStack, SerializedError, TestError } from '@vitest/utils';
-import { b as BirpcReturn } from './chunks/worker.d.ZpHpO4yb.js';
-export { C as ContextRPC, c as ContextTestEnvironment, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.ZpHpO4yb.js';
-import { b as SerializedRootConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.A1h_Y6Jt.js';
-export { c as RuntimeConfig, S as SerializedConfig, a as SerializedCoverageConfig } from './chunks/config.d.A1h_Y6Jt.js';
-import { U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext } from './chunks/traces.d.D2T_R8rx.js';
-export { a as AfterSuiteRunMeta } from './chunks/traces.d.D2T_R8rx.js';
-import { ExpectStatic, MatcherState, SyncExpectationResult, AsyncExpectationResult, ExpectationResult } from '@vitest/expect';
-export { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectPollOptions, ExpectStatic, JestAssertion, RawMatcherFn as Matcher, ExpectationResult as MatcherResult, MatcherState, Matchers, chai } from '@vitest/expect';
-import { DomainSnapshotAdapter } from '@vitest/snapshot';
-export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
+import { B as BirpcReturn } from './chunks/worker.d.Bu1kXGw4.js';
+export { C as ContextRPC, a as ContextTestEnvironment, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.Bu1kXGw4.js';
+import { S as SerializedRootConfig, F as FakeTimerInstallOpts, R as RuntimeOptions, a as SerializedConfig } from './chunks/config.d.D91DHYaD.js';
+export { b as RuntimeConfig, c as SerializedCoverageConfig } from './chunks/config.d.D91DHYaD.js';
+import { U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext, D as DomainSnapshotAdapter } from './chunks/general.d.DFAHgpC2.js';
+export { A as AfterSuiteRunMeta, a as DomainMatchResult, S as SnapshotData, b as SnapshotMatchOptions, c as SnapshotResult, d as SnapshotSerializer, e as SnapshotStateOptions, f as SnapshotSummary, g as SnapshotUpdateState, h as UncheckedSnapshot } from './chunks/general.d.DFAHgpC2.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
 export { Mock, MockContext, MockInstance, MockResult, MockResultIncomplete, MockResultReturn, MockResultThrow, MockSettledResult, MockSettledResultFulfilled, MockSettledResultIncomplete, MockSettledResultRejected, Mocked, MockedClass, MockedFunction, MockedObject } from '@vitest/spy';
 import { Disposable } from 'vitest/optional-runtime-types.js';
 import { ModuleMockFactoryWithHelper, ModuleMockOptions } from '@vitest/mocker';
-export { b as bench } from './chunks/suite.d.udJtyAgw.js';
+import * as tinybench from 'tinybench';
+import { Options } from 'tinybench';
+export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
 export { V as EvaluatedModules } from './chunks/evaluatedModules.d.BxJ5omdx.js';
-export { NodeBenchmarkRunner as BenchmarkRunner, VitestTestRunner as TestRunner } from './runners.js';
-export { a as BenchFunction, b as Benchmark, c as BenchmarkAPI, B as BenchmarkResult } from './chunks/benchmark.d.DAaHLpsq.js';
+import { T as Traces } from './chunks/rpc.d.7JZuxZ8u.js';
+export { R as RunnerRPC, a as RuntimeRPC } from './chunks/rpc.d.7JZuxZ8u.js';
+import { createChainable, matchesTags } from '@vitest/runner/utils';
 export { ExpectTypeOf, expectTypeOf } from 'expect-type';
-export { a as RunnerRPC, R as RuntimeRPC } from './chunks/rpc.d.B_8sPU0w.js';
 export { DiffOptions } from '@vitest/utils/diff';
-export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
+import * as chai from 'chai';
+export { chai };
+import 'tinyrainbow';
+import '@vitest/utils/display';
 import '@vitest/pretty-format';
 import 'vite/module-runner';
 import './chunks/environment.d.CrsxCzP1.js';
-import '@vitest/runner/utils';
+import './chunks/environment.d-DOJxxZV9.d.DOJxxZV9.js';
 
 interface SourceMap {
 	file: string;
@@ -624,6 +625,67 @@ interface VitestUtils {
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
 
+declare function getBenchOptions(key: Test): Options;
+declare function getBenchFn(key: Test): BenchFunction;
+declare const bench: BenchmarkAPI;
+
+declare class NodeBenchmarkRunner implements VitestRunner {
+	config: SerializedConfig;
+	private moduleRunner;
+	constructor(config: SerializedConfig);
+	importTinybench(): Promise<typeof tinybench>;
+	importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+	runSuite(suite: Suite): Promise<void>;
+	runTask(): Promise<void>;
+}
+
+declare class TestRunner implements VitestRunner {
+	config: SerializedConfig;
+	private snapshotClient;
+	private workerState;
+	private moduleRunner;
+	private cancelRun;
+	private assertionsErrors;
+	pool: string;
+	private _otel;
+	viteEnvironment: string;
+	private viteModuleRunner;
+	constructor(config: SerializedConfig);
+	importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+	onCollectStart(file: File): void;
+	onCleanupWorkerContext(listener: () => unknown): void;
+	onAfterRunFiles(): void;
+	onAfterRunSuite(suite: Suite): Promise<void>;
+	onAfterRunTask(test: Task): void;
+	cancel(_reason: CancelReason): void;
+	injectValue(key: string): any;
+	onBeforeRunTask(test: Task): Promise<void>;
+	onBeforeRunSuite(suite: Suite): Promise<void>;
+	onBeforeTryTask(test: Task): void;
+	onAfterTryTask(test: Test): void;
+	extendTaskContext(context: TestContext): TestContext;
+	getImportDurations(): Record<string, ImportDuration>;
+	trace: <T>(name: string, attributes: Record<string, any> | (() => T), cb?: () => T) => T;
+	__setTraces(traces: Traces): void;
+	static createTaskCollector: typeof createTaskCollector;
+	static getCurrentSuite: typeof getCurrentSuite;
+	static getCurrentTest: typeof getCurrentTest;
+	static createChainable: typeof createChainable;
+	static getSuiteHooks: typeof getHooks;
+	static getTestFn: typeof getFn;
+	static setSuiteHooks: typeof getHooks;
+	static setTestFn: typeof getFn;
+	static matchesTags: typeof matchesTags;
+	/**
+	* @deprecated
+	*/
+	static getBenchFn: typeof getBenchFn;
+	/**
+	* @deprecated
+	*/
+	static getBenchOptions: typeof getBenchOptions;
+}
+
 interface AssertType {
 	<T>(value: T): void;
 }
@@ -638,5 +700,5 @@ declare namespace Experimental {
 	export { ModuleDefinitionDiagnostic, ModuleDefinitionDurationsDiagnostic, ModuleDefinitionLocation, SourceModuleDiagnostic, SourceModuleLocations, UntrackedModuleDefinitionDiagnostic };
 }
 
-export { Experimental, LabelColor, ModuleGraphData, ProvidedContext, SerializedRootConfig, SerializedTestSpecification, Snapshots, UserConsoleLog, assert, assertType, createExpect, globalExpect as expect, inject, should, vi, vitest };
+export { AsyncExpectationResult as AsyncMatcherResult, BenchFunction, BenchmarkAPI, NodeBenchmarkRunner as BenchmarkRunner, DomainSnapshotAdapter, ExpectStatic, Experimental, LabelColor, ExpectationResult as MatcherResult, MatcherState, ModuleGraphData, ProvidedContext, SerializedConfig, SerializedRootConfig, SerializedTestSpecification, Snapshots, SyncExpectationResult as SyncMatcherResult, TestRunner, UserConsoleLog, assert, assertType, bench, createExpect, globalExpect as expect, inject, should, vi, vitest };
 export type { AssertType, BrowserUI, ExternalResult, TransformResultWithSource, VitestUtils, WebSocketEvents, WebSocketHandlers, WebSocketRPC };

package/dist/index.js

@@ -1,21 +1,23 @@
-export { N as BenchmarkRunner, S as Snapshots, T as TestRunner, a as assert, c as createExpect, g as expect, i as inject, s as should, v as vi, b as vitest } from './chunks/test.DNmyFkvJ.js';
-export { b as bench } from './chunks/benchmark.CX_oY03V.js';
-export { V as EvaluatedModules } from './chunks/evaluatedModules.Dg1zASAC.js';
-export { a as assertType } from './chunks/index.DdgEv5B1.js';
+export { N as BenchmarkRunner, S as Snapshots, T as TestRunner, a as assert, b as assertType, c as bench, d as createExpect, g as expect, e as inject, s as should, v as vi, f as vitest } from './chunks/index.D_7-4CaB.js';
+export { V as EvaluatedModules } from './chunks/rpc.DFRWVnRh.js';
 export { expectTypeOf } from 'expect-type';
 export { afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
-export { chai } from '@vitest/expect';
-import '@vitest/utils/helpers';
-import '@vitest/utils/timers';
+import * as chai from 'chai';
+export { chai };
 import './chunks/utils.BX5Fg8C4.js';
-import '@vitest/runner/utils';
-import '@vitest/utils/error';
-import 'pathe';
+import '@vitest/utils/timers';
 import '@vitest/spy';
+import '@vitest/utils/helpers';
 import '@vitest/utils/offset';
 import '@vitest/utils/source-map';
 import './chunks/_commonjsHelpers.D26ty3Ew.js';
-import './chunks/rpc.MzXet3jl.js';
-import './chunks/index.Chj8NDwU.js';
-import '@vitest/snapshot';
+import '@vitest/runner/utils';
+import '@vitest/utils/error';
+import './chunks/plugins.DrsmdUE2.js';
+import '@vitest/pretty-format';
+import '@vitest/utils/diff';
+import '@vitest/utils/display';
+import 'tinyrainbow';
+import 'pathe';
 import 'vite/module-runner';
+import './chunks/index.Chj8NDwU.js';

package/dist/module-evaluator.d.ts

@@ -1,10 +1,12 @@
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode } from 'vite/module-runner';
 import { V as VitestEvaluatedModules } from './chunks/evaluatedModules.d.BxJ5omdx.js';
 import vm from 'node:vm';
-import { R as RuntimeRPC } from './chunks/rpc.d.B_8sPU0w.js';
+import { a as RuntimeRPC } from './chunks/rpc.d.7JZuxZ8u.js';
 import '@vitest/runner';
-import '@vitest/snapshot';
-import './chunks/traces.d.D2T_R8rx.js';
+import './chunks/general.d.DFAHgpC2.js';
+import '@vitest/pretty-format';
+import '@vitest/utils';
+import './chunks/environment.d-DOJxxZV9.d.DOJxxZV9.js';
 
 type ModuleExecutionInfo = Map<string, ModuleExecutionInfoEntry>;
 interface ModuleExecutionInfoEntry {

package/dist/module-evaluator.js

@@ -2,7 +2,7 @@ import { isBuiltin, createRequire } from 'node:module';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import vm from 'node:vm';
 import { ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey } from 'vite/module-runner';
-import { T as Traces } from './chunks/traces.DT5aQ62U.js';
+import { Traces } from './traces.js';
 
 const performanceNow = performance.now.bind(performance);
 class ModuleDebug {

package/dist/node.d.ts

@@ -1,39 +1,40 @@
 import * as vite from 'vite';
-import { InlineConfig, UserConfig as UserConfig$1, Plugin, ResolvedConfig as ResolvedConfig$1, ViteDevServer, LogLevel, LoggerOptions, Logger as Logger$1 } from 'vite';
+import { InlineConfig, UserConfig as UserConfig$1, TransformResult, Plugin, ResolvedConfig as ResolvedConfig$1, ViteDevServer, LogLevel, LoggerOptions, Logger as Logger$1 } from 'vite';
 export { vite as Vite };
 export { esbuildVersion, isCSSRequest, isFileLoadingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from 'vite';
 import { IncomingMessage } from 'node:http';
-import { R as ResolvedConfig, e as UserConfig, f as VitestRunMode, g as VitestOptions, V as Vitest, A as ApiConfig, L as Logger, h as TestSpecification, T as TestProject, P as PoolWorker, i as PoolOptions, j as WorkerRequest, k as TestSequencer } from './chunks/reporters.d.CEnv6XRv.js';
-export { M as AgentReporter, B as BaseCoverageOptions, l as BaseReporter, m as BenchmarkBuiltinReporters, n as BenchmarkReporter, o as BenchmarkReportsMap, p as BenchmarkUserOptions, q as BrowserBuiltinProvider, r as BrowserCommand, s as BrowserCommandContext, t as BrowserConfigOptions, u as BrowserInstanceOption, v as BrowserModuleMocker, w as BrowserOrchestrator, x as BrowserProvider, y as BrowserProviderOption, z as BrowserScript, D as BrowserServerFactory, E as BrowserServerOptions, G as BrowserServerState, H as BrowserServerStateSession, J as BuiltinEnvironment, K as BuiltinReporterOptions, N as BuiltinReporters, O as CSSModuleScopeStrategy, Q as CoverageInstrumenter, S as CoverageIstanbulOptions, C as CoverageOptions, X as CoverageProvider, Y as CoverageProviderModule, Z as CoverageReporter, _ as CoverageV8Options, $ as CustomProviderOptions, a0 as DefaultReporter, a1 as DepsOptimizationOptions, a2 as DotReporter, a3 as EnvironmentOptions, a4 as GithubActionsReporter, a5 as HTMLOptions, a6 as HangingProcessReporter, I as InlineConfig, a7 as InstrumenterOptions, a8 as JUnitOptions, a9 as JUnitReporter, aa as JsonAssertionResult, ab as JsonOptions, ac as JsonReporter, ad as JsonTestResult, ae as JsonTestResults, M as MinimalReporter, af as ModuleDiagnostic, ag as OnServerRestartHandler, ah as OnTestsRerunHandler, ai as ParentProjectBrowser, aj as Pool, ak as PoolRunnerInitializer, al as PoolTask, am as ProjectBrowser, an as ProjectConfig, ao as ReportContext, ap as ReportedHookContext, aq as Reporter, ar as ReportersMap, as as ResolveSnapshotPathHandler, at as ResolveSnapshotPathHandlerContext, au as ResolvedBrowserOptions, av as ResolvedCoverageOptions, aw as ResolvedProjectConfig, ax as SerializedTestProject, ay as TapFlatReporter, az as TapReporter, aA as TaskOptions, aB as TestCase, aC as TestCollection, aD as TestDiagnostic, aE as TestModule, aF as TestModuleState, aG as TestResult, aH as TestResultFailed, aI as TestResultPassed, aJ as TestResultSkipped, aK as TestRunEndReason, aL as TestRunResult, aM as TestSequencerConstructor, aN as TestSpecificationOptions, aO as TestState, aP as TestSuite, aQ as TestSuiteState, aR as ToMatchScreenshotComparators, aS as ToMatchScreenshotOptions, aT as TypecheckConfig, U as UserWorkspaceConfig, aU as VerboseBenchmarkReporter, aV as VerboseReporter, aW as VitestEnvironment, aX as VitestPackageInstaller, W as WatcherTriggerPattern, aY as WorkerResponse, aZ as _BrowserNames, a_ as experimental_getRunnerTask } from './chunks/reporters.d.CEnv6XRv.js';
-export { C as CacheKeyIdGenerator, a as CacheKeyIdGeneratorContext, V as VitestPluginContext } from './chunks/plugin.d.BM2TCi12.js';
-export { BaseCoverageProvider } from './coverage.js';
+import { R as ResolvedConfig, U as UserConfig, V as VitestRunMode, a as VitestOptions, b as Vitest, A as ApiConfig, L as Logger, c as ResolvedCoverageOptions, C as CoverageMap, d as ReportContext, T as TestProject, e as TestSpecification, P as PoolWorker, f as PoolOptions, W as WorkerRequest, g as TestSequencer } from './chunks/plugin.d.cIKZEZ16.js';
+export { M as AgentReporter, B as BaseCoverageOptions, h as BaseReporter, i as BenchmarkBuiltinReporters, j as BenchmarkReporter, k as BenchmarkReportsMap, l as BenchmarkUserOptions, m as BrowserBuiltinProvider, n as BrowserCommand, o as BrowserCommandContext, p as BrowserConfigOptions, q as BrowserInstanceOption, r as BrowserModuleMocker, s as BrowserOrchestrator, t as BrowserProvider, u as BrowserProviderOption, v as BrowserScript, w as BrowserServerFactory, x as BrowserServerOptions, y as BrowserServerState, z as BrowserServerStateSession, D as BuiltinEnvironment, E as BuiltinReporterOptions, F as BuiltinReporters, G as CSSModuleScopeStrategy, H as CacheKeyIdGenerator, I as CacheKeyIdGeneratorContext, J as CoverageInstrumenter, K as CoverageIstanbulOptions, N as CoverageOptions, O as CoverageProvider, Q as CoverageProviderModule, S as CoverageReporter, X as CoverageV8Options, Y as CustomProviderOptions, Z as DefaultReporter, _ as DepsOptimizationOptions, $ as DotReporter, a0 as EnvironmentOptions, a1 as GithubActionsReporter, a2 as HTMLOptions, a3 as HangingProcessReporter, a4 as InlineConfig, a5 as InstrumenterOptions, a6 as JUnitOptions, a7 as JUnitReporter, a8 as JsonAssertionResult, a9 as JsonOptions, aa as JsonReporter, ab as JsonTestResult, ac as JsonTestResults, M as MinimalReporter, ad as ModuleDiagnostic, ae as OnServerRestartHandler, af as OnTestsRerunHandler, ag as ParentProjectBrowser, ah as Pool, ai as PoolRunnerInitializer, aj as PoolTask, ak as ProjectBrowser, al as ProjectConfig, am as Report, an as ReportedHookContext, ao as Reporter, ap as ReportersMap, aq as ResolveSnapshotPathHandler, ar as ResolveSnapshotPathHandlerContext, as as ResolvedBrowserOptions, at as ResolvedProjectConfig, au as SerializedTestProject, av as TapFlatReporter, aw as TapReporter, ax as TaskOptions, ay as TestCase, az as TestCollection, aA as TestDiagnostic, aB as TestModule, aC as TestModuleState, aD as TestResult, aE as TestResultFailed, aF as TestResultPassed, aG as TestResultSkipped, aH as TestRunEndReason, aI as TestRunResult, aJ as TestSequencerConstructor, aK as TestSpecificationOptions, aL as TestState, aM as TestSuite, aN as TestSuiteState, aO as ToMatchScreenshotComparators, aP as ToMatchScreenshotOptions, aQ as TypecheckConfig, aR as UserWorkspaceConfig, aS as VerboseBenchmarkReporter, aT as VerboseReporter, aU as VitestEnvironment, aV as VitestPackageInstaller, aW as VitestPluginContext, aX as WatcherTriggerPattern, aY as WorkerResponse, aZ as _BrowserNames, a_ as experimental_getRunnerTask } from './chunks/plugin.d.cIKZEZ16.js';
+import './chunks/browser.d.BUhkKcDl.js';
+import { A as AfterSuiteRunMeta } from './chunks/general.d.DFAHgpC2.js';
 import { Awaitable } from '@vitest/utils';
 export { SerializedError } from '@vitest/utils';
-import { R as RuntimeRPC } from './chunks/rpc.d.B_8sPU0w.js';
+import { a as RuntimeRPC } from './chunks/rpc.d.7JZuxZ8u.js';
 import { Writable } from 'node:stream';
-import { C as ContextRPC } from './chunks/worker.d.ZpHpO4yb.js';
-export { T as TestExecutionType } from './chunks/worker.d.ZpHpO4yb.js';
+import { C as ContextRPC } from './chunks/worker.d.Bu1kXGw4.js';
+export { T as TestExecutionType } from './chunks/worker.d.Bu1kXGw4.js';
 import { Debugger } from 'obug';
-import './chunks/global.d.DVsSRdQ5.js';
+import './chunks/global.d.DhbKSQoV.js';
 export { Task as RunnerTask, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
-export { c as RuntimeConfig } from './chunks/config.d.A1h_Y6Jt.js';
+export { b as RuntimeConfig } from './chunks/config.d.D91DHYaD.js';
 export { generateFileHash } from '@vitest/runner/utils';
 export { CDPSession } from 'vitest/browser';
-import './chunks/traces.d.D2T_R8rx.js';
-import './chunks/browser.d.BcoexmFG.js';
+import 'node:fs/promises';
+import '@vitest/runner/types';
 import '@vitest/pretty-format';
-import '@vitest/snapshot';
 import '@vitest/utils/diff';
-import '@vitest/expect';
+import 'chai';
 import 'vitest/optional-types.js';
-import './chunks/benchmark.d.DAaHLpsq.js';
-import 'tinybench';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
-import './chunks/coverage.d.BZtK59WP.js';
-import '@vitest/snapshot/manager';
+import './chunks/coverage.d.g2xbl2sP.js';
 import 'node:console';
 import 'node:fs';
+import '@vitest/spy';
+import 'tinyrainbow';
+import '@vitest/utils/display';
+import 'tinybench';
+import './chunks/environment.d-DOJxxZV9.d.DOJxxZV9.js';
 import 'vite/module-runner';
 import './chunks/environment.d.CrsxCzP1.js';
 
@@ -122,6 +123,100 @@ declare function parseCLI(argv: string | string[], config?: CliParseOptions): {
 */
 declare function resolveApiServerConfig<Options extends ApiConfig & Omit<UserConfig, "expect">>(options: Options, defaultPort: number, parentApi?: ApiConfig, logger?: Logger): ApiConfig | undefined;
 
+type Threshold = "lines" | "functions" | "statements" | "branches";
+interface ResolvedThreshold {
+	coverageMap: CoverageMap;
+	name: string;
+	thresholds: Partial<Record<Threshold, number | undefined>>;
+}
+/**
+* Holds info about raw coverage results that are stored on file system:
+*
+* ```json
+* "project-a": {
+*   "web": {
+*     "tests/math.test.ts": "coverage-1.json",
+*     "tests/utils.test.ts": "coverage-2.json",
+* //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
+*   },
+*   "ssr": { ... },
+*   "browser": { ... },
+* },
+* "project-b": ...
+* ```
+*/
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["environment"], {
+	[TestFilenames: string]: string;
+}>>;
+declare class BaseCoverageProvider {
+	ctx: Vitest;
+	readonly name: "v8" | "istanbul";
+	version: string;
+	options: ResolvedCoverageOptions;
+	globCache: Map<string, boolean>;
+	autoUpdateMarker: string;
+	coverageFiles: CoverageFiles;
+	pendingPromises: Promise<void>[];
+	coverageFilesDirectory: string;
+	roots: string[];
+	changedFiles?: string[];
+	_initialize(ctx: Vitest): void;
+	/**
+	* Check if file matches `coverage.include` but not `coverage.exclude`
+	*/
+	isIncluded(_filename: string, root?: string): boolean;
+	private getUntestedFilesByRoot;
+	getUntestedFiles(testedFiles: string[]): Promise<string[]>;
+	createCoverageMap(): CoverageMap;
+	generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
+	parseConfigModule(_: string): Promise<{
+		generate: () => {
+			code: string;
+		};
+	}>;
+	resolveOptions(): ResolvedCoverageOptions;
+	clean(clean?: boolean): Promise<void>;
+	private normalizeCoverageFileError;
+	onAfterSuiteRun({ coverage, environment, projectName, testFiles }: AfterSuiteRunMeta): void;
+	readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
+		/** Callback invoked with a single coverage result */
+		onFileRead: (data: CoverageType) => void;
+		/** Callback invoked once all results of a project for specific transform mode are read */
+		onFinished: (project: Vitest["projects"][number], environment: string) => Promise<void>;
+		onDebug: ((...logs: any[]) => void) & {
+			enabled: boolean;
+		};
+	}): Promise<void>;
+	cleanAfterRun(): Promise<void>;
+	onTestRunStart(): Promise<void>;
+	onTestFailure(): Promise<void>;
+	reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+	reportThresholds(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
+	/**
+	* Constructs collected coverage and users' threshold options into separate sets
+	* where each threshold set holds their own coverage maps. Threshold set is either
+	* for specific files defined by glob pattern or global for all other files.
+	*/
+	private resolveThresholds;
+	/**
+	* Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+	*/
+	private checkThresholds;
+	/**
+	* Check if current coverage is above configured thresholds and bump the thresholds if needed
+	*/
+	updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
+		thresholds: ResolvedThreshold[];
+		configurationFile: unknown;
+		onUpdate: () => void;
+	}): Promise<void>;
+	mergeReports(coverageMaps: unknown[]): Promise<void>;
+	hasTerminalReporter(reporters: ResolvedCoverageOptions["reporter"]): boolean;
+	toSlices<T>(array: T[], size: number): T[][];
+	transformFile(url: string, project: TestProject, viteEnvironment: string, isTransformedByVite?: boolean): Promise<TransformResult | null | undefined>;
+	createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<TransformResult | null | undefined>;
+}
+
 declare function createVitest(mode: VitestRunMode, options: CliOptions, viteOverrides?: UserConfig$1, vitestOptions?: VitestOptions): Promise<Vitest>;
 
 declare class FilesNotFoundError extends Error {
@@ -261,5 +356,5 @@ declare const createViteServer: typeof vite.createServer;
 
 declare const rolldownVersion: string | undefined;
 
-export { ApiConfig, BaseSequencer, ForksPoolWorker, GitNotFoundError, PoolOptions, PoolWorker, ResolvedConfig, TestProject, TestSequencer, TestSpecification, UserConfig as TestUserConfig, FilesNotFoundError as TestsNotFoundError, ThreadsPoolWorker, TypecheckPoolWorker, Vitest, VitestOptions, VitestPlugin, VitestRunMode, VmForksPoolWorker, VmThreadsPoolWorker, WorkerRequest, createDebugger, createMethodsRPC, createViteLogger, createViteServer, createVitest, distDir, escapeTestName, getFilePoolName, isFileServingAllowed, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rolldownVersion, rootDir, startVitest, version };
+export { ApiConfig, BaseCoverageProvider, BaseSequencer, ForksPoolWorker, GitNotFoundError, PoolOptions, PoolWorker, ReportContext, ResolvedConfig, ResolvedCoverageOptions, TestProject, TestSequencer, TestSpecification, UserConfig as TestUserConfig, FilesNotFoundError as TestsNotFoundError, ThreadsPoolWorker, TypecheckPoolWorker, Vitest, VitestOptions, VitestPlugin, VitestRunMode, VmForksPoolWorker, VmThreadsPoolWorker, WorkerRequest, createDebugger, createMethodsRPC, createViteLogger, createViteServer, createVitest, distDir, escapeTestName, getFilePoolName, isFileServingAllowed, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rolldownVersion, rootDir, startVitest, version };
 export type { CliOptions, CliParseOptions, ProcessPool, CollectLineNumbers as TypeCheckCollectLineNumbers, CollectLines as TypeCheckCollectLines, Context as TypeCheckContext, TscErrorInfo as TypeCheckErrorInfo, RawErrsMap as TypeCheckRawErrorsMap, RootAndTarget as TypeCheckRootAndTarget, WorkerContext };