vitest 3.2.0-beta.3 → 3.2.1

package/dist/chunks/{vite.d.B-Kx3KCF.d.ts → vite.d.DqE4-hhK.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.Bt4IGtsa.js';
+import { V as Vitest, T as TestProject, b as TestProjectConfiguration, I as InlineConfig } from './reporters.d.C1ogPriE.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;

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

@@ -2,23 +2,21 @@ 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.Cwr-MFPV.js';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.B3q-2LPV.js';
+import { createCustomConsole } from './console.CtFJOzRO.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.B7h3T_Hc.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.BlI4TC7Y.js';
+import { p as provideWorkerState } from './utils.XdZDrNZV.js';
 
 function interopCommonJsModule(interopDefault, mod) {
-	if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) {
-		return {
-			keys: [],
-			moduleExports: {},
-			defaultExport: mod
-		};
-	}
+	if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) return {
+		keys: [],
+		moduleExports: {},
+		defaultExport: mod
+	};
 	if (interopDefault !== false && "__esModule" in mod && !isPrimitive(mod.default)) {
 		const defaultKets = Object.keys(mod.default);
 		const moduleKeys = Object.keys(mod);
@@ -42,12 +40,12 @@ const SyntheticModule = vm.SyntheticModule;
 const SourceTextModule = vm.SourceTextModule;
 
 const _require = createRequire(import.meta.url);
-const requiresCache = new WeakMap();
+const requiresCache = /* @__PURE__ */ new WeakMap();
 class CommonjsExecutor {
 	context;
-	requireCache = new Map();
+	requireCache = /* @__PURE__ */ new Map();
 	publicRequireCache = this.createProxyCache();
-	moduleCache = new Map();
+	moduleCache = /* @__PURE__ */ new Map();
 	builtinCache = Object.create(null);
 	extensions = Object.create(null);
 	fs;
@@ -81,9 +79,7 @@ class CommonjsExecutor {
 			}
 			get require() {
 				const require = requiresCache.get(this);
-				if (require) {
-					return require;
-				}
+				if (require) return require;
 				const _require = Module$1.createRequire(this.id);
 				requiresCache.set(this, _require);
 				return _require;
@@ -170,9 +166,7 @@ class CommonjsExecutor {
 		const require = (id) => {
 			const resolved = _require.resolve(id);
 			const ext = extname(resolved);
-			if (ext === ".node" || isNodeBuiltin(resolved)) {
-				return this.requireCoreModule(resolved);
-			}
+			if (ext === ".node" || isNodeBuiltin(resolved)) return this.requireCoreModule(resolved);
 			const module = new this.Module(resolved);
 			return this.loadCommonJSModule(module, resolved);
 		};
@@ -182,7 +176,7 @@ class CommonjsExecutor {
 			set: () => {},
 			configurable: true
 		});
-		require.main = undefined;
+		require.main = void 0;
 		require.cache = this.publicRequireCache;
 		return require;
 	};
@@ -205,9 +199,7 @@ class CommonjsExecutor {
 	// very naive implementation for Node.js require
 	loadCommonJSModule(module, filename) {
 		const cached = this.requireCache.get(filename);
-		if (cached) {
-			return cached.exports;
-		}
+		if (cached) return cached.exports;
 		const extension = this.findLongestRegisteredExtension(filename);
 		const loader = this.extensions[extension] || this.extensions[".js"];
 		loader(module, filename);
@@ -221,26 +213,18 @@ class CommonjsExecutor {
 		// eslint-disable-next-line no-cond-assign
 		while ((index = name.indexOf(".", startIndex)) !== -1) {
 			startIndex = index + 1;
-			if (index === 0) {
-				continue;
-			}
+			if (index === 0) continue;
 			currentExtension = name.slice(index);
-			if (this.extensions[currentExtension]) {
-				return currentExtension;
-			}
+			if (this.extensions[currentExtension]) return currentExtension;
 		}
 		return ".js";
 	}
 	getCoreSyntheticModule(identifier) {
-		if (this.moduleCache.has(identifier)) {
-			return this.moduleCache.get(identifier);
-		}
+		if (this.moduleCache.has(identifier)) return this.moduleCache.get(identifier);
 		const exports = this.require(identifier);
 		const keys = Object.keys(exports);
 		const module = new SyntheticModule([...keys, "default"], () => {
-			for (const key of keys) {
-				module.setExport(key, exports[key]);
-			}
+			for (const key of keys) module.setExport(key, exports[key]);
 			module.setExport("default", exports);
 		}, {
 			context: this.context,
@@ -250,16 +234,12 @@ class CommonjsExecutor {
 		return module;
 	}
 	getCjsSyntheticModule(path, identifier) {
-		if (this.moduleCache.has(identifier)) {
-			return this.moduleCache.get(identifier);
-		}
+		if (this.moduleCache.has(identifier)) 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) {
-				this.setExport(key, moduleExports[key]);
-			}
+			for (const key of keys) this.setExport(key, moduleExports[key]);
 			this.setExport("default", defaultExport);
 		}, {
 			context: this.context,
@@ -306,17 +286,13 @@ class CommonjsExecutor {
 	// }
 	require(identifier) {
 		const ext = extname(identifier);
-		if (ext === ".node" || isNodeBuiltin(identifier)) {
-			return this.requireCoreModule(identifier);
-		}
+		if (ext === ".node" || isNodeBuiltin(identifier)) return this.requireCoreModule(identifier);
 		const module = new this.Module(identifier);
 		return this.loadCommonJSModule(module, identifier);
 	}
 	requireCoreModule(identifier) {
 		const normalized = identifier.replace(/^node:/, "");
-		if (this.builtinCache[normalized]) {
-			return this.builtinCache[normalized].exports;
-		}
+		if (this.builtinCache[normalized]) return this.builtinCache[normalized].exports;
 		const moduleExports = _require(identifier);
 		if (identifier === "node:module" || identifier === "module") {
 			const module = new this.Module("/module.js");
@@ -332,8 +308,8 @@ class CommonjsExecutor {
 
 const dataURIRegex = /^data:(?<mime>text\/javascript|application\/json|application\/wasm)(?:;(?<encoding>charset=utf-8|base64))?,(?<code>.*)$/;
 class EsmExecutor {
-	moduleCache = new Map();
-	esmLinkMap = new WeakMap();
+	moduleCache = /* @__PURE__ */ new Map();
+	esmLinkMap = /* @__PURE__ */ new WeakMap();
 	context;
 	#httpIp = IPnumber("127.0.0.0");
 	constructor(executor, options) {
@@ -341,20 +317,14 @@ class EsmExecutor {
 		this.context = options.context;
 	}
 	async evaluateModule(m) {
-		if (m.status === "unlinked") {
-			this.esmLinkMap.set(m, m.link((identifier, referencer) => this.executor.resolveModule(identifier, referencer.identifier)));
-		}
+		if (m.status === "unlinked") this.esmLinkMap.set(m, m.link((identifier, referencer) => this.executor.resolveModule(identifier, referencer.identifier)));
 		await this.esmLinkMap.get(m);
-		if (m.status === "linked") {
-			await m.evaluate();
-		}
+		if (m.status === "linked") await m.evaluate();
 		return m;
 	}
 	async createEsModule(fileURL, getCode) {
 		const cached = this.moduleCache.get(fileURL);
-		if (cached) {
-			return cached;
-		}
+		if (cached) return cached;
 		const promise = this.loadEsModule(fileURL, getCode);
 		this.moduleCache.set(fileURL, promise);
 		return promise;
@@ -391,9 +361,7 @@ class EsmExecutor {
 	}
 	async createWebAssemblyModule(fileUrl, getCode) {
 		const cached = this.moduleCache.get(fileUrl);
-		if (cached) {
-			return cached;
-		}
+		if (cached) return cached;
 		const m = this.loadWebAssemblyModule(getCode(), fileUrl);
 		this.moduleCache.set(fileUrl, m);
 		return m;
@@ -402,43 +370,31 @@ class EsmExecutor {
 		// 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)."
-				);
-			}
+			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()));
 	}
 	async loadWebAssemblyModule(source, identifier) {
 		const cached = this.moduleCache.get(identifier);
-		if (cached) {
-			return cached;
-		}
+		if (cached) return cached;
 		const wasmModule = await WebAssembly.compile(source);
 		const exports = WebAssembly.Module.exports(wasmModule);
 		const imports = WebAssembly.Module.imports(wasmModule);
 		const moduleLookup = {};
-		for (const { module } of imports) {
-			if (moduleLookup[module] === undefined) {
-				moduleLookup[module] = await this.executor.resolveModule(module, identifier);
-			}
-		}
+		for (const { module } of imports) if (moduleLookup[module] === void 0) moduleLookup[module] = await this.executor.resolveModule(module, identifier);
 		const evaluateModule = (module) => this.evaluateModule(module);
 		const syntheticModule = new SyntheticModule(exports.map(({ name }) => name), async function() {
 			const importsObject = {};
 			for (const { module, name } of imports) {
-				if (!importsObject[module]) {
-					importsObject[module] = {};
-				}
+				if (!importsObject[module]) importsObject[module] = {};
 				await evaluateModule(moduleLookup[module]);
 				importsObject[module][name] = moduleLookup[module].namespace[name];
 			}
 			const wasmInstance = new WebAssembly.Instance(wasmModule, importsObject);
-			for (const { name } of exports) {
-				this.setExport(name, wasmInstance.exports[name]);
-			}
+			for (const { name } of exports) this.setExport(name, wasmInstance.exports[name]);
 		}, {
 			context: this.context,
 			identifier
@@ -453,34 +409,22 @@ class EsmExecutor {
 	}
 	async createDataModule(identifier) {
 		const cached = this.moduleCache.get(identifier);
-		if (cached) {
-			return cached;
-		}
+		if (cached) return cached;
 		const match = identifier.match(dataURIRegex);
-		if (!match || !match.groups) {
-			throw new Error("Invalid data URI");
-		}
+		if (!match || !match.groups) throw new Error("Invalid data URI");
 		const mime = match.groups.mime;
 		const encoding = match.groups.encoding;
 		if (mime === "application/wasm") {
-			if (!encoding) {
-				throw new Error("Missing data URI encoding");
-			}
-			if (encoding !== "base64") {
-				throw new Error(`Invalid data URI encoding: ${encoding}`);
-			}
+			if (!encoding) throw new Error("Missing data URI encoding");
+			if (encoding !== "base64") throw new Error(`Invalid data URI encoding: ${encoding}`);
 			const module = this.loadWebAssemblyModule(Buffer.from(match.groups.code, "base64"), identifier);
 			this.moduleCache.set(identifier, module);
 			return module;
 		}
 		let code = match.groups.code;
-		if (!encoding || encoding === "charset=utf-8") {
-			code = decodeURIComponent(code);
-		} else if (encoding === "base64") {
-			code = Buffer.from(code, "base64").toString();
-		} else {
-			throw new Error(`Invalid data URI encoding: ${encoding}`);
-		}
+		if (!encoding || encoding === "charset=utf-8") code = decodeURIComponent(code);
+		else if (encoding === "base64") code = Buffer.from(code, "base64").toString();
+		else throw new Error(`Invalid data URI encoding: ${encoding}`);
 		if (mime === "application/json") {
 			const module = new SyntheticModule(["default"], function() {
 				const obj = JSON.parse(code);
@@ -497,9 +441,7 @@ class EsmExecutor {
 }
 function IPnumber(address) {
 	const ip = address.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
-	if (ip) {
-		return (+ip[1] << 24) + (+ip[2] << 16) + (+ip[3] << 8) + +ip[4];
-	}
+	if (ip) return (+ip[1] << 24) + (+ip[2] << 16) + (+ip[3] << 8) + +ip[4];
 	throw new Error(`Expected IP address, received ${address}`);
 }
 function IPmask(maskSize) {
@@ -516,9 +458,7 @@ class ViteExecutor {
 	}
 	resolve = (identifier, parent) => {
 		if (identifier === CLIENT_ID) {
-			if (this.workerState.environment.transformMode === "web") {
-				return identifier;
-			}
+			if (this.workerState.environment.transformMode === "web") return identifier;
 			const packageName = this.getPackageName(parent);
 			throw new Error(`[vitest] Vitest cannot handle ${CLIENT_ID} imported in ${parent} when running in SSR environment. Add "${packageName}" to "ssr.noExternal" if you are using Vite SSR, or to "server.deps.inline" if you are using Vite Node.`);
 		}
@@ -529,27 +469,18 @@ class ViteExecutor {
 	getPackageName(modulePath) {
 		const path = normalize(modulePath);
 		let name = path.split("/node_modules/").pop() || "";
-		if (name?.startsWith("@")) {
-			name = name.split("/").slice(0, 2).join("/");
-		} else {
-			name = name.split("/")[0];
-		}
+		if (name?.startsWith("@")) name = name.split("/").slice(0, 2).join("/");
+		else name = name.split("/")[0];
 		return name;
 	}
 	async createViteModule(fileUrl) {
-		if (fileUrl === CLIENT_FILE) {
-			return this.createViteClientModule();
-		}
+		if (fileUrl === CLIENT_FILE) return this.createViteClientModule();
 		const cached = this.esm.resolveCachedModule(fileUrl);
-		if (cached) {
-			return cached;
-		}
+		if (cached) return cached;
 		return this.esm.createEsModule(fileUrl, async () => {
 			try {
 				const result = await this.options.transform(fileUrl, "web");
-				if (result.code) {
-					return result.code;
-				}
+				if (result.code) 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")) {
@@ -564,9 +495,7 @@ class ViteExecutor {
 	createViteClientModule() {
 		const identifier = CLIENT_ID;
 		const cached = this.esm.resolveCachedModule(identifier);
-		if (cached) {
-			return cached;
-		}
+		if (cached) return cached;
 		const stub = this.options.viteClientModule;
 		const moduleKeys = Object.keys(stub);
 		const module = new SyntheticModule(moduleKeys, function() {
@@ -582,23 +511,13 @@ class ViteExecutor {
 	}
 	canResolve = (fileUrl) => {
 		const transformMode = this.workerState.environment.transformMode;
-		if (transformMode !== "web") {
-			return false;
-		}
-		if (fileUrl === CLIENT_FILE) {
-			return true;
-		}
+		if (transformMode !== "web") return false;
+		if (fileUrl === CLIENT_FILE) return true;
 		const config = this.workerState.config.deps?.web || {};
 		const [modulePath] = fileUrl.split("?");
-		if (config.transformCss && CSS_LANGS_RE.test(modulePath)) {
-			return true;
-		}
-		if (config.transformAssets && KNOWN_ASSET_RE.test(modulePath)) {
-			return true;
-		}
-		if (toArray(config.transformGlobPattern).some((pattern) => pattern.test(modulePath))) {
-			return true;
-		}
+		if (config.transformCss && CSS_LANGS_RE.test(modulePath)) return true;
+		if (config.transformAssets && KNOWN_ASSET_RE.test(modulePath)) return true;
+		if (toArray(config.transformGlobPattern).some((pattern) => pattern.test(modulePath))) return true;
 		return false;
 	};
 }
@@ -652,17 +571,13 @@ class ExternalModulesExecutor {
 	};
 	resolveModule = async (specifier, referencer) => {
 		let identifier = this.resolve(specifier, referencer);
-		if (identifier instanceof Promise) {
-			identifier = await identifier;
-		}
+		if (identifier instanceof Promise) identifier = await identifier;
 		return await this.createModule(identifier);
 	};
 	resolve(specifier, parent) {
 		for (const resolver of this.resolvers) {
 			const id = resolver(specifier, parent);
-			if (id) {
-				return id;
-			}
+			if (id) return id;
 		}
 		// import.meta.resolve can be asynchronous in older +18 Node versions
 		return nativeResolve(specifier, parent);
@@ -672,65 +587,50 @@ class ExternalModulesExecutor {
 		const packageCache = this.options.packageCache;
 		while (basedir) {
 			const cached = getCachedData(packageCache, basedir, originalBasedir);
-			if (cached) {
-				return cached;
-			}
+			if (cached) return cached;
 			const pkgPath = join(basedir, "package.json");
 			try {
 				if (statSync(pkgPath, { throwIfNoEntry: false })?.isFile()) {
 					const pkgData = JSON.parse(this.fs.readFile(pkgPath));
-					if (packageCache) {
-						setCacheData(packageCache, pkgData, basedir, originalBasedir);
-					}
+					if (packageCache) setCacheData(packageCache, pkgData, basedir, originalBasedir);
 					return pkgData;
 				}
 			} catch {}
 			const nextBasedir = dirname$1(basedir);
-			if (nextBasedir === basedir) {
-				break;
-			}
+			if (nextBasedir === basedir) break;
 			basedir = nextBasedir;
 		}
 		return {};
 	}
 	getModuleInformation(identifier) {
-		if (identifier.startsWith("data:")) {
-			return {
-				type: "data",
-				url: identifier,
-				path: identifier
-			};
-		}
+		if (identifier.startsWith("data:")) return {
+			type: "data",
+			url: identifier,
+			path: identifier
+		};
 		const extension = extname(identifier);
-		if (extension === ".node" || isNodeBuiltin(identifier)) {
-			return {
-				type: "builtin",
-				url: identifier,
-				path: identifier
-			};
-		}
-		if (this.isNetworkSupported && (identifier.startsWith("http:") || identifier.startsWith("https:"))) {
-			return {
-				type: "network",
-				url: identifier,
-				path: identifier
-			};
-		}
+		if (extension === ".node" || isNodeBuiltin(identifier)) return {
+			type: "builtin",
+			url: identifier,
+			path: identifier
+		};
+		if (this.isNetworkSupported && (identifier.startsWith("http:") || identifier.startsWith("https:"))) return {
+			type: "network",
+			url: identifier,
+			path: identifier
+		};
 		const isFileUrl = identifier.startsWith("file://");
 		const pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier;
 		const fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
 		let type;
-		if (this.vite.canResolve(fileUrl)) {
-			type = "vite";
-		} else if (extension === ".mjs") {
-			type = "module";
-		} 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 {
+		if (this.vite.canResolve(fileUrl)) type = "vite";
+		else if (extension === ".mjs") type = "module";
+		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));
 			type = pkgData.type === "module" ? "module" : "commonjs";
 		}
@@ -764,46 +664,34 @@ class ExternalModulesExecutor {
 		}
 	}
 	get isNetworkSupported() {
-		if (this.#networkSupported == null) {
-			if (process.execArgv.includes("--experimental-network-imports")) {
-				this.#networkSupported = true;
-			} else if (process.env.NODE_OPTIONS?.includes("--experimental-network-imports")) {
-				this.#networkSupported = true;
-			} else {
-				this.#networkSupported = false;
-			}
-		}
+		if (this.#networkSupported == null) if (process.execArgv.includes("--experimental-network-imports")) this.#networkSupported = true;
+		else if (process.env.NODE_OPTIONS?.includes("--experimental-network-imports")) this.#networkSupported = true;
+		else this.#networkSupported = false;
 		return this.#networkSupported;
 	}
 }
 
 const { promises, readFileSync } = fs;
 class FileMap {
-	fsCache = new Map();
-	fsBufferCache = new Map();
+	fsCache = /* @__PURE__ */ new Map();
+	fsBufferCache = /* @__PURE__ */ new Map();
 	async readFileAsync(path) {
 		const cached = this.fsCache.get(path);
-		if (cached != null) {
-			return cached;
-		}
+		if (cached != null) return cached;
 		const source = await promises.readFile(path, "utf-8");
 		this.fsCache.set(path, source);
 		return source;
 	}
 	readFile(path) {
 		const cached = this.fsCache.get(path);
-		if (cached != null) {
-			return cached;
-		}
+		if (cached != null) return cached;
 		const source = readFileSync(path, "utf-8");
 		this.fsCache.set(path, source);
 		return source;
 	}
 	readBuffer(path) {
 		const cached = this.fsBufferCache.get(path);
-		if (cached != null) {
-			return cached;
-		}
+		if (cached != null) return cached;
 		const buffer = readFileSync(path);
 		this.fsBufferCache.set(path, buffer);
 		return buffer;
@@ -812,24 +700,20 @@ class FileMap {
 
 const entryFile = pathToFileURL(resolve(distDir, "workers/runVmTests.js")).href;
 const fileMap = new FileMap();
-const packageCache = new Map();
+const packageCache = /* @__PURE__ */ new Map();
 async function runVmTests(method, state) {
 	const { environment, ctx, rpc } = state;
 	if (!environment.setupVM) {
 		const envName = ctx.environment.name;
 		const packageId = envName[0] === "." ? envName : `vitest-environment-${envName}`;
-		throw new TypeError(`Environment "${ctx.environment.name}" is not a valid environment. ` + `Path "${packageId}" doesn't support vm environment because it doesn't provide "setupVM" method.`);
+		throw new TypeError(`Environment "${ctx.environment.name}" is not a valid environment. Path "${packageId}" doesn't support vm environment because it doesn't provide "setupVM" method.`);
 	}
 	const vm = await environment.setupVM(ctx.environment.options || ctx.config.environmentOptions || {});
 	state.durations.environment = performance.now() - state.durations.environment;
 	process.env.VITEST_VM_POOL = "1";
-	if (!vm.getVmContext) {
-		throw new TypeError(`Environment ${environment.name} doesn't provide "getVmContext" method. It should return a context created by "vm.createContext" method.`);
-	}
+	if (!vm.getVmContext) throw new TypeError(`Environment ${environment.name} doesn't provide "getVmContext" method. It should return a context created by "vm.createContext" method.`);
 	const context = vm.getVmContext();
-	if (!isContext(context)) {
-		throw new TypeError(`Environment ${environment.name} doesn't provide a valid context. It should be created by "vm.createContext" method.`);
-	}
+	if (!isContext(context)) 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
@@ -859,7 +743,7 @@ async function runVmTests(method, state) {
 	const { run } = await executor.importExternalModule(entryFile);
 	const fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
 		filepath: f,
-		testLocations: undefined
+		testLocations: void 0
 	} : f);
 	try {
 		await run(method, fileSpecs, ctx.config, executor);

package/dist/chunks/{worker.d.Bl1O4kuf.d.ts → worker.d.DvqK5Vmu.d.ts}

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

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

@@ -1,4 +1,4 @@
-import { File, TaskResultPack, TaskEventPack, CancelReason, FileSpecification, Task } from '@vitest/runner';
+import { File, TestAnnotation, TaskResultPack, TaskEventPack, CancelReason, FileSpecification, Task } from '@vitest/runner';
 import { ViteNodeResolveId, ModuleCacheMap, ModuleExecutionInfo } from 'vite-node';
 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';
@@ -121,6 +121,7 @@ interface RuntimeRPC {
 	onQueued: (file: File) => void;
 	onCollected: (files: File[]) => Promise<void>;
 	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+	onTaskAnnotate: (testId: string, annotation: TestAnnotation) => Promise<TestAnnotation>;
 	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
 	onCancel: (reason: CancelReason) => void;
 	getCountOfFailedTests: () => number;
@@ -162,6 +163,7 @@ interface WorkerGlobalState {
 	onCancel: Promise<CancelReason>;
 	moduleCache: ModuleCacheMap;
 	moduleExecutionInfo?: ModuleExecutionInfo;
+	onCleanup: (listener: () => unknown) => void;
 	providedContext: Record<string, any>;
 	durations: {
 		environment: number

package/dist/cli.js

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

package/dist/config.cjs

@@ -13,7 +13,7 @@ const extraInlineDeps = [
 ];
 
 const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
-const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== undefined;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
 (isNode || isDeno) && process.platform === "win32";
 (isNode || isDeno) && process.stdout?.isTTY && !stdEnv.isCI;