vitest 4.0.0-beta.10 → 4.0.0-beta.12

package/dist/chunks/{utils.D2R2NiOH.js → utils.CG9h5ccR.js}

@@ -1,13 +1,10 @@
-import { getSafeTimers } from '@vitest/utils';
+import { getSafeTimers } from '@vitest/utils/timers';
 
 const NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
 	// @ts-expect-error untyped global
 	const workerState = globalThis[NAME_WORKER_STATE];
-	if (!workerState) {
-		const errorMsg = "Vitest failed to access its internal state.\n\nOne of the following is possible:\n- \"vitest\" is imported directly without running \"vitest\" command\n- \"vitest\" is imported inside \"globalSetup\" (to fix this, use \"setupFiles\" instead, because \"globalSetup\" runs in a different context)\n- \"vitest\" is imported inside Vite / Vitest config file\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n";
-		throw new Error(errorMsg);
-	}
+	if (!workerState) throw new Error("Vitest failed to access its internal state.\n\nOne of the following is possible:\n- \"vitest\" is imported directly without running \"vitest\" command\n- \"vitest\" is imported inside \"globalSetup\" (to fix this, use \"setupFiles\" instead, because \"globalSetup\" runs in a different context)\n- \"vitest\" is imported inside Vite / Vitest config file\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n");
 	return workerState;
 }
 function provideWorkerState(context, state) {

package/dist/chunks/{vi.ZPgvtBao.js → vi.B2--mG9U.js}

@@ -1,13 +1,15 @@
-import { chai as chai$1, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
+import { chai, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
 import { getCurrentTest } from '@vitest/runner';
 import { getNames, getTestName } from '@vitest/runner/utils';
-import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.D2R2NiOH.js';
-import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
-import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
+import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.CG9h5ccR.js';
+import { getSafeTimers } from '@vitest/utils/timers';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import '@vitest/utils/error';
+import { assertTypes, createSimpleStackTrace } from '@vitest/utils/helpers';
 import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunction } from '@vitest/spy';
+import '@vitest/utils/offset';
 import { parseSingleStack } from '@vitest/utils/source-map';
+import { c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
 import { R as RealDate, r as resetDate, m as mockDate } from './date.-jtEtIeV.js';
 
 // these matchers are not supported because they don't make sense with poll
@@ -25,13 +27,13 @@ const unsupported = [
 ];
 function createExpectPoll(expect) {
 	return function poll(fn, options = {}) {
-		const state = getWorkerState(), defaults = state.config.expect?.poll ?? {}, { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options, assertion = expect(null, message).withContext({ poll: true });
+		const defaults = getWorkerState().config.expect?.poll ?? {}, { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options, assertion = expect(null, message).withContext({ poll: true });
 		fn = fn.bind(assertion);
-		const test = chai$1.util.flag(assertion, "vitest-test");
+		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) {
 			const assertionFunction = Reflect.get(target, key, receiver);
-			if (typeof assertionFunction !== "function") return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
+			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) {
@@ -39,15 +41,15 @@ function createExpectPoll(expect) {
 					let intervalId, timeoutId, lastError;
 					const { setTimeout, clearTimeout } = getSafeTimers(), check = async () => {
 						try {
-							chai$1.util.flag(assertion, "_name", key);
+							chai.util.flag(assertion, "_name", key);
 							const obj = await fn();
-							chai$1.util.flag(assertion, "object", obj), resolve(await assertionFunction.call(assertion, ...args)), clearTimeout(intervalId), clearTimeout(timeoutId);
+							chai.util.flag(assertion, "object", obj), resolve(await assertionFunction.call(assertion, ...args)), clearTimeout(intervalId), clearTimeout(timeoutId);
 						} catch (err) {
-							if (lastError = err, !chai$1.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
+							if (lastError = err, !chai.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
 						}
 					};
 					timeoutId = setTimeout(() => {
-						clearTimeout(intervalId), chai$1.util.flag(assertion, "_isLastPollAttempt", true);
+						clearTimeout(intervalId), chai.util.flag(assertion, "_isLastPollAttempt", true);
 						const rejectWithCause = (error) => {
 							if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
 							reject(copyStackTrace$1(error, STACK_TRACE_ERROR));
@@ -58,7 +60,7 @@ function createExpectPoll(expect) {
 				let awaited = false;
 				test.onFinished ??= [], test.onFinished.push(() => {
 					if (!awaited) {
-						const negated = chai$1.util.flag(assertion, "negate") ? "not." : "", name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)", assertionString = `expect.${name}.${negated}${String(key)}()`, error = /* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:\n\nawait ${assertionString}\n`);
+						const negated = chai.util.flag(assertion, "negate") ? "not." : "", assertionString = `expect.${chai.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`, error = /* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:\n\nawait ${assertionString}\n`);
 						throw copyStackTrace$1(error, STACK_TRACE_ERROR);
 					}
 				});
@@ -87,108 +89,9 @@ function copyStackTrace$1(target, source) {
 	return target;
 }
 
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-
-var chaiSubset$1 = {exports: {}};
-
-var chaiSubset = chaiSubset$1.exports;
-
-var hasRequiredChaiSubset;
-
-function requireChaiSubset () {
-	if (hasRequiredChaiSubset) return chaiSubset$1.exports;
-	hasRequiredChaiSubset = 1;
-	(function (module, exports) {
-		(function() {
-			(function(chaiSubset) {
-				if (typeof commonjsRequire === 'function' && 'object' === 'object' && 'object' === 'object') {
-					return module.exports = chaiSubset;
-				} else {
-					return chai.use(chaiSubset);
-				}
-			})(function(chai, utils) {
-				var Assertion = chai.Assertion;
-				var assertionPrototype = Assertion.prototype;
-
-				Assertion.addMethod('containSubset', function (expected) {
-					var actual = utils.flag(this, 'object');
-					var showDiff = chai.config.showDiff;
-
-					assertionPrototype.assert.call(this,
-						compare(expected, actual),
-						'expected #{act} to contain subset #{exp}',
-						'expected #{act} to not contain subset #{exp}',
-						expected,
-						actual,
-						showDiff
-					);
-				});
-
-				chai.assert.containSubset = function(val, exp, msg) {
-					new chai.Assertion(val, msg).to.be.containSubset(exp);
-				};
-
-				function compare(expected, actual) {
-					if (expected === actual) {
-						return true;
-					}
-					if (typeof(actual) !== typeof(expected)) {
-						return false;
-					}
-					if (typeof(expected) !== 'object' || expected === null) {
-						return expected === actual;
-					}
-					if (!!expected && !actual) {
-						return false;
-					}
-
-					if (Array.isArray(expected)) {
-						if (typeof(actual.length) !== 'number') {
-							return false;
-						}
-						var aa = Array.prototype.slice.call(actual);
-						return expected.every(function (exp) {
-							return aa.some(function (act) {
-								return compare(exp, act);
-							});
-						});
-					}
-
-					if (expected instanceof Date) {
-						if (actual instanceof Date) {
-							return expected.getTime() === actual.getTime();
-						} else {
-							return false;
-						}
-					}
-
-					return Object.keys(expected).every(function (key) {
-						var eo = expected[key];
-						var ao = actual[key];
-						if (typeof(eo) === 'object' && eo !== null && ao !== null) {
-							return compare(eo, ao);
-						}
-						if (typeof(eo) === 'function') {
-							return eo(ao);
-						}
-						return ao === eo;
-					});
-				}
-			});
-
-		}).call(chaiSubset); 
-	} (chaiSubset$1));
-	return chaiSubset$1.exports;
-}
-
-var chaiSubsetExports = requireChaiSubset();
-var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports);
-
 function createAssertionMessage(util, assertion, hasArgs) {
-	const not = util.flag(assertion, "negate") ? "not." : "", name = `${util.flag(assertion, "_name")}(${"expected" })`, promiseName = util.flag(assertion, "promise"), promise = promiseName ? `.${promiseName}` : "";
-	return `expect(actual)${promise}.${not}${name}`;
+	const not = util.flag(assertion, "negate") ? "not." : "", name = `${util.flag(assertion, "_name")}(${"expected" })`, promiseName = util.flag(assertion, "promise");
+	return `expect(actual)${promiseName ? `.${promiseName}` : ""}.${not}${name}`;
 }
 function recordAsyncExpect(_test, promise, assertion, error) {
 	const test = _test;
@@ -204,7 +107,7 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 		let resolved = false;
 		return test.onFinished ??= [], test.onFinished.push(() => {
 			if (!resolved) {
-				const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""), stack = processor(error.stack);
+				const stack = (globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""))(error.stack);
 				console.warn([
 					`Promise returned by \`${assertion}\` was not awaited. `,
 					"Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
@@ -262,9 +165,7 @@ const SnapshotPlugin = (chai, utils) => {
 		return test;
 	}
 	for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
-		utils.flag(this, "_name", key);
-		const isNot = utils.flag(this, "negate");
-		if (isNot) throw new Error(`${key} cannot be used with "not"`);
+		if (utils.flag(this, "_name", key), utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
 		const expected = utils.flag(this, "object"), test = getTest(key, this);
 		if (typeof properties === "string" && typeof message === "undefined") message = properties, properties = void 0;
 		const errorMessage = utils.flag(this, "message");
@@ -278,9 +179,7 @@ const SnapshotPlugin = (chai, utils) => {
 		});
 	});
 	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
-		utils.flag(this, "_name", "toMatchFileSnapshot");
-		const isNot = utils.flag(this, "negate");
-		if (isNot) throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
+		if (utils.flag(this, "_name", "toMatchFileSnapshot"), utils.flag(this, "negate")) throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
 		const error = /* @__PURE__ */ new Error("resolves"), expected = utils.flag(this, "object"), test = getTest("toMatchFileSnapshot", this), errorMessage = utils.flag(this, "message"), promise = getSnapshotClient().assertRaw({
 			received: expected,
 			message,
@@ -291,11 +190,9 @@ const SnapshotPlugin = (chai, utils) => {
 		});
 		return recordAsyncExpect(test, promise, createAssertionMessage(utils, this), error);
 	}), utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-		utils.flag(this, "_name", "toMatchInlineSnapshot");
-		const isNot = utils.flag(this, "negate");
-		if (isNot) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
-		const test = getTest("toMatchInlineSnapshot", this), isInsideEach = test.each || test.suite?.each;
-		if (isInsideEach) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+		if (utils.flag(this, "_name", "toMatchInlineSnapshot"), utils.flag(this, "negate")) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
+		const test = getTest("toMatchInlineSnapshot", this);
+		if (test.each || test.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
 		const expected = utils.flag(this, "object"), error = utils.flag(this, "error");
 		if (typeof properties === "string") message = inlineSnapshot, inlineSnapshot = properties, properties = void 0;
 		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
@@ -311,9 +208,7 @@ const SnapshotPlugin = (chai, utils) => {
 			...getTestNames(test)
 		});
 	}), utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
-		utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
-		const isNot = utils.flag(this, "negate");
-		if (isNot) throw new Error("toThrowErrorMatchingSnapshot cannot be used with \"not\"");
+		if (utils.flag(this, "_name", "toThrowErrorMatchingSnapshot"), utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingSnapshot cannot be used with \"not\"");
 		const expected = utils.flag(this, "object"), test = getTest("toThrowErrorMatchingSnapshot", this), promise = utils.flag(this, "promise"), errorMessage = utils.flag(this, "message");
 		getSnapshotClient().assert({
 			received: getError(expected, promise),
@@ -322,10 +217,9 @@ const SnapshotPlugin = (chai, utils) => {
 			...getTestNames(test)
 		});
 	}), utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
-		const isNot = utils.flag(this, "negate");
-		if (isNot) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
-		const test = getTest("toThrowErrorMatchingInlineSnapshot", this), isInsideEach = test.each || test.suite?.each;
-		if (isInsideEach) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+		if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
+		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
+		if (test.each || test.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
 		const expected = utils.flag(this, "object"), error = utils.flag(this, "error"), promise = utils.flag(this, "promise"), errorMessage = utils.flag(this, "message");
 		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
 		getSnapshotClient().assert({
@@ -340,16 +234,16 @@ const SnapshotPlugin = (chai, utils) => {
 	}), utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
 
-chai$1.use(JestExtend), chai$1.use(JestChaiExpect), chai$1.use(Subset), chai$1.use(SnapshotPlugin), chai$1.use(JestAsymmetricMatchers);
+chai.use(JestExtend), chai.use(JestChaiExpect), chai.use(SnapshotPlugin), chai.use(JestAsymmetricMatchers);
 
 function createExpect(test) {
 	const expect = ((value, message) => {
 		const { assertionCalls } = getState(expect);
 		setState({ assertionCalls: assertionCalls + 1 }, expect);
-		const assert = chai$1.expect(value, message), _test = test || getCurrentTest();
+		const assert = chai.expect(value, message), _test = test || getCurrentTest();
 		return _test ? assert.withTest(_test) : assert;
 	});
-	Object.assign(expect, chai$1.expect), Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]), expect.getState = () => getState(expect), expect.setState = (state) => setState(state, expect);
+	Object.assign(expect, chai.expect), Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]), expect.getState = () => getState(expect), expect.setState = (state) => setState(state, expect);
 	// @ts-expect-error global is not typed
 	const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
 	setState({
@@ -363,11 +257,11 @@ function createExpect(test) {
 			return getWorkerState().filepath;
 		},
 		currentTestName: test ? getTestName(test) : globalState.currentTestName
-	}, expect), expect.extend = (matchers) => chai$1.expect.extend(expect, matchers), expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters), expect.soft = (...args) => {
+	}, expect), expect.extend = (matchers) => chai.expect.extend(expect, matchers), expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters), expect.soft = (...args) => {
 		// @ts-expect-error private soft access
 		return expect(...args).withContext({ soft: true });
 	}, expect.poll = createExpectPoll(expect), expect.unreachable = (message) => {
-		chai$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+		chai.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
 	};
 	function assertions(expected) {
 		const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
@@ -385,7 +279,7 @@ function createExpect(test) {
 			isExpectingAssertionsError: error
 		});
 	}
-	return chai$1.util.addMethod(expect, "assertions", assertions), chai$1.util.addMethod(expect, "hasAssertions", hasAssertions), expect.extend(customMatchers), expect;
+	return chai.util.addMethod(expect, "assertions", assertions), chai.util.addMethod(expect, "hasAssertions", hasAssertions), expect.extend(customMatchers), expect;
 }
 const globalExpect = createExpect();
 Object.defineProperty(globalThis, GLOBAL_EXPECT, {
@@ -393,16 +287,15 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
 	writable: true,
 	configurable: true
 });
-const assert = chai$1.assert;
-const should = chai$1.should;
+const assert = chai.assert;
+const should = chai.should;
 
 /**
 * Gives access to injected context provided from the main thread.
 * This usually returns a value provided by `globalSetup` or an external library.
 */
 function inject(key) {
-	const workerState = getWorkerState();
-	return workerState.providedContext[key];
+	return getWorkerState().providedContext[key];
 }
 
 var fakeTimersSrc = {};
@@ -3857,10 +3750,10 @@ function _mocker() {
 	} });
 }
 function getImporter(name) {
-	const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 }), stackArray = stackTrace.split("\n"), importerStackIndex = stackArray.findLastIndex((stack) => {
+	const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n"), importerStackIndex = stackArray.findLastIndex((stack) => {
 		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
-	}), stack = parseSingleStack(stackArray[importerStackIndex + 1]);
-	return stack?.file || "";
+	});
+	return parseSingleStack(stackArray[importerStackIndex + 1])?.file || "";
 }
 
 export { getSnapshotClient as a, assert as b, createExpect as c, vitest as d, globalExpect as g, inject as i, should as s, vi as v };

package/dist/{worker.js → chunks/worker.DVTUM2IW.js}

@@ -1,18 +1,14 @@
-import { pathToFileURL } from 'node:url';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { ModuleRunner, EvaluatedModules } from 'vite/module-runner';
 import { readFileSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
+import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
-import { V as VitestTransport } from './chunks/moduleTransport.I-bgQy0S.js';
-import { e as environments } from './chunks/index.DIWhzsUh.js';
-import { s as setupInspect } from './chunks/inspector.CvQD-Nie.js';
-import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.BKr6mtxz.js';
-import { i as isChildProcess } from './chunks/utils.D2R2NiOH.js';
-import { d as disposeInternalListeners } from './chunks/utils.C2YI6McM.js';
-import 'node:console';
-import '@vitest/utils';
-import './chunks/index.Bgo3tNWt.js';
+import { b as VitestTransport } from './startModuleRunner.DPBo3mme.js';
+import { e as environments } from './index.Bt-upxGS.js';
+import { s as setupInspect } from './inspector.Br76Q2Mb.js';
+import { c as createRuntimeRpc, a as rpcDone } from './rpc.cD77ENhU.js';
+import { i as isChildProcess } from './utils.CG9h5ccR.js';
 
 function isBuiltinEnvironment(env) {
 	return env in environments;
@@ -28,13 +24,10 @@ async function createEnvironmentLoader(root, rpc) {
 			transport: new VitestTransport({
 				async fetchModule(id, importer, options) {
 					const result = await rpc.fetch(id, importer, "__vitest__", options);
-					if ("cached" in result) {
-						const code = readFileSync(result.tmp, "utf-8");
-						return {
-							code,
-							...result
-						};
-					}
+					if ("cached" in result) return {
+						code: readFileSync(result.tmp, "utf-8"),
+						...result
+					};
 					if (isWindows && "externalize" in result)
  // TODO: vitest returns paths for external modules, but Vite returns file://
 					// https://github.com/vitejs/vite/pull/20449
@@ -66,26 +59,72 @@ async function loadEnvironment(ctx, rpc) {
 	};
 }
 
-const listeners = /* @__PURE__ */ new Set();
-function addCleanupListener(listener) {
-	listeners.add(listener);
+const REGEXP_WRAP_PREFIX = "$$vitest:", processSend = process.send?.bind(process), processOn = process.on?.bind(process), processOff = process.off?.bind(process), dispose = [];
+function createThreadsRpcOptions({ port }) {
+	return {
+		post: (v) => {
+			port.postMessage(v);
+		},
+		on: (fn) => {
+			port.addListener("message", fn);
+		}
+	};
 }
-async function cleanup() {
-	const promises = [...listeners].map((l) => l());
-	await Promise.all(promises);
+function disposeInternalListeners() {
+	for (const fn of dispose) try {
+		fn();
+	} catch {}
+	dispose.length = 0;
+}
+function createForksRpcOptions(nodeV8) {
+	return {
+		serialize: nodeV8.serialize,
+		deserialize: (v) => nodeV8.deserialize(Buffer.from(v)),
+		post(v) {
+			processSend(v);
+		},
+		on(fn) {
+			const handler = (message, ...extras) => {
+				if (!message?.__tinypool_worker_message__) return fn(message, ...extras);
+			};
+			processOn("message", handler), dispose.push(() => processOff("message", handler));
+		}
+	};
+}
+/**
+* Reverts the wrapping done by `utils/config-helpers.ts`'s `wrapSerializableConfig`
+*/
+function unwrapSerializableConfig(config) {
+	if (config.testNamePattern && typeof config.testNamePattern === "string") {
+		const testNamePattern = config.testNamePattern;
+		if (testNamePattern.startsWith(REGEXP_WRAP_PREFIX)) config.testNamePattern = parseRegexp(testNamePattern.slice(9));
+	}
+	if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
+		const { keys, original } = config.defines, defines = {};
+		// Apply all keys from the original. Entries which had undefined value are missing from original now
+		for (const key of keys) defines[key] = original[key];
+		config.defines = defines;
+	}
+	return config;
+}
+function parseRegexp(input) {
+	// Parse input
+	// eslint-disable-next-line regexp/no-misleading-capturing-group
+	const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
+	// Create the regular expression
+	return m ? m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3]) ? new RegExp(input) : new RegExp(m[2], m[3]) : /$^/;
 }
 
 if (isChildProcess()) {
-	const isProfiling = process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"));
-	if (isProfiling)
+	if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir")))
  // Work-around for nodejs/node#55094
 	process.on("SIGTERM", () => {
 		process.exit();
 	});
 }
-const resolvingModules = /* @__PURE__ */ new Set();
+const resolvingModules = /* @__PURE__ */ new Set(), globalListeners = /* @__PURE__ */ new Set();
 // this is what every pool executes when running tests
-async function execute(method, ctx) {
+async function execute(method, ctx, worker) {
 	disposeInternalListeners();
 	const prepareStart = performance.now(), cleanups = [setupInspect(ctx)];
 	process.env.VITEST_WORKER_ID = String(ctx.workerId);
@@ -93,11 +132,6 @@ async function execute(method, ctx) {
 	process.env.VITEST_POOL_ID = String(poolId);
 	let environmentLoader;
 	try {
-		// worker is a filepath or URL to a file that exposes a default export with "getRpcOptions" and "runTests" methods
-		if (ctx.worker[0] === ".") throw new Error(`Path to the test runner cannot be relative, received "${ctx.worker}"`);
-		const file = ctx.worker.startsWith("file:") ? ctx.worker : pathToFileURL(ctx.worker).toString(), testRunnerModule = await import(file);
-		if (!testRunnerModule.default || typeof testRunnerModule.default !== "object") throw new TypeError(`Test worker object should be exposed as a default export. Received "${typeof testRunnerModule.default}"`);
-		const worker = testRunnerModule.default;
 		if (!worker.getRpcOptions || typeof worker.getRpcOptions !== "function") throw new TypeError(`Test worker should expose "getRpcOptions" method. Received "${typeof worker.getRpcOptions}".`);
 		// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
 		const { rpc, onCancel } = createRuntimeRpc(worker.getRpcOptions(ctx));
@@ -122,7 +156,7 @@ async function execute(method, ctx) {
 				prepare: prepareStart
 			},
 			rpc,
-			onCleanup: (listener) => addCleanupListener(listener),
+			onCleanup: (listener) => globalListeners.add(listener),
 			providedContext: ctx.providedContext,
 			onFilterStackTrace(stack) {
 				return createStackString(parseStacktrace(stack));
@@ -135,14 +169,9 @@ async function execute(method, ctx) {
 		await Promise.all(cleanups.map((fn) => fn())), await rpcDone().catch(() => {}), environmentLoader?.close();
 	}
 }
-function run(ctx) {
-	return execute("run", ctx);
-}
-function collect(ctx) {
-	return execute("collect", ctx);
-}
 async function teardown() {
-	return cleanup();
+	const promises = [...globalListeners].map((l) => l());
+	await Promise.all(promises);
 }
 function createImportMetaEnvProxy() {
 	// packages/vitest/src/node/plugins/index.ts:146
@@ -153,7 +182,7 @@ function createImportMetaEnvProxy() {
 	];
 	return new Proxy(process.env, {
 		get(_, key) {
-			return typeof key === "string" ? booleanKeys.includes(key) ? !!process.env[key] : process.env[key] : void 0;
+			if (typeof key === "string") return booleanKeys.includes(key) ? !!process.env[key] : process.env[key];
 		},
 		set(_, key, value) {
 			if (typeof key !== "string") return true;
@@ -164,4 +193,4 @@ function createImportMetaEnvProxy() {
 	});
 }
 
-export { collect, run, teardown };
+export { createThreadsRpcOptions as a, createForksRpcOptions as c, execute as e, teardown as t, unwrapSerializableConfig as u };

package/dist/chunks/{worker.d.BDsXGkwh.d.ts → worker.d.buwuBpBt.d.ts}

@@ -1,86 +1,12 @@
 import { CancelReason, File, TestAnnotation, TaskResultPack, TaskEventPack, FileSpecification, Task } from '@vitest/runner';
 import { FetchFunctionOptions, FetchResult, EvaluatedModules } from 'vite/module-runner';
-import { a as SerializedConfig } from './config.d.B_LthbQq.js';
+import { a as SerializedConfig } from './config.d.DGazh2r6.js';
 import { F as FetchCachedFileSystemResult, R as ResolveFunctionResult, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.BsToaxti.js';
 import { SnapshotResult } from '@vitest/snapshot';
 
 type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
 type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
 type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
-type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
-interface ChannelOptions {
-    /**
-     * Function to post raw message
-     */
-    post: (data: any, ...extras: any[]) => any | Promise<any>;
-    /**
-     * Listener to receive raw message
-     */
-    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
-    /**
-     * Clear the listener when `$close` is called
-     */
-    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
-    /**
-     * Custom function to serialize data
-     *
-     * by default it passes the data as-is
-     */
-    serialize?: (data: any) => any;
-    /**
-     * Custom function to deserialize data
-     *
-     * by default it passes the data as-is
-     */
-    deserialize?: (data: any) => any;
-    /**
-     * Call the methods with the RPC context or the original functions object
-     */
-    bind?: 'rpc' | 'functions';
-}
-interface EventOptions<Remote> {
-    /**
-     * Names of remote functions that do not need response.
-     */
-    eventNames?: (keyof Remote)[];
-    /**
-     * Maximum timeout for waiting for response, in milliseconds.
-     *
-     * @default 60_000
-     */
-    timeout?: number;
-    /**
-     * Custom resolver to resolve function to be called
-     *
-     * For advanced use cases only
-     */
-    resolver?: BirpcResolver;
-    /**
-     * Custom error handler
-     *
-     * @deprecated use `onFunctionError` and `onGeneralError` instead
-     */
-    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
-    /**
-     * Custom error handler for errors occurred in local functions being called
-     *
-     * @returns `true` to prevent the error from being thrown
-     */
-    onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
-    /**
-     * Custom error handler for errors occurred during serialization or messsaging
-     *
-     * @returns `true` to prevent the error from being thrown
-     */
-    onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
-    /**
-     * Custom error handler for timeouts
-     *
-     * @returns `true` to prevent the error from being thrown
-     */
-    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
-}
-type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
 type BirpcFn<T> = PromisifyFn<T> & {
     /**
      * Send event without asking for response
@@ -134,7 +60,6 @@ interface ContextTestEnvironment {
 type TestExecutionMethod = "run" | "collect";
 interface ContextRPC {
 	pool: string;
-	worker: string;
 	workerId: number;
 	config: SerializedConfig;
 	projectName: string;
@@ -172,4 +97,4 @@ interface WorkerGlobalState {
 	onFilterStackTrace?: (trace: string) => string;
 }
 
-export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, TestExecutionMethod as T, WorkerGlobalState as W, BirpcReturn as a, RunnerRPC as b, ContextTestEnvironment as c };
+export type { BirpcReturn as B, ContextRPC as C, RunnerRPC as R, TestExecutionMethod as T, WorkerGlobalState as W, RuntimeRPC as a, ContextTestEnvironment as b };

package/dist/cli.js

@@ -1,27 +1,29 @@
-import { c as createCLI } from './chunks/cac.DCxo_nSu.js';
-import '@vitest/utils';
+import { c as createCLI } from './chunks/cac.r1gel_VZ.js';
+import '@vitest/utils/helpers';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
 import './chunks/constants.D_Q9UYh-.js';
-import './chunks/index.BIP7prJq.js';
+import './chunks/index.CHrBLuEH.js';
 import 'node:fs';
 import 'node:fs/promises';
-import './chunks/typechecker.DB-fIMaH.js';
+import './chunks/typechecker.BfOQ86_a.js';
 import 'node:os';
 import 'node:perf_hooks';
-import '@vitest/utils/source-map';
 import 'tinyexec';
 import './path.js';
 import 'node:path';
 import 'node:url';
 import '@vitest/runner/utils';
 import 'vite';
+import '@vitest/utils/source-map';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
 import 'node:util';
 import 'node:console';
 import 'node:stream';
+import '@vitest/utils/display';
+import '@vitest/utils/offset';
 import 'node:module';
 
 createCLI().parse();