vitest 4.0.0-beta.11 → 4.0.0-beta.12

package/dist/chunks/{index.X0nbfr6-.js → index.Dc3xnDvT.js}

@@ -1,301 +1,60 @@
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import process$1 from 'node:process';
-import { promises } from 'node:fs';
+import { resolve, isAbsolute, dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import 'node:module';
+import 'node:url';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import require$$0 from 'readline';
 import require$$0$1 from 'events';
 
-function _mergeNamespaces(n, m) {
-	m.forEach(function (e) {
-		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-			if (k !== 'default' && !(k in n)) {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	});
-	return Object.freeze(n);
-}
-
-/*
-How it works:
-`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+/**
+* Resolve an absolute path from {@link root}, but only
+* if {@link input} isn't already absolute.
+*
+* @param input The path to resolve.
+* @param root The base path; default = process.cwd()
+* @returns The resolved absolute path.
 */
-
-class Node {
-	value;
-	next;
-
-	constructor(value) {
-		this.value = value;
-	}
-}
-
-class Queue {
-	#head;
-	#tail;
-	#size;
-
-	constructor() {
-		this.clear();
-	}
-
-	enqueue(value) {
-		const node = new Node(value);
-
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-
-		this.#size++;
-	}
-
-	dequeue() {
-		const current = this.#head;
-		if (!current) {
-			return;
-		}
-
-		this.#head = this.#head.next;
-		this.#size--;
-		return current.value;
-	}
-
-	clear() {
-		this.#head = undefined;
-		this.#tail = undefined;
-		this.#size = 0;
-	}
-
-	get size() {
-		return this.#size;
-	}
-
-	* [Symbol.iterator]() {
-		let current = this.#head;
-
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-}
-
-function pLimit(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
-	}
-
-	const queue = new Queue();
-	let activeCount = 0;
-
-	const next = () => {
-		activeCount--;
-
-		if (queue.size > 0) {
-			queue.dequeue()();
-		}
-	};
-
-	const run = async (fn, resolve, args) => {
-		activeCount++;
-
-		const result = (async () => fn(...args))();
-
-		resolve(result);
-
-		try {
-			await result;
-		} catch {}
-
-		next();
-	};
-
-	const enqueue = (fn, resolve, args) => {
-		queue.enqueue(run.bind(undefined, fn, resolve, args));
-
-		(async () => {
-			// This function needs to wait until the next microtask before comparing
-			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-			// when the run function is dequeued and called. The comparison in the if-statement
-			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-			await Promise.resolve();
-
-			if (activeCount < concurrency && queue.size > 0) {
-				queue.dequeue()();
-			}
-		})();
-	};
-
-	const generator = (fn, ...args) => new Promise(resolve => {
-		enqueue(fn, resolve, args);
-	});
-
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount,
-		},
-		pendingCount: {
-			get: () => queue.size,
-		},
-		clearQueue: {
-			value: () => {
-				queue.clear();
-			},
-		},
-	});
-
-	return generator;
-}
-
-class EndError extends Error {
-	constructor(value) {
-		super();
-		this.value = value;
-	}
+function absolute(input, root) {
+	return isAbsolute(input) ? input : resolve(root || ".", input);
 }
 
-// The input can also be a promise, so we await it.
-const testElement = async (element, tester) => tester(await element);
-
-// The input can also be a promise, so we `Promise.all()` them both.
-const finder = async element => {
-	const values = await Promise.all(element);
-	if (values[1] === true) {
-		throw new EndError(values[0]);
-	}
-
-	return false;
-};
-
-async function pLocate(
-	iterable,
-	tester,
-	{
-		concurrency = Number.POSITIVE_INFINITY,
-		preserveOrder = true,
-	} = {},
-) {
-	const limit = pLimit(concurrency);
-
-	// Start all the promises concurrently with optional limit.
-	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
-
-	// Check the promises either serially or concurrently.
-	const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
-
-	try {
-		await Promise.all(items.map(element => checkLimit(finder, element)));
-	} catch (error) {
-		if (error instanceof EndError) {
-			return error.value;
-		}
-
-		throw error;
-	}
-}
-
-const typeMappings = {
-	directory: 'isDirectory',
-	file: 'isFile',
-};
-
-function checkType(type) {
-	if (Object.hasOwnProperty.call(typeMappings, type)) {
-		return;
+/**
+* Get all parent directories of {@link base}.
+* Stops after {@link Options['last']} is processed.
+*
+* @returns An array of absolute paths of all parent directories.
+*/
+function up(base, options) {
+	let { last, cwd } = options || {};
+	let tmp = absolute(base, cwd);
+	let root = absolute(last || "/", cwd);
+	let prev, arr = [];
+	while (prev !== root) {
+		arr.push(tmp);
+		tmp = dirname(prev = tmp);
+		if (tmp === prev) break;
 	}
-
-	throw new Error(`Invalid type specified: ${type}`);
+	return arr;
 }
 
-const matchType = (type, stat) => stat[typeMappings[type]]();
-
-const toPath$1 = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-async function locatePath(
-	paths,
-	{
-		cwd = process$1.cwd(),
-		type = 'file',
-		allowSymlinks = true,
-		concurrency,
-		preserveOrder,
-	} = {},
-) {
-	checkType(type);
-	cwd = toPath$1(cwd);
-
-	const statFunction = allowSymlinks ? promises.stat : promises.lstat;
-
-	return pLocate(paths, async path_ => {
-		try {
-			const stat = await statFunction(path.resolve(cwd, path_));
-			return matchType(type, stat);
-		} catch {
-			return false;
-		}
-	}, {concurrency, preserveOrder});
-}
-
-const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-const findUpStop = Symbol('findUpStop');
-
-async function findUpMultiple(name, options = {}) {
-	let directory = path.resolve(toPath(options.cwd) || '');
-	const {root} = path.parse(directory);
-	const stopAt = path.resolve(directory, options.stopAt || root);
-	const limit = options.limit || Number.POSITIVE_INFINITY;
-	const paths = [name].flat();
-
-	const runMatcher = async locateOptions => {
-		if (typeof name !== 'function') {
-			return locatePath(paths, locateOptions);
-		}
-
-		const foundPath = await name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePath([foundPath], locateOptions);
-		}
-
-		return foundPath;
-	};
-
-	const matches = [];
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		// eslint-disable-next-line no-await-in-loop
-		const foundPath = await runMatcher({...options, cwd: directory});
-
-		if (foundPath === findUpStop) {
-			break;
-		}
-
-		if (foundPath) {
-			matches.push(path.resolve(directory, foundPath));
-		}
-
-		if (directory === stopAt || matches.length >= limit) {
-			break;
+/**
+* Get the first path that matches any of the names provided.
+*
+* > [NOTE]
+* > The order of {@link names} is respected.
+*
+* @param names The item names to find.
+* @returns The absolute path of the first item found, if any.
+*/
+function any(names, options) {
+	let dir, start = options && options.cwd || "";
+	let j = 0, len = names.length, tmp;
+	for (dir of up(start, options)) {
+		for (j = 0; j < len; j++) {
+			tmp = join(dir, names[j]);
+			if (existsSync(tmp)) return tmp;
 		}
-
-		directory = path.dirname(directory);
 	}
-
-	return matches;
-}
-
-async function findUp(name, options = {}) {
-	const matches = await findUpMultiple(name, {...options, limit: 1});
-	return matches[0];
 }
 
 var prompts$2 = {};
@@ -6576,9 +6335,9 @@ function requirePrompts () {
 var promptsExports = requirePrompts();
 var prompt = /*@__PURE__*/getDefaultExportFromCjs(promptsExports);
 
-var index = /*#__PURE__*/_mergeNamespaces({
+var index = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	default: prompt
-}, [promptsExports]);
+});
 
-export { findUp as f, index as i, prompt as p };
+export { any as a, index as i, prompt as p };

package/dist/chunks/{index.AZOjjqWP.js → index.Dnl38iQ_.js}

@@ -1,5 +1,5 @@
-import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.CiJ0Laa6.js';
-import { b as bench } from './benchmark.LXhJ0F0X.js';
+import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.B2--mG9U.js';
+import { b as bench } from './benchmark.DHKMYAts.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 import { EvaluatedModules } from 'vite/module-runner';

package/dist/chunks/{index.BhY64fF0.js → index.uLUz1RDt.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.BwBttQPf.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.CHrBLuEH.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils/helpers';
 

package/dist/chunks/{inspector.CvQD-Nie.js → inspector.Br76Q2Mb.js}

@@ -10,10 +10,7 @@ let inspector, session;
 function setupInspect(ctx) {
 	const config = ctx.config, isEnabled = config.inspector.enabled;
 	if (isEnabled) {
-		inspector = __require("node:inspector");
-		// Inspector may be open already if "isolate: false" is used
-		const isOpen = inspector.url() !== void 0;
-		if (!isOpen) {
+		if (inspector = __require("node:inspector"), !(inspector.url() !== void 0)) {
 			if (inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger), config.inspectBrk) {
 				const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
 				// Stop at first test file

package/dist/chunks/{moduleRunner.d.BNa-CL9e.d.ts → moduleRunner.d.CeYc7nZ0.d.ts}

@@ -2,7 +2,7 @@ import * as _vitest_spy from '@vitest/spy';
 import vm from 'node:vm';
 import * as viteModuleRunner from 'vite/module-runner';
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, EvaluatedModules } from 'vite/module-runner';
-import { a as RuntimeRPC, W as WorkerGlobalState } from './worker.d.B_Fd9M_w.js';
+import { a as RuntimeRPC, W as WorkerGlobalState } from './worker.d.buwuBpBt.js';
 import { R as ResolveFunctionResult } from './environment.d.BsToaxti.js';
 import { MockedModule, MockedModuleType } from '@vitest/mocker';
 import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './mocker.d.BE_2ls6u.js';

package/dist/chunks/{node.BsdMi6DV.js → node.BwAWWjHZ.js}

@@ -1,5 +1,5 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.DGKhod2J.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
 import '@vitest/utils/timers';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
@@ -7,8 +7,7 @@ class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
 		return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
 	}
 	resolvePath(filepath) {
-		const rpc = getWorkerState().rpc;
-		return rpc.resolveSnapshotPath(filepath);
+		return getWorkerState().rpc.resolveSnapshotPath(filepath);
 	}
 }
 

package/dist/chunks/{plugin.d.C5phQR6o.d.ts → plugin.d.XreRXLXS.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.CVzhsTvK.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.CJVTaaWb.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;

package/dist/chunks/{reporters.d.CVzhsTvK.d.ts → reporters.d.CJVTaaWb.d.ts}

@@ -5,8 +5,8 @@ import { Writable } from 'node:stream';
 import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
-import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.Dx7DO_Ce.js';
-import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.B_LthbQq.js';
+import { B as BrowserTraceViewMode, a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.DGazh2r6.js';
+import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.D9YV3JvA.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -178,6 +178,31 @@ interface BrowserConfigOptions {
 		testIdAttribute?: string;
 	};
 	/**
+	* Generate traces that can be viewed on https://trace.playwright.dev/
+	*
+	* This option is supported only by **playwright** provider.
+	*/
+	trace?: BrowserTraceViewMode | {
+		mode: BrowserTraceViewMode;
+		/**
+		* The directory where all traces will be stored. By default, Vitest
+		* stores all traces in `__traces__` folder close to the test file.
+		*/
+		tracesDir?: string;
+		/**
+		* Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.
+		* @default true
+		*/
+		screenshots?: boolean;
+		/**
+		* If this option is true tracing will
+		* - capture DOM snapshot on every action
+		* - record network activity
+		* @default true
+		*/
+		snapshots?: boolean;
+	};
+	/**
 	* Directory where screenshots will be saved when page.screenshot() is called
 	* If not set, all screenshots are saved to __screenshots__ directory in the same folder as the test file.
 	* If this is set, it will be resolved relative to the project root.
@@ -261,7 +286,7 @@ interface ProjectBrowser {
 	parseStacktrace: (stack: string) => ParsedStack[];
 	parseErrorStacktrace: (error: TestError, options?: StackTraceParserOptions) => ParsedStack[];
 }
-interface BrowserCommand<Payload extends unknown[]> {
+interface BrowserCommand<Payload extends unknown[] = []> {
 	(context: BrowserCommandContext, ...payload: Payload): Awaitable<any>;
 }
 interface BrowserScript {
@@ -308,6 +333,12 @@ interface ResolvedBrowserOptions extends BrowserConfigOptions {
 	locators: {
 		testIdAttribute: string;
 	};
+	trace: {
+		mode: BrowserTraceViewMode;
+		tracesDir?: string;
+		screenshots?: boolean;
+		snapshots?: boolean;
+	};
 }
 type ToMatchScreenshotResolvePath = (data: {
 	/**
@@ -1512,6 +1543,7 @@ declare class StateManager {
 	clearFiles(project: TestProject, paths?: string[]): void;
 	updateId(task: Task, project: TestProject): void;
 	getReportedEntity(task: Task): TestModule | TestCase | TestSuite | undefined;
+	getReportedEntityById(taskId: string): TestModule | TestCase | TestSuite | undefined;
 	updateTasks(packs: TaskResultPack[]): void;
 	updateUserLog(log: UserConsoleLog): void;
 	getCountOfFailedTests(): number;
@@ -1674,6 +1706,10 @@ declare class Vitest {
 	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
 	*/
 	mergeReports(directory?: string): Promise<TestRunResult>;
+	/**
+	* Returns the seed, if tests are running in a random order.
+	*/
+	getSeed(): number | null;
 	collect(filters?: string[]): Promise<TestRunResult>;
 	/**
 	* Returns the list of test files that match the config and filters.

package/dist/chunks/{resolveSnapshotEnvironment.DQVamkje.js → resolveSnapshotEnvironment.BsJpmVZR.js}

@@ -1,8 +1,8 @@
 import { chai } from '@vitest/expect';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.NAWRuMRP.js';
-import { r as rpc } from './rpc.jKGRSXIH.js';
-import { g as getWorkerState } from './utils.DGKhod2J.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.KC5tH8hC.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.BewgbkTd.js';
+import { r as rpc } from './rpc.cD77ENhU.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.CTuWuHYH.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
@@ -15,7 +15,7 @@ async function getTestRunnerConstructor(config, moduleRunner) {
 	return mod.default;
 }
 async function resolveTestRunner(config, moduleRunner) {
-	const TestRunner = await getTestRunnerConstructor(config, moduleRunner), testRunner = new TestRunner(config);
+	const testRunner = new (await (getTestRunnerConstructor(config, moduleRunner)))(config);
 	if (Object.defineProperty(testRunner, "moduleRunner", {
 		value: moduleRunner,
 		enumerable: false,
@@ -61,8 +61,7 @@ async function resolveTestRunner(config, moduleRunner) {
 	const originalOnAfterRunTask = testRunner.onAfterRunTask;
 	return testRunner.onAfterRunTask = async (test) => {
 		if (config.bail && test.result?.state === "fail") {
-			const previousFailures = await rpc().getCountOfFailedTests(), currentFailures = 1 + previousFailures;
-			if (currentFailures >= config.bail) rpc().onCancel("test-failure"), testRunner.cancel?.("test-failure");
+			if (1 + await rpc().getCountOfFailedTests() >= config.bail) rpc().onCancel("test-failure"), testRunner.cancel?.("test-failure");
 		}
 		await originalOnAfterRunTask?.call(testRunner, test);
 	}, testRunner;
@@ -70,7 +69,7 @@ async function resolveTestRunner(config, moduleRunner) {
 
 async function resolveSnapshotEnvironment(config, executor) {
 	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.BsdMi6DV.js');
+		const { VitestNodeSnapshotEnvironment } = await import('./node.BwAWWjHZ.js');
 		return new VitestNodeSnapshotEnvironment();
 	}
 	const mod = await executor.import(config.snapshotEnvironment);

package/dist/chunks/{rpc.jKGRSXIH.js → rpc.cD77ENhU.js}

@@ -1,6 +1,6 @@
 import { getSafeTimers } from '@vitest/utils/timers';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { g as getWorkerState } from './utils.DGKhod2J.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {
@@ -9,8 +9,7 @@ function withSafeTimers(fn) {
 		if (globalThis.setTimeout = setTimeout, globalThis.clearTimeout = clearTimeout, setImmediate) globalThis.setImmediate = setImmediate;
 		if (clearImmediate) globalThis.clearImmediate = clearImmediate;
 		if (globalThis.process && nextTick) globalThis.process.nextTick = nextTick;
-		const result = fn();
-		return result;
+		return fn();
 	} finally {
 		if (globalThis.setTimeout = currentSetTimeout, globalThis.clearTimeout = currentClearTimeout, globalThis.setImmediate = currentSetImmediate, globalThis.clearImmediate = currentClearImmediate, globalThis.process && nextTick) nextTick(() => {
 			globalThis.process.nextTick = currentNextTick;
@@ -27,17 +26,17 @@ function createRuntimeRpc(options) {
 	let setCancel = (_reason) => {};
 	const onCancel = new Promise((resolve) => {
 		setCancel = resolve;
-	}), rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
-		eventNames: [
-			"onUserConsoleLog",
-			"onCollected",
-			"onCancel"
-		],
-		timeout: -1,
-		...options
-	}));
+	});
 	return {
-		rpc,
+		rpc: createSafeRpc(createBirpc({ onCancel: setCancel }, {
+			eventNames: [
+				"onUserConsoleLog",
+				"onCollected",
+				"onCancel"
+			],
+			timeout: -1,
+			...options
+		})),
 		onCancel
 	};
 }

package/dist/chunks/{setup-common.NAWRuMRP.js → setup-common.BewgbkTd.js}

@@ -1,7 +1,7 @@
 import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 import { addSerializer } from '@vitest/snapshot';
 import { setSafeTimers } from '@vitest/utils/timers';
-import { g as getWorkerState } from './utils.DGKhod2J.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
 
 async function startCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
@@ -18,7 +18,7 @@ async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
-	if (setupDefines(config), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.BjvYA-AD.js')).registerApiGlobally();
+	if (setupDefines(config), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.DC4ntO86.js')).registerApiGlobally();
 }
 function setupDefines(config) {
 	for (const key in config.defines) globalThis[key] = config.defines[key];
@@ -35,14 +35,14 @@ async function loadDiffConfig(config, moduleRunner) {
 	throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
 }
 async function loadSnapshotSerializers(config, moduleRunner) {
-	const files = config.snapshotSerializers, snapshotSerializers = await Promise.all(files.map(async (file) => {
+	const files = config.snapshotSerializers;
+	(await Promise.all(files.map(async (file) => {
 		const mo = await moduleRunner.import(file);
 		if (!mo || typeof mo.default !== "object" || mo.default === null) throw new Error(`invalid snapshot serializer file ${file}. Must export a default object`);
 		const config = mo.default;
 		if (typeof config.test !== "function" || typeof config.serialize !== "function" && typeof config.print !== "function") throw new TypeError(`invalid snapshot serializer in ${file}. Must have a 'test' method along with either a 'serialize' or 'print' method.`);
 		return config;
-	}));
-	snapshotSerializers.forEach((serializer) => addSerializer(serializer));
+	}))).forEach((serializer) => addSerializer(serializer));
 }
 
 export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };