vitest 4.0.9 → 4.0.11

package/dist/chunks/{cli-api.D48wY175.js → cli-api.-bIZD4XU.js}

@@ -1,20 +1,21 @@
-import fs, { promises as promises$1, existsSync, mkdirSync, readFileSync, statSync, readdirSync, writeFileSync } from 'node:fs';
+import fs, { promises, existsSync, mkdirSync, readFileSync, statSync, readdirSync, writeFileSync } from 'node:fs';
 import { relative, resolve, dirname, join, extname, normalize, basename, isAbsolute } from 'pathe';
 import { C as CoverageProviderMap } from './coverage.D_JHT54q.js';
 import path, { resolve as resolve$1 } from 'node:path';
-import { noop, createDefer, slash, isExternalUrl, unwrapId, nanoid, withTrailingSlash, cleanUrl, wrapId, toArray, deepMerge, deepClone, isPrimitive, notNullish } from '@vitest/utils/helpers';
-import { a as any, p as prompt } from './index.z7NPOg2E.js';
-import { h as hash, R as RandomSequencer, i as isPackageExists, c as isBrowserEnabled, r as resolveConfig, g as getCoverageProvider, a as resolveApiServerConfig, d as resolveModule } from './coverage.BUlIqJrL.js';
+import { noop, createDefer, slash, isExternalUrl, unwrapId, withTrailingSlash, cleanUrl, wrapId, toArray, deepMerge, nanoid, deepClone, isPrimitive, notNullish } from '@vitest/utils/helpers';
+import { a as any, p as prompt } from './index.D4KonVSU.js';
+import { h as hash, R as RandomSequencer, i as isPackageExists, c as isBrowserEnabled, r as resolveConfig, g as getCoverageProvider, a as resolveApiServerConfig, d as resolveModule } from './coverage.CtyeYmKM.js';
 import * as vite from 'vite';
-import { parseAst, fetchModule, version, searchForWorkspaceRoot, mergeConfig, createServer } from 'vite';
+import { parseAst, searchForWorkspaceRoot, fetchModule, version, mergeConfig, createServer } from 'vite';
 import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.D_Q9UYh-.js';
 import * as nodeos from 'node:os';
 import nodeos__default, { tmpdir } from 'node:os';
 import { generateHash as generateHash$1, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, hasFailed, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, getTasks, isTestCase } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { v as version$1 } from './cac.B_NTJoIH.js';
+import { v as version$1 } from './cac.aVhqBj0-.js';
+import { performance as performance$1 } from 'node:perf_hooks';
 import { c as createBirpc } from './index.0kCJoeWi.js';
-import { p as parse, d as stringify, e as TraceMap, o as originalPositionFor, h as ancestor, i as printError, f as formatProjectName, w as withLabel, j as errorBanner, k as divider, l as Typechecker, m as generateCodeFrame, n as createDefinesScript, R as ReportersMap, B as BlobReporter, r as readBlobs, q as convertTasksToEvents, H as HangingProcessReporter } from './index.kotH7DY7.js';
+import { p as parse, d as stringify, e as TraceMap, o as originalPositionFor, h as ancestor, i as printError, f as formatProjectName, w as withLabel, j as errorBanner, k as divider, l as Typechecker, m as generateCodeFrame, n as createDefinesScript, R as ReportersMap, B as BlobReporter, r as readBlobs, q as convertTasksToEvents, H as HangingProcessReporter } from './index.DWDW6mLz.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -25,15 +26,16 @@ import require$$0$2 from 'stream';
 import require$$7 from 'url';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
-import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers.D26ty3Ew.js';
 import crypto, { createHash } from 'node:crypto';
 import { rootDir, distDir } from '../path.js';
+import { T as Traces } from './traces.BVPrsYso.js';
 import createDebug from 'debug';
-import { readFile, writeFile, rename, stat, unlink, rm, mkdir, copyFile } from 'node:fs/promises';
+import { rm, readFile, writeFile, rename, stat, unlink, mkdir, copyFile } from 'node:fs/promises';
+import c from 'tinyrainbow';
 import { VitestModuleEvaluator } from '#module-evaluator';
 import { ModuleRunner } from 'vite/module-runner';
 import { Console } from 'node:console';
-import c from 'tinyrainbow';
 import { highlight } from '@vitest/utils/highlight';
 import { createRequire, isBuiltin, builtinModules } from 'node:module';
 import url, { fileURLToPath, pathToFileURL } from 'node:url';
@@ -41,7 +43,6 @@ import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
 import { isatty } from 'node:tty';
 import EventEmitter$1, { EventEmitter } from 'node:events';
 import { fork } from 'node:child_process';
-import v8 from 'node:v8';
 import { Worker } from 'node:worker_threads';
 import pm from 'picomatch';
 import { glob, isDynamicPattern } from 'tinyglobby';
@@ -51,7 +52,7 @@ import { c as configDefaults } from './defaults.BOqNVLsY.js';
 import { KNOWN_ASSET_RE } from '@vitest/utils/constants';
 import { findNearestPackageData } from '@vitest/utils/resolver';
 import * as esModuleLexer from 'es-module-lexer';
-import { a as BenchmarkReportsMap } from './index.op2Re5rn.js';
+import { a as BenchmarkReportsMap } from './index.CMvpbrsJ.js';
 import assert$1 from 'node:assert';
 import { serializeValue } from '@vitest/utils/serialize';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
@@ -5124,11 +5125,11 @@ function setup(ctx, _server) {
 			},
 			async readTestFile(id) {
 				if (!ctx.state.filesMap.has(id) || !existsSync(id)) return null;
-				return promises$1.readFile(id, "utf-8");
+				return promises.readFile(id, "utf-8");
 			},
 			async saveTestFile(id, content) {
 				if (!ctx.state.filesMap.has(id) || !existsSync(id)) throw new Error(`Test file "${id}" was not registered, so it cannot be updated using the API.`);
-				return promises$1.writeFile(id, content, "utf-8");
+				return promises.writeFile(id, content, "utf-8");
 			},
 			async rerun(files, resetTestNamePattern) {
 				await ctx.rerunFiles(files, void 0, true, resetTestNamePattern);
@@ -5150,7 +5151,7 @@ function setup(ctx, _server) {
 				const result = browser ? await project.browser.vite.transformRequest(id) : await project.vite.transformRequest(id);
 				if (result) {
 					try {
-						result.source = result.source || await promises$1.readFile(id, "utf-8");
+						result.source = result.source || await promises.readFile(id, "utf-8");
 					} catch {}
 					return result;
 				}
@@ -5198,6 +5199,8 @@ function setup(ctx, _server) {
 	ctx.reporters.push(new WebSocketReporter(ctx, wss, clients));
 }
 class WebSocketReporter {
+	start = 0;
+	end = 0;
 	constructor(ctx, wss, clients) {
 		this.ctx = ctx;
 		this.wss = wss;
@@ -5211,6 +5214,7 @@ class WebSocketReporter {
 	}
 	onTestRunStart(specifications) {
 		if (this.clients.size === 0) return;
+		this.start = performance$1.now();
 		const serializedSpecs = specifications.map((spec) => spec.toJSON());
 		this.clients.forEach((client) => {
 			client.onSpecsCollected?.(serializedSpecs)?.catch?.(noop);
@@ -5222,18 +5226,33 @@ class WebSocketReporter {
 			client.onTestAnnotate?.(testCase.id, annotation)?.catch?.(noop);
 		});
 	}
+	async onTestCaseArtifactRecord(testCase, artifact) {
+		if (this.clients.size === 0) return;
+		this.clients.forEach((client) => {
+			client.onTestArtifactRecord?.(testCase.id, artifact)?.catch?.(noop);
+		});
+	}
 	async onTaskUpdate(packs, events) {
 		if (this.clients.size === 0) return;
 		this.clients.forEach((client) => {
 			client.onTaskUpdate?.(packs, events)?.catch?.(noop);
 		});
 	}
+	sum(items, cb) {
+		return items.reduce((total, next) => {
+			return total + Math.max(cb(next) || 0, 0);
+		}, 0);
+	}
 	onTestRunEnd(testModules, unhandledErrors) {
 		if (!this.clients.size) return;
 		const files = testModules.map((testModule) => testModule.task);
 		const errors = [...unhandledErrors];
+		this.end = performance$1.now();
+		const blobs = this.ctx.state.blobs;
+		// Execution time is either sum of all runs of `--merge-reports` or the current run's time
+		const executionTime = blobs?.executionTimes ? this.sum(blobs.executionTimes, (time) => time) : this.end - this.start;
 		this.clients.forEach((client) => {
-			client.onFinished?.(files, errors)?.catch?.(noop);
+			client.onFinished?.(files, errors, void 0, executionTime)?.catch?.(noop);
 		});
 	}
 	onFinishedReportCoverage() {
@@ -5488,7 +5507,8 @@ function createFileTask(testFilepath, code, requestMap, options) {
 			dynamic: definition.dynamic,
 			meta: {},
 			timeout: 0,
-			annotations: []
+			annotations: [],
+			artifacts: []
 		};
 		definition.task = task;
 		latestSuite.tasks.push(task);
@@ -5633,8 +5653,9 @@ class ResultsCache {
 	cachePath = null;
 	version;
 	root = "/";
-	constructor(version) {
-		this.version = version;
+	constructor(logger) {
+		this.logger = logger;
+		this.version = Vitest.version;
 	}
 	getCachePath() {
 		return this.cachePath;
@@ -5646,6 +5667,15 @@ class ResultsCache {
 	getResults(key) {
 		return this.cache.get(key);
 	}
+	async clearCache() {
+		if (this.cachePath && existsSync(this.cachePath)) {
+			await rm(this.cachePath, {
+				force: true,
+				recursive: true
+			});
+			this.logger.log("[cache] cleared results cache at", this.cachePath);
+		}
+	}
 	async readFromCache() {
 		if (!this.cachePath) return;
 		if (!fs.existsSync(this.cachePath)) return;
@@ -5698,8 +5728,8 @@ class ResultsCache {
 class VitestCache {
 	results;
 	stats = new FilesStatsCache();
-	constructor(version) {
-		this.results = new ResultsCache(version);
+	constructor(logger) {
+		this.results = new ResultsCache(logger);
 	}
 	getFileTestResults(key) {
 		return this.results.getResults(key);
@@ -5712,93 +5742,526 @@ class VitestCache {
 	}
 }
 
-const created = /* @__PURE__ */ new Set();
-const promises = /* @__PURE__ */ new Map();
-function createFetchModuleFunction(resolver, tmpDir = join(tmpdir(), nanoid()), dump) {
-	return async (url, importer, environment, cacheFs, options) => {
-		// We are copy pasting Vite's externalization logic from `fetchModule` because
-		// we instead rely on our own `shouldExternalize` method because Vite
-		// doesn't support `resolve.external` in non SSR environments (jsdom/happy-dom)
-		if (url.startsWith("data:")) return {
-			externalize: url,
-			type: "builtin"
-		};
-		if (url === "/@vite/client" || url === "@vite/client")
- // this will be stubbed
+const debugFs = createDebugger("vitest:cache:fs");
+const debugMemory = createDebugger("vitest:cache:memory");
+const cacheComment = "\n//# vitestCache=";
+const cacheCommentLength = 17;
+const METADATA_FILE = "_metadata.json";
+/**
+* @experimental
+*/
+class FileSystemModuleCache {
+	/**
+	* Even though it's possible to override the folder of project's caches
+	* We still keep a single metadata file for all projects because
+	* - they can reference files between each other
+	* - lockfile changes are reflected for the whole workspace, not just for a single project
+	*/
+	rootCache;
+	metadataFilePath;
+	version = "1.0.0-beta.1";
+	fsCacheRoots = /* @__PURE__ */ new WeakMap();
+	fsEnvironmentHashMap = /* @__PURE__ */ new WeakMap();
+	fsCacheKeyGenerators = /* @__PURE__ */ new Set();
+	// this exists only to avoid the perf. cost of reading a file and generating a hash again
+	// surprisingly, on some machines this has negligible effect
+	fsCacheKeys = /* @__PURE__ */ new WeakMap();
+	constructor(vitest) {
+		this.vitest = vitest;
+		const workspaceRoot = searchForWorkspaceRoot(vitest.vite.config.root);
+		this.rootCache = vitest.config.experimental.fsModuleCachePath || join(workspaceRoot, "node_modules", ".experimental-vitest-cache");
+		this.metadataFilePath = join(this.rootCache, METADATA_FILE);
+	}
+	defineCacheKeyGenerator(callback) {
+		this.fsCacheKeyGenerators.add(callback);
+	}
+	async clearCache(log = true) {
+		const fsCachePaths = this.vitest.projects.map((r) => {
+			return r.config.experimental.fsModuleCachePath || this.rootCache;
+		});
+		const uniquePaths = Array.from(new Set(fsCachePaths));
+		await Promise.all(uniquePaths.map((directory) => rm(directory, {
+			force: true,
+			recursive: true
+		})));
+		if (log) this.vitest.logger.log(`[cache] cleared fs module cache at ${uniquePaths.join(", ")}`);
+	}
+	async getCachedModule(cachedFilePath) {
+		if (!existsSync(cachedFilePath)) {
+			debugFs?.(`${c.red("[empty]")} ${cachedFilePath} doesn't exist, transforming by vite instead`);
+			return;
+		}
+		const code = await readFile(cachedFilePath, "utf-8");
+		const matchIndex = code.lastIndexOf(cacheComment);
+		if (matchIndex === -1) {
+			debugFs?.(`${c.red("[empty]")} ${cachedFilePath} exists, but doesn't have a ${cacheComment} comment, transforming by vite instead`);
+			return;
+		}
+		const meta = this.fromBase64(code.slice(matchIndex + cacheCommentLength));
+		if (meta.externalize) {
+			debugFs?.(`${c.green("[read]")} ${meta.externalize} is externalized inside ${cachedFilePath}`);
+			return {
+				externalize: meta.externalize,
+				type: meta.type
+			};
+		}
+		debugFs?.(`${c.green("[read]")} ${meta.id} is cached in ${cachedFilePath}`);
 		return {
-			externalize: "/@vite/client",
-			type: "module"
+			id: meta.id,
+			url: meta.url,
+			file: meta.file,
+			code,
+			importers: meta.importers,
+			mappings: meta.mappings
 		};
+	}
+	async saveCachedModule(cachedFilePath, fetchResult, importers = [], mappings = false) {
+		if ("externalize" in fetchResult) {
+			debugFs?.(`${c.yellow("[write]")} ${fetchResult.externalize} is externalized inside ${cachedFilePath}`);
+			await atomicWriteFile(cachedFilePath, `${cacheComment}${this.toBase64(fetchResult)}`);
+		} else if ("code" in fetchResult) {
+			const result = {
+				file: fetchResult.file,
+				id: fetchResult.id,
+				url: fetchResult.url,
+				importers,
+				mappings
+			};
+			debugFs?.(`${c.yellow("[write]")} ${fetchResult.id} is cached in ${cachedFilePath}`);
+			await atomicWriteFile(cachedFilePath, `${fetchResult.code}${cacheComment}${this.toBase64(result)}`);
+		}
+	}
+	toBase64(obj) {
+		const json = stringify(obj);
+		return Buffer.from(json).toString("base64");
+	}
+	fromBase64(obj) {
+		return parse(Buffer.from(obj, "base64").toString("utf-8"));
+	}
+	invalidateCachePath(environment, id) {
+		debugFs?.(`cache for ${id} in ${environment.name} environment is invalidated`);
+		this.fsCacheKeys.get(environment)?.delete(id);
+	}
+	invalidateAllCachePaths(environment) {
+		debugFs?.(`the ${environment.name} environment cache is invalidated`);
+		this.fsCacheKeys.get(environment)?.clear();
+	}
+	getMemoryCachePath(environment, id) {
+		const result = this.fsCacheKeys.get(environment)?.get(id);
+		if (result != null) debugMemory?.(`${c.green("[read]")} ${id} was cached in ${result}`);
+		else if (result === null) debugMemory?.(`${c.green("[read]")} ${id} was bailed out`);
+		return result;
+	}
+	generateCachePath(vitestConfig, environment, resolver, id, fileContent) {
+		let hashString = "";
+		// bail out if file has import.meta.glob because it depends on other files
+		// TODO: figure out a way to still support it
+		if (fileContent.includes("import.meta.glob(")) {
+			this.saveMemoryCache(environment, id, null);
+			debugMemory?.(`${c.yellow("[write]")} ${id} was bailed out`);
+			return null;
+		}
+		for (const generator of this.fsCacheKeyGenerators) {
+			const result = generator({
+				environment,
+				id,
+				sourceCode: fileContent
+			});
+			if (typeof result === "string") hashString += result;
+			if (result === false) {
+				this.saveMemoryCache(environment, id, null);
+				debugMemory?.(`${c.yellow("[write]")} ${id} was bailed out by a custom generator`);
+				return null;
+			}
+		}
+		const config = environment.config;
+		// coverage provider is dynamic, so we also clear the whole cache if
+		// vitest.enableCoverage/vitest.disableCoverage is called
+		const coverageAffectsCache = String(this.vitest.config.coverage.enabled && this.vitest.coverageProvider?.requiresTransform?.(id));
+		let cacheConfig = this.fsEnvironmentHashMap.get(environment);
+		if (!cacheConfig) {
+			cacheConfig = JSON.stringify({
+				root: config.root,
+				base: config.base,
+				mode: config.mode,
+				consumer: config.consumer,
+				resolve: config.resolve,
+				plugins: config.plugins.map((p) => p.name),
+				configFileDependencies: config.configFileDependencies.map((file) => tryReadFileSync(file)),
+				environment: environment.name,
+				css: vitestConfig.css,
+				resolver: {
+					inline: resolver.options.inline,
+					external: resolver.options.external,
+					inlineFiles: resolver.options.inlineFiles,
+					moduleDirectories: resolver.options.moduleDirectories
+				}
+			}, (_, value) => {
+				if (typeof value === "function" || value instanceof RegExp) return value.toString();
+				return value;
+			});
+			this.fsEnvironmentHashMap.set(environment, cacheConfig);
+		}
+		hashString += id + fileContent + (process.env.NODE_ENV ?? "") + this.version + cacheConfig + coverageAffectsCache;
+		const cacheKey = hash("sha1", hashString, "hex");
+		let cacheRoot = this.fsCacheRoots.get(vitestConfig);
+		if (cacheRoot == null) {
+			cacheRoot = vitestConfig.experimental.fsModuleCachePath || this.rootCache;
+			if (!existsSync(cacheRoot)) mkdirSync(cacheRoot, { recursive: true });
+		}
+		const fsResultPath = join(cacheRoot, cacheKey);
+		debugMemory?.(`${c.yellow("[write]")} ${id} generated a cache in ${fsResultPath}`);
+		this.saveMemoryCache(environment, id, fsResultPath);
+		return fsResultPath;
+	}
+	saveMemoryCache(environment, id, cache) {
+		let environmentKeys = this.fsCacheKeys.get(environment);
+		if (!environmentKeys) {
+			environmentKeys = /* @__PURE__ */ new Map();
+			this.fsCacheKeys.set(environment, environmentKeys);
+		}
+		environmentKeys.set(id, cache);
+	}
+	async readMetadata() {
+		// metadata is shared between every projects in the workspace, so we ignore project's fsModuleCachePath
+		if (!existsSync(this.metadataFilePath)) return;
+		try {
+			const content = await readFile(this.metadataFilePath, "utf-8");
+			return JSON.parse(content);
+		} catch {}
+	}
+	// before vitest starts running tests, we check that the lockfile wasn't updated
+	// if it was, we nuke the previous cache in case a custom plugin was updated
+	// or a new version of vite/vitest is installed
+	// for the same reason we also cache config file content, but that won't catch changes made in external plugins
+	async ensureCacheIntegrity() {
+		if (![this.vitest.getRootProject(), ...this.vitest.projects].some((p) => p.config.experimental.fsModuleCache)) return;
+		const metadata = await this.readMetadata();
+		const currentLockfileHash = getLockfileHash(this.vitest.vite.config.root);
+		// no metadata found, just store a new one, don't reset the cache
+		if (!metadata) {
+			if (!existsSync(this.rootCache)) mkdirSync(this.rootCache, { recursive: true });
+			debugFs?.(`fs metadata file was created with hash ${currentLockfileHash}`);
+			await writeFile(this.metadataFilePath, JSON.stringify({ lockfileHash: currentLockfileHash }, null, 2), "utf-8");
+			return;
+		}
+		// if lockfile didn't change, don't do anything
+		if (metadata.lockfileHash === currentLockfileHash) return;
+		// lockfile changed, let's clear all caches
+		await this.clearCache(false);
+		this.vitest.vite.config.logger.info(`fs cache was cleared because lockfile has changed`, {
+			timestamp: true,
+			environment: c.yellow("[vitest]")
+		});
+		debugFs?.(`fs cache was cleared because lockfile has changed`);
+	}
+}
+/**
+* Performs an atomic write operation using the write-then-rename pattern.
+*
+* Why we need this:
+* - Ensures file integrity by never leaving partially written files on disk
+* - Prevents other processes from reading incomplete data during writes
+* - Particularly important for test files where incomplete writes could cause test failures
+*
+* The implementation writes to a temporary file first, then renames it to the target path.
+* This rename operation is atomic on most filesystems (including POSIX-compliant ones),
+* guaranteeing that other processes will only ever see the complete file.
+*
+* Added in https://github.com/vitest-dev/vitest/pull/7531
+*/
+async function atomicWriteFile(realFilePath, data) {
+	const tmpFilePath = join(dirname(realFilePath), `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	try {
+		await writeFile(tmpFilePath, data, "utf-8");
+		await rename(tmpFilePath, realFilePath);
+	} finally {
+		try {
+			if (await stat(tmpFilePath)) await unlink(tmpFilePath);
+		} catch {}
+	}
+}
+// lockfile hash resolution taken from vite
+// since this is experimental, we don't ask to expose it
+const lockfileFormats = [
+	{
+		path: "node_modules/.package-lock.json",
+		checkPatchesDir: "patches",
+		manager: "npm"
+	},
+	{
+		path: "node_modules/.yarn-state.yml",
+		checkPatchesDir: false,
+		manager: "yarn"
+	},
+	{
+		path: ".pnp.cjs",
+		checkPatchesDir: ".yarn/patches",
+		manager: "yarn"
+	},
+	{
+		path: ".pnp.js",
+		checkPatchesDir: ".yarn/patches",
+		manager: "yarn"
+	},
+	{
+		path: "node_modules/.yarn-integrity",
+		checkPatchesDir: "patches",
+		manager: "yarn"
+	},
+	{
+		path: "node_modules/.pnpm/lock.yaml",
+		checkPatchesDir: false,
+		manager: "pnpm"
+	},
+	{
+		path: ".rush/temp/shrinkwrap-deps.json",
+		checkPatchesDir: false,
+		manager: "pnpm"
+	},
+	{
+		path: "bun.lock",
+		checkPatchesDir: "patches",
+		manager: "bun"
+	},
+	{
+		path: "bun.lockb",
+		checkPatchesDir: "patches",
+		manager: "bun"
+	}
+].sort((_, { manager }) => {
+	return process.env.npm_config_user_agent?.startsWith(manager) ? 1 : -1;
+});
+const lockfilePaths = lockfileFormats.map((l) => l.path);
+function getLockfileHash(root) {
+	const lockfilePath = lookupFile(root, lockfilePaths);
+	let content = lockfilePath ? fs.readFileSync(lockfilePath, "utf-8") : "";
+	if (lockfilePath) {
+		const normalizedLockfilePath = lockfilePath.replaceAll("\\", "/");
+		const lockfileFormat = lockfileFormats.find((f) => normalizedLockfilePath.endsWith(f.path));
+		if (lockfileFormat.checkPatchesDir) {
+			const stat = tryStatSync(join(lockfilePath.slice(0, -lockfileFormat.path.length), lockfileFormat.checkPatchesDir));
+			if (stat?.isDirectory()) content += stat.mtimeMs.toString();
+		}
+	}
+	return hash("sha256", content, "hex").substring(0, 8).padEnd(8, "_");
+}
+function lookupFile(dir, fileNames) {
+	while (dir) {
+		for (const fileName of fileNames) {
+			const fullPath = join(dir, fileName);
+			if (tryStatSync(fullPath)?.isFile()) return fullPath;
+		}
+		const parentDir = dirname(dir);
+		if (parentDir === dir) return;
+		dir = parentDir;
+	}
+}
+function tryReadFileSync(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return "";
+	}
+}
+function tryStatSync(file) {
+	try {
+		// The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
+}
+
+const saveCachePromises = /* @__PURE__ */ new Map();
+const readFilePromises = /* @__PURE__ */ new Map();
+class ModuleFetcher {
+	tmpDirectories = /* @__PURE__ */ new Set();
+	fsCacheEnabled;
+	constructor(resolver, config, fsCache, traces, tmpProjectDir) {
+		this.resolver = resolver;
+		this.config = config;
+		this.fsCache = fsCache;
+		this.traces = traces;
+		this.tmpProjectDir = tmpProjectDir;
+		this.fsCacheEnabled = config.experimental?.fsModuleCache === true;
+	}
+	async fetch(trace, url, importer, environment, makeTmpCopies, options) {
+		if (url.startsWith("data:")) {
+			trace.setAttribute("vitest.module.external", url);
+			return {
+				externalize: url,
+				type: "builtin"
+			};
+		}
+		if (url === "/@vite/client" || url === "@vite/client") {
+			trace.setAttribute("vitest.module.external", url);
+			return {
+				externalize: "/@vite/client",
+				type: "module"
+			};
+		}
 		const isFileUrl = url.startsWith("file://");
-		if (isExternalUrl(url) && !isFileUrl) return {
-			externalize: url,
-			type: "network"
-		};
-		// Vite does the same in `fetchModule`, but we want to externalize modules ourselves,
-		// so we do this first to resolve the module and check its `id`. The next call of
-		// `ensureEntryFromUrl` inside `fetchModule` is cached and should take no time
-		// This also makes it so externalized modules are inside the module graph.
+		if (isExternalUrl(url) && !isFileUrl) {
+			trace.setAttribute("vitest.module.external", url);
+			return {
+				externalize: url,
+				type: "network"
+			};
+		}
 		const moduleGraphModule = await environment.moduleGraph.ensureEntryFromUrl(unwrapId(url));
 		const cached = !!moduleGraphModule.transformResult;
-		// if url is already cached, we can just confirm it's also cached on the server
+		if (moduleGraphModule.file) trace.setAttribute("code.file.path", moduleGraphModule.file);
 		if (options?.cached && cached) return { cache: true };
-		if (moduleGraphModule.id) {
-			const externalize = await resolver.shouldExternalize(moduleGraphModule.id);
-			if (externalize) return {
-				externalize,
-				type: "module"
-			};
+		const cachePath = await this.getCachePath(environment, moduleGraphModule);
+		// full fs caching is disabled, but we still want to keep tmp files if makeTmpCopies is enabled
+		// this is primarily used by the forks pool to avoid using process.send(bigBuffer)
+		if (cachePath == null) {
+			const result = await this.fetchAndProcess(environment, url, importer, moduleGraphModule, options);
+			this.recordResult(trace, result);
+			if (!makeTmpCopies || !("code" in result)) return result;
+			const transformResult = moduleGraphModule.transformResult;
+			const tmpPath = transformResult && Reflect.get(transformResult, "_vitest_tmp");
+			if (typeof tmpPath === "string") return getCachedResult(result, tmpPath);
+			const tmpDir = join(this.tmpProjectDir, environment.name);
+			if (!this.tmpDirectories.has(tmpDir)) {
+				if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });
+				this.tmpDirectories.add(tmpDir);
+			}
+			const tmpFile = join(tmpDir, hash("sha1", result.id, "hex"));
+			return this.cacheResult(result, tmpFile).then((result) => {
+				if (transformResult) Reflect.set(transformResult, "_vitest_tmp", tmpFile);
+				return result;
+			});
 		}
-		let moduleRunnerModule;
-		if (dump?.dumpFolder && dump.readFromDump) {
-			const path = resolve(dump?.dumpFolder, url.replace(/[^\w+]/g, "-"));
-			if (existsSync(path)) {
-				const code = await readFile(path, "utf-8");
-				const matchIndex = code.lastIndexOf("\n//");
-				if (matchIndex !== -1) {
-					const { id, file } = JSON.parse(code.slice(matchIndex + 4));
-					moduleRunnerModule = {
-						code,
-						id,
-						url,
-						file,
-						invalidate: false
-					};
-				}
+		if (saveCachePromises.has(cachePath)) return saveCachePromises.get(cachePath).then((result) => {
+			this.recordResult(trace, result);
+			return result;
+		});
+		const cachedModule = await this.getCachedModule(cachePath, environment, moduleGraphModule);
+		if (cachedModule) {
+			this.recordResult(trace, cachedModule);
+			return cachedModule;
+		}
+		const result = await this.fetchAndProcess(environment, url, importer, moduleGraphModule, options);
+		const importers = this.getSerializedDependencies(moduleGraphModule);
+		const map = moduleGraphModule.transformResult?.map;
+		const mappings = map && !("version" in map) && map.mappings === "";
+		return this.cacheResult(result, cachePath, importers, !!mappings);
+	}
+	getSerializedDependencies(node) {
+		const dependencies = [];
+		node.importers.forEach((importer) => {
+			if (importer.id) dependencies.push(importer.id);
+		});
+		return dependencies;
+	}
+	recordResult(trace, result) {
+		if ("externalize" in result) trace.setAttributes({
+			"vitest.module.external": result.externalize,
+			"vitest.fetched_module.type": result.type
+		});
+		if ("id" in result) {
+			trace.setAttributes({
+				"vitest.fetched_module.invalidate": result.invalidate,
+				"vitest.fetched_module.id": result.id,
+				"vitest.fetched_module.url": result.url,
+				"vitest.fetched_module.cache": false
+			});
+			if (result.file) trace.setAttribute("code.file.path", result.file);
+		}
+		if ("code" in result) trace.setAttribute("vitest.fetched_module.code_length", result.code.length);
+	}
+	async getCachePath(environment, moduleGraphModule) {
+		if (!this.fsCacheEnabled) return null;
+		const moduleId = moduleGraphModule.id;
+		const memoryCacheKey = this.fsCache.getMemoryCachePath(environment, moduleId);
+		// undefined means there is no key in memory
+		// null means the file should not be cached
+		if (memoryCacheKey !== void 0) return memoryCacheKey;
+		const fileContent = await this.readFileContentToCache(environment, moduleGraphModule);
+		return this.fsCache.generateCachePath(this.config, environment, this.resolver, moduleGraphModule.id, fileContent);
+	}
+	async readFileContentToCache(environment, moduleGraphModule) {
+		if (moduleGraphModule.file && !moduleGraphModule.file.startsWith("\0") && !moduleGraphModule.file.startsWith("virtual:")) {
+			const result = await this.readFileConcurrently(moduleGraphModule.file);
+			if (result != null) return result;
+		}
+		const loadResult = await environment.pluginContainer.load(moduleGraphModule.id);
+		if (typeof loadResult === "string") return loadResult;
+		if (loadResult != null) return loadResult.code;
+		return "";
+	}
+	async getCachedModule(cachePath, environment, moduleGraphModule) {
+		const cachedModule = await this.fsCache.getCachedModule(cachePath);
+		if (cachedModule && "code" in cachedModule) {
+			// keep the module graph in sync
+			if (!moduleGraphModule.transformResult) {
+				let map = extractSourceMap(cachedModule.code);
+				if (map && cachedModule.file) map.file = cachedModule.file;
+				// mappings is a special source map identifier in rollup
+				if (!map && cachedModule.mappings) map = { mappings: "" };
+				moduleGraphModule.transformResult = {
+					code: cachedModule.code,
+					map,
+					ssr: true
+				};
+				// we populate the module graph to make the watch mode work because it relies on importers
+				cachedModule.importers.forEach((importer) => {
+					const environmentNode = environment.moduleGraph.getModuleById(importer);
+					if (environmentNode) moduleGraphModule.importers.add(environmentNode);
+				});
 			}
+			return {
+				cached: true,
+				file: cachedModule.file,
+				id: cachedModule.id,
+				tmp: cachePath,
+				url: cachedModule.url,
+				invalidate: false
+			};
 		}
-		if (!moduleRunnerModule) moduleRunnerModule = await fetchModule(environment, url, importer, {
+		return cachedModule;
+	}
+	async fetchAndProcess(environment, url, importer, moduleGraphModule, options) {
+		const externalize = await this.resolver.shouldExternalize(moduleGraphModule.id);
+		if (externalize) return {
+			externalize,
+			type: "module"
+		};
+		return processResultSource(environment, await fetchModule(environment, url, importer, {
 			...options,
 			inlineSourceMap: false
-		}).catch(handleRollupError);
-		const result = processResultSource(environment, moduleRunnerModule);
-		if (dump?.dumpFolder && "code" in result) await writeFile(resolve(dump?.dumpFolder, result.url.replace(/[^\w+]/g, "-")), `${result.code}\n// ${JSON.stringify({
-			id: result.id,
-			file: result.file
-		})}`, "utf-8");
-		if (!cacheFs || !("code" in result)) return result;
-		const code = result.code;
-		const transformResult = result.transformResult;
-		if (!transformResult) throw new Error(`"transformResult" in not defined. This is a bug in Vitest.`);
-		// to avoid serialising large chunks of code,
-		// we store them in a tmp file and read in the test thread
-		if ("_vitestTmp" in transformResult) return getCachedResult(result, Reflect.get(transformResult, "_vitestTmp"));
-		const dir = join(tmpDir, environment.name);
-		const tmp = join(dir, hash("sha1", result.id, "hex"));
-		if (!created.has(dir)) {
-			mkdirSync(dir, { recursive: true });
-			created.add(dir);
-		}
-		if (promises.has(tmp)) {
-			await promises.get(tmp);
-			return getCachedResult(result, tmp);
-		}
-		promises.set(tmp, atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => {
-			Reflect.set(transformResult, "_vitestTmp", tmp);
-			promises.delete(tmp);
-		}));
-		await promises.get(tmp);
-		return getCachedResult(result, tmp);
+		}).catch(handleRollupError));
+	}
+	async cacheResult(result, cachePath, importers = [], mappings = false) {
+		const returnResult = "code" in result ? getCachedResult(result, cachePath) : result;
+		if (saveCachePromises.has(cachePath)) {
+			await saveCachePromises.get(cachePath);
+			return returnResult;
+		}
+		const savePromise = this.fsCache.saveCachedModule(cachePath, result, importers, mappings).then(() => result).finally(() => {
+			saveCachePromises.delete(cachePath);
+		});
+		saveCachePromises.set(cachePath, savePromise);
+		await savePromise;
+		return returnResult;
+	}
+	readFileConcurrently(file) {
+		if (!readFilePromises.has(file)) readFilePromises.set(
+			file,
+			// virtual file can have a "file" property
+			readFile(file, "utf-8").catch(() => null).finally(() => {
+				readFilePromises.delete(file);
+			})
+		);
+		return readFilePromises.get(file);
+	}
+}
+function createFetchModuleFunction(resolver, config, fsCache, traces, tmpProjectDir) {
+	const fetcher = new ModuleFetcher(resolver, config, fsCache, traces, tmpProjectDir);
+	return async (url, importer, environment, cacheFs, options, otelCarrier) => {
+		await traces.waitInit();
+		const context = otelCarrier ? traces.getContextFromCarrier(otelCarrier) : void 0;
+		return traces.$("vitest.module.transform", context ? { context } : {}, (span) => fetcher.fetch(span, url, importer, environment, cacheFs, options));
 	};
 }
 let SOURCEMAPPING_URL = "sourceMa";
@@ -5813,8 +6276,7 @@ function processResultSource(environment, result) {
 	inlineSourceMap(node.transformResult);
 	return {
 		...result,
-		code: node?.transformResult?.code || result.code,
-		transformResult: node?.transformResult
+		code: node?.transformResult?.code || result.code
 	};
 }
 const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, "gm");
@@ -5850,6 +6312,20 @@ function getCachedResult(result, tmp) {
 		invalidate: result.invalidate
 	};
 }
+const MODULE_RUNNER_SOURCEMAPPING_REGEXP = /* @__PURE__ */ new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`);
+function extractSourceMap(code) {
+	const pattern = `//# ${SOURCEMAPPING_URL}=data:application/json;base64,`;
+	const lastIndex = code.lastIndexOf(pattern);
+	if (lastIndex === -1) return null;
+	const mapString = MODULE_RUNNER_SOURCEMAPPING_REGEXP.exec(code.slice(lastIndex))?.[1];
+	if (!mapString) return null;
+	const sourceMap = JSON.parse(Buffer.from(mapString, "base64").toString("utf-8"));
+	// remove source map mapping added by "inlineSourceMap" to keep the original behaviour of transformRequest
+	if (sourceMap.mappings.startsWith("AAAA,CAAA;"))
+ // 9 because we want to only remove "AAAA,CAAA", but keep ; at the start
+	sourceMap.mappings = sourceMap.mappings.slice(9);
+	return sourceMap;
+}
 // serialize rollup error on server to preserve details as a test error
 function handleRollupError(e) {
 	if (e instanceof Error && ("plugin" in e || "frame" in e || "id" in e))
@@ -5868,31 +6344,6 @@ function handleRollupError(e) {
 	};
 	throw e;
 }
-/**
-* Performs an atomic write operation using the write-then-rename pattern.
-*
-* Why we need this:
-* - Ensures file integrity by never leaving partially written files on disk
-* - Prevents other processes from reading incomplete data during writes
-* - Particularly important for test files where incomplete writes could cause test failures
-*
-* The implementation writes to a temporary file first, then renames it to the target path.
-* This rename operation is atomic on most filesystems (including POSIX-compliant ones),
-* guaranteeing that other processes will only ever see the complete file.
-*
-* Added in https://github.com/vitest-dev/vitest/pull/7531
-*/
-async function atomicWriteFile(realFilePath, data) {
-	const tmpFilePath = join(dirname(realFilePath), `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-	try {
-		await writeFile(tmpFilePath, data, "utf-8");
-		await rename(tmpFilePath, realFilePath);
-	} finally {
-		try {
-			if (await stat(tmpFilePath)) await unlink(tmpFilePath);
-		} catch {}
-	}
-}
 
 // this is copy pasted from vite
 function normalizeResolvedIdToUrl(environment, resolvedId) {
@@ -5926,7 +6377,15 @@ class ServerModuleRunner extends ModuleRunner {
 				if (name === "getBuiltins") return await environment.hot.handleInvoke(event);
 				if (name !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
 				try {
-					return { result: await fetcher(data[0], data[1], environment, false, data[2]) };
+					const result = await fetcher(data[0], data[1], environment, false, data[2]);
+					if ("tmp" in result) {
+						const code = await readFile(result.tmp);
+						return { result: {
+							...result,
+							code
+						} };
+					}
+					return { result };
 				} catch (error) {
 					return { error };
 				}
@@ -6214,7 +6673,7 @@ class VitestPackageInstaller {
 		if (/* @__PURE__ */ isPackageExists(dependency, { paths: [root, __dirname$1] })) return true;
 		process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEPENDENCY "))} Cannot find dependency '${dependency}'\n\n`));
 		if (!isTTY) return false;
-		const { install } = await (await import('./index.z7NPOg2E.js').then(function (n) { return n.i; })).default({
+		const { install } = await (await import('./index.D4KonVSU.js').then(function (n) { return n.i; })).default({
 			type: "confirm",
 			name: "install",
 			message: c.reset(`Do you want to install ${c.green(dependency)}?`)
@@ -6283,7 +6742,7 @@ async function getSpecificationsEnvironments(specifications) {
 		// reuse if projects have the same test files
 		let code = cache.get(filepath);
 		if (!code) {
-			code = await promises$1.readFile(filepath, "utf-8");
+			code = await promises.readFile(filepath, "utf-8");
 			cache.set(filepath, code);
 		}
 		// 1. Check for control comments in the file
@@ -6514,7 +6973,7 @@ class BrowserPool {
 					return;
 				}
 				debug?.("[%s] error during %s test run: %s", sessionId, file, error);
-				this.reject(error);
+				this.reject(new Error(`Failed to run the test ${file.filepath}.`, { cause: error }));
 			});
 		}).catch((err) => this.reject(err));
 	}
@@ -6541,9 +7000,9 @@ function shouldIgnoreDebugger(provider, browser) {
 	return browser !== "chromium";
 }
 
-function createMethodsRPC(project, options = {}) {
+function createMethodsRPC(project, methodsOptions = {}) {
 	const vitest = project.vitest;
-	const cacheFs = options.cacheFs ?? false;
+	const cacheFs = methodsOptions.cacheFs ?? false;
 	project.vitest.state.metadata[project.name] ??= {
 		externalized: {},
 		duration: {},
@@ -6552,11 +7011,11 @@ function createMethodsRPC(project, options = {}) {
 	if (project.config.dumpDir && !existsSync(project.config.dumpDir)) mkdirSync(project.config.dumpDir, { recursive: true });
 	project.vitest.state.metadata[project.name].dumpDir = project.config.dumpDir;
 	return {
-		async fetch(url, importer, environmentName, options) {
+		async fetch(url, importer, environmentName, options, otelCarrier) {
 			const environment = project.vite.environments[environmentName];
 			if (!environment) throw new Error(`The environment ${environmentName} was not defined in the Vite config.`);
 			const start = performance.now();
-			return await project._fetcher(url, importer, environment, cacheFs, options).then((result) => {
+			return await project._fetcher(url, importer, environment, cacheFs, options, otelCarrier).then((result) => {
 				const duration = performance.now() - start;
 				project.vitest.state.transformTime += duration;
 				const metadata = project.vitest.state.metadata[project.name];
@@ -6597,25 +7056,25 @@ function createMethodsRPC(project, options = {}) {
 			return { code: (await environment.transformRequest(url).catch(handleRollupError))?.code };
 		},
 		async onQueued(file) {
-			if (options.collect) vitest.state.collectFiles(project, [file]);
+			if (methodsOptions.collect) vitest.state.collectFiles(project, [file]);
 			else await vitest._testRun.enqueued(project, file);
 		},
 		async onCollected(files) {
-			if (options.collect) vitest.state.collectFiles(project, files);
+			if (methodsOptions.collect) vitest.state.collectFiles(project, files);
 			else await vitest._testRun.collected(project, files);
 		},
 		onAfterSuiteRun(meta) {
 			vitest.coverageProvider?.onAfterSuiteRun(meta);
 		},
-		async onTaskAnnotate(testId, annotation) {
-			return vitest._testRun.annotate(testId, annotation);
+		async onTaskArtifactRecord(testId, artifact) {
+			return vitest._testRun.recordArtifact(testId, artifact);
 		},
 		async onTaskUpdate(packs, events) {
-			if (options.collect) vitest.state.updateTasks(packs);
+			if (methodsOptions.collect) vitest.state.updateTasks(packs);
 			else await vitest._testRun.updated(packs, events);
 		},
 		async onUserConsoleLog(log) {
-			if (options.collect) vitest.state.updateUserLog(log);
+			if (methodsOptions.collect) vitest.state.updateUserLog(log);
 			else await vitest._testRun.log(log);
 		},
 		onUnhandledError(err, type) {
@@ -6648,11 +7107,18 @@ class PoolRunner {
 	environment;
 	_state = RunnerState.IDLE;
 	_operationLock = null;
+	_terminatePromise = createDefer();
 	_eventEmitter = new EventEmitter();
+	_offCancel;
 	_rpc;
+	_otel = null;
+	_traces;
 	get isTerminated() {
 		return this._state === RunnerState.STOPPED;
 	}
+	waitForTerminated() {
+		return this._terminatePromise;
+	}
 	get isStarted() {
 		return this._state === RunnerState.STARTED;
 	}
@@ -6660,22 +7126,65 @@ class PoolRunner {
 		this.worker = worker;
 		this.project = options.project;
 		this.environment = options.environment;
+		const vitest = this.project.vitest;
+		this._traces = vitest._traces;
+		if (this._traces.isEnabled()) {
+			const { span: workerSpan, context } = this._traces.startContextSpan("vitest.worker");
+			this._otel = {
+				span: workerSpan,
+				workerContext: context,
+				files: []
+			};
+			this._otel.span.setAttributes({
+				"vitest.worker.name": this.worker.name,
+				"vitest.project": this.project.name,
+				"vitest.environment": this.environment.name
+			});
+		}
 		this._rpc = createBirpc(createMethodsRPC(this.project, {
 			collect: options.method === "collect",
 			cacheFs: worker.cacheFs
 		}), {
 			eventNames: ["onCancel"],
-			post: (request) => this.postMessage(request),
+			post: (request) => {
+				if (this._state !== RunnerState.STOPPING && this._state !== RunnerState.STOPPED) this.postMessage(request);
+			},
 			on: (callback) => this._eventEmitter.on("rpc", callback),
 			timeout: -1
 		});
-		this.project.vitest.onCancel((reason) => this._rpc.onCancel(reason));
+		this._offCancel = vitest.onCancel((reason) => this._rpc.onCancel(reason));
 	}
 	postMessage(message) {
 		// Only send messages when runner is active (not fully stopped)
 		// Allow sending during STOPPING state for the 'stop' message itself
 		if (this._state !== RunnerState.STOPPED) return this.worker.send(message);
 	}
+	startTracesSpan(name) {
+		const traces = this._traces;
+		if (!this._otel) return traces.startSpan(name);
+		const { span, context } = traces.startContextSpan(name, this._otel.workerContext);
+		this._otel.currentContext = context;
+		const end = span.end.bind(span);
+		span.end = (endTime) => {
+			this._otel.currentContext = void 0;
+			return end(endTime);
+		};
+		return span;
+	}
+	request(method, context) {
+		this._otel?.files.push(...context.files.map((f) => f.filepath));
+		return this.postMessage({
+			__vitest_worker_request__: true,
+			type: method,
+			context,
+			poolId: this.poolId,
+			otelCarrier: this.getOTELCarrier()
+		});
+	}
+	getOTELCarrier() {
+		const activeContext = this._otel?.currentContext || this._otel?.workerContext;
+		return activeContext ? this._traces.getContextCarrier(activeContext) : void 0;
+	}
 	async start() {
 		// Wait for any ongoing operation to complete
 		if (this._operationLock) await this._operationLock;
@@ -6683,15 +7192,21 @@ class PoolRunner {
 		if (this._state === RunnerState.STOPPED) throw new Error("[vitest-pool-runner]: Cannot start a stopped runner");
 		// Create operation lock to prevent concurrent start/stop
 		this._operationLock = createDefer();
+		let startSpan;
 		try {
 			this._state = RunnerState.STARTING;
-			await this.worker.start();
+			await this._traces.$(`vitest.${this.worker.name}.start`, { context: this._otel?.workerContext }, () => this.worker.start());
 			// Attach event listeners AFTER starting worker to avoid issues
 			// if worker.start() fails
 			this.worker.on("error", this.emitWorkerError);
 			this.worker.on("exit", this.emitUnexpectedExit);
 			this.worker.on("message", this.emitWorkerMessage);
+			startSpan = this.startTracesSpan("vitest.worker.start");
 			const startPromise = this.withTimeout(this.waitForStart(), START_TIMEOUT);
+			const globalConfig = this.project.vitest.config.experimental.openTelemetry;
+			const projectConfig = this.project.config.experimental.openTelemetry;
+			const tracesEnabled = projectConfig?.enabled ?? globalConfig?.enabled === true;
+			const tracesSdk = projectConfig?.sdkPath ?? globalConfig?.sdkPath;
 			this.postMessage({
 				type: "start",
 				__vitest_worker_request__: true,
@@ -6703,14 +7218,21 @@ class PoolRunner {
 					},
 					config: this.project.serializedConfig,
 					pool: this.worker.name
+				},
+				traces: {
+					enabled: tracesEnabled,
+					sdkPath: tracesSdk,
+					otelCarrier: this.getOTELCarrier()
 				}
 			});
 			await startPromise;
 			this._state = RunnerState.STARTED;
 		} catch (error) {
 			this._state = RunnerState.IDLE;
+			startSpan?.recordException(error);
 			throw error;
 		} finally {
+			startSpan?.end();
 			this._operationLock.resolve();
 			this._operationLock = null;
 		}
@@ -6719,7 +7241,9 @@ class PoolRunner {
 		// Wait for any ongoing operation to complete
 		if (this._operationLock) await this._operationLock;
 		if (this._state === RunnerState.STOPPED || this._state === RunnerState.STOPPING) return;
+		this._otel?.span.setAttribute("vitest.worker.files", this._otel.files);
 		if (this._state === RunnerState.IDLE) {
+			this._otel?.span.end();
 			this._state = RunnerState.STOPPED;
 			return;
 		}
@@ -6729,10 +7253,14 @@ class PoolRunner {
 			this._state = RunnerState.STOPPING;
 			// Remove exit listener early to avoid "unexpected exit" errors during shutdown
 			this.worker.off("exit", this.emitUnexpectedExit);
+			const stopSpan = this.startTracesSpan("vitest.worker.stop");
 			await this.withTimeout(new Promise((resolve) => {
 				const onStop = (response) => {
 					if (response.type === "stopped") {
-						if (response.error) this.project.vitest.state.catchError(response.error, "Teardown Error");
+						if (response.error) {
+							stopSpan.recordException(response.error);
+							this.project.vitest.state.catchError(response.error, "Teardown Error");
+						}
 						resolve();
 						this.off("message", onStop);
 					}
@@ -6740,14 +7268,18 @@ class PoolRunner {
 				this.on("message", onStop);
 				this.postMessage({
 					type: "stop",
-					__vitest_worker_request__: true
+					__vitest_worker_request__: true,
+					otelCarrier: this.getOTELCarrier()
 				});
-			}), STOP_TIMEOUT);
+			}), STOP_TIMEOUT).finally(() => {
+				stopSpan.end();
+			});
 			this._eventEmitter.removeAllListeners();
+			this._offCancel();
 			this._rpc.$close(/* @__PURE__ */ new Error("[vitest-pool-runner]: Pending methods while closing rpc"));
 			// Stop the worker process (this sets _fork/_thread to undefined)
 			// Worker's event listeners (error, message) are implicitly removed when worker terminates
-			await this.worker.stop();
+			await this._traces.$(`vitest.${this.worker.name}.stop`, { context: this._otel?.workerContext }, () => this.worker.stop());
 			this._state = RunnerState.STOPPED;
 		} catch (error) {
 			// Ensure we transition to stopped state even on error
@@ -6756,6 +7288,8 @@ class PoolRunner {
 		} finally {
 			this._operationLock.resolve();
 			this._operationLock = null;
+			this._otel?.span.end();
+			this._terminatePromise.resolve();
 		}
 	}
 	on(event, callback) {
@@ -6835,14 +7369,14 @@ class ForksPoolWorker {
 		this.fork.off(event, callback);
 	}
 	send(message) {
-		if ("context" in message && "config" in message.context) message.context.config = wrapSerializableConfig(message.context.config);
-		this.fork.send(v8.serialize(message));
+		this.fork.send(message);
 	}
 	async start() {
 		this._fork ||= fork(this.entrypoint, [], {
 			env: this.env,
 			execArgv: this.execArgv,
-			stdio: "pipe"
+			stdio: "pipe",
+			serialization: "advanced"
 		});
 		if (this._fork.stdout) {
 			this.stdout.setMaxListeners(1 + this.stdout.getMaxListeners());
@@ -6880,41 +7414,13 @@ class ForksPoolWorker {
 		this._fork = void 0;
 	}
 	deserialize(data) {
-		try {
-			return v8.deserialize(Buffer.from(data));
-		} catch (error) {
-			let stringified = "";
-			try {
-				stringified = `\nReceived value: ${JSON.stringify(data)}`;
-			} catch {}
-			throw new Error(`[vitest-pool]: Unexpected call to process.send(). Make sure your test cases are not interfering with process's channel.${stringified}`, { cause: error });
-		}
+		return data;
 	}
 	get fork() {
 		if (!this._fork) throw new Error(`The child process was torn down or never initialized. This is a bug in Vitest.`);
 		return this._fork;
 	}
 }
-/**
-* Prepares `SerializedConfig` for serialization, e.g. `node:v8.serialize`
-* - Unwrapping done in {@link file://./../../../runtime/workers/init-forks.ts}
-*/
-function wrapSerializableConfig(config) {
-	let testNamePattern = config.testNamePattern;
-	let defines = config.defines;
-	// v8 serialize does not support regex
-	if (testNamePattern && typeof testNamePattern !== "string") testNamePattern = `$$vitest:${testNamePattern.toString()}`;
-	// v8 serialize drops properties with undefined value
-	if (defines) defines = {
-		keys: Object.keys(defines),
-		original: defines
-	};
-	return {
-		...config,
-		testNamePattern,
-		defines
-	};
-}
 
 /** @experimental */
 class ThreadsPoolWorker {
@@ -7215,8 +7721,9 @@ class Pool {
 				cancelTask
 			};
 			this.activeTasks.push(activeTask);
+			// active tasks receive cancel signal and shut down gracefully
 			async function cancelTask() {
-				await runner.stop();
+				await runner.waitForTerminated();
 				resolver.reject(/* @__PURE__ */ new Error("Cancelled"));
 			}
 			const onFinished = (message) => {
@@ -7237,14 +7744,15 @@ class Pool {
 			}
 			const poolId = runner.poolId ?? this.getWorkerId();
 			runner.poolId = poolId;
+			const span = runner.startTracesSpan(`vitest.worker.${method}`);
 			// Start running the test in the worker
-			runner.postMessage({
-				__vitest_worker_request__: true,
-				type: method,
-				context: task.context,
-				poolId
+			runner.request(method, task.context);
+			await resolver.promise.catch((error) => {
+				span.recordException(error);
+				throw error;
+			}).finally(() => {
+				span.end();
 			});
-			await resolver.promise;
 			const index = this.activeTasks.indexOf(activeTask);
 			if (index !== -1) this.activeTasks.splice(index, 1);
 			if (!task.isolate && !isMemoryLimitReached && this.queue[0]?.task.isolate === false && isEqualRunner(runner, this.queue[0].task)) {
@@ -7680,7 +8188,8 @@ function serializeConfig(project) {
 		standalone: config.standalone,
 		printConsoleTrace: config.printConsoleTrace ?? globalConfig.printConsoleTrace,
 		benchmark: config.benchmark && { includeSamples: config.benchmark.includeSamples },
-		serializedDefines: config.browser.enabled ? "" : project._serializedDefines || ""
+		serializedDefines: config.browser.enabled ? "" : project._serializedDefines || "",
+		experimental: { fsModuleCache: config.experimental.fsModuleCache ?? false }
 	};
 }
 
@@ -8731,13 +9240,19 @@ function WorkspaceVitestPlugin(project, options) {
 						return project.vitest.matchesProjectFilter(name);
 					})) throw new VitestFilteredOutProjectError();
 				}
+				const vitestConfig = { name: {
+					label: name,
+					color
+				} };
+				// always inherit the global `fsModuleCache` value even without `extends: true`
+				if (testConfig.experimental?.fsModuleCache == null && project.vitest.config.experimental?.fsModuleCache !== null) {
+					vitestConfig.experimental ??= {};
+					vitestConfig.experimental.fsModuleCache = project.vitest.config.experimental.fsModuleCache;
+				}
 				return {
 					base: "/",
 					environments: { __vitest__: { dev: {} } },
-					test: { name: {
-						label: name,
-						color
-					} }
+					test: vitestConfig
 				};
 			}
 		},
@@ -8822,16 +9337,21 @@ class VitestResolver {
 	options;
 	externalizeCache = /* @__PURE__ */ new Map();
 	constructor(cacheDir, config) {
+		// sorting to make cache consistent
+		const inline = config.server.deps?.inline;
+		if (Array.isArray(inline)) inline.sort();
+		const external = config.server.deps?.external;
+		if (Array.isArray(external)) external.sort();
 		this.options = {
-			moduleDirectories: config.deps.moduleDirectories,
+			moduleDirectories: config.deps.moduleDirectories?.sort(),
 			inlineFiles: config.setupFiles.flatMap((file) => {
 				if (file.startsWith("file://")) return file;
 				const resolvedId = resolve(file);
 				return [resolvedId, pathToFileURL(resolvedId).href];
 			}),
 			cacheDir,
-			inline: config.server.deps?.inline,
-			external: config.server.deps?.external
+			inline,
+			external
 		};
 	}
 	shouldExternalize(file) {
@@ -8888,7 +9408,7 @@ async function isValidNodeImport(id) {
 	if (/\.(?:\w+-)?esm?(?:-\w+)?\.js$|\/esm?\//.test(id)) return false;
 	try {
 		await esModuleLexer.init;
-		const code = await promises$1.readFile(id, "utf8");
+		const code = await promises.readFile(id, "utf8");
 		const [, , , hasModuleSyntax] = esModuleLexer.parse(code);
 		return !hasModuleSyntax;
 	} catch {
@@ -9154,15 +9674,24 @@ class TestProject {
 	* @param filters String filters to match the test files.
 	*/
 	async globTestFiles(filters = []) {
-		const dir = this.config.dir || this.config.root;
-		const { include, exclude, includeSource } = this.config;
-		const typecheck = this.config.typecheck;
-		const [testFiles, typecheckTestFiles] = await Promise.all([typecheck.enabled && typecheck.only ? [] : this.globAllTestFiles(include, exclude, includeSource, dir), typecheck.enabled ? this.typecheckFilesList || this.globFiles(typecheck.include, typecheck.exclude, dir) : []]);
-		this.typecheckFilesList = typecheckTestFiles;
-		return {
-			testFiles: this.filterFiles(testFiles, filters, dir),
-			typecheckTestFiles: this.filterFiles(typecheckTestFiles, filters, dir)
-		};
+		return this.vitest._traces.$("vitest.config.resolve_include_project", async (span) => {
+			const dir = this.config.dir || this.config.root;
+			const { include, exclude, includeSource } = this.config;
+			const typecheck = this.config.typecheck;
+			span.setAttributes({
+				cwd: dir,
+				include,
+				exclude,
+				includeSource,
+				typecheck: typecheck.enabled ? typecheck.include : []
+			});
+			const [testFiles, typecheckTestFiles] = await Promise.all([typecheck.enabled && typecheck.only ? [] : this.globAllTestFiles(include, exclude, includeSource, dir), typecheck.enabled ? this.typecheckFilesList || this.globFiles(typecheck.include, typecheck.exclude, dir) : []]);
+			this.typecheckFilesList = typecheckTestFiles;
+			return {
+				testFiles: this.filterFiles(testFiles, filters, dir),
+				typecheckTestFiles: this.filterFiles(typecheckTestFiles, filters, dir)
+			};
+		});
 	}
 	async globAllTestFiles(include, exclude, includeSource, cwd) {
 		if (this.testFilesList) return this.testFilesList;
@@ -9171,7 +9700,7 @@ class TestProject {
 			const files = await this.globFiles(includeSource, exclude, cwd);
 			await Promise.all(files.map(async (file) => {
 				try {
-					const code = await promises$1.readFile(file, "utf-8");
+					const code = await promises.readFile(file, "utf-8");
 					if (this.isInSourceTestCode(code)) testFiles.push(file);
 				} catch {
 					return null;
@@ -9323,10 +9852,7 @@ class TestProject {
 		this._resolver = new VitestResolver(server.config.cacheDir, this._config);
 		this._vite = server;
 		this._serializedDefines = createDefinesScript(server.config.define);
-		this._fetcher = createFetchModuleFunction(this._resolver, this.tmpDir, {
-			dumpFolder: this.config.dumpDir,
-			readFromDump: this.config.server.debug?.load ?? process.env.VITEST_DEBUG_LOAD_DUMP != null
-		});
+		this._fetcher = createFetchModuleFunction(this._resolver, this._config, this.vitest._fsCache, this.vitest._traces, this.tmpDir);
 		const environment = server.environments.__vitest__;
 		this.runner = new ServerModuleRunner(environment, this._fetcher, this._config);
 	}
@@ -9394,7 +9920,7 @@ function deduped(cb) {
 }
 async function initializeProject(workspacePath, ctx, options) {
 	const project = new TestProject(ctx, options);
-	const { configFile,...restOptions } = options;
+	const { configFile, ...restOptions } = options;
 	await createViteServer({
 		...restOptions,
 		configFile,
@@ -9567,8 +10093,8 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	});
 	return resolvedProjects.filter((project) => !removeProjects.has(project));
 }
-function cloneConfig(project, { browser,...config }) {
-	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name, provider,...overrideConfig } = config;
+function cloneConfig(project, { browser, ...config }) {
+	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name, provider, ...overrideConfig } = config;
 	const currentConfig = project.config.browser;
 	const clonedConfig = deepClone(project.config);
 	return mergeConfig({
@@ -9986,6 +10512,14 @@ class TestCase extends ReportedTaskImplementation {
 		return [...this.task.annotations];
 	}
 	/**
+	* @experimental
+	*
+	* Test artifacts recorded via the `recordArtifact` API during the test execution.
+	*/
+	artifacts() {
+		return [...this.task.artifacts];
+	}
+	/**
 	* Useful information about the test like duration, memory usage, etc.
 	* Diagnostic is only available after the test has finished.
 	*/
@@ -10840,15 +11374,22 @@ class TestRun {
 		this.vitest.state.updateUserLog(log);
 		await this.vitest.report("onUserConsoleLog", log);
 	}
-	async annotate(testId, annotation) {
+	async recordArtifact(testId, artifact) {
 		const task = this.vitest.state.idMap.get(testId);
 		const entity = task && this.vitest.state.getReportedEntity(task);
 		assert$1(task && entity, `Entity must be found for task ${task?.name || testId}`);
-		assert$1(entity.type === "test", `Annotation can only be added to a test, instead got ${entity.type}`);
-		await this.resolveTestAttachment(entity, annotation);
-		entity.task.annotations.push(annotation);
-		await this.vitest.report("onTestCaseAnnotate", entity, annotation);
-		return annotation;
+		assert$1(entity.type === "test", `Artifacts can only be recorded on a test, instead got ${entity.type}`);
+		// annotations won't resolve as artifacts for backwards compatibility until next major
+		if (artifact.type === "internal:annotation") {
+			await this.resolveTestAttachment(entity, artifact.annotation.attachment, artifact.annotation.message);
+			entity.task.annotations.push(artifact.annotation);
+			await this.vitest.report("onTestCaseAnnotate", entity, artifact.annotation);
+			return artifact;
+		}
+		if (Array.isArray(artifact.attachments)) await Promise.all(artifact.attachments.map((attachment) => this.resolveTestAttachment(entity, attachment)));
+		entity.task.artifacts.push(artifact);
+		await this.vitest.report("onTestCaseArtifactRecord", entity, artifact);
+		return artifact;
 	}
 	async updated(update, events) {
 		this.syncUpdateStacks(update);
@@ -10935,15 +11476,14 @@ class TestRun {
 			}
 		}
 	}
-	async resolveTestAttachment(test, annotation) {
+	async resolveTestAttachment(test, attachment, filename) {
 		const project = test.project;
-		const attachment = annotation.attachment;
 		if (!attachment) return attachment;
 		const path = attachment.path;
 		if (path && !path.startsWith("http://") && !path.startsWith("https://")) {
 			const currentPath = resolve(project.config.root, path);
 			const hash = createHash("sha1").update(currentPath).digest("hex");
-			const newPath = resolve(project.config.attachmentsDir, `${sanitizeFilePath(annotation.message)}-${hash}${extname(currentPath)}`);
+			const newPath = resolve(project.config.attachmentsDir, `${filename ? `${sanitizeFilePath(filename)}-` : ""}${hash}${extname(currentPath)}`);
 			if (!existsSync(project.config.attachmentsDir)) await mkdir(project.config.attachmentsDir, { recursive: true });
 			await copyFile(currentPath, newPath);
 			attachment.path = newPath;
@@ -11166,6 +11706,7 @@ class Vitest {
 	/** @internal */ filenamePattern;
 	/** @internal */ runningPromise;
 	/** @internal */ closingPromise;
+	/** @internal */ cancelPromise;
 	/** @internal */ isCancelling = false;
 	/** @internal */ coreWorkspaceProject;
 	/** @internal */ _browserSessions = new BrowserSessions();
@@ -11175,7 +11716,9 @@ class Vitest {
 	/** @internal */ _testRun = void 0;
 	/** @internal */ _resolver;
 	/** @internal */ _fetcher;
+	/** @internal */ _fsCache;
 	/** @internal */ _tmpDir = join(tmpdir(), nanoid());
+	/** @internal */ _traces;
 	isFirstRun = true;
 	restartsCount = 0;
 	specifications;
@@ -11197,7 +11740,7 @@ class Vitest {
 	_onRestartListeners = [];
 	_onClose = [];
 	_onSetServer = [];
-	_onCancelListeners = [];
+	_onCancelListeners = /* @__PURE__ */ new Set();
 	_onUserTestsRerun = [];
 	_onFilterWatchedSpecification = [];
 	/**
@@ -11254,15 +11797,19 @@ class Vitest {
 		const resolved = resolveConfig(this, options, server.config);
 		this._config = resolved;
 		this._state = new StateManager({ onUnhandledError: resolved.onUnhandledError });
-		this._cache = new VitestCache(this.version);
+		this._cache = new VitestCache(this.logger);
 		this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
 		this._testRun = new TestRun(this);
+		const otelSdkPath = resolved.experimental.openTelemetry?.sdkPath;
+		this._traces = new Traces({
+			enabled: !!resolved.experimental.openTelemetry?.enabled,
+			sdkPath: otelSdkPath,
+			watchMode: resolved.watch
+		});
 		if (this.config.watch) this.watcher.registerWatcher();
 		this._resolver = new VitestResolver(server.config.cacheDir, resolved);
-		this._fetcher = createFetchModuleFunction(this._resolver, this._tmpDir, {
-			dumpFolder: this.config.dumpDir,
-			readFromDump: this.config.server.debug?.load ?? process.env.VITEST_DEBUG_LOAD_DUMP != null
-		});
+		this._fsCache = new FileSystemModuleCache(this);
+		this._fetcher = createFetchModuleFunction(this._resolver, this._config, this._fsCache, this._traces, this._tmpDir);
 		const environment = server.environments.__vitest__;
 		this.runner = new ServerModuleRunner(environment, this._fetcher, resolved);
 		if (this.config.watch) {
@@ -11295,7 +11842,8 @@ class Vitest {
 			return project.vite.config.getSortedPluginHooks("configureVitest").map((hook) => hook({
 				project,
 				vitest: this,
-				injectTestProjects: this.injectTestProject
+				injectTestProjects: this.injectTestProject,
+				experimental_defineCacheKeyGenerator: (callback) => this._fsCache.defineCacheKeyGenerator(callback)
 			}));
 		}));
 		if (this._cliOptions.browser?.enabled) {
@@ -11313,7 +11861,8 @@ class Vitest {
 		if (!this.coreWorkspaceProject) this.coreWorkspaceProject = TestProject._createBasicProject(this);
 		if (this.config.testNamePattern) this.configOverride.testNamePattern = this.config.testNamePattern;
 		this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this);
-		await Promise.all(this._onSetServer.map((fn) => fn()));
+		await this._fsCache.ensureCacheIntegrity();
+		await Promise.all([...this._onSetServer.map((fn) => fn()), this._traces.waitInit()]);
 	}
 	/** @internal */
 	get coverageProvider() {
@@ -11325,10 +11874,19 @@ class Vitest {
 		this.configOverride.coverage.enabled = true;
 		await this.createCoverageProvider();
 		await this.coverageProvider?.onEnabled?.();
+		// onFileTransform is the only thing that affects hash
+		if (this.coverageProvider?.onFileTransform) this.clearAllCachePaths();
 	}
 	disableCoverage() {
 		this.configOverride.coverage ??= {};
 		this.configOverride.coverage.enabled = false;
+		// onFileTransform is the only thing that affects hash
+		if (this.coverageProvider?.onFileTransform) this.clearAllCachePaths();
+	}
+	clearAllCachePaths() {
+		this.projects.forEach(({ vite, browser }) => {
+			[...Object.values(vite.environments), ...Object.values(browser?.vite.environments || {})].forEach((environment) => this._fsCache.invalidateAllCachePaths(environment));
+		});
 	}
 	_coverageOverrideCache = /* @__PURE__ */ new WeakMap();
 	/** @internal */
@@ -11424,33 +11982,43 @@ class Vitest {
 		return this._coverageProvider;
 	}
 	/**
+	* Deletes all Vitest caches, including `experimental.fsModuleCache`.
+	* @experimental
+	*/
+	async experimental_clearCache() {
+		await this.cache.results.clearCache();
+		await this._fsCache.clearCache();
+	}
+	/**
 	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
 	*/
 	async mergeReports(directory) {
-		if (this.reporters.some((r) => r instanceof BlobReporter)) throw new Error("Cannot merge reports when `--reporter=blob` is used. Remove blob reporter from the config first.");
-		const { files, errors, coverages, executionTimes } = await readBlobs(this.version, directory || this.config.mergeReports, this.projects);
-		this.state.blobs = {
-			files,
-			errors,
-			coverages,
-			executionTimes
-		};
-		await this.report("onInit", this);
-		const specifications = [];
-		for (const file of files) {
-			const specification = this.getProjectByName(file.projectName || "").createSpecification(file.filepath, void 0, file.pool);
-			specifications.push(specification);
-		}
-		await this._testRun.start(specifications).catch(noop);
-		for (const file of files) await this._reportFileTask(file);
-		this._checkUnhandledErrors(errors);
-		await this._testRun.end(specifications, errors).catch(noop);
-		await this.initCoverageProvider();
-		await this.coverageProvider?.mergeReports?.(coverages);
-		return {
-			testModules: this.state.getTestModules(),
-			unhandledErrors: this.state.getUnhandledErrors()
-		};
+		return this._traces.$("vitest.merge_reports", async () => {
+			if (this.reporters.some((r) => r instanceof BlobReporter)) throw new Error("Cannot merge reports when `--reporter=blob` is used. Remove blob reporter from the config first.");
+			const { files, errors, coverages, executionTimes } = await readBlobs(this.version, directory || this.config.mergeReports, this.projects);
+			this.state.blobs = {
+				files,
+				errors,
+				coverages,
+				executionTimes
+			};
+			await this.report("onInit", this);
+			const specifications = [];
+			for (const file of files) {
+				const specification = this.getProjectByName(file.projectName || "").createSpecification(file.filepath, void 0, file.pool);
+				specifications.push(specification);
+			}
+			await this._testRun.start(specifications).catch(noop);
+			for (const file of files) await this._reportFileTask(file);
+			this._checkUnhandledErrors(errors);
+			await this._testRun.end(specifications, errors).catch(noop);
+			await this.initCoverageProvider();
+			await this.coverageProvider?.mergeReports?.(coverages);
+			return {
+				testModules: this.state.getTestModules(),
+				unhandledErrors: this.state.getUnhandledErrors()
+			};
+		});
 	}
 	/**
 	* Returns the seed, if tests are running in a random order.
@@ -11472,13 +12040,25 @@ class Vitest {
 		await this._testRun.updated(packs, events).catch(noop);
 	}
 	async collect(filters) {
-		const files = await this.specifications.getRelevantTestSpecifications(filters);
-		// if run with --changed, don't exit if no tests are found
-		if (!files.length) return {
-			testModules: [],
-			unhandledErrors: []
-		};
-		return this.collectTests(files);
+		return this._traces.$("vitest.collect", async (collectSpan) => {
+			const filenamePattern = filters && filters?.length > 0 ? filters : [];
+			collectSpan.setAttribute("vitest.collect.filters", filenamePattern);
+			const files = await this._traces.$("vitest.config.resolve_include_glob", async () => {
+				const specifications = await this.specifications.getRelevantTestSpecifications(filters);
+				collectSpan.setAttribute("vitest.collect.specifications", specifications.map((s) => {
+					const relativeModuleId = relative(s.project.config.root, s.moduleId);
+					if (s.project.name) return `|${s.project.name}| ${relativeModuleId}`;
+					return relativeModuleId;
+				}));
+				return specifications;
+			});
+			// if run with --changed, don't exit if no tests are found
+			if (!files.length) return {
+				testModules: [],
+				unhandledErrors: []
+			};
+			return this.collectTests(files);
+		});
 	}
 	/**
 	* Returns the list of test files that match the config and filters.
@@ -11496,49 +12076,67 @@ class Vitest {
 	* @param filters String filters to match the test files
 	*/
 	async start(filters) {
-		try {
-			await this.initCoverageProvider();
-			await this.coverageProvider?.clean(this._coverageOptions.clean);
-		} finally {
-			await this.report("onInit", this);
-		}
-		this.filenamePattern = filters && filters?.length > 0 ? filters : void 0;
-		const files = await this.specifications.getRelevantTestSpecifications(filters);
-		// if run with --changed, don't exit if no tests are found
-		if (!files.length) {
-			await this._testRun.start([]);
-			const coverage = await this.coverageProvider?.generateCoverage?.({ allTestsRun: true });
-			await this._testRun.end([], [], coverage);
-			// Report coverage for uncovered files
-			await this.reportCoverage(coverage, true);
-			if (!this.config.watch || !(this.config.changed || this.config.related?.length)) throw new FilesNotFoundError(this.mode);
-		}
-		let testModules = {
-			testModules: [],
-			unhandledErrors: []
-		};
-		if (files.length) {
-			// populate once, update cache on watch
-			await this.cache.stats.populateStats(this.config.root, files);
-			testModules = await this.runFiles(files, true);
-		}
-		if (this.config.watch) await this.report("onWatcherStart");
-		return testModules;
+		return this._traces.$("vitest.start", async (startSpan) => {
+			startSpan.setAttributes({ config: this.vite.config.configFile });
+			try {
+				await this._traces.$("vitest.coverage.init", async () => {
+					await this.initCoverageProvider();
+					await this.coverageProvider?.clean(this._coverageOptions.clean);
+				});
+			} finally {
+				await this.report("onInit", this);
+			}
+			this.filenamePattern = filters && filters?.length > 0 ? filters : void 0;
+			startSpan.setAttribute("vitest.start.filters", this.filenamePattern || []);
+			const files = await this._traces.$("vitest.config.resolve_include_glob", async () => {
+				const specifications = await this.specifications.getRelevantTestSpecifications(filters);
+				startSpan.setAttribute("vitest.start.specifications", specifications.map((s) => {
+					const relativeModuleId = relative(s.project.config.root, s.moduleId);
+					if (s.project.name) return `|${s.project.name}| ${relativeModuleId}`;
+					return relativeModuleId;
+				}));
+				return specifications;
+			});
+			// if run with --changed, don't exit if no tests are found
+			if (!files.length) {
+				await this._traces.$("vitest.test_run", async () => {
+					await this._testRun.start([]);
+					const coverage = await this.coverageProvider?.generateCoverage?.({ allTestsRun: true });
+					await this._testRun.end([], [], coverage);
+					// Report coverage for uncovered files
+					await this.reportCoverage(coverage, true);
+				});
+				if (!this.config.watch || !(this.config.changed || this.config.related?.length)) throw new FilesNotFoundError(this.mode);
+			}
+			let testModules = {
+				testModules: [],
+				unhandledErrors: []
+			};
+			if (files.length) {
+				// populate once, update cache on watch
+				await this.cache.stats.populateStats(this.config.root, files);
+				testModules = await this.runFiles(files, true);
+			}
+			if (this.config.watch) await this.report("onWatcherStart");
+			return testModules;
+		});
 	}
 	/**
 	* Initialize reporters and the coverage provider. This method doesn't run any tests.
 	* If the `--watch` flag is provided, Vitest will still run changed tests even if this method was not called.
 	*/
 	async init() {
-		try {
-			await this.initCoverageProvider();
-			await this.coverageProvider?.clean(this._coverageOptions.clean);
-		} finally {
-			await this.report("onInit", this);
-		}
-		// populate test files cache so watch mode can trigger a file rerun
-		await this.globTestSpecifications();
-		if (this.config.watch) await this.report("onWatcherStart");
+		await this._traces.$("vitest.init", async () => {
+			try {
+				await this.initCoverageProvider();
+				await this.coverageProvider?.clean(this._coverageOptions.clean);
+			} finally {
+				await this.report("onInit", this);
+			}
+			// populate test files cache so watch mode can trigger a file rerun
+			await this.globTestSpecifications();
+			if (this.config.watch) await this.report("onWatcherStart");
+		});
 	}
 	/**
 	* If there is a test run happening, returns a promise that will
@@ -11588,50 +12186,53 @@ class Vitest {
 		return result;
 	}
 	async runFiles(specs, allTestsRun) {
-		await this._testRun.start(specs);
-		// previous run
-		await this.runningPromise;
-		this._onCancelListeners = [];
-		this.isCancelling = false;
-		// schedule the new run
-		this.runningPromise = (async () => {
-			try {
-				if (!this.pool) this.pool = createPool(this);
-				const invalidates = Array.from(this.watcher.invalidates);
-				this.watcher.invalidates.clear();
-				this.snapshot.clear();
-				this.state.clearErrors();
-				if (!this.isFirstRun && this._coverageOptions.cleanOnRerun) await this.coverageProvider?.clean();
-				await this.initializeGlobalSetup(specs);
+		return this._traces.$("vitest.test_run", async () => {
+			await this._testRun.start(specs);
+			// previous run
+			await this.cancelPromise;
+			await this.runningPromise;
+			this._onCancelListeners.clear();
+			this.isCancelling = false;
+			// schedule the new run
+			this.runningPromise = (async () => {
 				try {
-					await this.pool.runTests(specs, invalidates);
-				} catch (err) {
-					this.state.catchError(err, "Unhandled Error");
+					if (!this.pool) this.pool = createPool(this);
+					const invalidates = Array.from(this.watcher.invalidates);
+					this.watcher.invalidates.clear();
+					this.snapshot.clear();
+					this.state.clearErrors();
+					if (!this.isFirstRun && this._coverageOptions.cleanOnRerun) await this.coverageProvider?.clean();
+					await this.initializeGlobalSetup(specs);
+					try {
+						await this.pool.runTests(specs, invalidates);
+					} catch (err) {
+						this.state.catchError(err, "Unhandled Error");
+					}
+					const files = this.state.getFiles();
+					this.cache.results.updateResults(files);
+					try {
+						await this.cache.results.writeToCache();
+					} catch {}
+					return {
+						testModules: this.state.getTestModules(),
+						unhandledErrors: this.state.getUnhandledErrors()
+					};
+				} finally {
+					const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun });
+					const errors = this.state.getUnhandledErrors();
+					this._checkUnhandledErrors(errors);
+					await this._testRun.end(specs, errors, coverage);
+					await this.reportCoverage(coverage, allTestsRun);
 				}
-				const files = this.state.getFiles();
-				this.cache.results.updateResults(files);
-				try {
-					await this.cache.results.writeToCache();
-				} catch {}
-				return {
-					testModules: this.state.getTestModules(),
-					unhandledErrors: this.state.getUnhandledErrors()
-				};
-			} finally {
-				const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun });
-				const errors = this.state.getUnhandledErrors();
-				this._checkUnhandledErrors(errors);
-				await this._testRun.end(specs, errors, coverage);
-				await this.reportCoverage(coverage, allTestsRun);
-			}
-		})().finally(() => {
-			this.runningPromise = void 0;
-			this.isFirstRun = false;
-			// all subsequent runs will treat this as a fresh run
-			this.config.changed = false;
-			this.config.related = void 0;
+			})().finally(() => {
+				this.runningPromise = void 0;
+				this.isFirstRun = false;
+				// all subsequent runs will treat this as a fresh run
+				this.config.changed = false;
+				this.config.related = void 0;
+			});
+			return await this.runningPromise;
 		});
-		return await this.runningPromise;
 	}
 	async experimental_parseSpecifications(specifications, options) {
 		if (this.mode !== "test") throw new Error(`The \`experimental_parseSpecifications\` does not support "${this.mode}" mode.`);
@@ -11656,8 +12257,9 @@ class Vitest {
 		const filepaths = specifications.map((spec) => spec.moduleId);
 		this.state.collectPaths(filepaths);
 		// previous run
+		await this.cancelPromise;
 		await this.runningPromise;
-		this._onCancelListeners = [];
+		this._onCancelListeners.clear();
 		this.isCancelling = false;
 		// schedule the new run
 		this.runningPromise = (async () => {
@@ -11692,7 +12294,8 @@ class Vitest {
 	*/
 	async cancelCurrentRun(reason) {
 		this.isCancelling = true;
-		await Promise.all(this._onCancelListeners.splice(0).map((listener) => listener(reason)));
+		this.cancelPromise = Promise.all([...this._onCancelListeners].map((listener) => listener(reason)));
+		await this.cancelPromise.finally(() => this.cancelPromise = void 0);
 		await this.runningPromise;
 	}
 	/** @internal */
@@ -11817,6 +12420,7 @@ class Vitest {
 	async scheduleRerun(triggerId) {
 		const currentCount = this.restartsCount;
 		clearTimeout(this._rerunTimer);
+		await this.cancelPromise;
 		await this.runningPromise;
 		clearTimeout(this._rerunTimer);
 		// server restarted
@@ -11854,8 +12458,14 @@ class Vitest {
 	*/
 	invalidateFile(filepath) {
 		this.projects.forEach(({ vite, browser }) => {
-			[...Object.values(vite.environments), ...Object.values(browser?.vite.environments || {})].forEach(({ moduleGraph }) => {
-				moduleGraph.getModulesByFile(filepath)?.forEach((module) => moduleGraph.invalidateModule(module));
+			[...Object.values(vite.environments), ...Object.values(browser?.vite.environments || {})].forEach((environment) => {
+				const { moduleGraph } = environment;
+				const modules = moduleGraph.getModulesByFile(filepath);
+				if (!modules) return;
+				modules.forEach((module) => {
+					moduleGraph.invalidateModule(module);
+					this._fsCache.invalidateCachePath(environment, module.id);
+				});
 			});
 		});
 	}
@@ -11893,11 +12503,12 @@ class Vitest {
 				this.pool = void 0;
 			})());
 			closePromises.push(...this._onClose.map((fn) => fn()));
-			return Promise.allSettled(closePromises).then((results) => {
+			await Promise.allSettled(closePromises).then((results) => {
 				results.forEach((r) => {
 					if (r.status === "rejected") this.logger.error("error during close", r.reason);
 				});
 			});
+			await this._traces?.finish();
 		})();
 		return this.closingPromise;
 	}
@@ -11950,7 +12561,10 @@ class Vitest {
 	* Register a handler that will be called when the test run is cancelled with `vitest.cancelCurrentRun`.
 	*/
 	onCancel(fn) {
-		this._onCancelListeners.push(fn);
+		this._onCancelListeners.add(fn);
+		return () => {
+			this._onCancelListeners.delete(fn);
+		};
 	}
 	/**
 	* Register a handler that will be called when the server is closed.
@@ -12091,7 +12705,7 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				options.api = resolveApiServerConfig(options, defaultPort);
 				// we replace every "import.meta.env" with "process.env"
 				// to allow reassigning, so we need to put all envs on process.env
-				const { PROD, DEV,...envs } = viteConfig.env;
+				const { PROD, DEV, ...envs } = viteConfig.env;
 				// process.env can have only string values and will cast string on it if we pass other type,
 				// so we are making them truthy
 				process.env.PROD ??= PROD ? "1" : "";
@@ -12143,7 +12757,7 @@ async function createVitest(mode, options, viteOverrides = {}, vitestOptions = {
 	const root = slash(resolve$1(options.root || process.cwd()));
 	const configPath = options.config === false ? false : options.config ? resolveModule(options.config, { paths: [root] }) ?? resolve$1(root, options.config) : any(configFiles, { cwd: root });
 	options.config = configPath;
-	const { browser: _removeBrowser,...restOptions } = options;
+	const { browser: _removeBrowser, ...restOptions } = options;
 	const server = await createViteServer(mergeConfig({
 		configFile: configPath,
 		configLoader: options.configLoader,
@@ -12471,7 +13085,8 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
 		else ctx.start(cliFilters);
 	});
 	try {
-		if (ctx.config.mergeReports) await ctx.mergeReports();
+		if (ctx.config.clearCache) await ctx.experimental_clearCache();
+		else if (ctx.config.mergeReports) await ctx.mergeReports();
 		else if (ctx.config.standalone) await ctx.init();
 		else await ctx.start(cliFilters);
 	} catch (e) {