vitest 4.1.5 → 5.0.0-beta.2

package/dist/chunks/{config.d.A1h_Y6Jt.d.ts → config.d.D91DHYaD.d.ts}

@@ -1,8 +1,8 @@
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SequenceHooks, SequenceSetupFiles, SerializableRetry, TestTagDefinition } from '@vitest/runner';
-import { SnapshotUpdateState, SnapshotEnvironment } from '@vitest/snapshot';
+import { L as LabelColor, g as SnapshotUpdateState } from './general.d.DFAHgpC2.js';
+import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.d.DOJxxZV9.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { L as LabelColor } from './traces.d.D2T_R8rx.js';
 
 /**
  * Names of clock methods that may be faked by install.
@@ -139,6 +139,7 @@ interface SerializedConfig {
 		showDiff?: boolean;
 		truncateThreshold?: number;
 	} | undefined;
+	taskTitleValueFormatTruncate: number;
 	api: {
 		allowExec: boolean | undefined;
 		allowWrite: boolean | undefined;
@@ -175,6 +176,11 @@ interface SerializedConfig {
 			actionTimeout?: number;
 		};
 		trace: BrowserTraceViewMode;
+		traceView: {
+			enabled: boolean;
+			recordCanvas: boolean;
+			inlineImages: boolean;
+		};
 		trackUnhandledErrors: boolean;
 		detailsPanelPosition: "right" | "bottom";
 	};
@@ -208,6 +214,7 @@ interface SerializedConfig {
 	tags: TestTagDefinition[];
 	tagsFilter: string[] | undefined;
 	strictTags: boolean;
+	mergeReportsLabel: string | undefined;
 	slowTestThreshold: number | undefined;
 	isAgent: boolean;
 }
@@ -217,6 +224,7 @@ interface SerializedCoverageConfig {
 	htmlDir: string | undefined;
 	enabled: boolean;
 	customProviderModule: string | undefined;
+	autoAttachSubprocess: boolean;
 }
 interface SerializedRootConfig extends SerializedConfig {
 	projects: SerializedConfig[];
@@ -229,4 +237,4 @@ type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookT
 type RuntimeOptions = Partial<RuntimeConfig>;
 type BrowserTraceViewMode = "on" | "off" | "on-first-retry" | "on-all-retries" | "retain-on-failure";
 
-export type { BrowserTraceViewMode as B, FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedConfig as S, SerializedCoverageConfig as a, SerializedRootConfig as b, RuntimeConfig as c };
+export type { BrowserTraceViewMode as B, FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedRootConfig as S, SerializedConfig as a, RuntimeConfig as b, SerializedCoverageConfig as c };

package/dist/chunks/{console.3WNpx0tS.js → console.B3IRP8fX.js}

@@ -3,8 +3,10 @@ import { relative } from 'node:path';
 import { Writable } from 'node:stream';
 import { getSafeTimers } from '@vitest/utils/timers';
 import c from 'tinyrainbow';
-import { R as RealDate } from './rpc.MzXet3jl.js';
+import { R as RealDate } from './rpc.DFRWVnRh.js';
 import { g as getWorkerState } from './utils.BX5Fg8C4.js';
+import 'pathe';
+import 'vite/module-runner';
 import './index.Chj8NDwU.js';
 
 const UNKNOWN_TEST_ID = "__vitest__unknown_test__";

package/dist/chunks/{constants.CPYnjOGj.js → constants.-juJ8b_4.js}

@@ -35,4 +35,4 @@ const globalApis = [
 	"aroundAll"
 ];
 
-export { API_PATH as A, defaultInspectPort as a, defaultPort as b, configFiles as c, defaultBrowserPort as d, globalApis as g };
+export { API_PATH as A, defaultPort as a, defaultInspectPort as b, configFiles as c, defaultBrowserPort as d, globalApis as g };

package/dist/chunks/{coverage.d.BZtK59WP.d.ts → coverage.d.g2xbl2sP.d.ts}

@@ -17,6 +17,10 @@ interface RuntimeCoverageProviderModule {
 	*/
 	startCoverage?: (runtimeOptions: {
 		isolate: boolean;
+		/** @internal */
+		autoAttachSubprocess: boolean;
+		/** @internal */
+		reportsDirectory: string;
 	}) => unknown | Promise<unknown>;
 	/**
 	* Executed on after each run in the worker thread. Possible to return a payload passed to the provider

package/dist/chunks/{creator.DgVhQm5q.js → creator.BqL2U_x4.js}

@@ -5,7 +5,7 @@ import { detectPackageManager, installPackage } from './index.CMESou6r.js';
 import { p as prompt, a as any } from './index.og1WyBLx.js';
 import { x } from 'tinyexec';
 import c from 'tinyrainbow';
-import { c as configFiles } from './constants.CPYnjOGj.js';
+import { c as configFiles } from './constants.-juJ8b_4.js';
 import 'node:process';
 import 'node:module';
 import 'node:url';

package/dist/chunks/{defaults.9aQKnqFk.js → defaults.szbHWQun.js}

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

package/dist/chunks/environment.d-DOJxxZV9.d.DOJxxZV9.d.ts

@@ -0,0 +1,17 @@
+import { ParsedStack } from '@vitest/utils';
+
+interface SnapshotEnvironment {
+	getVersion: () => string;
+	getHeader: () => string;
+	resolvePath: (filepath: string) => Promise<string>;
+	resolveRawPath: (testPath: string, rawPath: string) => Promise<string>;
+	saveSnapshotFile: (filepath: string, snapshot: string) => Promise<void>;
+	readSnapshotFile: (filepath: string) => Promise<string | null>;
+	removeSnapshotFile: (filepath: string) => Promise<void>;
+	processStackTrace?: (stack: ParsedStack) => ParsedStack;
+}
+interface SnapshotEnvironmentOptions {
+	snapshotsDirName?: string;
+}
+
+export type { SnapshotEnvironment as S, SnapshotEnvironmentOptions as a };

package/dist/chunks/general.d.DFAHgpC2.d.ts

@@ -0,0 +1,247 @@
+import { OptionsReceived, Plugin } from '@vitest/pretty-format';
+import { ParsedStack } from '@vitest/utils';
+import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.d.DOJxxZV9.js';
+
+interface DomainMatchResult {
+	pass: boolean;
+	message?: string;
+	/**
+	* The captured value viewed through the template's lens.
+	*
+	* Where the template uses patterns (e.g. regexes) or omits details,
+	* the resolved string adopts those patterns. Where the template doesn't
+	* match, the resolved string uses literal captured values instead.
+	*
+	* Used for two purposes:
+	* - **Diff display** (actual side): compared against `expected`
+	*   so the diff highlights only genuine mismatches, not pattern-vs-literal noise.
+	* - **Snapshot update** (`--update`): written as the new snapshot content,
+	*   preserving user-edited patterns from matched regions while incorporating
+	*   actual values for mismatched regions.
+	*
+	* When omitted, falls back to `render(capture(received))` (the raw rendered value).
+	*/
+	resolved?: string;
+	/**
+	* The stored template re-rendered as a string, representing what the user
+	* originally wrote or last saved.
+	*
+	* Used as the expected side in diff display.
+	*
+	* When omitted, falls back to the raw snapshot string from the snap file
+	* or inline snapshot.
+	*/
+	expected?: string;
+}
+interface DomainSnapshotAdapter<
+	Captured = unknown,
+	Expected = unknown
+> {
+	name: string;
+	capture: (received: unknown) => Captured;
+	render: (captured: Captured) => string;
+	parseExpected: (input: string) => Expected;
+	match: (captured: Captured, expected: Expected) => DomainMatchResult;
+}
+
+/**
+* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+declare class DefaultMap<
+	K,
+	V
+> extends Map<K, V> {
+	private defaultFn;
+	constructor(defaultFn: (key: K) => V, entries?: Iterable<readonly [K, V]>);
+	get(key: K): V;
+}
+declare class CounterMap<K> extends DefaultMap<K, number> {
+	constructor();
+	_total: number | undefined;
+	valueOf(): number;
+	increment(key: K): void;
+	total(): number;
+}
+
+interface SnapshotReturnOptions {
+	actual: string;
+	count: number;
+	expected?: string;
+	key: string;
+	pass: boolean;
+}
+interface SaveStatus {
+	deleted: boolean;
+	saved: boolean;
+}
+interface ExpectedSnapshot {
+	key: string;
+	count: number;
+	data?: string;
+	markAsChecked: () => void;
+}
+declare class SnapshotState {
+	testFilePath: string;
+	snapshotPath: string;
+	private _counters;
+	private _dirty;
+	private _updateSnapshot;
+	private _snapshotData;
+	private _initialData;
+	private _inlineSnapshots;
+	private _inlineSnapshotStacks;
+	private _testIdToKeys;
+	private _rawSnapshots;
+	private _uncheckedKeys;
+	private _snapshotFormat;
+	private _environment;
+	private _fileExists;
+	expand: boolean;
+	private _added;
+	private _matched;
+	private _unmatched;
+	private _updated;
+	get added(): CounterMap<string>;
+	set added(value: number);
+	get matched(): CounterMap<string>;
+	set matched(value: number);
+	get unmatched(): CounterMap<string>;
+	set unmatched(value: number);
+	get updated(): CounterMap<string>;
+	set updated(value: number);
+	private constructor();
+	static create(testFilePath: string, options: SnapshotStateOptions): Promise<SnapshotState>;
+	get snapshotUpdateState(): SnapshotUpdateState;
+	get environment(): SnapshotEnvironment;
+	markSnapshotsAsCheckedForTest(testName: string): void;
+	clearTest(testId: string): void;
+	protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
+	private _addSnapshot;
+	private _resolveKey;
+	private _resolveInlineStack;
+	private _reconcile;
+	save(): Promise<SaveStatus>;
+	getUncheckedCount(): number;
+	getUncheckedKeys(): Array<string>;
+	removeUncheckedKeys(): void;
+	probeExpectedSnapshot(options: Pick<SnapshotMatchOptions, "testName" | "testId" | "isInline" | "inlineSnapshot">): ExpectedSnapshot;
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }: SnapshotMatchOptions): SnapshotReturnOptions;
+	processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }: ProcessDomainSnapshotOptions): SnapshotReturnOptions;
+	pack(): Promise<SnapshotResult>;
+}
+
+type SnapshotData = Record<string, string>;
+type SnapshotUpdateState = "all" | "new" | "none";
+type SnapshotSerializer = Plugin;
+interface SnapshotStateOptions {
+	updateSnapshot: SnapshotUpdateState;
+	snapshotEnvironment: SnapshotEnvironment;
+	expand?: boolean;
+	snapshotFormat?: OptionsReceived;
+	resolveSnapshotPath?: (path: string, extension: string, context?: any) => string;
+}
+interface SnapshotMatchOptions {
+	testId: string;
+	testName: string;
+	received: unknown;
+	key?: string;
+	inlineSnapshot?: string;
+	isInline: boolean;
+	error?: Error;
+	rawSnapshot?: RawSnapshotInfo;
+	assertionName?: string;
+}
+interface ProcessDomainSnapshotOptions {
+	testId: string;
+	received: string;
+	expectedSnapshot: ExpectedSnapshot;
+	matchResult?: DomainMatchResult;
+	isInline?: boolean;
+	assertionName?: string;
+	error?: Error;
+}
+interface SnapshotResult {
+	filepath: string;
+	added: number;
+	fileDeleted: boolean;
+	matched: number;
+	unchecked: number;
+	uncheckedKeys: Array<string>;
+	unmatched: number;
+	updated: number;
+}
+interface UncheckedSnapshot {
+	filePath: string;
+	keys: Array<string>;
+}
+interface SnapshotSummary {
+	added: number;
+	didUpdate: boolean;
+	failure: boolean;
+	filesAdded: number;
+	filesRemoved: number;
+	filesRemovedList: Array<string>;
+	filesUnmatched: number;
+	filesUpdated: number;
+	matched: number;
+	total: number;
+	unchecked: number;
+	uncheckedKeysByFile: Array<UncheckedSnapshot>;
+	unmatched: number;
+	updated: number;
+}
+
+interface RawSnapshotInfo {
+	file: string;
+	readonly?: boolean;
+	content?: string;
+}
+
+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;
+}
+
+export { SnapshotState as i };
+export type { AfterSuiteRunMeta as A, DomainSnapshotAdapter as D, FetchCachedFileSystemResult as F, LabelColor as L, ModuleGraphData as M, ProvidedContext as P, ResolveFunctionResult as R, SnapshotData as S, UserConsoleLog as U, DomainMatchResult as a, SnapshotMatchOptions as b, SnapshotResult as c, SnapshotSerializer as d, SnapshotStateOptions as e, SnapshotSummary as f, SnapshotUpdateState as g, UncheckedSnapshot as h, AsyncLeak as j };

package/dist/chunks/{global.d.DVsSRdQ5.d.ts → global.d.DhbKSQoV.d.ts}

@@ -1,9 +1,7 @@
-import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
+import { P as PromisifyAssertion, T as Tester, E as ExpectStatic, l as BenchmarkResult } from './browser.d.BUhkKcDl.js';
 import { Plugin } from '@vitest/pretty-format';
 import { Test } from '@vitest/runner';
-import { SnapshotState } from '@vitest/snapshot';
-import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
-import { U as UserConsoleLog } from './traces.d.D2T_R8rx.js';
+import { i as SnapshotState, U as UserConsoleLog } from './general.d.DFAHgpC2.js';
 
 interface SnapshotMatcher<T> {
 	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;
@@ -13,7 +11,7 @@ interface InlineSnapshotMatcher<T> {
 	<U extends { [P in keyof T] : any }>(properties: Partial<U>, snapshot?: string, hint?: string): void;
 	(hint?: string): void;
 }
-declare module "@vitest/expect" {
+declare module "vitest" {
 	interface MatcherState {
 		environment: string;
 		snapshotState: SnapshotState;
@@ -86,6 +84,7 @@ declare module "@vitest/runner" {
 	interface TaskMeta {
 		typecheck?: boolean;
 		benchmark?: boolean;
+		__vitest_label__?: string;
 	}
 	interface File {
 		prepareDuration?: number;

package/dist/chunks/{globals.Dj1TGiMC.js → globals.EHmmu0nC.js}

@@ -1,24 +1,25 @@
-import { g as globalApis } from './constants.CPYnjOGj.js';
-import { i as index } from './index.DdgEv5B1.js';
-import './test.DNmyFkvJ.js';
+import { g as globalApis } from './constants.-juJ8b_4.js';
+import { i as index } from './index.D_7-4CaB.js';
 import '@vitest/runner';
-import '@vitest/utils/helpers';
-import '@vitest/utils/timers';
-import './benchmark.CX_oY03V.js';
-import '@vitest/runner/utils';
 import './utils.BX5Fg8C4.js';
-import '@vitest/expect';
-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 './_commonjsHelpers.D26ty3Ew.js';
-import './rpc.MzXet3jl.js';
-import './index.Chj8NDwU.js';
-import '@vitest/snapshot';
-import './evaluatedModules.Dg1zASAC.js';
+import './rpc.DFRWVnRh.js';
+import 'pathe';
 import 'vite/module-runner';
+import './index.Chj8NDwU.js';
+import 'chai';
+import '@vitest/runner/utils';
+import '@vitest/utils/error';
+import './plugins.DrsmdUE2.js';
+import '@vitest/pretty-format';
+import '@vitest/utils/diff';
+import '@vitest/utils/display';
+import 'tinyrainbow';
 import 'expect-type';
 
 function registerApiGlobally() {

package/dist/chunks/{index.DXx9Dtk7.js → index.CViWo__T.js}

@@ -1,9 +1,9 @@
-import { chai } from '@vitest/expect';
+import * as chai from 'chai';
 import { createHook } from 'node:async_hooks';
-import { l as loadDiffConfig, a as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.DYx3LtFI.js';
-import { r as rpc } from './rpc.MzXet3jl.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.Hpq30zVk.js';
+import { r as rpc } from './rpc.DFRWVnRh.js';
 import { g as getWorkerState } from './utils.BX5Fg8C4.js';
-import { T as TestRunner, N as NodeBenchmarkRunner } from './test.DNmyFkvJ.js';
+import { T as TestRunner, N as NodeBenchmarkRunner } from './index.D_7-4CaB.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
@@ -11,7 +11,7 @@ function setupChaiConfig(config) {
 
 async function resolveSnapshotEnvironment(config, moduleRunner) {
 	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.COQbm6gK.js');
+		const { VitestNodeSnapshotEnvironment } = await import('./node.CwFbQqI1.js');
 		return new VitestNodeSnapshotEnvironment();
 	}
 	const mod = await moduleRunner.import(config.snapshotEnvironment);