vitest 4.0.0-beta.8 → 4.0.0

package/dist/chunks/{vi.BfdOiD4j.js → vi.BZvkKVkM.js}

@@ -1,14 +1,15 @@
-import { 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 * as chai$1 from 'chai';
-import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.C7__0Iv5.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
@@ -26,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) {
@@ -40,17 +41,18 @@ 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);
-						const rejectWithCause = (cause) => {
-							reject(copyStackTrace$1(new Error("Matcher did not succeed in time.", { cause }), STACK_TRACE_ERROR));
+						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));
 						};
 						check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
 					}, timeout), check();
@@ -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({
@@ -359,16 +253,15 @@ function createExpect(test) {
 		isExpectingAssertionsError: null,
 		expectedAssertionsNumber: null,
 		expectedAssertionsNumberErrorGen: null,
-		environment: getCurrentEnvironment(),
 		get testPath() {
 			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.assert = chai.assert, 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}`);
@@ -386,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, {
@@ -394,14 +287,15 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
 	writable: true,
 	configurable: true
 });
+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 = {};
@@ -3503,9 +3397,9 @@ class FakeTimers {
 	// | _fakingTime | _fakingDate |
 	// +-------------+-------------+
 	// | false       | falsy       | initial
-	// | false       | truthy     | vi.setSystemTime called first (for mocking only Date without fake timers)
+	// | false       | truthy      | vi.setSystemTime called first (for mocking only Date without fake timers)
 	// | true        | falsy       | vi.useFakeTimers called first
-	// | true        | truthy     | unreachable
+	// | true        | truthy      | unreachable
 	_fakingTime;
 	_fakingDate;
 	_fakeTimers;
@@ -3561,17 +3455,17 @@ class FakeTimers {
 		if (this._fakingTime) this._clock.uninstall(), this._fakingTime = false;
 	}
 	useFakeTimers() {
-		if (this._fakingDate) throw new Error("\"setSystemTime\" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.");
-		if (!this._fakingTime) {
-			const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
-			if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process");
-			this._clock = this._fakeTimers.install({
-				now: Date.now(),
-				...this._userConfig,
-				toFake: this._userConfig?.toFake || toFake,
-				ignoreMissingTimers: true
-			}), this._fakingTime = true;
-		}
+		const fakeDate = this._fakingDate || Date.now();
+		if (this._fakingDate) resetDate(), this._fakingDate = null;
+		if (this._fakingTime) this._clock.uninstall();
+		const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
+		if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process");
+		this._clock = this._fakeTimers.install({
+			now: fakeDate,
+			...this._userConfig,
+			toFake: this._userConfig?.toFake || toFake,
+			ignoreMissingTimers: true
+		}), this._fakingTime = true;
 	}
 	reset() {
 		if (this._checkFakeTimers()) {
@@ -3600,7 +3494,7 @@ class FakeTimers {
 		return this._fakingTime;
 	}
 	_checkFakeTimers() {
-		if (!this._fakingTime) throw new Error("Timers are not mocked. Try calling \"vi.useFakeTimers()\" first.");
+		if (!this._fakingTime) throw new Error("A function to advance timers was called but the timers APIs are not mocked. Call `vi.useFakeTimers()` in the test file first.");
 		return this._fakingTime;
 	}
 }
@@ -3677,11 +3571,11 @@ function waitUntil(callback, options = {}) {
 
 function createVitest() {
 	let _config = null;
-	const workerState = getWorkerState();
+	const state = () => getWorkerState();
 	let _timers;
 	const timers = () => _timers ||= new FakeTimers({
 		global: globalThis,
-		config: workerState.config.fakeTimers
+		config: state().config.fakeTimers
 	}), _stubsGlobal = /* @__PURE__ */ new Map(), _stubsEnv = /* @__PURE__ */ new Map(), _envBooleans = [
 		"PROD",
 		"DEV",
@@ -3689,13 +3583,13 @@ function createVitest() {
 	], utils = {
 		useFakeTimers(config) {
 			if (isChildProcess()) {
-				if (config?.toFake?.includes("nextTick") || workerState.config?.fakeTimers?.toFake?.includes("nextTick")) throw new Error("vi.useFakeTimers({ toFake: [\"nextTick\"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.");
+				if (config?.toFake?.includes("nextTick") || state().config?.fakeTimers?.toFake?.includes("nextTick")) throw new Error("vi.useFakeTimers({ toFake: [\"nextTick\"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.");
 			}
 			if (config) timers().configure({
-				...workerState.config.fakeTimers,
+				...state().config.fakeTimers,
 				...config
 			});
-			else timers().configure(workerState.config.fakeTimers);
+			else timers().configure(state().config.fakeTimers);
 			return timers().useFakeTimers(), utils;
 		},
 		isFakeTimers() {
@@ -3772,13 +3666,16 @@ function createVitest() {
 		},
 		doUnmock(path) {
 			if (typeof path !== "string") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
-			_mocker().queueUnmock(path, getImporter("doUnmock"));
+			const importer = getImporter("doUnmock");
+			_mocker().queueUnmock(path, importer);
 		},
 		async importActual(path) {
-			return _mocker().importActual(path, getImporter("importActual"), _mocker().getMockContext().callstack);
+			const importer = getImporter("importActual");
+			return _mocker().importActual(path, importer, _mocker().getMockContext().callstack);
 		},
 		async importMock(path) {
-			return _mocker().importMock(path, getImporter("importMock"));
+			const importer = getImporter("importMock");
+			return _mocker().importMock(path, importer);
 		},
 		mockObject(value, options) {
 			return _mocker().mockObject({ value }, void 0, options?.spy ? "autospy" : "automock").value;
@@ -3808,7 +3705,7 @@ function createVitest() {
 			}), utils;
 		},
 		stubEnv(name, value) {
-			const state = getWorkerState(), env = state.metaEnv;
+			const env = state().metaEnv;
 			if (!_stubsEnv.has(name)) _stubsEnv.set(name, env[name]);
 			if (_envBooleans.includes(name)) env[name] = value ? "1" : "";
 			else if (value === void 0) delete env[name];
@@ -3822,24 +3719,24 @@ function createVitest() {
 			}), _stubsGlobal.clear(), utils;
 		},
 		unstubAllEnvs() {
-			const state = getWorkerState(), env = state.metaEnv;
+			const env = state().metaEnv;
 			return _stubsEnv.forEach((original, name) => {
 				if (original === void 0) delete env[name];
 				else env[name] = original;
 			}), _stubsEnv.clear(), utils;
 		},
 		resetModules() {
-			return resetModules(workerState.evaluatedModules), utils;
+			return resetModules(state().evaluatedModules), utils;
 		},
 		async dynamicImportSettled() {
 			return waitForImportsToResolve();
 		},
 		setConfig(config) {
-			if (!_config) _config = { ...workerState.config };
-			Object.assign(workerState.config, config);
+			if (!_config) _config = { ...state().config };
+			Object.assign(state().config, config);
 		},
 		resetConfig() {
-			if (_config) Object.assign(workerState.config, _config);
+			if (_config) Object.assign(state().config, _config);
 		}
 	};
 	return utils;
@@ -3853,10 +3750,10 @@ function _mocker() {
 	} });
 }
 function getImporter(name) {
-	const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 }), stackArray = stackTrace.split("\n"), importerStackIndex = stackArray.findIndex((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 { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, inject as i, vi as v };
+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/chunks/{vm.BHBje7cC.js → vm.DBeOXrP9.js}

@@ -1,16 +1,17 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import vm, { isContext } from 'node:vm';
+import vm, { isContext, runInContext } from 'node:vm';
 import { dirname, basename, extname, normalize, resolve } from 'pathe';
 import { distDir } from '../path.js';
-import { createCustomConsole } from './console.B0quX7yH.js';
+import { createCustomConsole } from './console.CTJL2nuH.js';
 import fs from 'node:fs';
 import { createRequire, Module, isBuiltin } from 'node:module';
-import { CSS_LANGS_RE, KNOWN_ASSET_RE, toArray, isBareImport } from '@vitest/utils';
-import { f as findNearestPackageData } from './resolver.Bx6lE0iq.js';
+import { toArray, isBareImport } from '@vitest/utils/helpers';
+import { findNearestPackageData } from '@vitest/utils/resolver';
 import { dirname as dirname$1 } from 'node:path';
+import { CSS_LANGS_RE, KNOWN_ASSET_RE } from '@vitest/utils/constants';
 import { getDefaultRequestStubs } from '../module-evaluator.js';
-import { s as startVitestModuleRunner, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.C8TW8zTN.js';
-import { p as provideWorkerState } from './utils.C7__0Iv5.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.C2tTvmF9.js';
+import { p as provideWorkerState } from './utils.CG9h5ccR.js';
 
 function interopCommonJsModule(interopDefault, mod) {
 	if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) return {
@@ -35,8 +36,7 @@ function interopCommonJsModule(interopDefault, mod) {
 	};
 }
 function isPrimitive(obj) {
-	const isObject = obj != null && (typeof obj === "object" || typeof obj === "function");
-	return !isObject;
+	return !(obj != null && (typeof obj === "object" || typeof obj === "function"));
 }
 const SyntheticModule = vm.SyntheticModule;
 const SourceTextModule = vm.SourceTextModule;
@@ -105,8 +105,7 @@ class CommonjsExecutor {
 			}
 			// exposed for external use, Node.js does the opposite
 			static _load = (request, parent, _isMain) => {
-				const require = Module$1.createRequire(parent?.filename ?? request);
-				return require(request);
+				return Module$1.createRequire(parent?.filename ?? request)(request);
 			};
 			static wrap = (script) => {
 				return Module$1.wrapper[0] + script + Module$1.wrapper[1];
@@ -156,8 +155,8 @@ class CommonjsExecutor {
 	};
 	createRequire = (filename) => {
 		const _require = createRequire(filename), require = ((id) => {
-			const resolved = _require.resolve(id), ext = extname(resolved);
-			if (ext === ".node" || isBuiltin(resolved)) return this.requireCoreModule(resolved);
+			const resolved = _require.resolve(id);
+			if (extname(resolved) === ".node" || isBuiltin(resolved)) return this.requireCoreModule(resolved);
 			const module = new this.Module(resolved);
 			return this.loadCommonJSModule(module, resolved);
 		});
@@ -187,8 +186,8 @@ class CommonjsExecutor {
 	loadCommonJSModule(module, filename) {
 		const cached = this.requireCache.get(filename);
 		if (cached) return cached.exports;
-		const extension = this.findLongestRegisteredExtension(filename), loader = this.extensions[extension] || this.extensions[".js"];
-		return loader(module, filename), module.exports;
+		const extension = this.findLongestRegisteredExtension(filename);
+		return (this.extensions[extension] || this.extensions[".js"])(module, filename), module.exports;
 	}
 	findLongestRegisteredExtension(filename) {
 		const name = basename(filename);
@@ -259,8 +258,7 @@ class CommonjsExecutor {
 	//   return namedExports
 	// }
 	require(identifier) {
-		const ext = extname(identifier);
-		if (ext === ".node" || isBuiltin(identifier)) return this.requireCoreModule(identifier);
+		if (extname(identifier) === ".node" || isBuiltin(identifier)) return this.requireCoreModule(identifier);
 		const module = new this.Module(identifier);
 		return this.loadCommonJSModule(module, identifier);
 	}
@@ -345,7 +343,8 @@ class EsmExecutor {
 		if (cached) return cached;
 		const wasmModule = await WebAssembly.compile(source), exports = WebAssembly.Module.exports(wasmModule), imports = WebAssembly.Module.imports(wasmModule), moduleLookup = {};
 		for (const { module } of imports) if (moduleLookup[module] === void 0) moduleLookup[module] = await this.executor.resolveModule(module, identifier);
-		const evaluateModule = (module) => this.evaluateModule(module), syntheticModule = new SyntheticModule(exports.map(({ name }) => name), async function() {
+		const evaluateModule = (module) => this.evaluateModule(module);
+		return new SyntheticModule(exports.map(({ name }) => name), async function() {
 			const importsObject = {};
 			for (const { module, name } of imports) {
 				if (!importsObject[module]) importsObject[module] = {};
@@ -357,7 +356,6 @@ class EsmExecutor {
 			context: this.context,
 			identifier
 		});
-		return syntheticModule;
 	}
 	cacheModule(identifier, module) {
 		this.moduleCache.set(identifier, module);
@@ -416,9 +414,7 @@ class ViteExecutor {
 		return this.options.context.__vitest_worker__;
 	}
 	async createViteModule(fileUrl) {
-		if (fileUrl === CLIENT_FILE || fileUrl === CLIENT_ID) return this.createViteClientModule();
-		const cached = this.esm.resolveCachedModule(fileUrl);
-		return cached || this.esm.createEsModule(fileUrl, async () => {
+		return fileUrl === CLIENT_FILE || fileUrl === CLIENT_ID ? this.createViteClientModule() : this.esm.resolveCachedModule(fileUrl) || this.esm.createEsModule(fileUrl, async () => {
 			try {
 				const result = await this.options.transform(fileUrl);
 				if (result.code) return result.code;
@@ -529,10 +525,7 @@ class ExternalModulesExecutor {
  // still experimental on NodeJS --experimental-wasm-modules
 		// cf. ESM_FILE_FORMAT(url) in https://nodejs.org/docs/latest-v20.x/api/esm.html#resolution-algorithm
 		type = "wasm";
-		else {
-			const pkgData = findNearestPackageData(normalize(pathUrl));
-			type = pkgData.type === "module" ? "module" : "commonjs";
-		}
+		else type = findNearestPackageData(normalize(pathUrl)).type === "module" ? "module" : "commonjs";
 		return {
 			type,
 			path: pathUrl,
@@ -555,10 +548,7 @@ class ExternalModulesExecutor {
 			case "module": return this.esm.createEsModule(url, () => this.fs.readFileAsync(path));
 			case "commonjs": return this.cjs.getCjsSyntheticModule(path, identifier);
 			case "network": return this.esm.createNetworkModule(url);
-			default: {
-				const _deadend = type;
-				return _deadend;
-			}
+			default: return type;
 		}
 	}
 	get isNetworkSupported() {
@@ -611,13 +601,14 @@ async function runVmTests(method, state) {
 		packageCache,
 		transform: rpc.transform,
 		viteClientModule: stubs["/@vite/client"]
-	}), moduleRunner = await startVitestModuleRunner({
+	}), moduleRunner = startVitestModuleRunner({
 		context,
 		evaluatedModules: state.evaluatedModules,
 		state,
-		externalModulesExecutor
+		externalModulesExecutor,
+		createImportMeta: createNodeImportMeta
 	});
-	Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
+	if (Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
 		value: {
 			context,
 			externalModulesExecutor
@@ -625,7 +616,12 @@ async function runVmTests(method, state) {
 		configurable: true,
 		enumerable: false,
 		writable: false
-	}), context.__vitest_mocker__ = moduleRunner.mocker;
+	}), context.__vitest_mocker__ = moduleRunner.mocker, ctx.config.serializedDefines) try {
+		runInContext(ctx.config.serializedDefines, context, { filename: "virtual:load-defines.js" });
+	} catch (error) {
+		throw new Error(`Failed to load custom "defines": ${error.message}`);
+	}
+	await moduleRunner.mocker.initializeSpyModule();
 	const { run } = await moduleRunner.import(entryFile), fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
 		filepath: f,
 		testLocations: void 0