vitest 3.2.0-beta.2 → 3.2.0

package/dist/chunks/{execute.JlGHLJZT.js → execute.B7h3T_Hc.js}

@@ -13,9 +13,7 @@ import { highlight } from '@vitest/utils';
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
-	if (!input) {
-		return input;
-	}
+	if (!input) return input;
 	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
 const _UNC_REGEX = /^[/\\]{2}/;
@@ -23,30 +21,20 @@ const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
 const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
 const normalize = function(path) {
-	if (path.length === 0) {
-		return ".";
-	}
+	if (path.length === 0) return ".";
 	path = normalizeWindowsPath(path);
 	const isUNCPath = path.match(_UNC_REGEX);
 	const isPathAbsolute = isAbsolute(path);
 	const trailingSeparator = path[path.length - 1] === "/";
 	path = normalizeString(path, !isPathAbsolute);
 	if (path.length === 0) {
-		if (isPathAbsolute) {
-			return "/";
-		}
+		if (isPathAbsolute) return "/";
 		return trailingSeparator ? "./" : ".";
 	}
-	if (trailingSeparator) {
-		path += "/";
-	}
-	if (_DRIVE_LETTER_RE.test(path)) {
-		path += "/";
-	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
 	if (isUNCPath) {
-		if (!isPathAbsolute) {
-			return `//./${path}`;
-		}
+		if (!isPathAbsolute) return `//./${path}`;
 		return `//${path}`;
 	}
 	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
@@ -54,28 +42,19 @@ const normalize = function(path) {
 const join = function(...segments) {
 	let path = "";
 	for (const seg of segments) {
-		if (!seg) {
-			continue;
-		}
+		if (!seg) continue;
 		if (path.length > 0) {
 			const pathTrailing = path[path.length - 1] === "/";
 			const segLeading = seg[0] === "/";
 			const both = pathTrailing && segLeading;
-			if (both) {
-				path += seg.slice(1);
-			} else {
-				path += pathTrailing || segLeading ? seg : `/${seg}`;
-			}
-		} else {
-			path += seg;
-		}
+			if (both) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
 	}
 	return normalize(path);
 };
 function cwd() {
-	if (typeof process !== "undefined" && typeof process.cwd === "function") {
-		return process.cwd().replace(/\\/g, "/");
-	}
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
 	return "/";
 }
 const resolve = function(...arguments_) {
@@ -84,16 +63,12 @@ const resolve = function(...arguments_) {
 	let resolvedAbsolute = false;
 	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
 		const path = index >= 0 ? arguments_[index] : cwd();
-		if (!path || path.length === 0) {
-			continue;
-		}
+		if (!path || path.length === 0) continue;
 		resolvedPath = `${path}/${resolvedPath}`;
 		resolvedAbsolute = isAbsolute(path);
 	}
 	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-	if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-		return `/${resolvedPath}`;
-	}
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
 	return resolvedPath.length > 0 ? resolvedPath : ".";
 };
 function normalizeString(path, allowAboveRoot) {
@@ -103,13 +78,9 @@ function normalizeString(path, allowAboveRoot) {
 	let dots = 0;
 	let char = null;
 	for (let index = 0; index <= path.length; ++index) {
-		if (index < path.length) {
-			char = path[index];
-		} else if (char === "/") {
-			break;
-		} else {
-			char = "/";
-		}
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
 		if (char === "/") {
 			if (lastSlash === index - 1 || dots === 1);
 			else if (dots === 2) {
@@ -139,20 +110,14 @@ function normalizeString(path, allowAboveRoot) {
 					lastSegmentLength = 2;
 				}
 			} else {
-				if (res.length > 0) {
-					res += `/${path.slice(lastSlash + 1, index)}`;
-				} else {
-					res = path.slice(lastSlash + 1, index);
-				}
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
 				lastSegmentLength = index - lastSlash - 1;
 			}
 			lastSlash = index;
 			dots = 0;
-		} else if (char === "." && dots !== -1) {
-			++dots;
-		} else {
-			dots = -1;
-		}
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
 	}
 	return res;
 }
@@ -166,9 +131,7 @@ const extname = function(p) {
 };
 const dirname = function(p) {
 	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
-	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
-		segments[0] += "/";
-	}
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
 	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
 };
 const basename = function(p, extension) {
@@ -187,12 +150,12 @@ const basename = function(p, extension) {
 const { existsSync, readdirSync, statSync } = fs;
 function findMockRedirect(root, mockPath, external) {
 	const path = external || mockPath;
+	// it's a node_module alias
+	// all mocks should be inside <root>/__mocks__
 	if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
 		const mockDirname = dirname(path);
 		const mockFolder = join(root, "__mocks__", mockDirname);
-		if (!existsSync(mockFolder)) {
-			return null;
-		}
+		if (!existsSync(mockFolder)) return null;
 		const baseOriginal = basename(path);
 		function findFile(mockFolder, baseOriginal) {
 			const files = readdirSync(mockFolder);
@@ -200,13 +163,12 @@ function findMockRedirect(root, mockPath, external) {
 				const baseFile = basename(file, extname(file));
 				if (baseFile === baseOriginal) {
 					const path = resolve(mockFolder, file);
-					if (statSync(path).isFile()) {
-						return path;
-					} else {
+					// if the same name, return the file
+					if (statSync(path).isFile()) return path;
+					else {
+						// find folder/index.{js,ts}
 						const indexFile = findFile(path, "index");
-						if (indexFile) {
-							return indexFile;
-						}
+						if (indexFile) return indexFile;
 					}
 				}
 			}
@@ -235,6 +197,7 @@ const builtins = new Set([
 	"util/types",
 	"wasi"
 ]);
+// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
 const prefixedBuiltins = new Set([
 	"node:sea",
 	"node:sqlite",
@@ -243,9 +206,7 @@ const prefixedBuiltins = new Set([
 ]);
 const NODE_BUILTIN_NAMESPACE = "node:";
 function isNodeBuiltin(id) {
-	if (prefixedBuiltins.has(id)) {
-		return true;
-	}
+	if (prefixedBuiltins.has(id)) return true;
 	return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id);
 }
 
@@ -255,24 +216,21 @@ class VitestMocker {
 	spyModule;
 	primitives;
 	filterPublicKeys;
-	registries = new Map();
+	registries = /* @__PURE__ */ new Map();
 	mockContext = { callstack: null };
 	constructor(executor) {
 		this.executor = executor;
 		const context = this.executor.options.context;
-		if (context) {
-			this.primitives = vm.runInContext("({ Object, Error, Function, RegExp, Symbol, Array, Map })", context);
-		} else {
-			this.primitives = {
-				Object,
-				Error,
-				Function,
-				RegExp,
-				Symbol: globalThis.Symbol,
-				Array,
-				Map
-			};
-		}
+		if (context) this.primitives = vm.runInContext("({ Object, Error, Function, RegExp, Symbol, Array, Map })", context);
+		else this.primitives = {
+			Object,
+			Error,
+			Function,
+			RegExp,
+			Symbol: globalThis.Symbol,
+			Array,
+			Map
+		};
 		const Symbol = this.primitives.Symbol;
 		this.filterPublicKeys = [
 			"__esModule",
@@ -305,9 +263,7 @@ class VitestMocker {
 	}
 	getMockerRegistry() {
 		const suite = this.getSuiteFilepath();
-		if (!this.registries.has(suite)) {
-			this.registries.set(suite, new MockerRegistry());
-		}
+		if (!this.registries.has(suite)) this.registries.set(suite, new MockerRegistry());
 		return this.registries.get(suite);
 	}
 	reset() {
@@ -315,9 +271,7 @@ class VitestMocker {
 	}
 	deleteCachedItem(id) {
 		const mockId = this.getMockPath(id);
-		if (this.moduleCache.has(mockId)) {
-			this.moduleCache.delete(mockId);
-		}
+		if (this.moduleCache.has(mockId)) this.moduleCache.delete(mockId);
 	}
 	isModuleDirectory(path) {
 		return this.moduleDirectories.some((dir) => path.includes(dir));
@@ -337,14 +291,15 @@ class VitestMocker {
 		try {
 			[id, fsPath] = await this.executor.originalResolveUrl(rawId, importer);
 		} catch (error) {
+			// it's allowed to mock unresolved modules
 			if (error.code === "ERR_MODULE_NOT_FOUND") {
 				const { id: unresolvedId } = error[Symbol.for("vitest.error.not_found.data")];
 				id = unresolvedId;
 				fsPath = unresolvedId;
-			} else {
-				throw error;
-			}
+			} else throw error;
 		}
+		// external is node_module or unresolved module
+		// for example, some people mock "vscode" and don't have it installed
 		const external = !isAbsolute$1(fsPath) || this.isModuleDirectory(fsPath) ? rawId : null;
 		return {
 			id,
@@ -353,37 +308,28 @@ class VitestMocker {
 		};
 	}
 	async resolveMocks() {
-		if (!VitestMocker.pendingIds.length) {
-			return;
-		}
+		if (!VitestMocker.pendingIds.length) return;
 		await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
 			const { fsPath, external } = await this.resolvePath(mock.id, mock.importer);
-			if (mock.action === "unmock") {
-				this.unmockPath(fsPath);
-			}
-			if (mock.action === "mock") {
-				this.mockPath(mock.id, fsPath, external, mock.type, mock.factory);
-			}
+			if (mock.action === "unmock") this.unmockPath(fsPath);
+			if (mock.action === "mock") this.mockPath(mock.id, fsPath, external, mock.type, mock.factory);
 		}));
 		VitestMocker.pendingIds = [];
 	}
 	async callFunctionMock(dep, mock) {
 		const cached = this.moduleCache.get(dep)?.exports;
-		if (cached) {
-			return cached;
-		}
+		if (cached) return cached;
 		const exports = await mock.resolve();
 		const moduleExports = new Proxy(exports, { get: (target, prop) => {
 			const val = target[prop];
+			// 'then' can exist on non-Promise objects, need nested instanceof check for logic to work
 			if (prop === "then") {
-				if (target instanceof Promise) {
-					return target.then.bind(target);
-				}
+				if (target instanceof Promise) return target.then.bind(target);
 			} else if (!(prop in target)) {
-				if (this.filterPublicKeys.includes(prop)) {
-					return undefined;
-				}
-				throw this.createError(`[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. ` + "Did you forget to return it from \"vi.mock\"?" + "\nIf you need to partially mock a module, you can use \"importOriginal\" helper inside:\n", highlight(`vi.mock(import("${mock.raw}"), async (importOriginal) => {
+				if (this.filterPublicKeys.includes(prop)) return void 0;
+				throw this.createError(`[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. Did you forget to return it from "vi.mock"?
+If you need to partially mock a module, you can use "importOriginal" helper inside:
+`, highlight(`vi.mock(import("${mock.raw}"), async (importOriginal) => {
   const actual = await importOriginal()
   return {
     ...actual,
@@ -396,9 +342,11 @@ class VitestMocker {
 		this.moduleCache.set(dep, { exports: moduleExports });
 		return moduleExports;
 	}
+	// public method to avoid circular dependency
 	getMockContext() {
 		return this.mockContext;
 	}
+	// path used to store mocked dependencies
 	getMockPath(dep) {
 		return `mock:${dep}`;
 	}
@@ -414,9 +362,7 @@ class VitestMocker {
 	}
 	mockObject(object, mockExports = {}, behavior = "automock") {
 		const spyOn = this.spyModule?.spyOn;
-		if (!spyOn) {
-			throw this.createError("[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
-		}
+		if (!spyOn) throw this.createError("[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
 		return mockObject({
 			globalConstructors: this.primitives,
 			spyOn,
@@ -432,18 +378,14 @@ class VitestMocker {
 	mockPath(originalId, path, external, mockType, factory) {
 		const registry = this.getMockerRegistry();
 		const id = this.normalizePath(path);
-		if (mockType === "manual") {
-			registry.register("manual", originalId, id, id, factory);
-		} else if (mockType === "autospy") {
-			registry.register("autospy", originalId, id, id);
-		} else {
+		if (mockType === "manual") registry.register("manual", originalId, id, id, factory);
+		else if (mockType === "autospy") registry.register("autospy", originalId, id, id);
+		else {
 			const redirect = this.resolveMockPath(id, external);
-			if (redirect) {
-				registry.register("redirect", originalId, id, id, redirect);
-			} else {
-				registry.register("automock", originalId, id, id);
-			}
+			if (redirect) registry.register("redirect", originalId, id, id, redirect);
+			else registry.register("automock", originalId, id, id);
 		}
+		// every time the mock is registered, we remove the previous one from the cache
 		this.deleteCachedItem(id);
 	}
 	async importActual(rawId, importer, callstack) {
@@ -457,52 +399,44 @@ class VitestMocker {
 		let mock = this.getDependencyMock(normalizedId);
 		if (!mock) {
 			const redirect = this.resolveMockPath(normalizedId, external);
-			if (redirect) {
-				mock = new RedirectedModule(rawId, normalizedId, normalizedId, redirect);
-			} else {
-				mock = new AutomockedModule(rawId, normalizedId, normalizedId);
-			}
+			if (redirect) mock = new RedirectedModule(rawId, normalizedId, normalizedId, redirect);
+			else mock = new AutomockedModule(rawId, normalizedId, normalizedId);
 		}
 		if (mock.type === "automock" || mock.type === "autospy") {
 			const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
 			return this.mockObject(mod, {}, mock.type);
 		}
-		if (mock.type === "manual") {
-			return this.callFunctionMock(fsPath, mock);
-		}
+		if (mock.type === "manual") return this.callFunctionMock(fsPath, mock);
 		return this.executor.dependencyRequest(mock.redirect, mock.redirect, [importee]);
 	}
 	async requestWithMock(url, callstack) {
 		const id = this.normalizePath(url);
 		const mock = this.getDependencyMock(id);
-		if (!mock) {
-			return;
-		}
+		if (!mock) return;
 		const mockPath = this.getMockPath(id);
 		if (mock.type === "automock" || mock.type === "autospy") {
 			const cache = this.moduleCache.get(mockPath);
-			if (cache.exports) {
-				return cache.exports;
-			}
+			if (cache.exports) return cache.exports;
 			const exports = {};
+			// Assign the empty exports object early to allow for cycles to work. The object will be filled by mockObject()
 			this.moduleCache.set(mockPath, { exports });
 			const mod = await this.executor.directRequest(url, url, callstack);
 			this.mockObject(mod, exports, mock.type);
 			return exports;
 		}
-		if (mock.type === "manual" && !callstack.includes(mockPath) && !callstack.includes(url)) {
-			try {
-				callstack.push(mockPath);
-				this.mockContext.callstack = callstack;
-				return await this.callFunctionMock(mockPath, mock);
-			} finally {
-				this.mockContext.callstack = null;
-				const indexMock = callstack.indexOf(mockPath);
-				callstack.splice(indexMock, 1);
-			}
-		} else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) {
-			return mock.redirect;
+		if (mock.type === "manual" && !callstack.includes(mockPath) && !callstack.includes(url)) try {
+			callstack.push(mockPath);
+			// this will not work if user does Promise.all(import(), import())
+			// we can also use AsyncLocalStorage to store callstack, but this won't work in the browser
+			// maybe we should improve mock API in the future?
+			this.mockContext.callstack = callstack;
+			return await this.callFunctionMock(mockPath, mock);
+		} finally {
+			this.mockContext.callstack = null;
+			const indexMock = callstack.indexOf(mockPath);
+			callstack.splice(indexMock, 1);
 		}
+		else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) return mock.redirect;
 	}
 	queueMock(id, importer, factoryOrOptions) {
 		const mockType = getMockType(factoryOrOptions);
@@ -510,7 +444,7 @@ class VitestMocker {
 			action: "mock",
 			id,
 			importer,
-			factory: typeof factoryOrOptions === "function" ? factoryOrOptions : undefined,
+			factory: typeof factoryOrOptions === "function" ? factoryOrOptions : void 0,
 			type: mockType
 		});
 	}
@@ -523,12 +457,8 @@ class VitestMocker {
 	}
 }
 function getMockType(factoryOrOptions) {
-	if (!factoryOrOptions) {
-		return "automock";
-	}
-	if (typeof factoryOrOptions === "function") {
-		return "manual";
-	}
+	if (!factoryOrOptions) return "automock";
+	if (typeof factoryOrOptions === "function") return "manual";
 	return factoryOrOptions.spy ? "autospy" : "automock";
 }
 
@@ -540,7 +470,7 @@ async function createVitestExecutor(options) {
 	await runner.mocker.initializeSpyModule();
 	return runner;
 }
-const externalizeMap = new Map();
+const externalizeMap = /* @__PURE__ */ new Map();
 const bareVitestRegexp = /^@?vitest(?:\/|$)/;
 const dispose = [];
 function listenForErrors(state) {
@@ -549,15 +479,13 @@ function listenForErrors(state) {
 	function catchError(err, type, event) {
 		const worker = state();
 		const listeners = process.listeners(event);
-		if (listeners.length > 1) {
-			return;
-		}
+		// if there is another listener, assume that it's handled by user code
+		// one is Vitest's own listener
+		if (listeners.length > 1) return;
 		const error = processError(err);
 		if (!isPrimitive(error)) {
-			error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : undefined;
-			if (worker.filepath) {
-				error.VITEST_TEST_PATH = worker.filepath;
-			}
+			error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0;
+			if (worker.filepath) error.VITEST_TEST_PATH = worker.filepath;
 			error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
 		}
 		state().rpc.onUnhandledError(error, type);
@@ -573,9 +501,9 @@ function listenForErrors(state) {
 }
 const relativeIds = {};
 function getVitestImport(id, state) {
-	if (externalizeMap.has(id)) {
-		return { externalize: externalizeMap.get(id) };
-	}
+	if (externalizeMap.has(id)) return { externalize: externalizeMap.get(id) };
+	// always externalize Vitest because we import from there before running tests
+	// so we already have it cached by Node.js
 	const root = state().config.root;
 	const relativeRoot = relativeIds[root] ?? (relativeIds[root] = normalizedDistDir.slice(root.length));
 	if (id.includes(distDir) || id.includes(normalizedDistDir) || relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
@@ -603,9 +531,7 @@ async function startVitestExecutor(options) {
 	return await createVitestExecutor({
 		async fetchModule(id) {
 			const vitest = getVitestImport(id, state);
-			if (vitest) {
-				return vitest;
-			}
+			if (vitest) return vitest;
 			const result = await rpc().fetch(id, getTransformMode());
 			if (result.id && !result.externalize) {
 				const code = readFileSync(result.id, "utf-8");
@@ -638,9 +564,7 @@ async function startVitestExecutor(options) {
 	});
 }
 function updateStyle(id, css) {
-	if (typeof document === "undefined") {
-		return;
-	}
+	if (typeof document === "undefined") return;
 	const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
 	if (element) {
 		element.textContent = css;
@@ -654,13 +578,9 @@ function updateStyle(id, css) {
 	head?.appendChild(style);
 }
 function removeStyle(id) {
-	if (typeof document === "undefined") {
-		return;
-	}
+	if (typeof document === "undefined") return;
 	const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
-	if (sheet) {
-		document.head.removeChild(sheet);
-	}
+	if (sheet) document.head.removeChild(sheet);
 }
 function getDefaultRequestStubs(context) {
 	if (!context) {
@@ -705,36 +625,31 @@ class VitestExecutor extends ViteNodeRunner {
 		} else if (options.externalModulesExecutor) {
 			this.primitives = vm.runInContext("({ Object, Reflect, Symbol })", options.context);
 			this.externalModules = options.externalModulesExecutor;
-		} else {
-			throw new Error("When context is provided, externalModulesExecutor must be provided as well.");
-		}
+		} else throw new Error("When context is provided, externalModulesExecutor must be provided as well.");
 	}
 	getContextPrimitives() {
 		return this.primitives;
 	}
 	get state() {
+		// @ts-expect-error injected untyped global
 		return globalThis.__vitest_worker__ || this.options.state;
 	}
 	get moduleExecutionInfo() {
 		return this.options.moduleExecutionInfo;
 	}
 	shouldResolveId(id, _importee) {
-		if (isInternalRequest(id) || id.startsWith("data:")) {
-			return false;
-		}
+		if (isInternalRequest(id) || id.startsWith("data:")) return false;
 		const transformMode = this.state.environment?.transformMode ?? "ssr";
+		// do not try and resolve node builtins in Node
+		// import('url') returns Node internal even if 'url' package is installed
 		return transformMode === "ssr" ? !isNodeBuiltin$1(id) : !id.startsWith("node:");
 	}
 	async originalResolveUrl(id, importer) {
 		return super.resolveUrl(id, importer);
 	}
 	async resolveUrl(id, importer) {
-		if (VitestMocker.pendingIds.length) {
-			await this.mocker.resolveMocks();
-		}
-		if (importer && importer.startsWith("mock:")) {
-			importer = importer.slice(5);
-		}
+		if (VitestMocker.pendingIds.length) await this.mocker.resolveMocks();
+		if (importer && importer.startsWith("mock:")) importer = importer.slice(5);
 		try {
 			return await super.resolveUrl(id, importer);
 		} catch (error) {
@@ -742,18 +657,15 @@ class VitestExecutor extends ViteNodeRunner {
 				const { id } = error[Symbol.for("vitest.error.not_found.data")];
 				const path = this.mocker.normalizePath(id);
 				const mock = this.mocker.getDependencyMock(path);
-				if (mock !== undefined) {
-					return [id, id];
-				}
+				if (mock !== void 0) return [id, id];
 			}
 			throw error;
 		}
 	}
 	async runModule(context, transformed) {
 		const vmContext = this.options.context;
-		if (!vmContext || !this.externalModules) {
-			return super.runModule(context, transformed);
-		}
+		if (!vmContext || !this.externalModules) return super.runModule(context, transformed);
+		// add 'use strict' since ESM enables it by default
 		const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
 		const code = `${codeDefinition}${transformed}\n}}`;
 		const options = {
@@ -761,37 +673,34 @@ class VitestExecutor extends ViteNodeRunner {
 			lineOffset: 0,
 			columnOffset: -codeDefinition.length
 		};
-		this.options.moduleExecutionInfo?.set(options.filename, { startOffset: codeDefinition.length });
-		const fn = vm.runInContext(code, vmContext, {
-			...options,
-			importModuleDynamically: this.externalModules.importModuleDynamically
-		});
-		await fn(...Object.values(context));
+		const finishModuleExecutionInfo = this.startCalculateModuleExecutionInfo(options.filename, codeDefinition.length);
+		try {
+			const fn = vm.runInContext(code, vmContext, {
+				...options,
+				importModuleDynamically: this.externalModules.importModuleDynamically
+			});
+			await fn(...Object.values(context));
+		} finally {
+			this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
+		}
 	}
 	async importExternalModule(path) {
-		if (this.externalModules) {
-			return this.externalModules.import(path);
-		}
+		if (this.externalModules) return this.externalModules.import(path);
 		return super.importExternalModule(path);
 	}
 	async dependencyRequest(id, fsPath, callstack) {
 		const mocked = await this.mocker.requestWithMock(fsPath, callstack);
-		if (typeof mocked === "string") {
-			return super.dependencyRequest(mocked, mocked, callstack);
-		}
-		if (mocked && typeof mocked === "object") {
-			return mocked;
-		}
+		if (typeof mocked === "string") return super.dependencyRequest(mocked, mocked, callstack);
+		if (mocked && typeof mocked === "object") return mocked;
 		return super.dependencyRequest(id, fsPath, callstack);
 	}
 	prepareContext(context) {
+		// support `import.meta.vitest` for test entry
 		if (this.state.filepath && normalize$1(this.state.filepath) === normalize$1(context.__filename)) {
 			const globalNamespace = this.options.context || globalThis;
 			Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalNamespace.__vitest_index__ });
 		}
-		if (this.options.context && this.externalModules) {
-			context.require = this.externalModules.createRequire(context.__filename);
-		}
+		if (this.options.context && this.externalModules) context.require = this.externalModules.createRequire(context.__filename);
 		return context;
 	}
 }

package/dist/chunks/{git.DXfdBEfR.js → git.BVQ8w_Sw.js}

@@ -18,9 +18,7 @@ class VitestGit {
 	}
 	async findChangedFiles(options) {
 		const root = await this.getRoot(this.cwd);
-		if (!root) {
-			return null;
-		}
+		if (!root) return null;
 		this.root = root;
 		const changedSince = options.changedSince;
 		if (typeof changedSince === "string") {