vitest 3.2.0-beta.2 → 3.2.0-beta.3

package/dist/chunks/{typechecker.DnTrplSJ.js → typechecker.BgzF-6iO.js}

@@ -64,9 +64,11 @@ function getOutputFile(config, reporter) {
 function wrapSerializableConfig(config) {
 	let testNamePattern = config.testNamePattern;
 	let defines = config.defines;
+	// v8 serialize does not support regex
 	if (testNamePattern && typeof testNamePattern !== "string") {
 		testNamePattern = `${REGEXP_WRAP_PREFIX}${testNamePattern.toString()}`;
 	}
+	// v8 serialize drops properties with undefined value
 	if (defines) {
 		defines = {
 			keys: Object.keys(defines),
@@ -402,11 +404,14 @@ async function collectTests(ctx, filepath) {
 			].includes(callee.object.name)) {
 				return callee.object?.name;
 			}
+			// direct call as `__vite_ssr_exports_0__.test()`
 			if (callee.object?.name?.startsWith("__vite_ssr_")) {
 				return getName(callee.property);
 			}
+			// call as `__vite_ssr__.test.skip()`
 			return getName(callee.object?.property);
 		}
+		// unwrap (0, ...)
 		if (callee.type === "SequenceExpression" && callee.expressions.length === 2) {
 			const [e0, e1] = callee.expressions;
 			if (e0.type === "Literal" && e0.value === 0) {
@@ -431,6 +436,7 @@ async function collectTests(ctx, filepath) {
 		}
 		const property = callee?.property?.name;
 		let mode = !property || property === name ? "run" : property;
+		// they will be picked up in the next iteration
 		if ([
 			"each",
 			"for",
@@ -441,6 +447,7 @@ async function collectTests(ctx, filepath) {
 		}
 		let start;
 		const end = node.end;
+		// .each
 		if (callee.type === "CallExpression") {
 			start = callee.end;
 		} else if (callee.type === "TaggedTemplateExpression") {
@@ -451,6 +458,7 @@ async function collectTests(ctx, filepath) {
 		const { arguments: [messageNode] } = node;
 		const isQuoted = messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral";
 		const message = isQuoted ? request.code.slice(messageNode.start + 1, messageNode.end - 1) : request.code.slice(messageNode.start, messageNode.end);
+		// cannot statically analyze, so we always skip it
 		if (mode === "skipIf" || mode === "runIf") {
 			mode = "skip";
 		}
@@ -474,6 +482,7 @@ async function collectTests(ctx, filepath) {
 		const latestSuite = updateLatestSuite(definition.start);
 		let mode = definition.mode;
 		if (latestSuite.mode !== "run") {
+			// inherit suite mode, if it's set
 			mode = latestSuite.mode;
 		}
 		if (definition.type === "suite") {
@@ -530,6 +539,7 @@ async function makeTscErrorInfo(errInfo) {
 		return ["unknown filepath", null];
 	}
 	const errMsgRaw = errMsgRawArr.join("").trim();
+	// get filePath, line, col
 	const [errFilePath, errPos] = errFilePathPos.slice(0, -1).split("(");
 	if (!errFilePath || !errPos) {
 		return ["unknown filepath", null];
@@ -538,6 +548,7 @@ async function makeTscErrorInfo(errInfo) {
 	if (!errLine || !errCol) {
 		return [errFilePath, null];
 	}
+	// get errCode, errMsg
 	const execArr = errCodeRegExp.exec(errMsgRaw);
 	if (!execArr) {
 		return [errFilePath, null];
@@ -559,6 +570,7 @@ async function makeTscErrorInfo(errInfo) {
 }
 async function getRawErrsMapFromTsCompile(tscErrorStdout) {
 	const rawErrsMap = new Map();
+	// Merge details line with main line (i.e. which contains file path)
 	const infos = await Promise.all(tscErrorStdout.split(newLineRegExp).reduce((prev, next) => {
 		if (!next) {
 			return prev;
@@ -686,6 +698,7 @@ class Typechecker {
 				return;
 			}
 			const sortedDefinitions = [...definitions.sort((a, b) => b.start - a.start)];
+			// has no map for ".js" files that use // @ts-check
 			const traceMap = map && new TraceMap(map);
 			const indexMap = createIndexMap(parsed);
 			const markState = (task, state) => {
@@ -743,6 +756,7 @@ class Typechecker {
 			const suiteErrors = errors.map((info) => {
 				const limit = Error.stackTraceLimit;
 				Error.stackTraceLimit = 0;
+				// Some expect-type errors have the most useful information on the second line e.g. `This expression is not callable.\n  Type 'ExpectString<number>' has no call signatures.`
 				const errMsg = info.errMsg.replace(/\r?\n\s*(Type .* has no call signatures)/g, " $1");
 				const error = new TypeCheckError(errMsg, [{
 					file: filepath,
@@ -784,10 +798,7 @@ class Typechecker {
 	getOutput() {
 		return this._output;
 	}
-	async start() {
-		if (this.process) {
-			return;
-		}
+	async spawn() {
 		const { root, watch, typecheck } = this.project.config;
 		const args = [
 			"--noEmit",
@@ -797,6 +808,7 @@ class Typechecker {
 			"--tsBuildInfoFile",
 			join(process.versions.pnp ? join(nodeos__default.tmpdir(), this.project.hash) : distDir, "tsconfig.tmp.tsbuildinfo")
 		];
+		// use builtin watcher because it's faster
 		if (watch) {
 			args.push("--watch");
 		}
@@ -816,30 +828,72 @@ class Typechecker {
 			throwOnError: false
 		});
 		this.process = child.process;
-		await this._onParseStart?.();
 		let rerunTriggered = false;
-		child.process?.stdout?.on("data", (chunk) => {
-			this._output += chunk;
-			if (!watch) {
+		let dataReceived = false;
+		return new Promise((resolve, reject) => {
+			if (!child.process || !child.process.stdout) {
+				reject(new Error(`Failed to initialize ${typecheck.checker}. This is a bug in Vitest - please, open an issue with reproduction.`));
 				return;
 			}
-			if (this._output.includes("File change detected") && !rerunTriggered) {
-				this._onWatcherRerun?.();
-				this._startTime = performance.now();
-				this._result.sourceErrors = [];
-				this._result.files = [];
-				this._tests = null;
-				rerunTriggered = true;
+			child.process.stdout.on("data", (chunk) => {
+				dataReceived = true;
+				this._output += chunk;
+				if (!watch) {
+					return;
+				}
+				if (this._output.includes("File change detected") && !rerunTriggered) {
+					this._onWatcherRerun?.();
+					this._startTime = performance.now();
+					this._result.sourceErrors = [];
+					this._result.files = [];
+					this._tests = null;
+					rerunTriggered = true;
+				}
+				if (/Found \w+ errors*. Watching for/.test(this._output)) {
+					rerunTriggered = false;
+					this.prepareResults(this._output).then((result) => {
+						this._result = result;
+						this._onParseEnd?.(result);
+					});
+					this._output = "";
+				}
+			});
+			const timeout = setTimeout(() => reject(new Error(`${typecheck.checker} spawn timed out`)), this.project.config.typecheck.spawnTimeout);
+			function onError(cause) {
+				clearTimeout(timeout);
+				reject(new Error("Spawning typechecker failed - is typescript installed?", { cause }));
 			}
-			if (/Found \w+ errors*. Watching for/.test(this._output)) {
-				rerunTriggered = false;
-				this.prepareResults(this._output).then((result) => {
-					this._result = result;
-					this._onParseEnd?.(result);
+			child.process.once("spawn", () => {
+				this._onParseStart?.();
+				child.process?.off("error", onError);
+				clearTimeout(timeout);
+				if (process.platform === "win32") {
+					// on Windows, the process might be spawned but fail to start
+					// we wait for a potential error here. if "close" event didn't trigger,
+					// we resolve the promise
+					setTimeout(() => {
+						resolve({ result: child });
+					}, 200);
+				} else {
+					resolve({ result: child });
+				}
+			});
+			if (process.platform === "win32") {
+				child.process.once("close", (code) => {
+					if (code != null && code !== 0 && !dataReceived) {
+						onError(new Error(`The ${typecheck.checker} command exited with code ${code}.`));
+					}
 				});
-				this._output = "";
 			}
+			child.process.once("error", onError);
 		});
+	}
+	async start() {
+		if (this.process) {
+			return;
+		}
+		const { watch } = this.project.config;
+		const { result: child } = await this.spawn();
 		if (!watch) {
 			await child;
 			this._result = await this.prepareResults(this._output);
@@ -875,6 +929,9 @@ function findGeneratedPosition(traceMap, { line, column, source }) {
 	if (found.line !== null) {
 		return found;
 	}
+	// find the next source token position when the exact error position doesn't exist in source map.
+	// this can happen, for example, when the type error is in the comment "// @ts-expect-error"
+	// and comments are stripped away in the generated code.
 	const mappings = [];
 	eachMapping(traceMap, (m) => {
 		if (m.source === source && m.originalLine !== null && m.originalColumn !== null && (line === m.originalLine ? column < m.originalColumn : line < m.originalLine)) {

package/dist/chunks/{utils.CgTj3MsC.js → utils.BlI4TC7Y.js}

@@ -2,6 +2,7 @@ import { getSafeTimers } from '@vitest/utils';
 
 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";

package/dist/chunks/{utils.BfxieIyZ.js → utils.DPCq3gzW.js}

@@ -1,6 +1,7 @@
 import { parseRegexp } from '@vitest/utils';
 
 const REGEXP_WRAP_PREFIX = "$$vitest:";
+// Store global APIs in case process is overwritten by tests
 const processSend = process.send?.bind(process);
 const processOn = process.on?.bind(process);
 const processOff = process.off?.bind(process);
@@ -32,6 +33,7 @@ function createForksRpcOptions(nodeV8) {
 		},
 		on(fn) {
 			const handler = (message, ...extras) => {
+				// Do not react on Tinypool's internal messaging
 				if (message?.__tinypool_worker_message__) {
 					return;
 				}
@@ -55,6 +57,7 @@ function unwrapSerializableConfig(config) {
 	if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
 		const { keys, original } = config.defines;
 		const 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];
 		}

package/dist/chunks/{vi.BFR5YIgu.js → vi.pkoYCV6A.js}

@@ -2,15 +2,16 @@ import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, J
 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.CgTj3MsC.js';
+import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.BlI4TC7Y.js';
 import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import '@vitest/utils/error';
 import { fn, spyOn, mocks, isMockFunction } from '@vitest/spy';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.CDOsz-HY.js';
+import { R as RealDate, r as resetDate, m as mockDate } from './date.ByMsSlOr.js';
 
+// these matchers are not supported because they don't make sense with poll
 const unsupported = [
 	"matchSnapshot",
 	"toMatchSnapshot",
@@ -28,6 +29,7 @@ function createExpectPoll(expect) {
 		const state = getWorkerState();
 		const defaults = state.config.expect?.poll ?? {};
 		const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+		// @ts-expect-error private poll access
 		const assertion = expect(null, message).withContext({ poll: true });
 		fn = fn.bind(assertion);
 		const test = chai$1.util.flag(assertion, "vitest-test");
@@ -89,6 +91,8 @@ function createExpectPoll(expect) {
 					}
 				});
 				let resultPromise;
+				// only .then is enough to check awaited, but we type this as `Promise<void>` in global types
+				// so let's follow it
 				return {
 					then(onFulfilled, onRejected) {
 						awaited = true;
@@ -222,7 +226,9 @@ function createAssertionMessage(util, assertion, hasArgs) {
 }
 function recordAsyncExpect(_test, promise, assertion, error) {
 	const test = _test;
+	// record promise for test, that resolves before test ends
 	if (test && promise instanceof Promise) {
+		// if promise is explicitly awaited, remove it from the list
 		promise = promise.finally(() => {
 			if (!test.promises) {
 				return;
@@ -232,6 +238,7 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 				test.promises.splice(index, 1);
 			}
 		});
+		// record promise
 		if (!test.promises) {
 			test.promises = [];
 		}
@@ -281,6 +288,7 @@ function getError(expected, promise) {
 		if (!promise) {
 			throw new Error(`expected must be a function, received ${typeof expected}`);
 		}
+		// when "promised", it receives thrown error
 		return expected;
 	}
 	try {
@@ -442,6 +450,7 @@ function createExpect(test) {
 		const assert = chai$1.expect(value, message);
 		const _test = test || getCurrentTest();
 		if (_test) {
+			// @ts-expect-error internal
 			return assert.withTest(_test);
 		} else {
 			return assert;
@@ -451,6 +460,7 @@ function createExpect(test) {
 	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({
 		...globalState,
@@ -465,9 +475,11 @@ function createExpect(test) {
 		},
 		currentTestName: test ? getTestName(test) : globalState.currentTestName
 	}, expect);
+	// @ts-expect-error untyped
 	expect.extend = (matchers) => chai$1.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);
@@ -3611,6 +3623,12 @@ var fakeTimersSrcExports = requireFakeTimersSrc();
 class FakeTimers {
 	_global;
 	_clock;
+	// | _fakingTime | _fakingDate |
+	// +-------------+-------------+
+	// | false       | falsy       | initial
+	// | false       | truthy     | vi.setSystemTime called first (for mocking only Date without fake timers)
+	// | true        | falsy       | vi.useFakeTimers called first
+	// | true        | truthy     | unreachable
 	_fakingTime;
 	_fakingDate;
 	_fakeTimers;
@@ -3655,6 +3673,7 @@ class FakeTimers {
 		if (this._checkFakeTimers()) {
 			for (let i = steps; i > 0; i--) {
 				this._clock.next();
+				// Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250
 				this._clock.tick(0);
 				if (this._clock.countTimers() === 0) {
 					break;
@@ -3666,6 +3685,7 @@ class FakeTimers {
 		if (this._checkFakeTimers()) {
 			for (let i = steps; i > 0; i--) {
 				await this._clock.nextAsync();
+				// Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250
 				this._clock.tick(0);
 				if (this._clock.countTimers() === 0) {
 					break;
@@ -3690,6 +3710,7 @@ class FakeTimers {
 	}
 	runAllTicks() {
 		if (this._checkFakeTimers()) {
+			// @ts-expect-error method not exposed
 			this._clock.runMicrotasks();
 		}
 	}
@@ -4124,6 +4145,7 @@ function createVitest() {
 const vitest = createVitest();
 const vi = vitest;
 function _mocker() {
+	// @ts-expect-error injected by vite-nide
 	return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_, name) {
 		throw new Error("Vitest mocker was not initialized in this environment. " + `vi.${String(name)}() is forbidden.`);
 	} });
@@ -4131,6 +4153,7 @@ function _mocker() {
 function getImporter(name) {
 	const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
 	const stackArray = stackTrace.split("\n");
+	// if there is no message in a stack trace, use the item - 1
 	const importerStackIndex = stackArray.findIndex((stack) => {
 		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
 	});

package/dist/chunks/{vite.d.CBZ3M_ru.d.ts → vite.d.B-Kx3KCF.d.ts}

@@ -1,5 +1,5 @@
 import { HookHandler } from 'vite';
-import { V as Vitest, T as TestProject, b as TestProjectConfiguration, I as InlineConfig } from './reporters.d.CLC9rhKy.js';
+import { V as Vitest, T as TestProject, b as TestProjectConfiguration, I as InlineConfig } from './reporters.d.Bt4IGtsa.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;
@@ -7,6 +7,8 @@ interface VitestPluginContext {
 	injectTestProjects: (config: TestProjectConfiguration | TestProjectConfiguration[]) => Promise<TestProject[]>;
 }
 
+/* eslint-disable unused-imports/no-unused-vars */
+
 type VitestInlineConfig = InlineConfig;
 declare module "vite" {
 	interface UserConfig {

package/dist/chunks/{vm.C1HHjtNS.js → vm.DPYem2so.js}

@@ -2,14 +2,14 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import vm, { isContext } from 'node:vm';
 import { dirname, basename, extname, normalize, join, resolve } from 'pathe';
 import { distDir } from '../path.js';
-import { createCustomConsole } from './console.K1NMVOSc.js';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.JlGHLJZT.js';
+import { createCustomConsole } from './console.Cwr-MFPV.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.B3q-2LPV.js';
 import fs from 'node:fs';
 import { dirname as dirname$1 } from 'node:path';
 import { isPrimitive, isNodeBuiltin, toArray, getCachedData, setCacheData, isBareImport } from 'vite-node/utils';
 import { createRequire, Module } from 'node:module';
 import { CSS_LANGS_RE, KNOWN_ASSET_RE } from 'vite-node/constants';
-import { p as provideWorkerState } from './utils.CgTj3MsC.js';
+import { p as provideWorkerState } from './utils.BlI4TC7Y.js';
 
 function interopCommonJsModule(interopDefault, mod) {
 	if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) {
@@ -58,6 +58,7 @@ class CommonjsExecutor {
 		this.fs = options.fileMap;
 		this.interopDefault = options.interopDefault;
 		const primitives = vm.runInContext("({ Object, Array, Error })", this.context);
+		// eslint-disable-next-line ts/no-this-alias
 		const executor = this;
 		this.Module = class Module$1 {
 			exports;
@@ -71,6 +72,7 @@ class CommonjsExecutor {
 			paths = [];
 			constructor(id = "", parent) {
 				this.exports = primitives.Object.create(Object.prototype);
+				// in our case the path should always be resolved already
 				this.path = dirname(id);
 				this.id = id;
 				this.filename = id;
@@ -89,12 +91,16 @@ class CommonjsExecutor {
 			static register = () => {
 				throw new Error(`[vitest] "register" is not available when running in Vitest.`);
 			};
+			static registerHooks = () => {
+				throw new Error(`[vitest] "registerHooks" is not available when running in Vitest.`);
+			};
 			_compile(code, filename) {
 				const cjsModule = Module$1.wrap(code);
 				const script = new vm.Script(cjsModule, {
 					filename,
 					importModuleDynamically: options.importModuleDynamically
 				});
+				// @ts-expect-error mark script with current identifier
 				script.identifier = filename;
 				const fn = script.runInContext(executor.context);
 				const __dirname = dirname(filename);
@@ -106,6 +112,7 @@ class CommonjsExecutor {
 					this.loaded = true;
 				}
 			}
+			// 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);
@@ -126,11 +133,17 @@ class CommonjsExecutor {
 			static runMain = () => {
 				throw new primitives.Error("[vitest] \"runMain\" is not implemented.");
 			};
+			// @ts-expect-error not typed
 			static _resolveFilename = Module._resolveFilename;
+			// @ts-expect-error not typed
 			static _findPath = Module._findPath;
+			// @ts-expect-error not typed
 			static _initPaths = Module._initPaths;
+			// @ts-expect-error not typed
 			static _preloadModules = Module._preloadModules;
+			// @ts-expect-error not typed
 			static _resolveLookupPaths = Module._resolveLookupPaths;
+			// @ts-expect-error not typed
 			static globalPaths = Module.globalPaths;
 			static isBuiltin = Module.isBuiltin;
 			static constants = Module.constants;
@@ -189,6 +202,7 @@ class CommonjsExecutor {
 			}
 		});
 	}
+	// very naive implementation for Node.js require
 	loadCommonJSModule(module, filename) {
 		const cached = this.requireCache.get(filename);
 		if (cached) {
@@ -204,6 +218,7 @@ class CommonjsExecutor {
 		let currentExtension;
 		let index;
 		let startIndex = 0;
+		// eslint-disable-next-line no-cond-assign
 		while ((index = name.indexOf(".", startIndex)) !== -1) {
 			startIndex = index + 1;
 			if (index === 0) {
@@ -239,6 +254,7 @@ class CommonjsExecutor {
 			return this.moduleCache.get(identifier);
 		}
 		const exports = this.require(path);
+		// TODO: technically module should be parsed to find static exports, implement for strict mode in #2854
 		const { keys, moduleExports, defaultExport } = interopCommonJsModule(this.interopDefault, exports);
 		const module = new SyntheticModule([...keys, "default"], function() {
 			for (const key of keys) {
@@ -252,6 +268,42 @@ class CommonjsExecutor {
 		this.moduleCache.set(identifier, module);
 		return module;
 	}
+	// TODO: use this in strict mode, when available in #2854
+	// private _getNamedCjsExports(path: string): Set<string> {
+	//   const cachedNamedExports = this.cjsNamedExportsMap.get(path)
+	//   if (cachedNamedExports) {
+	//     return cachedNamedExports
+	//   }
+	//   if (extname(path) === '.node') {
+	//     const moduleExports = this.require(path)
+	//     const namedExports = new Set(Object.keys(moduleExports))
+	//     this.cjsNamedExportsMap.set(path, namedExports)
+	//     return namedExports
+	//   }
+	//   const code = this.fs.readFile(path)
+	//   const { exports, reexports } = parseCjs(code, path)
+	//   const namedExports = new Set(exports)
+	//   this.cjsNamedExportsMap.set(path, namedExports)
+	//   for (const reexport of reexports) {
+	//     if (isNodeBuiltin(reexport)) {
+	//       const exports = this.require(reexport)
+	//       if (exports !== null && typeof exports === 'object') {
+	//         for (const e of Object.keys(exports)) {
+	//           namedExports.add(e)
+	//         }
+	//       }
+	//     }
+	//     else {
+	//       const require = this.createRequire(path)
+	//       const resolved = require.resolve(reexport)
+	//       const exports = this._getNamedCjsExports(resolved)
+	//       for (const e of exports) {
+	//         namedExports.add(e)
+	//       }
+	//     }
+	//   }
+	//   return namedExports
+	// }
 	require(identifier) {
 		const ext = extname(identifier);
 		if (ext === ".node" || isNodeBuiltin(identifier)) {
@@ -273,6 +325,7 @@ class CommonjsExecutor {
 			return module.exports;
 		}
 		this.builtinCache[normalized] = _require.cache[normalized];
+		// TODO: should we wrap module to rethrow context errors?
 		return moduleExports;
 	}
 }
@@ -308,6 +361,7 @@ class EsmExecutor {
 	}
 	async loadEsModule(fileURL, getCode) {
 		const code = await getCode();
+		// TODO: should not be allowed in strict mode, implement in #2854
 		if (fileURL.endsWith(".json")) {
 			const m = new SyntheticModule(["default"], function() {
 				const result = JSON.parse(code);
@@ -345,13 +399,14 @@ class EsmExecutor {
 		return m;
 	}
 	async createNetworkModule(fileUrl) {
+		// https://nodejs.org/api/esm.html#https-and-http-imports
 		if (fileUrl.startsWith("http:")) {
 			const url = new URL(fileUrl);
 			if (url.hostname !== "localhost" && url.hostname !== "::1" && (IPnumber(url.hostname) & IPmask(8)) !== this.#httpIp) {
 				throw new Error(
 					// we don't know the importer, so it's undefined (the same happens in --pool=threads)
 					`import of '${fileUrl}' by undefined is not supported: ` + "http can only be used to load local resources (use https instead)."
-);
+				);
 			}
 		}
 		return this.createEsModule(fileUrl, () => fetch(fileUrl).then((r) => r.text()));
@@ -496,6 +551,7 @@ class ViteExecutor {
 					return result.code;
 				}
 			} catch (cause) {
+				// rethrow vite error if it cannot load the module because it's not resolved
 				if (typeof cause === "object" && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url")) {
 					const error = new Error(`Cannot find module '${fileUrl}'`, { cause });
 					error.code = "ERR_MODULE_NOT_FOUND";
@@ -548,7 +604,9 @@ class ViteExecutor {
 }
 
 const { existsSync, statSync } = fs;
+// always defined when we use vm pool
 const nativeResolve = import.meta.resolve;
+// TODO: improve Node.js strict mode support in #2854
 class ExternalModulesExecutor {
 	cjs;
 	esm;
@@ -587,6 +645,7 @@ class ExternalModulesExecutor {
 	createRequire(identifier) {
 		return this.cjs.createRequire(identifier);
 	}
+	// dynamic import can be used in both ESM and CJS, so we have it in the executor
 	importModuleDynamically = async (specifier, referencer) => {
 		const module = await this.resolveModule(specifier, referencer.identifier);
 		return await this.esm.evaluateModule(module);
@@ -605,6 +664,7 @@ class ExternalModulesExecutor {
 				return id;
 			}
 		}
+		// import.meta.resolve can be asynchronous in older +18 Node versions
 		return nativeResolve(specifier, parent);
 	}
 	findNearestPackageData(basedir) {
@@ -667,6 +727,8 @@ class ExternalModulesExecutor {
 		} else if (extension === ".cjs") {
 			type = "commonjs";
 		} else if (extension === ".wasm") {
+			// 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 = this.findNearestPackageData(normalize(pathUrl));
@@ -680,6 +742,8 @@ class ExternalModulesExecutor {
 	}
 	createModule(identifier) {
 		const { type, url, path } = this.getModuleInformation(identifier);
+		// create ERR_MODULE_NOT_FOUND on our own since latest NodeJS's import.meta.resolve doesn't throw on non-existing namespace or path
+		// https://github.com/nodejs/node/pull/49038
 		if ((type === "module" || type === "commonjs" || type === "wasm") && !existsSync(path)) {
 			const error = new Error(`Cannot find ${isBareImport(path) ? "package" : "module"} '${path}'`);
 			error.code = "ERR_MODULE_NOT_FOUND";
@@ -767,9 +831,13 @@ async function runVmTests(method, state) {
 		throw new TypeError(`Environment ${environment.name} doesn't provide a valid context. It should be created by "vm.createContext" method.`);
 	}
 	provideWorkerState(context, state);
+	// this is unfortunately needed for our own dependencies
+	// we need to find a way to not rely on this by default
+	// because browser doesn't provide these globals
 	context.process = process;
 	context.global = context;
 	context.console = state.config.disableConsoleIntercept ? console : createCustomConsole(state);
+	// TODO: don't hardcode setImmediate in fake timers defaults
 	context.setImmediate = setImmediate;
 	context.clearImmediate = clearImmediate;
 	const stubs = getDefaultRequestStubs(context);

package/dist/chunks/{worker.d.CoCI7hzP.d.ts → worker.d.BKbBp2ga.d.ts}

@@ -1,7 +1,7 @@
 import { File, TaskResultPack, TaskEventPack, CancelReason, FileSpecification, Task } from '@vitest/runner';
 import { ViteNodeResolveId, ModuleCacheMap, ModuleExecutionInfo } from 'vite-node';
-import { a as SerializedConfig } from './config.d.UqE-KR0o.js';
-import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.D8YDy2v5.js';
+import { a as SerializedConfig } from './config.d.D2ROskhv.js';
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.cL3nLXbE.js';
 import { SnapshotResult } from '@vitest/snapshot';
 
 type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;

package/dist/chunks/{worker.d.D5Xdi-Zr.d.ts → worker.d.Bl1O4kuf.d.ts}

@@ -1,5 +1,5 @@
 import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.d.CoCI7hzP.js';
+import { C as ContextRPC } from './worker.d.BKbBp2ga.js';
 
 interface WorkerContext extends ContextRPC {
 	port: MessagePort;

package/dist/cli.js

@@ -1,16 +1,16 @@
-import { c as createCLI } from './chunks/cac.I9MLYfT-.js';
+import { c as createCLI } from './chunks/cac.DWaWHIIE.js';
 import '@vitest/utils';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
-import './chunks/constants.BZZyIeIE.js';
-import './chunks/index.CV36oG_L.js';
+import './chunks/constants.DnKduX2e.js';
+import './chunks/index.Bter3jj9.js';
 import 'node:perf_hooks';
 import '@vitest/runner/utils';
 import '@vitest/utils/source-map';
 import './chunks/env.Dq0hM4Xv.js';
 import 'std-env';
-import './chunks/typechecker.DnTrplSJ.js';
+import './chunks/typechecker.BgzF-6iO.js';
 import 'node:os';
 import 'tinyexec';
 import './path.js';