@vitest/snapshot 4.1.2 → 4.1.4

package/dist/index.d.ts

@@ -1,86 +1,8 @@
-import { S as SnapshotStateOptions, a as SnapshotMatchOptions, b as SnapshotResult, R as RawSnapshotInfo } from './rawSnapshot.d-U2kJUxDr.js';
-export { c as SnapshotData, d as SnapshotSerializer, e as SnapshotSummary, f as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot.d-U2kJUxDr.js';
-import { ParsedStack } from '@vitest/utils';
-import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
+import { S as SnapshotState, a as SnapshotStateOptions, b as SnapshotResult, R as RawSnapshotInfo, D as DomainSnapshotAdapter } from './rawSnapshot.d-D_X3-62x.js';
+export { c as DomainMatchResult, d as SnapshotData, e as SnapshotMatchOptions, f as SnapshotSerializer, g as SnapshotSummary, h as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot.d-D_X3-62x.js';
 import { Plugin, Plugins } from '@vitest/pretty-format';
-
-/**
-* 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;
-}
-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 environment(): SnapshotEnvironment;
-	markSnapshotsAsCheckedForTest(testName: string): void;
-	clearTest(testId: string): void;
-	protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
-	private _addSnapshot;
-	save(): Promise<SaveStatus>;
-	getUncheckedCount(): number;
-	getUncheckedKeys(): Array<string>;
-	removeUncheckedKeys(): void;
-	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot }: SnapshotMatchOptions): SnapshotReturnOptions;
-	pack(): Promise<SnapshotResult>;
-}
+export { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
+import '@vitest/utils';
 
 interface AssertOptions {
 	received: unknown;
@@ -98,6 +20,23 @@ interface AssertOptions {
 	error?: Error;
 	errorMessage?: string;
 	rawSnapshot?: RawSnapshotInfo;
+	assertionName?: string;
+}
+interface AssertDomainOptions extends Omit<AssertOptions, "received"> {
+	received: unknown;
+	adapter: DomainSnapshotAdapter<any, any>;
+}
+interface AssertDomainPollOptions extends Omit<AssertDomainOptions, "received"> {
+	poll: () => Promise<unknown> | unknown;
+	timeout?: number;
+	interval?: number;
+}
+/** Same shape as expect.extend custom matcher result (SyncExpectationResult from @vitest/expect) */
+interface MatchResult {
+	pass: boolean;
+	message: () => string;
+	actual?: unknown;
+	expected?: unknown;
 }
 interface SnapshotClientOptions {
 	isEqual?: (received: unknown, expected: unknown) => boolean;
@@ -111,7 +50,10 @@ declare class SnapshotClient {
 	skipTest(filepath: string, testName: string): void;
 	clearTest(filepath: string, testId: string): void;
 	getSnapshotState(filepath: string): SnapshotState;
+	match(options: AssertOptions): MatchResult;
 	assert(options: AssertOptions): void;
+	matchDomain(options: AssertDomainOptions): MatchResult;
+	pollMatchDomain(options: AssertDomainPollOptions): Promise<MatchResult>;
 	assertRaw(options: AssertOptions): Promise<void>;
 	clear(): void;
 }
@@ -128,4 +70,5 @@ declare function stripSnapshotIndentation(inlineSnapshot: string): string;
 declare function addSerializer(plugin: Plugin): void;
 declare function getSerializers(): Plugins;
 
-export { SnapshotClient, SnapshotEnvironment, SnapshotMatchOptions, SnapshotResult, SnapshotState, SnapshotStateOptions, addSerializer, getSerializers, stripSnapshotIndentation };
+export { DomainSnapshotAdapter, SnapshotClient, SnapshotResult, SnapshotState, SnapshotStateOptions, addSerializer, getSerializers, stripSnapshotIndentation };
+export type { MatchResult };

package/dist/index.js

@@ -1,171 +1,8 @@
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
-import { getCallLastIndex, isObject } from '@vitest/utils/helpers';
+import { isObject, getCallLastIndex } from '@vitest/utils/helpers';
 import { positionToOffset, offsetToLineNumber, lineSplitRE } from '@vitest/utils/offset';
 import { plugins, format } from '@vitest/pretty-format';
 
-async function saveInlineSnapshots(environment, snapshots) {
-	const MagicString = (await import('magic-string')).default;
-	const files = new Set(snapshots.map((i) => i.file));
-	await Promise.all(Array.from(files).map(async (file) => {
-		const snaps = snapshots.filter((i) => i.file === file);
-		const code = await environment.readSnapshotFile(file);
-		if (code == null) {
-			throw new Error(`cannot read ${file} when saving inline snapshot`);
-		}
-		const s = new MagicString(code);
-		for (const snap of snaps) {
-			const index = positionToOffset(code, snap.line, snap.column);
-			replaceInlineSnap(code, s, index, snap.snapshot);
-		}
-		const transformed = s.toString();
-		if (transformed !== code) {
-			await environment.saveSnapshotFile(file, transformed);
-		}
-	}));
-}
-const startObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
-function replaceObjectSnap(code, s, index, newSnap) {
-	let _code = code.slice(index);
-	const startMatch = startObjectRegex.exec(_code);
-	if (!startMatch) {
-		return false;
-	}
-	_code = _code.slice(startMatch.index);
-	let callEnd = getCallLastIndex(_code);
-	if (callEnd === null) {
-		return false;
-	}
-	callEnd += index + startMatch.index;
-	const shapeStart = index + startMatch.index + startMatch[0].length;
-	const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
-	const snap = `, ${prepareSnapString(newSnap, code, index)}`;
-	if (shapeEnd === callEnd) {
-		// toMatchInlineSnapshot({ foo: expect.any(String) })
-		s.appendLeft(callEnd, snap);
-	} else {
-		// toMatchInlineSnapshot({ foo: expect.any(String) }, ``)
-		s.overwrite(shapeEnd, callEnd, snap);
-	}
-	return true;
-}
-function getObjectShapeEndIndex(code, index) {
-	let startBraces = 1;
-	let endBraces = 0;
-	while (startBraces !== endBraces && index < code.length) {
-		const s = code[index++];
-		if (s === "{") {
-			startBraces++;
-		} else if (s === "}") {
-			endBraces++;
-		}
-	}
-	return index;
-}
-function prepareSnapString(snap, source, index) {
-	const lineNumber = offsetToLineNumber(source, index);
-	const line = source.split(lineSplitRE)[lineNumber - 1];
-	const indent = line.match(/^\s*/)[0] || "";
-	const indentNext = indent.includes("	") ? `${indent}\t` : `${indent}  `;
-	const lines = snap.trim().replace(/\\/g, "\\\\").split(/\n/g);
-	const isOneline = lines.length <= 1;
-	const quote = "`";
-	if (isOneline) {
-		return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
-	}
-	return `${quote}\n${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}\n${indent}${quote}`;
-}
-const toMatchInlineName = "toMatchInlineSnapshot";
-const toThrowErrorMatchingInlineName = "toThrowErrorMatchingInlineSnapshot";
-// on webkit, the line number is at the end of the method, not at the start
-function getCodeStartingAtIndex(code, index) {
-	const indexInline = index - toMatchInlineName.length;
-	if (code.slice(indexInline, index) === toMatchInlineName) {
-		return {
-			code: code.slice(indexInline),
-			index: indexInline
-		};
-	}
-	const indexThrowInline = index - toThrowErrorMatchingInlineName.length;
-	if (code.slice(index - indexThrowInline, index) === toThrowErrorMatchingInlineName) {
-		return {
-			code: code.slice(index - indexThrowInline),
-			index: index - indexThrowInline
-		};
-	}
-	return {
-		code: code.slice(index),
-		index
-	};
-}
-const startRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
-function replaceInlineSnap(code, s, currentIndex, newSnap) {
-	const { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex);
-	const startMatch = startRegex.exec(codeStartingAtIndex);
-	const firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(codeStartingAtIndex);
-	if (!startMatch || startMatch.index !== firstKeywordMatch?.index) {
-		return replaceObjectSnap(code, s, index, newSnap);
-	}
-	const quote = startMatch[1];
-	const startIndex = index + startMatch.index + startMatch[0].length;
-	const snapString = prepareSnapString(newSnap, code, index);
-	if (quote === ")") {
-		s.appendRight(startIndex - 1, snapString);
-		return true;
-	}
-	const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
-	const endMatch = quoteEndRE.exec(code.slice(startIndex));
-	if (!endMatch) {
-		return false;
-	}
-	const endIndex = startIndex + endMatch.index + endMatch[0].length;
-	s.overwrite(startIndex - 1, endIndex, snapString);
-	return true;
-}
-const INDENTATION_REGEX = /^([^\S\n]*)\S/m;
-function stripSnapshotIndentation(inlineSnapshot) {
-	// Find indentation if exists.
-	const match = inlineSnapshot.match(INDENTATION_REGEX);
-	if (!match || !match[1]) {
-		// No indentation.
-		return inlineSnapshot;
-	}
-	const indentation = match[1];
-	const lines = inlineSnapshot.split(/\n/g);
-	if (lines.length <= 2) {
-		// Must be at least 3 lines.
-		return inlineSnapshot;
-	}
-	if (lines[0].trim() !== "" || lines.at(-1)?.trim() !== "") {
-		// If not blank first and last lines, abort.
-		return inlineSnapshot;
-	}
-	for (let i = 1; i < lines.length - 1; i++) {
-		if (lines[i] !== "") {
-			if (lines[i].indexOf(indentation) !== 0) {
-				// All lines except first and last should either be blank or have the same
-				// indent as the first line (or more). If this isn't the case we don't
-				// want to touch the snapshot at all.
-				return inlineSnapshot;
-			}
-			lines[i] = lines[i].substring(indentation.length);
-		}
-	}
-	// Last line is a special case because it won't have the same indent as others
-	// but may still have been given some indent to line up.
-	lines[lines.length - 1] = "";
-	// Return inline snapshot, now at indent 0.
-	inlineSnapshot = lines.join("\n");
-	return inlineSnapshot;
-}
-
-async function saveRawSnapshots(environment, snapshots) {
-	await Promise.all(snapshots.map(async (snap) => {
-		if (!snap.readonly) {
-			await environment.saveSnapshotFile(snap.file, snap.snapshot);
-		}
-	}));
-}
-
 function getDefaultExportFromCjs(x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -448,6 +285,188 @@ class CounterMap extends DefaultMap {
 		return total;
 	}
 }
+/* @__NO_SIDE_EFFECTS__ */
+function memo(fn) {
+	const cache = new Map();
+	return (arg) => {
+		if (!cache.has(arg)) {
+			cache.set(arg, fn(arg));
+		}
+		return cache.get(arg);
+	};
+}
+
+async function saveInlineSnapshots(environment, snapshots) {
+	const MagicString = (await import('magic-string')).default;
+	const files = new Set(snapshots.map((i) => i.file));
+	await Promise.all(Array.from(files).map(async (file) => {
+		const snaps = snapshots.filter((i) => i.file === file);
+		const code = await environment.readSnapshotFile(file);
+		if (code == null) {
+			throw new Error(`cannot read ${file} when saving inline snapshot`);
+		}
+		const s = new MagicString(code);
+		for (const snap of snaps) {
+			const index = positionToOffset(code, snap.line, snap.column);
+			replaceInlineSnap(code, s, index, snap.snapshot, snap.assertionName);
+		}
+		const transformed = s.toString();
+		if (transformed !== code) {
+			await environment.saveSnapshotFile(file, transformed);
+		}
+	}));
+}
+const defaultStartObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
+function escapeRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const buildStartObjectRegex = memo((assertionName) => {
+	const replaced = defaultStartObjectRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
+	return new RegExp(replaced);
+});
+function replaceObjectSnap(code, s, index, newSnap, assertionName) {
+	let _code = code.slice(index);
+	const regex = assertionName ? buildStartObjectRegex(assertionName) : defaultStartObjectRegex;
+	const startMatch = regex.exec(_code);
+	if (!startMatch) {
+		return false;
+	}
+	_code = _code.slice(startMatch.index);
+	let callEnd = getCallLastIndex(_code);
+	if (callEnd === null) {
+		return false;
+	}
+	callEnd += index + startMatch.index;
+	const shapeStart = index + startMatch.index + startMatch[0].length;
+	const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
+	const snap = `, ${prepareSnapString(newSnap, code, index)}`;
+	if (shapeEnd === callEnd) {
+		// toMatchInlineSnapshot({ foo: expect.any(String) })
+		s.appendLeft(callEnd, snap);
+	} else {
+		// toMatchInlineSnapshot({ foo: expect.any(String) }, ``)
+		s.overwrite(shapeEnd, callEnd, snap);
+	}
+	return true;
+}
+function getObjectShapeEndIndex(code, index) {
+	let startBraces = 1;
+	let endBraces = 0;
+	while (startBraces !== endBraces && index < code.length) {
+		const s = code[index++];
+		if (s === "{") {
+			startBraces++;
+		} else if (s === "}") {
+			endBraces++;
+		}
+	}
+	return index;
+}
+function prepareSnapString(snap, source, index) {
+	const lineNumber = offsetToLineNumber(source, index);
+	const line = source.split(lineSplitRE)[lineNumber - 1];
+	const indent = line.match(/^\s*/)[0] || "";
+	const indentNext = indent.includes("	") ? `${indent}\t` : `${indent}  `;
+	const lines = snap.trim().replace(/\\/g, "\\\\").split(/\n/g);
+	const isOneline = lines.length <= 1;
+	const quote = "`";
+	if (isOneline) {
+		return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
+	}
+	return `${quote}\n${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}\n${indent}${quote}`;
+}
+const defaultMethodNames = ["toMatchInlineSnapshot", "toThrowErrorMatchingInlineSnapshot"];
+// on webkit, the line number is at the end of the method, not at the start
+function getCodeStartingAtIndex(code, index, methodNames) {
+	for (const name of methodNames) {
+		const adjusted = index - name.length;
+		if (adjusted >= 0 && code.slice(adjusted, index) === name) {
+			return {
+				code: code.slice(adjusted),
+				index: adjusted
+			};
+		}
+	}
+	return {
+		code: code.slice(index),
+		index
+	};
+}
+const defaultStartRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
+const buildStartRegex = memo((assertionName) => {
+	const replaced = defaultStartRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
+	return new RegExp(replaced);
+});
+function replaceInlineSnap(code, s, currentIndex, newSnap, assertionName) {
+	const methodNames = assertionName ? [assertionName] : defaultMethodNames;
+	const { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex, methodNames);
+	const startRegex = assertionName ? buildStartRegex(assertionName) : defaultStartRegex;
+	const startMatch = startRegex.exec(codeStartingAtIndex);
+	const keywordRegex = assertionName ? new RegExp(escapeRegExp(assertionName)) : /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/;
+	const firstKeywordMatch = keywordRegex.exec(codeStartingAtIndex);
+	if (!startMatch || startMatch.index !== firstKeywordMatch?.index) {
+		return replaceObjectSnap(code, s, index, newSnap, assertionName);
+	}
+	const quote = startMatch[1];
+	const startIndex = index + startMatch.index + startMatch[0].length;
+	const snapString = prepareSnapString(newSnap, code, index);
+	if (quote === ")") {
+		s.appendRight(startIndex - 1, snapString);
+		return true;
+	}
+	const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
+	const endMatch = quoteEndRE.exec(code.slice(startIndex));
+	if (!endMatch) {
+		return false;
+	}
+	const endIndex = startIndex + endMatch.index + endMatch[0].length;
+	s.overwrite(startIndex - 1, endIndex, snapString);
+	return true;
+}
+const INDENTATION_REGEX = /^([^\S\n]*)\S/m;
+function stripSnapshotIndentation(inlineSnapshot) {
+	// Find indentation if exists.
+	const match = inlineSnapshot.match(INDENTATION_REGEX);
+	if (!match || !match[1]) {
+		// No indentation.
+		return inlineSnapshot;
+	}
+	const indentation = match[1];
+	const lines = inlineSnapshot.split(/\n/g);
+	if (lines.length <= 2) {
+		// Must be at least 3 lines.
+		return inlineSnapshot;
+	}
+	if (lines[0].trim() !== "" || lines.at(-1)?.trim() !== "") {
+		// If not blank first and last lines, abort.
+		return inlineSnapshot;
+	}
+	for (let i = 1; i < lines.length - 1; i++) {
+		if (lines[i] !== "") {
+			if (lines[i].indexOf(indentation) !== 0) {
+				// All lines except first and last should either be blank or have the same
+				// indent as the first line (or more). If this isn't the case we don't
+				// want to touch the snapshot at all.
+				return inlineSnapshot;
+			}
+			lines[i] = lines[i].substring(indentation.length);
+		}
+	}
+	// Last line is a special case because it won't have the same indent as others
+	// but may still have been given some indent to line up.
+	lines[lines.length - 1] = "";
+	// Return inline snapshot, now at indent 0.
+	inlineSnapshot = lines.join("\n");
+	return inlineSnapshot;
+}
+
+async function saveRawSnapshots(environment, snapshots) {
+	await Promise.all(snapshots.map(async (snap) => {
+		if (!snap.readonly) {
+			await environment.saveSnapshotFile(snap.file, snap.snapshot);
+		}
+	}));
+}
 
 function isSameStackPosition(x, y) {
 	return x.file === y.file && x.column === y.column && x.line === y.line;
@@ -523,6 +542,9 @@ class SnapshotState {
 		const content = await options.snapshotEnvironment.readSnapshotFile(snapshotPath);
 		return new SnapshotState(testFilePath, snapshotPath, content, options);
 	}
+	get snapshotUpdateState() {
+		return this._updateSnapshot;
+	}
 	get environment() {
 		return this._environment;
 	}
@@ -564,6 +586,11 @@ class SnapshotState {
 		if (promiseIndex !== -1) {
 			return stacks[promiseIndex + 3];
 		}
+		// support poll + inline snapshot
+		const pollChainIndex = stacks.findIndex((i) => i.method.match(/__VITEST_POLL_CHAIN__/));
+		if (pollChainIndex !== -1) {
+			return stacks[pollChainIndex + 1];
+		}
 		// inline snapshot function can be named __INLINE_SNAPSHOT_OFFSET_<n>__
 		// to specify a custom stack offset
 		for (let i = 0; i < stacks.length; i++) {
@@ -572,6 +599,12 @@ class SnapshotState {
 				return stacks[i + Number(match[1])] ?? null;
 			}
 		}
+		// custom matcher registered via expect.extend() — the wrapper function
+		// in jest-extend.ts is named __VITEST_EXTEND_ASSERTION__
+		const customMatcherIndex = stacks.findIndex((i) => i.method.includes("__VITEST_EXTEND_ASSERTION__"));
+		if (customMatcherIndex !== -1) {
+			return stacks[customMatcherIndex + 3] ?? null;
+		}
 		// inline snapshot function is called __INLINE_SNAPSHOT__
 		// in integrations/snapshot/chai.ts
 		const stackIndex = stacks.findIndex((i) => i.method.includes("__INLINE_SNAPSHOT__"));
@@ -581,9 +614,10 @@ class SnapshotState {
 		this._dirty = true;
 		if (options.stack) {
 			this._inlineSnapshots.push({
+				...options.stack,
 				snapshot: receivedSerialized,
 				testId: options.testId,
-				...options.stack
+				assertionName: options.assertionName
 			});
 		} else if (options.rawSnapshot) {
 			this._rawSnapshots.push({
@@ -594,6 +628,114 @@ class SnapshotState {
 			this._snapshotData[key] = receivedSerialized;
 		}
 	}
+	_resolveKey(testId, testName, key) {
+		this._counters.increment(testName);
+		const count = this._counters.get(testName);
+		if (!key) {
+			key = testNameToKey(testName, count);
+		}
+		this._testIdToKeys.get(testId).push(key);
+		return {
+			key,
+			count
+		};
+	}
+	_resolveInlineStack(options) {
+		const { testId, snapshot, assertionName, error } = options;
+		const stacks = parseErrorStacktrace(error, { ignoreStackEntries: [] });
+		const _stack = this._inferInlineSnapshotStack(stacks);
+		if (!_stack) {
+			const message = stacks.map((s) => `  ${s.file}:${s.line}:${s.column}${s.method ? ` (${s.method})` : ""}`).join("\n");
+			throw new Error(`@vitest/snapshot: Couldn't infer stack frame for inline snapshot.\n${message}`);
+		}
+		const stack = this.environment.processStackTrace?.(_stack) || _stack;
+		// removing 1 column, because source map points to the wrong
+		// location for js files, but `column-1` points to the same in both js/ts
+		// https://github.com/vitejs/vite/issues/8657
+		stack.column--;
+		// reject multiple inline snapshots at the same location if snapshot is different
+		const snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s) => isSameStackPosition(s, stack));
+		if (snapshotsWithSameStack.length > 0) {
+			// ensure only one snapshot will be written at the same location
+			this._inlineSnapshots = this._inlineSnapshots.filter((s) => !isSameStackPosition(s, stack));
+			const differentSnapshot = snapshotsWithSameStack.find((s) => s.snapshot !== snapshot);
+			if (differentSnapshot) {
+				throw Object.assign(new Error(`${assertionName} with different snapshots cannot be called at the same location`), {
+					actual: snapshot,
+					expected: differentSnapshot.snapshot
+				});
+			}
+		}
+		this._inlineSnapshotStacks.push({
+			...stack,
+			testId,
+			snapshot
+		});
+		return stack;
+	}
+	_reconcile(opts) {
+		// These are the conditions on when to write snapshots:
+		//  * There's no snapshot file in a non-CI environment.
+		//  * There is a snapshot file and we decided to update the snapshot.
+		//  * There is a snapshot file, but it doesn't have this snapshot.
+		// These are the conditions on when not to write snapshots:
+		//  * The update flag is set to 'none'.
+		//  * There's no snapshot file or a file without this snapshot on a CI environment.
+		if (opts.hasSnapshot && this._updateSnapshot === "all" || (!opts.hasSnapshot || !opts.snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
+			if (this._updateSnapshot === "all") {
+				if (!opts.pass) {
+					if (opts.hasSnapshot) {
+						this.updated.increment(opts.testId);
+					} else {
+						this.added.increment(opts.testId);
+					}
+					this._addSnapshot(opts.key, opts.addValue, {
+						stack: opts.stack,
+						testId: opts.testId,
+						rawSnapshot: opts.rawSnapshot,
+						assertionName: opts.assertionName
+					});
+				} else {
+					this.matched.increment(opts.testId);
+				}
+			} else {
+				this._addSnapshot(opts.key, opts.addValue, {
+					stack: opts.stack,
+					testId: opts.testId,
+					rawSnapshot: opts.rawSnapshot,
+					assertionName: opts.assertionName
+				});
+				this.added.increment(opts.testId);
+			}
+			return {
+				actual: "",
+				count: opts.count,
+				expected: "",
+				key: opts.key,
+				pass: true
+			};
+		} else {
+			if (!opts.pass) {
+				this.unmatched.increment(opts.testId);
+				return {
+					actual: opts.actualDisplay,
+					count: opts.count,
+					expected: opts.expectedDisplay,
+					key: opts.key,
+					pass: false
+				};
+			} else {
+				this.matched.increment(opts.testId);
+				return {
+					actual: "",
+					count: opts.count,
+					expected: "",
+					key: opts.key,
+					pass: true
+				};
+			}
+		}
+	}
 	async save() {
 		const hasExternalSnapshots = Object.keys(this._snapshotData).length;
 		const hasInlineSnapshots = this._inlineSnapshots.length;
@@ -637,14 +779,24 @@ class SnapshotState {
 			this._uncheckedKeys.clear();
 		}
 	}
-	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot }) {
-		// this also increments counter for inline snapshots. maybe we shouldn't?
-		this._counters.increment(testName);
-		const count = this._counters.get(testName);
-		if (!key) {
-			key = testNameToKey(testName, count);
-		}
-		this._testIdToKeys.get(testId).push(key);
+	probeExpectedSnapshot(options) {
+		const count = this._counters.get(options.testName) + 1;
+		const key = testNameToKey(options.testName, count);
+		return {
+			key,
+			count,
+			data: options?.isInline ? options.inlineSnapshot : this._snapshotData[key],
+			markAsChecked: () => {
+				this._counters.increment(options.testName);
+				this._testIdToKeys.get(options.testId).push(key);
+				this._uncheckedKeys.delete(key);
+			}
+		};
+	}
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }) {
+		const resolved = this._resolveKey(testId, testName, key);
+		key = resolved.key;
+		const count = resolved.count;
 		// Do not mark the snapshot as "checked" if the snapshot is inline and
 		// there's an external snapshot. This way the external snapshot can be
 		// removed with `--updateSnapshot`.
@@ -667,105 +819,57 @@ class SnapshotState {
 		const hasSnapshot = expected !== undefined;
 		const snapshotIsPersisted = isInline || this._fileExists || rawSnapshot && rawSnapshot.content != null;
 		if (pass && !isInline && !rawSnapshot) {
-			// Executing a snapshot file as JavaScript and writing the strings back
-			// when other snapshots have changed loses the proper escaping for some
-			// characters. Since we check every snapshot in every test, use the newly
-			// generated formatted string.
-			// Note that this is only relevant when a snapshot is added and the dirty
-			// flag is set.
+			// When the file is re-saved (because other snapshots changed), the JS
+			// round-trip can lose proper escaping. Refresh in-memory data with the
+			// freshly serialized string so the file is written correctly.
+			// _reconcile does not write _snapshotData on pass, so this is the only
+			// place it gets refreshed. Domain snapshots skip this because the stored
+			// value may contain match patterns that differ from the received output.
 			this._snapshotData[key] = receivedSerialized;
 		}
-		// find call site of toMatchInlineSnapshot
-		let stack;
-		if (isInline) {
-			const stacks = parseErrorStacktrace(error || new Error("snapshot"), { ignoreStackEntries: [] });
-			const _stack = this._inferInlineSnapshotStack(stacks);
-			if (!_stack) {
-				throw new Error(`@vitest/snapshot: Couldn't infer stack frame for inline snapshot.\n${JSON.stringify(stacks)}`);
-			}
-			stack = this.environment.processStackTrace?.(_stack) || _stack;
-			// removing 1 column, because source map points to the wrong
-			// location for js files, but `column-1` points to the same in both js/ts
-			// https://github.com/vitejs/vite/issues/8657
-			stack.column--;
-			// reject multiple inline snapshots at the same location if snapshot is different
-			const snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s) => isSameStackPosition(s, stack));
-			if (snapshotsWithSameStack.length > 0) {
-				// ensure only one snapshot will be written at the same location
-				this._inlineSnapshots = this._inlineSnapshots.filter((s) => !isSameStackPosition(s, stack));
-				const differentSnapshot = snapshotsWithSameStack.find((s) => s.snapshot !== receivedSerialized);
-				if (differentSnapshot) {
-					throw Object.assign(new Error("toMatchInlineSnapshot with different snapshots cannot be called at the same location"), {
-						actual: receivedSerialized,
-						expected: differentSnapshot.snapshot
-					});
-				}
-			}
-			this._inlineSnapshotStacks.push({
-				...stack,
-				testId,
-				snapshot: receivedSerialized
-			});
-		}
-		// These are the conditions on when to write snapshots:
-		//  * There's no snapshot file in a non-CI environment.
-		//  * There is a snapshot file and we decided to update the snapshot.
-		//  * There is a snapshot file, but it doesn't have this snapshot.
-		// These are the conditions on when not to write snapshots:
-		//  * The update flag is set to 'none'.
-		//  * There's no snapshot file or a file without this snapshot on a CI environment.
-		if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
-			if (this._updateSnapshot === "all") {
-				if (!pass) {
-					if (hasSnapshot) {
-						this.updated.increment(testId);
-					} else {
-						this.added.increment(testId);
-					}
-					this._addSnapshot(key, receivedSerialized, {
-						stack,
-						testId,
-						rawSnapshot
-					});
-				} else {
-					this.matched.increment(testId);
-				}
-			} else {
-				this._addSnapshot(key, receivedSerialized, {
-					stack,
-					testId,
-					rawSnapshot
-				});
-				this.added.increment(testId);
-			}
-			return {
-				actual: "",
-				count,
-				expected: "",
-				key,
-				pass: true
-			};
-		} else {
-			if (!pass) {
-				this.unmatched.increment(testId);
-				return {
-					actual: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
-					count,
-					expected: expectedTrimmed !== undefined ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : undefined,
-					key,
-					pass: false
-				};
-			} else {
-				this.matched.increment(testId);
-				return {
-					actual: "",
-					count,
-					expected: "",
-					key,
-					pass: true
-				};
-			}
-		}
+		const stack = isInline ? this._resolveInlineStack({
+			testId,
+			snapshot: receivedSerialized,
+			assertionName: assertionName || "toMatchInlineSnapshot",
+			error: error || new Error("snapshot")
+		}) : undefined;
+		return this._reconcile({
+			testId,
+			key,
+			count,
+			pass,
+			hasSnapshot,
+			snapshotIsPersisted: !!snapshotIsPersisted,
+			addValue: receivedSerialized,
+			actualDisplay: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
+			expectedDisplay: expectedTrimmed !== undefined ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : undefined,
+			stack,
+			rawSnapshot,
+			assertionName
+		});
+	}
+	processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }) {
+		const stack = isInline ? this._resolveInlineStack({
+			testId,
+			snapshot: received,
+			assertionName,
+			error: error || new Error("STACK_TRACE_ERROR")
+		}) : undefined;
+		const actualResolved = matchResult?.resolved ?? received;
+		const expectedResolved = matchResult?.expected ?? expectedSnapshot.data;
+		return this._reconcile({
+			testId,
+			key: expectedSnapshot.key,
+			count: expectedSnapshot.count,
+			pass: matchResult?.pass ?? false,
+			hasSnapshot: !!expectedSnapshot.data,
+			snapshotIsPersisted: isInline ? true : this._fileExists,
+			addValue: actualResolved,
+			actualDisplay: removeExtraLineBreaks(actualResolved),
+			expectedDisplay: expectedResolved !== undefined ? removeExtraLineBreaks(expectedResolved) : undefined,
+			stack,
+			assertionName
+		});
 	}
 	async pack() {
 		const snapshot = {
@@ -844,31 +948,44 @@ class SnapshotClient {
 		}
 		return state;
 	}
-	assert(options) {
-		const { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot } = options;
+	match(options) {
+		const { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot, assertionName } = options;
 		let { received } = options;
 		if (!filepath) {
 			throw new Error("Snapshot cannot be used outside of test");
 		}
 		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		// Probe first so we can mark as checked even on early return
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
 		if (typeof properties === "object") {
 			if (typeof received !== "object" || !received) {
+				expectedSnapshot.markAsChecked();
 				throw new Error("Received value must be an object when the matcher has properties");
 			}
+			let propertiesPass;
 			try {
-				const pass = this.options.isEqual?.(received, properties) ?? false;
-				// const pass = equals(received, properties, [iterableEquality, subsetEquality])
-				if (!pass) {
-					throw createMismatchError("Snapshot properties mismatched", snapshotState.expand, received, properties);
-				} else {
-					received = deepMergeSnapshot(received, properties);
-				}
+				propertiesPass = this.options.isEqual?.(received, properties) ?? false;
 			} catch (err) {
-				err.message = errorMessage || "Snapshot mismatched";
+				expectedSnapshot.markAsChecked();
 				throw err;
 			}
+			if (!propertiesPass) {
+				expectedSnapshot.markAsChecked();
+				return {
+					pass: false,
+					message: () => errorMessage || "Snapshot properties mismatched",
+					actual: received,
+					expected: properties
+				};
+			}
+			received = deepMergeSnapshot(received, properties);
 		}
-		const testName = [name, ...message ? [message] : []].join(" > ");
 		const { actual, expected, key, pass } = snapshotState.match({
 			testId,
 			testName,
@@ -876,11 +993,109 @@ class SnapshotClient {
 			isInline,
 			error,
 			inlineSnapshot,
-			rawSnapshot
+			rawSnapshot,
+			assertionName
 		});
-		if (!pass) {
-			throw createMismatchError(`Snapshot \`${key || "unknown"}\` mismatched`, snapshotState.expand, rawSnapshot ? actual : actual?.trim(), rawSnapshot ? expected : expected?.trim());
+		return {
+			pass,
+			message: () => `Snapshot \`${key || "unknown"}\` mismatched`,
+			actual: rawSnapshot ? actual : actual?.trim(),
+			expected: rawSnapshot ? expected : expected?.trim()
+		};
+	}
+	assert(options) {
+		const result = this.match(options);
+		if (!result.pass) {
+			const snapshotState = this.getSnapshotState(options.filepath);
+			throw createMismatchError(result.message(), snapshotState.expand, result.actual, result.expected);
+		}
+	}
+	matchDomain(options) {
+		const { received, filepath, name, testId = name, message, adapter, isInline = false, inlineSnapshot, error } = options;
+		if (!filepath) {
+			throw new Error("Snapshot cannot be used outside of test");
+		}
+		const captured = adapter.capture(received);
+		const rendered = adapter.render(captured);
+		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
+		expectedSnapshot.markAsChecked();
+		const matchResult = expectedSnapshot.data ? adapter.match(captured, adapter.parseExpected(expectedSnapshot.data)) : undefined;
+		const { actual, expected, key, pass } = snapshotState.processDomainSnapshot({
+			testId,
+			received: rendered,
+			expectedSnapshot,
+			matchResult,
+			isInline,
+			error,
+			assertionName: options.assertionName
+		});
+		return {
+			pass,
+			message: () => `Snapshot \`${key}\` mismatched`,
+			actual: actual?.trim(),
+			expected: expected?.trim()
+		};
+	}
+	async pollMatchDomain(options) {
+		const { poll, filepath, name, testId = name, message, adapter, isInline = false, inlineSnapshot, error, timeout = 1e3, interval = 50 } = options;
+		if (!filepath) {
+			throw new Error("Snapshot cannot be used outside of test");
+		}
+		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
+		const reference = expectedSnapshot.data && snapshotState.snapshotUpdateState !== "all" ? adapter.parseExpected(expectedSnapshot.data) : undefined;
+		const timedOut = timeout > 0 ? new Promise((r) => setTimeout(r, timeout)) : undefined;
+		const stableResult = await getStableSnapshot({
+			adapter,
+			poll,
+			interval,
+			timedOut,
+			match: reference ? (captured) => adapter.match(captured, reference).pass : undefined
+		});
+		expectedSnapshot.markAsChecked();
+		if (!stableResult?.rendered) {
+			// the original caller `expect.poll` later manipulates error via `throwWithCause`,
+			// so here we can directly throw `lastPollError` if exists.
+			if (stableResult?.lastPollError) {
+				throw stableResult.lastPollError;
+			}
+			return {
+				pass: false,
+				message: () => `poll() did not produce a stable snapshot within the timeout`
+			};
 		}
+		// TODO: should `all` mode ignore parse error?
+		// Sielently hiding the error and creating snaphsot full scratch isn't good either.
+		// Users can fix or purge the broken snapshot manually and that decision affects how domain snapshot gets updated.
+		const matchResult = expectedSnapshot.data ? adapter.match(stableResult.captured, adapter.parseExpected(expectedSnapshot.data)) : undefined;
+		const { actual, expected, key, pass } = snapshotState.processDomainSnapshot({
+			testId,
+			received: stableResult.rendered,
+			expectedSnapshot,
+			matchResult,
+			isInline,
+			error,
+			assertionName: options.assertionName
+		});
+		return {
+			pass,
+			message: () => `Snapshot \`${key}\` mismatched`,
+			actual: actual?.trim(),
+			expected: expected?.trim()
+		};
 	}
 	async assertRaw(options) {
 		if (!options.rawSnapshot) {
@@ -904,5 +1119,69 @@ class SnapshotClient {
 		this.snapshotStateMap.clear();
 	}
 }
+/**
+* Polls repeatedly until the value reaches a stable state.
+*
+* Compares consecutive rendered outputs from the current session —
+* when two consecutive polls produce the same rendered string,
+* the value is considered stable.
+*
+* Every `await` (poll call, interval delay) races against `timedOut`
+* so that hanging polls and delays are interrupted.
+*/
+async function getStableSnapshot({ adapter, poll, interval, timedOut, match }) {
+	let lastRendered;
+	let lastPollError;
+	let lastStable;
+	while (true) {
+		try {
+			const pollResult = await raceWith(Promise.resolve(poll()), timedOut);
+			if (!pollResult.ok) {
+				break;
+			}
+			const captured = adapter.capture(pollResult.value);
+			const rendered = adapter.render(captured);
+			if (lastRendered !== undefined && rendered === lastRendered) {
+				lastStable = {
+					captured,
+					rendered
+				};
+				if (!match || match(captured)) {
+					break;
+				}
+			} else {
+				lastRendered = rendered;
+				lastStable = undefined;
+			}
+		} catch (pollError) {
+			// poll() threw — reset stability baseline and retry
+			lastRendered = undefined;
+			lastStable = undefined;
+			lastPollError = pollError;
+		}
+		const delayed = await raceWith(new Promise((r) => setTimeout(r, interval)), timedOut);
+		if (!delayed.ok) {
+			break;
+		}
+	}
+	return {
+		...lastStable,
+		lastPollError
+	};
+}
+/** Type-safe `Promise.race` — tells you which promise won. */
+function raceWith(promise, other) {
+	const left = promise.then((value) => ({
+		ok: true,
+		value
+	}));
+	if (!other) {
+		return left;
+	}
+	return Promise.race([left, other.then((value) => ({
+		ok: false,
+		value
+	}))]);
+}
 
 export { SnapshotClient, SnapshotState, addSerializer, getSerializers, stripSnapshotIndentation };

package/dist/manager.d.ts

@@ -1,7 +1,7 @@
-import { S as SnapshotStateOptions, e as SnapshotSummary, b as SnapshotResult } from './rawSnapshot.d-U2kJUxDr.js';
+import { a as SnapshotStateOptions, g as SnapshotSummary, b as SnapshotResult } from './rawSnapshot.d-D_X3-62x.js';
 import '@vitest/pretty-format';
-import './environment.d-DOJxxZV9.js';
 import '@vitest/utils';
+import './environment.d-DOJxxZV9.js';
 
 declare class SnapshotManager {
 	options: Omit<SnapshotStateOptions, "snapshotEnvironment">;

package/dist/rawSnapshot.d-D_X3-62x.d.ts

@@ -0,0 +1,205 @@
+import { OptionsReceived, Plugin } from '@vitest/pretty-format';
+import { ParsedStack } from '@vitest/utils';
+import { S as SnapshotEnvironment } from './environment.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;
+}
+
+export { SnapshotState as S };
+export type { DomainSnapshotAdapter as D, RawSnapshotInfo as R, UncheckedSnapshot as U, SnapshotStateOptions as a, SnapshotResult as b, DomainMatchResult as c, SnapshotData as d, SnapshotMatchOptions as e, SnapshotSerializer as f, SnapshotSummary as g, SnapshotUpdateState as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/snapshot",
   "type": "module",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "description": "Vitest snapshot manager",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -45,8 +45,8 @@
   "dependencies": {
     "magic-string": "^0.30.21",
     "pathe": "^2.0.3",
-    "@vitest/pretty-format": "4.1.2",
-    "@vitest/utils": "4.1.2"
+    "@vitest/pretty-format": "4.1.4",
+    "@vitest/utils": "4.1.4"
   },
   "devDependencies": {
     "@types/natural-compare": "^1.4.3",

package/dist/rawSnapshot.d-U2kJUxDr.d.ts

@@ -1,61 +0,0 @@
-import { OptionsReceived, Plugin } from '@vitest/pretty-format';
-import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
-
-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;
-}
-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;
-}
-
-export type { RawSnapshotInfo as R, SnapshotStateOptions as S, UncheckedSnapshot as U, SnapshotMatchOptions as a, SnapshotResult as b, SnapshotData as c, SnapshotSerializer as d, SnapshotSummary as e, SnapshotUpdateState as f };