vitest 4.0.0-beta.9 → 4.0.1

package/dist/chunks/{vi.BB37KeLx.js → vi.BZvkKVkM.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,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();
@@ -57,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);
 					}
 				});
@@ -86,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;
@@ -203,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. ",
@@ -261,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");
@@ -277,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,
@@ -290,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);
@@ -310,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),
@@ -321,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({
@@ -339,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({
@@ -362,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.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}`);
@@ -384,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, {
@@ -392,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 = {};
@@ -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;
 	}
 }
@@ -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;
@@ -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 { 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.CjLTDaST.js → vm.CuMWYx_F.js}

@@ -2,15 +2,16 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import vm, { isContext, runInContext } from 'node:vm';
 import { dirname, basename, extname, normalize, resolve } from 'pathe';
 import { distDir } from '../path.js';
-import { createCustomConsole } from './console.7h5kHUIf.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.BDRvKSdz.js';
-import { p as provideWorkerState } from './utils.D2R2NiOH.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.iF1E9Bt4.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() {
@@ -615,7 +605,8 @@ async function runVmTests(method, state) {
 		context,
 		evaluatedModules: state.evaluatedModules,
 		state,
-		externalModulesExecutor
+		externalModulesExecutor,
+		createImportMeta: createNodeImportMeta
 	});
 	if (Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
 		value: {

package/dist/chunks/{worker.d.B2r4Ln6p.d.ts → worker.d.BFk-vvBU.d.ts}

@@ -1,9 +1,45 @@
 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.DacWrqWe.js';
-import { F as FetchCachedFileSystemResult, R as ResolveFunctionResult, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.2fYMoz3o.js';
+import { S as SerializedConfig } from './config.d.u2CUDWwS.js';
+import { E as Environment } from './environment.d.CrsxCzP1.js';
 import { SnapshotResult } from '@vitest/snapshot';
 
+interface AfterSuiteRunMeta {
+	coverage?: unknown;
+	testFiles: string[];
+	environment: string;
+	projectName?: string;
+}
+interface UserConsoleLog {
+	content: string;
+	origin?: string;
+	browser?: boolean;
+	type: "stdout" | "stderr";
+	taskId?: string;
+	time: number;
+	size: number;
+}
+interface ModuleGraphData {
+	graph: Record<string, string[]>;
+	externalized: string[];
+	inlined: string[];
+}
+interface ProvidedContext {}
+interface ResolveFunctionResult {
+	id: string;
+	file: string;
+	url: string;
+}
+interface FetchCachedFileSystemResult {
+	cached: true;
+	tmp: string;
+	id: string;
+	file: string | null;
+	url: string;
+	invalidate: boolean;
+}
+type LabelColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+
 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>>>;
@@ -134,14 +170,14 @@ interface ContextTestEnvironment {
 type TestExecutionMethod = "run" | "collect";
 interface ContextRPC {
 	pool: string;
-	worker: string;
-	workerId: number;
 	config: SerializedConfig;
 	projectName: string;
-	files: string[] | FileSpecification[];
+	files: FileSpecification[];
 	environment: ContextTestEnvironment;
 	providedContext: Record<string, any>;
 	invalidates?: string[];
+	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
+	workerId: number;
 }
 interface WorkerGlobalState {
 	ctx: ContextRPC;
@@ -172,4 +208,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 { AfterSuiteRunMeta as A, BirpcOptions as B, ContextRPC as C, LabelColor as L, ModuleGraphData as M, ProvidedContext as P, RuntimeRPC as R, TestExecutionMethod as T, UserConsoleLog as U, WorkerGlobalState as W, BirpcReturn as a, RunnerRPC as b, ContextTestEnvironment as c, ResolveFunctionResult as d };

package/dist/cli.js

@@ -1,27 +1,28 @@
-import { c as createCLI } from './chunks/cac.Dt7e1TIu.js';
-import '@vitest/utils';
+import { c as createCLI } from './chunks/cac.DrF4Gm0S.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.CcRZ6fUh.js';
 import 'node:fs';
 import 'node:fs/promises';
-import './chunks/typechecker.DB-fIMaH.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 'node:os';
+import 'tinyexec';
+import './path.js';
+import 'node:path';
+import 'node:url';
+import 'vite';
+import '@vitest/utils/offset';
 import 'node:module';
 
 createCLI().parse();

package/dist/config.cjs

@@ -43,7 +43,6 @@ const configDefaults = Object.freeze({
 	watch: !stdEnv.isCI && process.stdin.isTTY,
 	globals: false,
 	environment: "node",
-	pool: "forks",
 	clearMocks: false,
 	restoreMocks: false,
 	mockReset: false,