vitest 4.1.3 → 4.1.5

package/dist/chunks/{reporters.d.yJ2fBir5.d.ts → reporters.d.CEnv6XRv.d.ts}

@@ -1,17 +1,16 @@
 import { TaskMeta, Suite, File, SerializableRetry, TestAnnotation, TestArtifact, ImportDuration, Test, Task, TaskResultPack, FileSpecification, CancelReason, SequenceSetupFiles, SequenceHooks, TestTagDefinition } from '@vitest/runner';
 import { TestError, SerializedError, Arrayable, ParsedStack, Awaitable } from '@vitest/utils';
-import { A as AfterSuiteRunMeta, U as UserConsoleLog, b as AsyncLeak, P as ProvidedContext, L as LabelColor } from './rpc.d.BFMWpdph.js';
+import { a as AfterSuiteRunMeta, U as UserConsoleLog, A as AsyncLeak, P as ProvidedContext, O as OTELCarrier, L as LabelColor } from './traces.d.D2T_R8rx.js';
 import { Writable } from 'node:stream';
 import { DevEnvironment, TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
-import { S as SerializedTestSpecification, c as SourceModuleDiagnostic, B as BrowserTesterOptions } from './browser.d.C0zGu1u9.js';
-import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.ChUh6-ad.js';
+import { b as SerializedRootConfig, B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.A1h_Y6Jt.js';
+import { S as SerializedTestSpecification, c as SourceModuleDiagnostic, B as BrowserTesterOptions } from './browser.d.BcoexmFG.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
 import { chai } from '@vitest/expect';
 import { happyDomTypes, jsdomTypes } from 'vitest/optional-types.js';
-import { c as ContextTestEnvironment, d as WorkerExecuteContext, e as WorkerTestEnvironment } from './worker.d.CckNUvI5.js';
-import { O as OTELCarrier } from './traces.d.402V_yFI.js';
+import { c as ContextTestEnvironment, d as WorkerExecuteContext, e as WorkerTestEnvironment } from './worker.d.ZpHpO4yb.js';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
@@ -98,19 +97,19 @@ declare class TestSpecification {
 	/**
 	* Line numbers of the test locations to run.
 	*/
-	readonly testLines: number[] | undefined;
+	testLines: number[] | undefined;
 	/**
 	* Regular expression pattern to filter test names.
 	*/
-	readonly testNamePattern: RegExp | undefined;
+	testNamePattern: RegExp | undefined;
 	/**
 	* The ids of tasks inside of this specification to run.
 	*/
-	readonly testIds: string[] | undefined;
+	testIds: string[] | undefined;
 	/**
 	* The tags of tests to run.
 	*/
-	readonly testTagsFilter: string[] | undefined;
+	testTagsFilter: string[] | undefined;
 	/**
 	* Test module associated with the specification. This will be `undefined` if tests have not been run yet.
 	*/
@@ -827,6 +826,33 @@ interface CoverageOptions {
 	*/
 	ignoreClassMethods?: string[];
 	/**
+	* Custom instrumenter factory to use instead of the default `istanbul-lib-instrument`.
+	*
+	* The factory receives the same runtime coverage options Vitest passes to its
+	* built-in Istanbul instrumenter and must return an object implementing the
+	* `CoverageInstrumenter` interface.
+	*
+	* This allows using faster instrumenters (e.g., oxc-coverage-instrument, SWC) while
+	* keeping the Istanbul coverage pipeline for collection, merging, and reporting.
+	*
+	* @example
+	* ```ts
+	* import { defineConfig } from 'vitest/config'
+	* import { createOxcInstrumenter } from 'oxc-coverage-instrument/vitest'
+	*
+	* export default defineConfig({
+	*   test: {
+	*     coverage: {
+	*       provider: 'istanbul',
+	*       instrumenter: options => createOxcInstrumenter(options),
+	*     }
+	*   }
+	* })
+	*
+	* @experimental
+	*/
+	instrumenter?: (options: InstrumenterOptions) => CoverageInstrumenter;
+	/**
 	* Directory of HTML coverage output to be served in UI mode and HTML reporter.
 	* This is automatically configured for builtin reporter with html output (`html`, `html-spa`, and `lcov` reporters).
 	* Use this option to override with custom coverage reporting location.
@@ -863,6 +889,34 @@ interface Thresholds {
 	/** Thresholds for lines */
 	lines?: number;
 }
+/**
+* Options passed to the custom instrumenter factory.
+*/
+interface InstrumenterOptions {
+	/** Global variable name that Vitest uses to store coverage data at runtime. */
+	coverageVariable: string;
+	/** Global scope where the coverage variable is attached at runtime. */
+	coverageGlobalScope: string;
+	/** Whether the coverage global scope should be resolved through an evaluated function. */
+	coverageGlobalScopeFunc: boolean;
+	/** Class method names to exclude from function coverage. */
+	ignoreClassMethods: string[];
+}
+/**
+* Interface for custom coverage instrumenters.
+*
+* Matches the subset of istanbul-lib-instrument's `Instrumenter` that Vitest
+* actually uses. Implement this to plug in a faster instrumenter while keeping
+* the Istanbul coverage pipeline for collection, merging, and reporting.
+*/
+interface CoverageInstrumenter {
+	/** Instrument source code synchronously. Returns the instrumented code string. */
+	instrumentSync: (code: string, filename: string, inputSourceMap?: any) => string;
+	/** Get the source map of the last instrumented file. */
+	lastSourceMap: () => any;
+	/** Get the Istanbul-compatible file coverage object of the last instrumented file. */
+	lastFileCoverage: () => any;
+}
 /** @deprecated Use `CoverageOptions` instead */
 interface CoverageV8Options extends CoverageOptions {}
 /** @deprecated Use `CoverageOptions` instead */
@@ -1272,6 +1326,7 @@ declare class Vitest {
 	* Return project that has the root (or "global") config.
 	*/
 	getRootProject(): TestProject;
+	get serializedRootConfig(): SerializedRootConfig;
 	getProjectByName(name: string): TestProject;
 	/**
 	* Import a file using Vite module runner. The file will be transformed by Vite and executed in a separate context.
@@ -2268,6 +2323,8 @@ interface JsonTestResults {
 }
 interface JsonOptions {
 	outputFile?: string;
+	/** @experimental */
+	filterMeta?: (key: string, value: unknown) => unknown;
 }
 declare class JsonReporter implements Reporter {
 	start: number;
@@ -2328,14 +2385,6 @@ declare class JUnitReporter implements Reporter {
 	onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
 }
 
-declare class AgentReporter extends DefaultReporter {
-	renderSucceed: boolean;
-	constructor(options?: DefaultReporterOptions);
-	onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
-	protected printTestModule(testModule: TestModule): void;
-	protected printTestCase(moduleState: TestModuleState, test: TestCase): void;
-}
-
 declare class DotReporter extends BaseReporter {
 	private renderer?;
 	private tests;
@@ -2358,6 +2407,14 @@ declare class HangingProcessReporter implements Reporter {
 	onProcessTimeout(): void;
 }
 
+declare class MinimalReporter extends DefaultReporter {
+	renderSucceed: boolean;
+	constructor(options?: DefaultReporterOptions);
+	onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
+	protected printTestModule(testModule: TestModule): void;
+	protected printTestCase(moduleState: TestModuleState, test: TestCase): void;
+}
+
 declare class TapReporter implements Reporter {
 	protected ctx: Vitest;
 	private logger;
@@ -2421,7 +2478,8 @@ type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
 
 declare const ReportersMap: {
 	default: typeof DefaultReporter;
-	agent: typeof AgentReporter;
+	agent: typeof MinimalReporter;
+	minimal: typeof MinimalReporter;
 	blob: typeof BlobReporter;
 	verbose: typeof VerboseReporter;
 	dot: typeof DotReporter;
@@ -2436,6 +2494,7 @@ declare const ReportersMap: {
 type BuiltinReporters = keyof typeof ReportersMap;
 interface BuiltinReporterOptions {
 	"default": DefaultReporterOptions;
+	"minimal": DefaultReporterOptions;
 	"agent": DefaultReporterOptions;
 	"verbose": DefaultReporterOptions;
 	"dot": BaseOptions;
@@ -3548,5 +3607,5 @@ type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
 });
 type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 
-export { DefaultReporter as $, Logger as L, TestProject as T, Vitest as V, DotReporter as a1, GithubActionsReporter as a3, HangingProcessReporter as a5, JUnitReporter as a7, TestCollection as aA, TestModule as aC, TestSuite as aN, VerboseBenchmarkReporter as aS, VerboseReporter as aT, VitestPackageInstaller as aV, experimental_getRunnerTask as aY, CoverageMap as aZ, JsonReporter as aa, ReportersMap as ap, TapFlatReporter as aw, TapReporter as ax, TestCase as az, TestSpecification as h, AgentReporter as l, BaseReporter as m, BenchmarkReporter as o, BenchmarkReportsMap as p };
-export type { ApiConfig as A, BaseCoverageOptions as B, CoverageOptions as C, BrowserScript as D, BrowserServerFactory as E, FieldsWithDefaultValues as F, BrowserServerOptions as G, BrowserServerState as H, InlineConfig as I, BrowserServerStateSession as J, BuiltinEnvironment as K, BuiltinReporterOptions as M, BuiltinReporters as N, CSSModuleScopeStrategy as O, PoolWorker as P, CoverageIstanbulOptions as Q, ResolvedConfig as R, CoverageProvider as S, UserWorkspaceConfig as U, WatcherTriggerPattern as W, CoverageProviderModule as X, CoverageReporter as Y, CoverageV8Options as Z, CustomProviderOptions as _, TestProjectConfiguration as a, DepsOptimizationOptions as a0, EnvironmentOptions as a2, HTMLOptions as a4, JUnitOptions as a6, JsonAssertionResult as a8, JsonOptions as a9, TestDiagnostic as aB, TestModuleState as aD, TestResult as aE, TestResultFailed as aF, TestResultPassed as aG, TestResultSkipped as aH, TestRunEndReason as aI, TestRunResult as aJ, TestSequencerConstructor as aK, TestSpecificationOptions as aL, TestState as aM, TestSuiteState as aO, ToMatchScreenshotComparators as aP, ToMatchScreenshotOptions as aQ, TypecheckConfig as aR, VitestEnvironment as aU, WorkerResponse as aW, _BrowserNames as aX, JsonTestResult as ab, JsonTestResults as ac, ModuleDiagnostic as ad, OnServerRestartHandler as ae, OnTestsRerunHandler as af, ParentProjectBrowser as ag, Pool as ah, PoolRunnerInitializer as ai, PoolTask as aj, ProjectBrowser as ak, ProjectConfig as al, ReportContext as am, ReportedHookContext as an, Reporter as ao, ResolveSnapshotPathHandler as aq, ResolveSnapshotPathHandlerContext as ar, ResolvedBrowserOptions as as, ResolvedCoverageOptions as at, ResolvedProjectConfig as au, SerializedTestProject as av, TaskOptions as ay, UserProjectConfigFn as b, UserProjectConfigExport as c, TestProjectInlineConfiguration as d, UserConfig as e, VitestRunMode as f, VitestOptions as g, PoolOptions as i, WorkerRequest as j, TestSequencer as k, BenchmarkBuiltinReporters as n, BenchmarkUserOptions as q, BrowserBuiltinProvider as r, BrowserCommand as s, BrowserCommandContext as t, BrowserConfigOptions as u, BrowserInstanceOption as v, BrowserModuleMocker as w, BrowserOrchestrator as x, BrowserProvider as y, BrowserProviderOption as z };
+export { Logger as L, MinimalReporter as M, TestProject as T, Vitest as V, CoverageMap as a$, DefaultReporter as a0, DotReporter as a2, GithubActionsReporter as a4, HangingProcessReporter as a6, JUnitReporter as a9, TestCase as aB, TestCollection as aC, TestModule as aE, TestSuite as aP, VerboseBenchmarkReporter as aU, VerboseReporter as aV, VitestPackageInstaller as aX, experimental_getRunnerTask as a_, JsonReporter as ac, ReportersMap as ar, TapFlatReporter as ay, TapReporter as az, TestSpecification as h, BaseReporter as l, BenchmarkReporter as n, BenchmarkReportsMap as o };
+export type { CustomProviderOptions as $, ApiConfig as A, BaseCoverageOptions as B, CoverageOptions as C, BrowserServerFactory as D, BrowserServerOptions as E, FieldsWithDefaultValues as F, BrowserServerState as G, BrowserServerStateSession as H, InlineConfig as I, BuiltinEnvironment as J, BuiltinReporterOptions as K, BuiltinReporters as N, CSSModuleScopeStrategy as O, PoolWorker as P, CoverageInstrumenter as Q, ResolvedConfig as R, CoverageIstanbulOptions as S, UserWorkspaceConfig as U, WatcherTriggerPattern as W, CoverageProvider as X, CoverageProviderModule as Y, CoverageReporter as Z, CoverageV8Options as _, TestProjectConfiguration as a, DepsOptimizationOptions as a1, EnvironmentOptions as a3, HTMLOptions as a5, InstrumenterOptions as a7, JUnitOptions as a8, TaskOptions as aA, TestDiagnostic as aD, TestModuleState as aF, TestResult as aG, TestResultFailed as aH, TestResultPassed as aI, TestResultSkipped as aJ, TestRunEndReason as aK, TestRunResult as aL, TestSequencerConstructor as aM, TestSpecificationOptions as aN, TestState as aO, TestSuiteState as aQ, ToMatchScreenshotComparators as aR, ToMatchScreenshotOptions as aS, TypecheckConfig as aT, VitestEnvironment as aW, WorkerResponse as aY, _BrowserNames as aZ, JsonAssertionResult as aa, JsonOptions as ab, JsonTestResult as ad, JsonTestResults as ae, ModuleDiagnostic as af, OnServerRestartHandler as ag, OnTestsRerunHandler as ah, ParentProjectBrowser as ai, Pool as aj, PoolRunnerInitializer as ak, PoolTask as al, ProjectBrowser as am, ProjectConfig as an, ReportContext as ao, ReportedHookContext as ap, Reporter as aq, ResolveSnapshotPathHandler as as, ResolveSnapshotPathHandlerContext as at, ResolvedBrowserOptions as au, ResolvedCoverageOptions as av, ResolvedProjectConfig as aw, SerializedTestProject as ax, UserProjectConfigFn as b, UserProjectConfigExport as c, TestProjectInlineConfiguration as d, UserConfig as e, VitestRunMode as f, VitestOptions as g, PoolOptions as i, WorkerRequest as j, TestSequencer as k, BenchmarkBuiltinReporters as m, BenchmarkUserOptions as p, BrowserBuiltinProvider as q, BrowserCommand as r, BrowserCommandContext as s, BrowserConfigOptions as t, BrowserInstanceOption as u, BrowserModuleMocker as v, BrowserOrchestrator as w, BrowserProvider as x, BrowserProviderOption as y, BrowserScript as z };

package/dist/chunks/{rpc.d.BFMWpdph.d.ts → rpc.d.B_8sPU0w.d.ts}

@@ -1,49 +1,7 @@
 import { File, TestArtifact, TaskResultPack, TaskEventPack, CancelReason } from '@vitest/runner';
 import { SnapshotResult } from '@vitest/snapshot';
 import { FetchFunctionOptions, FetchResult } from 'vite/module-runner';
-import { O as OTELCarrier } from './traces.d.402V_yFI.js';
-
-interface AfterSuiteRunMeta {
-	coverage?: unknown;
-	testFiles: string[];
-	environment: string;
-	projectName?: string;
-}
-interface UserConsoleLog {
-	content: string;
-	origin?: string;
-	browser?: boolean;
-	type: "stdout" | "stderr";
-	taskId?: string;
-	time: number;
-	size: number;
-}
-interface ModuleGraphData {
-	graph: Record<string, string[]>;
-	externalized: string[];
-	inlined: string[];
-}
-interface ProvidedContext {}
-interface ResolveFunctionResult {
-	id: string;
-	file: string;
-	url: string;
-}
-interface FetchCachedFileSystemResult {
-	cached: true;
-	tmp: string;
-	id: string;
-	file: string | null;
-	url: string;
-	invalidate: boolean;
-}
-type LabelColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
-interface AsyncLeak {
-	filename: string;
-	projectName: string;
-	stack: string;
-	type: string;
-}
+import { O as OTELCarrier, F as FetchCachedFileSystemResult, R as ResolveFunctionResult, U as UserConsoleLog, A as AsyncLeak, a as AfterSuiteRunMeta } from './traces.d.D2T_R8rx.js';
 
 interface RuntimeRPC {
 	fetch: (id: string, importer: string | undefined, environment: string, options?: FetchFunctionOptions, otelCarrier?: OTELCarrier) => Promise<FetchResult | FetchCachedFileSystemResult>;
@@ -69,4 +27,4 @@ interface RunnerRPC {
 	onCancel: (reason: CancelReason) => void;
 }
 
-export type { AfterSuiteRunMeta as A, LabelColor as L, ModuleGraphData as M, ProvidedContext as P, RuntimeRPC as R, UserConsoleLog as U, RunnerRPC as a, AsyncLeak as b };
+export type { RuntimeRPC as R, RunnerRPC as a };

package/dist/chunks/{setup-common.NdrZGMhw.js → setup-common.DYx3LtFI.js}

@@ -26,7 +26,7 @@ async function setupCommonEnv(config) {
 	if (globalSetup) return;
 	globalSetup = true;
 	setSafeTimers();
-	if (config.globals) (await import('./globals.7B-4LHAF.js')).registerApiGlobally();
+	if (config.globals) (await import('./globals.Dj1TGiMC.js')).registerApiGlobally();
 }
 function setupDefines(config) {
 	for (const key in config.defines) globalThis[key] = config.defines[key];

package/dist/chunks/{test.BmQO5GaM.js → test.DNmyFkvJ.js}

@@ -3552,7 +3552,7 @@ function createVitest() {
 		waitUntil,
 		defineHelper: (fn) => {
 			return function __VITEST_HELPER__(...args) {
-				const result = fn(...args);
+				const result = fn.apply(this, args);
 				if (result && typeof result === "object" && typeof result.then === "function") return (async function __VITEST_HELPER__() {
 					return await result;
 				})();
@@ -3715,6 +3715,10 @@ function createExpectPoll(expect) {
 		// @ts-expect-error private poll access
 		const assertion = expect(null, message).withContext({ poll: true });
 		fn = fn.bind(assertion);
+		// injected so that domain snapshot can take over poll implementation.
+		chai.util.flag(assertion, "_poll.fn", fn);
+		chai.util.flag(assertion, "_poll.timeout", timeout);
+		chai.util.flag(assertion, "_poll.interval", interval);
 		const test = chai.util.flag(assertion, "vitest-test");
 		if (!test) throw new Error("expect.poll() must be called inside a test");
 		const proxy = new Proxy(assertion, { get(target, key, receiver) {
@@ -3722,17 +3726,50 @@ function createExpectPoll(expect) {
 			if (typeof assertionFunction !== "function") return assertionFunction instanceof chai.Assertion ? proxy : assertionFunction;
 			if (key === "assert") return assertionFunction;
 			if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
-			return function(...args) {
+			// Core poll stack-trace trick:
+			//   1. capture STACK_TRACE_ERROR here before entering the async poll loop
+			//   2. when the matcher eventually fails, rethrow via throwWithCause()
+			//      so the final error keeps this earlier stack
+			//
+			// For example, when user writes:
+			//    await expect.poll(...).toBeSomething()
+			// STACK_TRACE_ERROR.stack would look like
+			//   at ...(more internal stacks)...
+			//   at __VITEST_POLL_CHAIN__ .../packages/vitest/dist/...
+			//   at .../my-file.test.ts:12:3   (this points to `toBeSomething()` callsite in user test file)
+			// Vitest later filters out internal stacks from `vitest/dist`, so the reported errors correctly
+			// points to the user callsite for poll assertion errors.
+			//
+			// Inline snapshots piggyback on the same idea. We pass
+			// STACK_TRACE_ERROR through `chai.util.flag(assertion, 'error', ...)`.
+			// Inline snapshot assertion access the same error stack for
+			// extracting inline snapshot location to validate and update new snapshots.
+			return function __VITEST_POLL_CHAIN__(...args) {
 				const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
 				const promise = async () => {
+					chai.util.flag(assertion, "_name", key);
+					chai.util.flag(assertion, "error", STACK_TRACE_ERROR);
+					const onSettled = chai.util.flag(assertion, "_poll.onSettled");
+					if (Object.getOwnPropertyDescriptor(assertionFunction, "__vitest_poll_takeover__")?.value) try {
+						const output = await assertionFunction.call(assertion, ...args);
+						await onSettled?.({
+							assertion,
+							status: "pass"
+						});
+						return output;
+					} catch (err) {
+						await onSettled?.({
+							assertion,
+							status: "fail"
+						});
+						throwWithCause(err, STACK_TRACE_ERROR);
+					}
 					const { setTimeout, clearTimeout } = getSafeTimers();
 					let executionPhase = "fn";
 					let hasTimedOut = false;
 					const timerId = setTimeout(() => {
 						hasTimedOut = true;
 					}, timeout);
-					chai.util.flag(assertion, "_name", key);
-					const onSettled = chai.util.flag(assertion, "_poll.onSettled");
 					try {
 						while (true) {
 							const isLastAttempt = hasTimedOut;
@@ -3847,7 +3884,7 @@ const SnapshotPlugin = (chai, utils) => {
 			assertion: this,
 			received: utils.flag(this, "object"),
 			...normalizeArguments(propertiesOrHint, hint)
-		}));
+		}), chai.util.flag(this, "message"));
 	}));
 	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(filepath, hint) {
 		// set name manually since it's not wrapped by wrapAssertion
@@ -3859,7 +3896,7 @@ const SnapshotPlugin = (chai, utils) => {
 			received: utils.flag(this, "object"),
 			filepath,
 			hint
-		}).then((result) => assertMatchResult(result));
+		}).then((result) => assertMatchResult(result, chai.util.flag(this, "message")));
 		return recordAsyncExpect(getTest(this), assertPromise, createAssertionMessage(utils, this, true), /* @__PURE__ */ new Error("resolves"), utils.flag(this, "soft"));
 	});
 	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", wrapAssertion(utils, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
@@ -3868,7 +3905,7 @@ const SnapshotPlugin = (chai, utils) => {
 			received: utils.flag(this, "object"),
 			isInline: true,
 			...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)
-		}));
+		}), chai.util.flag(this, "message"));
 	}));
 	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", wrapAssertion(utils, "toThrowErrorMatchingSnapshot", function(propertiesOrHint, hint) {
 		validateAssertion(this);
@@ -3878,7 +3915,7 @@ const SnapshotPlugin = (chai, utils) => {
 			assertion: this,
 			received: getError(received, promise),
 			...normalizeArguments(propertiesOrHint, hint)
-		}));
+		}), chai.util.flag(this, "message"));
 	}));
 	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", wrapAssertion(utils, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshotOrHint, hint) {
 		validateAssertion(this);
@@ -3889,10 +3926,43 @@ const SnapshotPlugin = (chai, utils) => {
 			received: getError(received, promise),
 			isInline: true,
 			...normalizeInlineArguments(void 0, inlineSnapshotOrHint, hint)
-		}));
+		}), chai.util.flag(this, "message"));
 	}));
 	utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
+function toMatchDomainSnapshotImpl(opts) {
+	const { assertion } = opts;
+	validateAssertion(assertion);
+	const assertionName = getAssertionName(assertion);
+	const test = getTest(assertion);
+	let { inlineSnapshot } = opts;
+	if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+	const pollFn = chai.util.flag(assertion, "_poll.fn");
+	if (pollFn) return getSnapshotClient().pollMatchDomain({
+		poll: pollFn,
+		adapter: opts.adapter,
+		message: opts.hint,
+		isInline: opts.isInline,
+		errorMessage: chai.util.flag(assertion, "message"),
+		timeout: chai.util.flag(assertion, "_poll.timeout"),
+		interval: chai.util.flag(assertion, "_poll.interval"),
+		assertionName,
+		inlineSnapshot,
+		error: chai.util.flag(assertion, "error"),
+		...getTestNames(test)
+	});
+	return getSnapshotClient().matchDomain({
+		received: opts.received,
+		adapter: opts.adapter,
+		message: opts.hint,
+		isInline: opts.isInline,
+		errorMessage: chai.util.flag(assertion, "message"),
+		assertionName,
+		inlineSnapshot,
+		error: chai.util.flag(assertion, "error"),
+		...getTestNames(test)
+	});
+}
 // toMatchSnapshot(propertiesOrHint?, hint?)
 function normalizeArguments(propertiesOrHint, hint) {
 	if (typeof propertiesOrHint === "string") return { hint: propertiesOrHint };
@@ -3929,7 +3999,6 @@ function toMatchSnapshotImpl(options) {
 		message: options.hint,
 		isInline: options.isInline,
 		inlineSnapshot: options.inlineSnapshot,
-		errorMessage: chai.util.flag(assertion, "message"),
 		assertionName,
 		error: chai.util.flag(assertion, "error"),
 		...getTestNames(test)
@@ -3945,7 +4014,6 @@ async function toMatchFileSnapshotImpl(options) {
 	return getSnapshotClient().match({
 		received: options.received,
 		message: options.hint,
-		errorMessage: chai.util.flag(assertion, "message"),
 		rawSnapshot: {
 			file: rawSnapshotFile,
 			content: rawSnapshotContent ?? void 0
@@ -3953,12 +4021,15 @@ async function toMatchFileSnapshotImpl(options) {
 		...testNames
 	});
 }
-function assertMatchResult(result) {
-	if (!result.pass) throw Object.assign(new Error(result.message()), {
-		actual: result.actual,
-		expected: result.expected,
-		diffOptions: { expand: getWorkerState().config.snapshotOptions.expand }
-	});
+function assertMatchResult(result, customMessage) {
+	if (!result.pass) {
+		const errorMessage = (customMessage ? `${customMessage}: ` : "") + result.message();
+		throw Object.assign(new Error(errorMessage), {
+			actual: result.actual,
+			expected: result.expected,
+			diffOptions: { expand: getWorkerState().config.snapshotOptions.expand }
+		});
+	}
 }
 /**
 * Composable snapshot matcher helpers for building custom snapshot matchers
@@ -3970,14 +4041,14 @@ function assertMatchResult(result) {
 const Snapshots = {
 	toMatchSnapshot(received, propertiesOrHint, hint) {
 		return toMatchSnapshotImpl({
-			assertion: this.__vitest_assertion__,
+			assertion: this.assertion,
 			received,
 			...normalizeArguments(propertiesOrHint, hint)
 		});
 	},
 	toMatchInlineSnapshot(received, propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
 		return toMatchSnapshotImpl({
-			assertion: this.__vitest_assertion__,
+			assertion: this.assertion,
 			received,
 			isInline: true,
 			...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)
@@ -3985,11 +4056,27 @@ const Snapshots = {
 	},
 	toMatchFileSnapshot(received, filepath, hint) {
 		return toMatchFileSnapshotImpl({
-			assertion: this.__vitest_assertion__,
+			assertion: this.assertion,
 			received,
 			filepath,
 			hint
 		});
+	},
+	toMatchDomainSnapshot(domain, received) {
+		return toMatchDomainSnapshotImpl({
+			assertion: this.assertion,
+			adapter: domain,
+			received
+		});
+	},
+	toMatchDomainInlineSnapshot(domain, received, inlineSnapshot) {
+		return toMatchDomainSnapshotImpl({
+			assertion: this.assertion,
+			adapter: domain,
+			received,
+			isInline: true,
+			inlineSnapshot
+		});
 	}
 };
 

package/dist/chunks/traces.d.D2T_R8rx.d.ts

@@ -0,0 +1,60 @@
+interface AfterSuiteRunMeta {
+	coverage?: unknown;
+	testFiles: string[];
+	environment: string;
+	projectName?: string;
+}
+interface UserConsoleLog {
+	content: string;
+	origin?: string;
+	browser?: boolean;
+	type: "stdout" | "stderr";
+	taskId?: string;
+	time: number;
+	size: number;
+}
+interface ModuleGraphData {
+	graph: Record<string, string[]>;
+	externalized: string[];
+	inlined: string[];
+}
+interface ProvidedContext {}
+interface ResolveFunctionResult {
+	id: string;
+	file: string;
+	url: string;
+}
+interface FetchCachedFileSystemResult {
+	cached: true;
+	tmp: string;
+	id: string;
+	file: string | null;
+	url: string;
+	invalidate: boolean;
+}
+type LabelColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+interface AsyncLeak {
+	filename: string;
+	projectName: string;
+	stack: string;
+	type: string;
+}
+
+interface OTELCarrier {
+	traceparent?: string;
+	tracestate?: string;
+}
+interface TracesOptions {
+	enabled: boolean;
+	watchMode?: boolean;
+	sdkPath?: string;
+	tracerName?: string;
+}
+declare class Traces {
+	#private;
+	constructor(options: TracesOptions);
+	isEnabled(): boolean;
+}
+
+export { Traces as T };
+export type { AsyncLeak as A, FetchCachedFileSystemResult as F, LabelColor as L, ModuleGraphData as M, OTELCarrier as O, ProvidedContext as P, ResolveFunctionResult as R, UserConsoleLog as U, AfterSuiteRunMeta as a };

package/dist/chunks/{utils.DK8FXp4T.js → utils.BS4fH3nR.js}

@@ -138,7 +138,7 @@ function formatProjectName(project, suffix = " ") {
 }
 function withLabel(color, label, message) {
 	const bgColor = `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
-	return `${c.bold(c[bgColor](` ${label} `))} ${message ? c[color](message) : ""}`;
+	return `${c.bold(c.black(c[bgColor](` ${label} `)))} ${message ? c[color](message) : ""}`;
 }
 function padSummaryTitle(str) {
 	return c.dim(`${str.padStart(11)} `);

package/dist/chunks/{worker.d.CckNUvI5.d.ts → worker.d.ZpHpO4yb.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.ChUh6-ad.js';
+import { S as SerializedConfig } from './config.d.A1h_Y6Jt.js';
 import { E as Environment } from './environment.d.CrsxCzP1.js';
-import { R as RuntimeRPC, a as RunnerRPC } from './rpc.d.BFMWpdph.js';
+import { R as RuntimeRPC, a as RunnerRPC } from './rpc.d.B_8sPU0w.js';
 
 //#region src/messages.d.ts
 declare const TYPE_REQUEST: "q";

package/dist/cli.js

@@ -1,4 +1,4 @@
-import { c as createCLI } from './chunks/cac.Bb7YBzMA.js';
+import { c as createCLI } from './chunks/cac.DJJmV0dT.js';
 import '@vitest/utils/helpers';
 import 'events';
 import 'pathe';

package/dist/config.d.ts

@@ -1,19 +1,19 @@
 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.yJ2fBir5.js';
-export { a as TestProjectConfiguration, d as TestProjectInlineConfiguration, e as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.yJ2fBir5.js';
-import { V as VitestPluginContext } from './chunks/plugin.d.BssAumYw.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d.ChUh6-ad.js';
+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';
 export { TestTagDefinition } from '@vitest/runner';
 import '@vitest/utils';
-import './chunks/rpc.d.BFMWpdph.js';
-import '@vitest/snapshot';
-import 'vite/module-runner';
-import './chunks/traces.d.402V_yFI.js';
+import './chunks/traces.d.D2T_R8rx.js';
 import 'node:stream';
-import './chunks/browser.d.C0zGu1u9.js';
-import './chunks/worker.d.CckNUvI5.js';
+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 '@vitest/pretty-format';
 import '@vitest/utils/diff';
 import '@vitest/expect';

package/dist/coverage.d.ts

@@ -1,18 +1,18 @@
-import { V as Vitest, at as ResolvedCoverageOptions, aZ as CoverageMap, am as ReportContext, T as TestProject } from './chunks/reporters.d.yJ2fBir5.js';
+import { V as Vitest, av as ResolvedCoverageOptions, a$ as CoverageMap, ao as ReportContext, T as TestProject } from './chunks/reporters.d.CEnv6XRv.js';
 import { TransformResult } from 'vite';
-import { A as AfterSuiteRunMeta } from './chunks/rpc.d.BFMWpdph.js';
+import { a as AfterSuiteRunMeta } from './chunks/traces.d.D2T_R8rx.js';
 import '@vitest/runner';
 import '@vitest/utils';
 import 'node:stream';
-import './chunks/browser.d.C0zGu1u9.js';
-import './chunks/traces.d.402V_yFI.js';
-import './chunks/worker.d.CckNUvI5.js';
-import 'vite/module-runner';
-import './chunks/config.d.ChUh6-ad.js';
+import './chunks/config.d.A1h_Y6Jt.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
+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/expect';
 import 'vitest/optional-types.js';
 import './chunks/benchmark.d.DAaHLpsq.js';
@@ -79,6 +79,7 @@ declare class BaseCoverageProvider {
 	}>;
 	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 */