vitest 4.0.14 → 4.0.16

package/dist/chunks/{cli-api.CbjxIXjQ.js → cli-api.BKg19Fvw.js}

@@ -2,20 +2,20 @@ import fs, { promises, existsSync, mkdirSync, readFileSync, statSync, readdirSyn
 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, withTrailingSlash, cleanUrl, wrapId, toArray, deepMerge, nanoid, deepClone, isPrimitive, notNullish } from '@vitest/utils/helpers';
+import { noop, createDefer, slash, withTrailingSlash, cleanUrl, wrapId, isExternalUrl, unwrapId, 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 { 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.BuJUwVtg.js';
 import * as vite from 'vite';
-import { parseAst, searchForWorkspaceRoot, fetchModule, version, mergeConfig, createServer } from 'vite';
+import { isFileServingAllowed as isFileServingAllowed$1, parseAst, searchForWorkspaceRoot, fetchModule, version, mergeConfig, createServer, isFileLoadingAllowed, normalizePath } 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, createTaskName, 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.DnEx6DOX.js';
+import { v as version$1 } from './cac.BGonGPac.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.D6PC4Dpu.js';
+import { c as createBirpc } from './index.Chj8NDwU.js';
+import { p as parse, d as stringify, e as createIndexLocationsMap, h as TraceMap, o as originalPositionFor, i as ancestor, j as printError, f as formatProjectName, w as withLabel, k as errorBanner, l as divider, m as Typechecker, n as generateCodeFrame, q as escapeRegExp, r as createDefinesScript, R as ReportersMap, u as groupBy, B as BlobReporter, v as readBlobs, x as convertTasksToEvents, H as HangingProcessReporter, y as wildcardPatternToRegExp, z as stdout } from './index.456_DGfR.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -37,11 +37,12 @@ import { VitestModuleEvaluator } from '#module-evaluator';
 import { ModuleRunner } from 'vite/module-runner';
 import { Console } from 'node:console';
 import { highlight } from '@vitest/utils/highlight';
-import { createRequire, isBuiltin, builtinModules } from 'node:module';
+import { createRequire, builtinModules, isBuiltin as isBuiltin$1 } from 'node:module';
 import url, { fileURLToPath, pathToFileURL } from 'node:url';
 import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
 import { isatty } from 'node:tty';
 import EventEmitter$1, { EventEmitter } from 'node:events';
+import { t as toBuiltin, i as isBuiltin } from './modules.BJuCwlRJ.js';
 import { fork } from 'node:child_process';
 import { Worker } from 'node:worker_threads';
 import pm from 'picomatch';
@@ -52,7 +53,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.B88tjlE5.js';
+import { a as BenchmarkReportsMap } from './index.Drsj_6e7.js';
 import assert$1 from 'node:assert';
 import { serializeValue } from '@vitest/utils/serialize';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
@@ -5025,30 +5026,55 @@ function requireWebsocketServer () {
 var websocketServerExports = requireWebsocketServer();
 var WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServerExports);
 
-async function getModuleGraph(ctx, projectName, id, browser = false) {
+function getTestFileEnvironment(project, testFile, browser = false) {
+	let environment;
+	if (browser) environment = project.browser?.vite.environments.client;
+	else for (const name in project.vite.environments) {
+		const env = project.vite.environments[name];
+		if (env.moduleGraph.getModuleById(testFile)) {
+			environment = env;
+			break;
+		}
+	}
+	return environment;
+}
+
+async function getModuleGraph(ctx, projectName, testFilePath, browser = false) {
 	const graph = {};
 	const externalized = /* @__PURE__ */ new Set();
 	const inlined = /* @__PURE__ */ new Set();
 	const project = ctx.getProjectByName(projectName);
-	async function get(mod, seen = /* @__PURE__ */ new Map()) {
+	const environment = getTestFileEnvironment(project, testFilePath, browser);
+	if (!environment) throw new Error(`Cannot find environment for ${testFilePath}`);
+	const seen = /* @__PURE__ */ new Map();
+	function get(mod) {
 		if (!mod || !mod.id) return;
-		if (mod.id === "\0vitest/browser") return;
+		if (mod.id === "\0vitest/browser" || mod.id.includes("plugin-vue:export-helper")) return;
 		if (seen.has(mod)) return seen.get(mod);
-		let id = clearId(mod.id);
+		const id = clearId(mod.id);
 		seen.set(mod, id);
-		// TODO: how to know if it was rewritten(?) - what is rewritten?
-		const rewrote = browser ? mod.file?.includes(project.browser.vite.config.cacheDir) ? mod.id : false : false;
-		if (rewrote) {
-			id = rewrote;
-			externalized.add(id);
-			seen.set(mod, id);
-		} else inlined.add(id);
-		const mods = Array.from(mod.importedModules).filter((i) => i.id && !i.id.includes("/vitest/dist/"));
-		graph[id] = (await Promise.all(mods.map((m) => get(m, seen)))).filter(Boolean);
+		if (id.startsWith("__vite-browser-external:")) {
+			const external = id.slice(24);
+			externalized.add(external);
+			return external;
+		}
+		const external = project._resolver.wasExternalized(id);
+		if (typeof external === "string") {
+			externalized.add(external);
+			return external;
+		}
+		if (browser && mod.file?.includes(project.browser.vite.config.cacheDir)) {
+			externalized.add(mod.id);
+			return id;
+		}
+		inlined.add(id);
+		graph[id] = Array.from(mod.importedModules).filter((i) => i.id && !i.id.includes("/vitest/dist/")).map((m) => get(m)).filter(Boolean);
 		return id;
 	}
-	if (browser && project.browser) await get(project.browser.vite.moduleGraph.getModuleById(id));
-	else await get(project.vite.moduleGraph.getModuleById(id));
+	get(environment.moduleGraph.getModuleById(testFilePath));
+	project.config.setupFiles.forEach((setupFile) => {
+		get(environment.moduleGraph.getModuleById(setupFile));
+	});
 	return {
 		graph,
 		externalized: Array.from(externalized),
@@ -5146,15 +5172,36 @@ function setup(ctx, _server) {
 					color: p.color
 				}));
 			},
-			async getTransformResult(projectName, id, browser = false) {
+			async getExternalResult(moduleId, testFileTaskId) {
+				const testModule = ctx.state.getReportedEntityById(testFileTaskId);
+				if (!testModule) return;
+				if (!isFileServingAllowed$1(testModule.project.vite.config, moduleId)) return;
+				const result = {};
+				try {
+					result.source = await promises.readFile(moduleId, "utf-8");
+				} catch {}
+				return result;
+			},
+			async getTransformResult(projectName, moduleId, testFileTaskId, browser = false) {
 				const project = ctx.getProjectByName(projectName);
-				const result = browser ? await project.browser.vite.transformRequest(id) : await project.vite.transformRequest(id);
-				if (result) {
-					try {
-						result.source = result.source || await promises.readFile(id, "utf-8");
-					} catch {}
-					return result;
-				}
+				const testModule = ctx.state.getReportedEntityById(testFileTaskId);
+				if (!testModule || !isFileServingAllowed$1(project.vite.config, moduleId)) return;
+				const environment = getTestFileEnvironment(project, testModule.moduleId, browser);
+				const moduleNode = environment?.moduleGraph.getModuleById(moduleId);
+				if (!environment || !moduleNode?.transformResult) return;
+				const result = moduleNode.transformResult;
+				try {
+					result.source = result.source || (moduleNode.file ? await promises.readFile(moduleNode.file, "utf-8") : void 0);
+				} catch {}
+				// TODO: store this in HTML reporter separetly
+				const transformDuration = ctx.state.metadata[projectName]?.duration[moduleNode.url]?.[0];
+				if (transformDuration != null) result.transformTime = transformDuration;
+				try {
+					const diagnostic = await ctx.experimental_getSourceModuleDiagnostic(moduleId, testModule);
+					result.modules = diagnostic.modules;
+					result.untrackedModules = diagnostic.untrackedModules;
+				} catch {}
+				return result;
 			},
 			async getModuleGraph(project, id, browser) {
 				return getModuleGraph(ctx, project, id, browser);
@@ -5273,31 +5320,6 @@ var setup$1 = /*#__PURE__*/Object.freeze({
   setup: setup
 });
 
-function groupBy(collection, iteratee) {
-	return collection.reduce((acc, item) => {
-		const key = iteratee(item);
-		acc[key] ||= [];
-		acc[key].push(item);
-		return acc;
-	}, {});
-}
-function stdout() {
-	// @ts-expect-error Node.js maps process.stdout to console._stdout
-	// eslint-disable-next-line no-console
-	return console._stdout || process.stdout;
-}
-function escapeRegExp(s) {
-	// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
-	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function wildcardPatternToRegExp(pattern) {
-	const negated = pattern[0] === "!";
-	if (negated) pattern = pattern.slice(1);
-	let regexp = `${pattern.split("*").map(escapeRegExp).join(".*")}$`;
-	if (negated) regexp = `(?!${regexp})`;
-	return new RegExp(`^${regexp}`, "i");
-}
-
 function createDebugger(namespace) {
 	const debug = createDebug(namespace);
 	if (debug.enabled) return debug;
@@ -5450,7 +5472,7 @@ function createFileTask(testFilepath, code, requestMap, options) {
 		file: null
 	};
 	file.file = file;
-	const indexMap = createIndexMap(code);
+	const indexMap = createIndexLocationsMap(code);
 	const map = requestMap && new TraceMap(requestMap);
 	let lastSuite = file;
 	const updateLatestSuite = (index) => {
@@ -5552,23 +5574,6 @@ async function transformSSR(project, filepath) {
 	if (!request) return null;
 	return await project.vite.ssrTransform(request.code, request.map, filepath);
 }
-function createIndexMap(source) {
-	const map = /* @__PURE__ */ new Map();
-	let index = 0;
-	let line = 1;
-	let column = 1;
-	for (const char of source) {
-		map.set(index++, {
-			line,
-			column
-		});
-		if (char === "\n" || char === "\r\n") {
-			line++;
-			column = 0;
-		} else column++;
-	}
-	return map;
-}
 function markDynamicTests(tasks) {
 	for (const task of tasks) {
 		if (task.dynamic) task.id += "-dynamic";
@@ -5766,7 +5771,7 @@ class FileSystemModuleCache {
 	*/
 	rootCache;
 	metadataFilePath;
-	version = "1.0.0-beta.2";
+	version = "1.0.0-beta.3";
 	fsCacheRoots = /* @__PURE__ */ new WeakMap();
 	fsEnvironmentHashMap = /* @__PURE__ */ new WeakMap();
 	fsCacheKeyGenerators = /* @__PURE__ */ new Set();
@@ -5811,7 +5816,7 @@ class FileSystemModuleCache {
 	}
 	async getCachedModule(cachedFilePath) {
 		if (!existsSync(cachedFilePath)) {
-			debugFs?.(`${c.red("[empty]")} ${cachedFilePath} doesn't exist, transforming by vite instead`);
+			debugFs?.(`${c.red("[empty]")} ${cachedFilePath} doesn't exist, transforming by vite first`);
 			return;
 		}
 		const fileResult = await this.readCachedFileConcurrently(cachedFilePath);
@@ -5824,16 +5829,18 @@ class FileSystemModuleCache {
 			file: meta.file,
 			code,
 			importers: meta.importers,
+			importedUrls: meta.importedUrls,
 			mappings: meta.mappings
 		};
 	}
-	async saveCachedModule(cachedFilePath, fetchResult, importers = [], mappings = false) {
+	async saveCachedModule(cachedFilePath, fetchResult, importers = [], importedUrls = [], mappings = false) {
 		if ("code" in fetchResult) {
 			const result = {
 				file: fetchResult.file,
 				id: fetchResult.id,
 				url: fetchResult.url,
 				importers,
+				importedUrls,
 				mappings
 			};
 			debugFs?.(`${c.yellow("[write]")} ${fetchResult.id} is cached in ${cachedFilePath}`);
@@ -5861,12 +5868,12 @@ class FileSystemModuleCache {
 		else if (result === null) debugMemory?.(`${c.green("[read]")} ${id} was bailed out`);
 		return result;
 	}
-	generateCachePath(vitestConfig, environment, resolver, id, fileContent) {
+	generateCachePath(vitestConfig, environment, id, fileContent) {
 		// 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`);
+			debugMemory?.(`${c.yellow("[write]")} ${id} was bailed out because it has "import.meta.glob"`);
 			return null;
 		}
 		let hashString = "";
@@ -5895,7 +5902,7 @@ class FileSystemModuleCache {
 				mode: config.mode,
 				consumer: config.consumer,
 				resolve: config.resolve,
-				plugins: config.plugins.map((p) => p.name),
+				plugins: config.plugins.filter((p) => p.api?.vitest?.experimental?.ignoreFsModuleCache !== true).map((p) => p.name),
 				configFileDependencies: config.configFileDependencies.map((file) => tryReadFileSync(file)),
 				environment: environment.name,
 				css: vitestConfig.css
@@ -5910,6 +5917,7 @@ class FileSystemModuleCache {
 		let cacheRoot = this.fsCacheRoots.get(vitestConfig);
 		if (cacheRoot == null) {
 			cacheRoot = vitestConfig.experimental.fsModuleCachePath || this.rootCache;
+			this.fsCacheRoots.set(vitestConfig, cacheRoot);
 			if (!existsSync(cacheRoot)) mkdirSync(cacheRoot, { recursive: true });
 		}
 		const fsResultPath = join(cacheRoot, cacheKey);
@@ -6074,16 +6082,37 @@ function tryStatSync(file) {
 	} catch {}
 }
 
+// this is copy pasted from vite
+function normalizeResolvedIdToUrl(environment, resolvedId) {
+	const root = environment.config.root;
+	const depsOptimizer = environment.depsOptimizer;
+	let url;
+	// normalize all imports into resolved URLs
+	// e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
+	if (resolvedId.startsWith(withTrailingSlash(root)))
+ // in root: infer short absolute path from root
+	url = resolvedId.slice(root.length);
+	else if (depsOptimizer?.isOptimizedDepFile(resolvedId) || resolvedId !== "/@react-refresh" && path.isAbsolute(resolvedId) && existsSync(cleanUrl(resolvedId)))
+ // an optimized deps may not yet exists in the filesystem, or
+	// a regular file exists but is out of root: rewrite to absolute /@fs/ paths
+	url = path.posix.join("/@fs/", resolvedId);
+	else url = resolvedId;
+	// if the resolved id is not a valid browser import specifier,
+	// prefix it to make it valid. We will strip this before feeding it
+	// back into the transform pipeline
+	if (url[0] !== "." && url[0] !== "/") url = wrapId(resolvedId);
+	return url;
+}
+
 const saveCachePromises = /* @__PURE__ */ new Map();
 const readFilePromises = /* @__PURE__ */ new Map();
 class ModuleFetcher {
 	tmpDirectories = /* @__PURE__ */ new Set();
 	fsCacheEnabled;
-	constructor(resolver, config, fsCache, traces, tmpProjectDir) {
+	constructor(resolver, config, fsCache, tmpProjectDir) {
 		this.resolver = resolver;
 		this.config = config;
 		this.fsCache = fsCache;
-		this.traces = traces;
 		this.tmpProjectDir = tmpProjectDir;
 		this.fsCacheEnabled = config.experimental?.fsModuleCache === true;
 	}
@@ -6110,6 +6139,11 @@ class ModuleFetcher {
 				type: "network"
 			};
 		}
+		// handle unresolved id of dynamic import skipped by Vite import analysis
+		if (url[0] !== "/") {
+			const resolved = await environment.pluginContainer.resolveId(url, importer);
+			if (resolved) url = normalizeResolvedIdToUrl(environment, resolved.id);
+		}
 		const moduleGraphModule = await environment.moduleGraph.ensureEntryFromUrl(unwrapId(url));
 		const cached = !!moduleGraphModule.transformResult;
 		if (moduleGraphModule.file) trace.setAttribute("code.file.path", moduleGraphModule.file);
@@ -6151,10 +6185,20 @@ class ModuleFetcher {
 		}
 		const result = await this.fetchAndProcess(environment, url, importer, moduleGraphModule, options);
 		const importers = this.getSerializedDependencies(moduleGraphModule);
+		const importedUrls = this.getSerializedImports(moduleGraphModule);
 		const map = moduleGraphModule.transformResult?.map;
 		const mappings = map && !("version" in map) && map.mappings === "";
-		return this.cacheResult(result, cachePath, importers, !!mappings);
+		return this.cacheResult(result, cachePath, importers, importedUrls, !!mappings);
 	}
+	// we need this for UI to be able to show a module graph
+	getSerializedImports(node) {
+		const imports = [];
+		node.importedModules.forEach((importer) => {
+			imports.push(importer.url);
+		});
+		return imports;
+	}
+	// we need this for the watcher to be able to find the related test file
 	getSerializedDependencies(node) {
 		const dependencies = [];
 		node.importers.forEach((importer) => {
@@ -6186,7 +6230,7 @@ class ModuleFetcher {
 		// 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);
+		return this.fsCache.generateCachePath(this.config, environment, moduleGraphModule.id, fileContent);
 	}
 	async readFileContentToCache(environment, moduleGraphModule) {
 		if (moduleGraphModule.file && !moduleGraphModule.file.startsWith("\0") && !moduleGraphModule.file.startsWith("virtual:")) {
@@ -6225,6 +6269,10 @@ class ModuleFetcher {
 			const environmentNode = environment.moduleGraph.getModuleById(importer);
 			if (environmentNode) moduleGraphModule.importers.add(environmentNode);
 		});
+		await Promise.all(cachedModule.importedUrls.map(async (url) => {
+			const moduleNode = await environment.moduleGraph.ensureEntryFromUrl(url).catch(() => null);
+			if (moduleNode) moduleGraphModule.importedModules.add(moduleNode);
+		}));
 		return {
 			cached: true,
 			file: cachedModule.file,
@@ -6240,13 +6288,13 @@ class ModuleFetcher {
 			inlineSourceMap: false
 		}).catch(handleRollupError));
 	}
-	async cacheResult(result, cachePath, importers = [], mappings = false) {
+	async cacheResult(result, cachePath, importers = [], importedUrls = [], 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(() => {
+		const savePromise = this.fsCache.saveCachedModule(cachePath, result, importers, importedUrls, mappings).then(() => result).finally(() => {
 			saveCachePromises.delete(cachePath);
 		});
 		saveCachePromises.set(cachePath, savePromise);
@@ -6265,7 +6313,7 @@ class ModuleFetcher {
 	}
 }
 function createFetchModuleFunction(resolver, config, fsCache, traces, tmpProjectDir) {
-	const fetcher = new ModuleFetcher(resolver, config, fsCache, traces, tmpProjectDir);
+	const fetcher = new ModuleFetcher(resolver, config, fsCache, tmpProjectDir);
 	return async (url, importer, environment, cacheFs, options, otelCarrier) => {
 		await traces.waitInit();
 		const context = otelCarrier ? traces.getContextFromCarrier(otelCarrier) : void 0;
@@ -6353,28 +6401,6 @@ function handleRollupError(e) {
 	throw e;
 }
 
-// this is copy pasted from vite
-function normalizeResolvedIdToUrl(environment, resolvedId) {
-	const root = environment.config.root;
-	const depsOptimizer = environment.depsOptimizer;
-	let url;
-	// normalize all imports into resolved URLs
-	// e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
-	if (resolvedId.startsWith(withTrailingSlash(root)))
- // in root: infer short absolute path from root
-	url = resolvedId.slice(root.length);
-	else if (depsOptimizer?.isOptimizedDepFile(resolvedId) || resolvedId !== "/@react-refresh" && path.isAbsolute(resolvedId) && existsSync(cleanUrl(resolvedId)))
- // an optimized deps may not yet exists in the filesystem, or
-	// a regular file exists but is out of root: rewrite to absolute /@fs/ paths
-	url = path.posix.join("/@fs/", resolvedId);
-	else url = resolvedId;
-	// if the resolved id is not a valid browser import specifier,
-	// prefix it to make it valid. We will strip this before feeding it
-	// back into the transform pipeline
-	if (url[0] !== "." && url[0] !== "/") url = wrapId(resolvedId);
-	return url;
-}
-
 class ServerModuleRunner extends ModuleRunner {
 	constructor(environment, fetcher, config) {
 		super({
@@ -6664,6 +6690,238 @@ This might cause false positive tests. Resolve unhandled errors to make sure you
 	}
 }
 
+// this function recieves the module diagnostic with the location of imports
+// and populates it with collected import durations; the duration is injected
+// only if the current module is the one that imported the module
+// if testModule is not defined, then Vitest aggregates durations of ALL collected test modules
+function collectModuleDurationsDiagnostic(moduleId, state, moduleDiagnostic, testModule) {
+	if (!moduleDiagnostic) return {
+		modules: [],
+		untrackedModules: []
+	};
+	const modules = [];
+	const modulesById = {};
+	const allModules = [...moduleDiagnostic.modules, ...moduleDiagnostic.untracked];
+	const visitedByFiles = {};
+	// this aggregates the times for _ALL_ tests if testModule is not passed
+	// so if the module was imported in separate tests, the time will be accumulated
+	for (const files of testModule ? [[testModule.task]] : state.filesMap.values()) for (const file of files) {
+		const importDurations = file.importDurations;
+		if (!importDurations) continue;
+		const currentModule = state.getReportedEntity(file);
+		if (!currentModule) continue;
+		const visitedKey = currentModule.project.config.isolate === false ? "non-isolate" : file.id;
+		if (!visitedByFiles[visitedKey]) visitedByFiles[visitedKey] = /* @__PURE__ */ new Set();
+		const visited = visitedByFiles[visitedKey];
+		allModules.forEach(({ resolvedId, resolvedUrl }) => {
+			const durations = importDurations[resolvedId];
+			// do not accumulate if module was already visited by suite (or suites in non-isolate mode)
+			if (!durations || visited.has(resolvedId)) return;
+			const importer = getModuleImporter(moduleId, durations, currentModule);
+			modulesById[resolvedId] ??= {
+				selfTime: 0,
+				totalTime: 0,
+				transformTime: 0,
+				external: durations.external,
+				importer
+			};
+			// only track if the current module imported this module,
+			// otherwise it was imported instantly because it's cached
+			if (importer === moduleId) {
+				visited.add(resolvedId);
+				modulesById[resolvedId].selfTime += durations.selfTime;
+				modulesById[resolvedId].totalTime += durations.totalTime;
+				// don't aggregate
+				modulesById[resolvedId].transformTime = state.metadata[currentModule.project.name]?.duration[resolvedUrl]?.[0];
+			}
+		});
+	}
+	// if module was imported twice in the same file,
+	// show only one time - the second should be shown as 0
+	const visitedInFile = /* @__PURE__ */ new Set();
+	moduleDiagnostic.modules.forEach((diagnostic) => {
+		const durations = modulesById[diagnostic.resolvedId];
+		if (!durations) return;
+		if (visitedInFile.has(diagnostic.resolvedId)) modules.push({
+			...diagnostic,
+			selfTime: 0,
+			totalTime: 0,
+			transformTime: 0,
+			external: durations.external,
+			importer: durations.importer
+		});
+		else {
+			visitedInFile.add(diagnostic.resolvedId);
+			modules.push({
+				...diagnostic,
+				...durations
+			});
+		}
+	});
+	const untracked = [];
+	moduleDiagnostic.untracked.forEach((diagnostic) => {
+		const durations = modulesById[diagnostic.resolvedId];
+		if (!durations) return;
+		if (visitedInFile.has(diagnostic.resolvedId)) untracked.push({
+			selfTime: 0,
+			totalTime: 0,
+			transformTime: 0,
+			external: durations.external,
+			importer: durations.importer,
+			resolvedId: diagnostic.resolvedId,
+			resolvedUrl: diagnostic.resolvedUrl,
+			url: diagnostic.rawUrl
+		});
+		else {
+			visitedInFile.add(diagnostic.resolvedId);
+			untracked.push({
+				...durations,
+				resolvedId: diagnostic.resolvedId,
+				resolvedUrl: diagnostic.resolvedUrl,
+				url: diagnostic.rawUrl
+			});
+		}
+	});
+	return {
+		modules,
+		untrackedModules: untracked
+	};
+}
+function getModuleImporter(moduleId, durations, testModule) {
+	if (durations.importer === moduleId) return moduleId;
+	if (!durations.importer) {
+		if (moduleId === testModule.moduleId) return testModule.moduleId;
+		return testModule.project.config.setupFiles.includes(moduleId) ? moduleId : durations.importer;
+	}
+	return durations.importer;
+}
+// the idea of this is very simple
+// it parses the source code to extract import/export statements
+// it parses SSR transformed file to extract __vite_ssr_import__ and __vite_ssr_dynamic_import__
+// it combines the two by looking at the original positions of SSR primitives
+// in the end, we are able to return a list of modules that were imported by this module
+// mapped to their IDs in Vite's module graph
+async function collectSourceModulesLocations(moduleId, moduleGraph) {
+	const transformResult = moduleGraph.getModuleById(moduleId)?.transformResult;
+	if (!transformResult || !transformResult.ssr) return;
+	const map = transformResult.map;
+	if (!map || !("version" in map) || !map.sources.length) return;
+	const sourceImports = map.sources.reduce((acc, sourceId, index) => {
+		const source = map.sourcesContent?.[index];
+		if (source != null) acc[sourceId] = parseSourceImportsAndExports(source);
+		return acc;
+	}, {});
+	const transformImports = await parseTransformResult(moduleGraph, transformResult);
+	const traceMap = map && "version" in map && new TraceMap(map);
+	const modules = {};
+	const untracked = [];
+	transformImports.forEach((row) => {
+		const original = traceMap && originalPositionFor(traceMap, row.start);
+		if (original && original.source != null) {
+			// if there are several at the same position, this is a bug
+			// probably caused by import.meta.glob imports returning incorrect positions
+			// all the new import.meta.glob imports come first, so only the last module on this line is correct
+			const sourceImport = sourceImports[original.source].get(`${original.line}:${original.column}`);
+			if (sourceImport) {
+				if (modules[sourceImport.rawUrl]) {
+					// remove imports with a different resolvedId
+					const differentImports = modules[sourceImport.rawUrl].filter((d) => d.resolvedId !== row.resolvedId);
+					untracked.push(...differentImports);
+					modules[sourceImport.rawUrl] = modules[sourceImport.rawUrl].filter((d) => d.resolvedId === row.resolvedId);
+				}
+				modules[sourceImport.rawUrl] ??= [];
+				modules[sourceImport.rawUrl].push({
+					start: sourceImport.start,
+					end: sourceImport.end,
+					startIndex: sourceImport.startIndex,
+					endIndex: sourceImport.endIndex,
+					rawUrl: sourceImport.rawUrl,
+					resolvedId: row.resolvedId,
+					resolvedUrl: row.resolvedUrl
+				});
+			}
+		}
+	});
+	return {
+		modules: Object.values(modules).flat(),
+		untracked
+	};
+}
+function fillSourcesMap(syntax, sourcesMap, source, indexMap) {
+	const splitSeparator = `${syntax} `;
+	const splitSources = source.split(splitSeparator);
+	const chunks = [];
+	let index = 0;
+	for (const chunk of splitSources) {
+		chunks.push({
+			chunk,
+			startIndex: index
+		});
+		index += chunk.length + splitSeparator.length;
+	}
+	chunks.forEach(({ chunk, startIndex }) => {
+		const normalized = chunk.replace(/'/g, "\"");
+		const startQuoteIdx = normalized.indexOf("\"");
+		if (startQuoteIdx === -1) return;
+		const endQuoteIdx = normalized.indexOf("\"", startQuoteIdx + 1);
+		if (endQuoteIdx === -1) return;
+		const staticSyntax = {
+			startIndex: startIndex + startQuoteIdx,
+			endIndex: startIndex + endQuoteIdx + 1,
+			start: indexMap.get(startIndex + startQuoteIdx),
+			end: indexMap.get(startIndex + endQuoteIdx + 1),
+			rawUrl: normalized.slice(startQuoteIdx + 1, endQuoteIdx)
+		};
+		// -7 to include "import "
+		for (let i = startIndex - 7; i < staticSyntax.endIndex; i++) {
+			const location = indexMap.get(i);
+			if (location) sourcesMap.set(`${location.line}:${location.column}`, staticSyntax);
+		}
+	});
+}
+// this function tries to parse ESM static import and export statements from
+// the source. if the source is not JS/TS, but supports static ESM syntax,
+// then this will also find them because it' only checks the strings, it doesn't parse the AST
+function parseSourceImportsAndExports(source) {
+	if (!source.includes("import ") && !source.includes("export ")) return /* @__PURE__ */ new Map();
+	const sourcesMap = /* @__PURE__ */ new Map();
+	const indexMap = createIndexLocationsMap(source);
+	fillSourcesMap("import", sourcesMap, source, indexMap);
+	fillSourcesMap("export", sourcesMap, source, indexMap);
+	return sourcesMap;
+}
+async function parseTransformResult(moduleGraph, transformResult) {
+	const code = transformResult.code;
+	const regexp = /(?:__vite_ssr_import__|__vite_ssr_dynamic_import__)\("([^"]+)"/g;
+	const lineColumnMap = createIndexLocationsMap(code);
+	const importPositions = [];
+	let match;
+	// eslint-disable-next-line no-cond-assign
+	while (match = regexp.exec(code)) {
+		const startIndex = match.index;
+		const endIndex = match.index + match[0].length - 1;
+		importPositions.push({
+			raw: match[1],
+			startIndex,
+			endIndex
+		});
+	}
+	return (await Promise.all(importPositions.map(async ({ startIndex, endIndex, raw }) => {
+		const position = lineColumnMap.get(startIndex);
+		const endPosition = lineColumnMap.get(endIndex);
+		const moduleNode = await moduleGraph.getModuleByUrl(raw);
+		if (!position || !endPosition || !moduleNode || !moduleNode.id) return;
+		return {
+			resolvedId: moduleNode.id,
+			resolvedUrl: moduleNode.url,
+			start: position,
+			end: endPosition,
+			startIndex,
+			endIndex
+		};
+	}))).filter((n) => n != null);
+}
+
 const __dirname$1 = url.fileURLToPath(new URL(".", import.meta.url));
 class VitestPackageInstaller {
 	isPackageExists(name, options) {
@@ -7042,7 +7300,7 @@ function createMethodsRPC(project, methodsOptions = {}) {
 			const file = cleanUrl(resolved.id);
 			if (resolved.external) return {
 				file,
-				url: !resolved.id.startsWith("node:") && isBuiltin(resolved.id) ? `node:${resolved.id}` : resolved.id,
+				url: isBuiltin(resolved.id) ? toBuiltin(resolved.id) : resolved.id,
 				id: resolved.id
 			};
 			return {
@@ -7246,7 +7504,7 @@ class PoolRunner {
 			this._operationLock = null;
 		}
 	}
-	async stop() {
+	async stop(options) {
 		// Wait for any ongoing operation to complete
 		if (this._operationLock) await this._operationLock;
 		if (this._state === RunnerState.STOPPED || this._state === RunnerState.STOPPING) return;
@@ -7274,6 +7532,11 @@ class PoolRunner {
 						this.off("message", onStop);
 					}
 				};
+				// Don't wait for graceful exit's response when force exiting
+				if (options?.force) return onStop({
+					type: "stopped",
+					__vitest_worker_response__: true
+				});
 				this.on("message", onStop);
 				this.postMessage({
 					type: "stop",
@@ -7733,7 +7996,8 @@ class Pool {
 			};
 			this.activeTasks.push(activeTask);
 			// active tasks receive cancel signal and shut down gracefully
-			async function cancelTask() {
+			async function cancelTask(options) {
+				if (options?.force) await runner.stop({ force: true });
 				await runner.waitForTerminated();
 				resolver.reject(/* @__PURE__ */ new Error("Cancelled"));
 			}
@@ -7783,6 +8047,9 @@ catch (error) {
 		return this.schedule();
 	}
 	async cancel() {
+		// Force exit if previous cancel is still on-going
+		// for example when user does 'CTRL+c' twice in row
+		const force = this._isCancelling;
 		// Set flag to prevent new tasks from being queued
 		this._isCancelling = true;
 		const pendingTasks = this.queue.splice(0);
@@ -7790,11 +8057,12 @@ catch (error) {
 			const error = /* @__PURE__ */ new Error("Cancelled");
 			pendingTasks.forEach((task) => task.resolver.reject(error));
 		}
-		const activeTasks = this.activeTasks.splice(0);
-		await Promise.all(activeTasks.map((task) => task.cancelTask()));
-		const sharedRunners = this.sharedRunners.splice(0);
-		await Promise.all(sharedRunners.map((runner) => runner.stop()));
-		await Promise.all(this.exitPromises.splice(0));
+		await Promise.all(this.activeTasks.map((task) => task.cancelTask({ force })));
+		this.activeTasks = [];
+		await Promise.all(this.sharedRunners.map((runner) => runner.stop()));
+		this.sharedRunners = [];
+		await Promise.all(this.exitPromises);
+		this.exitPromises = [];
 		this.workerIds.forEach((_, id) => this.freeWorkerId(id));
 		// Reset flag after cancellation completes
 		this._isCancelling = false;
@@ -8198,7 +8466,10 @@ function serializeConfig(project) {
 		printConsoleTrace: config.printConsoleTrace ?? globalConfig.printConsoleTrace,
 		benchmark: config.benchmark && { includeSamples: config.benchmark.includeSamples },
 		serializedDefines: config.browser.enabled ? "" : project._serializedDefines || "",
-		experimental: { fsModuleCache: config.experimental.fsModuleCache ?? false }
+		experimental: {
+			fsModuleCache: config.experimental.fsModuleCache ?? false,
+			printImportBreakdown: config.experimental.printImportBreakdown
+		}
 	};
 }
 
@@ -9118,7 +9389,10 @@ function ModuleRunnerTransform() {
 					environment.resolve.noExternal = true;
 					// Workaround `noExternal` merging bug on Vite 6
 					// https://github.com/vitejs/vite/pull/20502
-					if (name === "ssr") delete config.ssr?.noExternal;
+					if (name === "ssr") {
+						delete config.ssr?.noExternal;
+						delete config.ssr?.external;
+					}
 					if (name === "__vitest_vm__" || name === "__vitest__") continue;
 					const currentOptimizeDeps = environment.optimizeDeps || (name === "client" ? config.optimizeDeps : name === "ssr" ? config.ssr?.optimizeDeps : void 0);
 					const optimizeDeps = resolveOptimizerConfig(testConfig.deps?.optimizer?.[name], currentOptimizeDeps);
@@ -9348,6 +9622,7 @@ function WorkspaceVitestPlugin(project, options) {
 
 class VitestResolver {
 	options;
+	externalizeConcurrentCache = /* @__PURE__ */ new Map();
 	externalizeCache = /* @__PURE__ */ new Map();
 	constructor(cacheDir, config) {
 		// sorting to make cache consistent
@@ -9367,8 +9642,20 @@ class VitestResolver {
 			external
 		};
 	}
-	shouldExternalize(file) {
-		return shouldExternalize(normalizeId(file), this.options, this.externalizeCache);
+	wasExternalized(file) {
+		const normalizedFile = normalizeId(file);
+		if (!this.externalizeCache.has(normalizedFile)) return false;
+		return this.externalizeCache.get(normalizedFile) ?? false;
+	}
+	async shouldExternalize(file) {
+		const normalizedFile = normalizeId(file);
+		if (this.externalizeCache.has(normalizedFile)) return this.externalizeCache.get(normalizedFile);
+		return shouldExternalize(normalizeId(file), this.options, this.externalizeConcurrentCache).then((result) => {
+			this.externalizeCache.set(normalizedFile, result);
+			return result;
+		}).finally(() => {
+			this.externalizeConcurrentCache.delete(normalizedFile);
+		});
 	}
 }
 function normalizeId(id) {
@@ -9413,6 +9700,9 @@ function guessCJSversion(id) {
 }
 // The code from https://github.com/unjs/mlly/blob/c5bcca0cda175921344fd6de1bc0c499e73e5dac/src/syntax.ts#L51-L98
 async function isValidNodeImport(id) {
+	// clean url to strip off `?v=...` query etc.
+	// node can natively import files with query params, so externalizing them is safe.
+	id = cleanUrl(id);
 	const extension = extname(id);
 	if (BUILTIN_EXTENSIONS.has(extension)) return true;
 	if (extension !== ".js") return false;
@@ -9433,7 +9723,7 @@ async function shouldExternalize(id, options, cache) {
 	return cache.get(id);
 }
 async function _shouldExternalize(id, options) {
-	if (isBuiltin(id)) return id;
+	if (isBuiltin$1(id)) return id;
 	// data: should be processed by native import,
 	// since it is a feature of ESM.
 	// also externalize network imports since nodejs allows it when --experimental-network-imports
@@ -9450,7 +9740,6 @@ async function _shouldExternalize(id, options) {
 	if (matchPattern(id, moduleDirectories, defaultInline)) return false;
 	if (matchPattern(id, moduleDirectories, depsExternal)) return id;
 	if (isLibraryModule && await isValidNodeImport(id)) return id;
-	return false;
 }
 function matchPattern(id, moduleDirectories, patterns) {
 	if (patterns == null) return false;
@@ -9527,6 +9816,21 @@ async function createViteServer(inlineConfig) {
 	console.error = error;
 	return server;
 }
+function isFileServingAllowed(configOrUrl, urlOrServer) {
+	const config = typeof urlOrServer === "string" ? configOrUrl : urlOrServer.config;
+	const url = typeof urlOrServer === "string" ? urlOrServer : configOrUrl;
+	if (!config.server.fs.strict) return true;
+	return isFileLoadingAllowed(config, fsPathFromUrl(url));
+}
+const FS_PREFIX = "/@fs/";
+const VOLUME_RE = /^[A-Z]:/i;
+function fsPathFromId(id) {
+	const fsPath = normalizePath(id.startsWith(FS_PREFIX) ? id.slice(5) : id);
+	return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
+}
+function fsPathFromUrl(url) {
+	return fsPathFromId(cleanUrl(url));
+}
 
 class TestProject {
 	/**
@@ -10681,6 +10985,12 @@ class TestSuite extends SuiteImplementation {
 class TestModule extends SuiteImplementation {
 	type = "module";
 	/**
+	* The Vite environment that processes files on the server.
+	*
+	* Can be empty if test module did not run yet.
+	*/
+	viteEnvironment;
+	/**
 	* This is usually an absolute UNIX file path.
 	* It can be a virtual ID if the file is not on the disk.
 	* This value corresponds to the ID in the Vite's module graph.
@@ -10695,6 +11005,8 @@ class TestModule extends SuiteImplementation {
 		super(task, project);
 		this.moduleId = task.filepath;
 		this.relativeModuleId = task.name;
+		if (task.viteEnvironment === "__browser__") this.viteEnvironment = project.browser?.vite.environments.client;
+		else if (typeof task.viteEnvironment === "string") this.viteEnvironment = project.vite.environments[task.viteEnvironment];
 	}
 	/**
 	* Checks the running state of the test file.
@@ -12247,6 +12559,39 @@ class Vitest {
 			return await this.runningPromise;
 		});
 	}
+	/**
+	* Returns module's diagnostic. If `testModule` is not provided, `selfTime` and `totalTime` will be aggregated across all tests.
+	*
+	* If the module was not transformed or executed, the diagnostic will be empty.
+	* @experimental
+	* @see {@link https://vitest.dev/api/advanced/vitest#getsourcemodulediagnostic}
+	*/
+	async experimental_getSourceModuleDiagnostic(moduleId, testModule) {
+		if (testModule) {
+			const viteEnvironment = testModule.viteEnvironment;
+			// if there is no viteEnvironment, it means the file did not run yet
+			if (!viteEnvironment) return {
+				modules: [],
+				untrackedModules: []
+			};
+			const moduleLocations = await collectSourceModulesLocations(moduleId, viteEnvironment.moduleGraph);
+			return collectModuleDurationsDiagnostic(moduleId, this.state, moduleLocations, testModule);
+		}
+		const environments = this.projects.flatMap((p) => {
+			return Object.values(p.vite.environments);
+		});
+		const aggregatedLocationsResult = await Promise.all(environments.map((environment) => collectSourceModulesLocations(moduleId, environment.moduleGraph)));
+		return collectModuleDurationsDiagnostic(moduleId, this.state, aggregatedLocationsResult.reduce((acc, locations) => {
+			if (locations) {
+				acc.modules.push(...locations.modules);
+				acc.untracked.push(...locations.untracked);
+			}
+			return acc;
+		}, {
+			modules: [],
+			untracked: []
+		}));
+	}
 	async experimental_parseSpecifications(specifications, options) {
 		if (this.mode !== "test") throw new Error(`The \`experimental_parseSpecifications\` does not support "${this.mode}" mode.`);
 		const limit = limitConcurrency(options?.concurrency ?? (typeof nodeos__default.availableParallelism === "function" ? nodeos__default.availableParallelism() : nodeos__default.cpus().length));
@@ -13242,4 +13587,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { FilesNotFoundError as F, GitNotFoundError as G, ThreadsPoolWorker as T, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, createMethodsRPC as d, escapeTestName as e, ForksPoolWorker as f, getFilePoolName as g, TypecheckPoolWorker as h, isValidApiRequest as i, VmForksPoolWorker as j, VmThreadsPoolWorker as k, experimental_getRunnerTask as l, registerConsoleShortcuts as m, createViteLogger as n, createDebugger as o, cliApi as p, resolveFsAllow as r, startVitest as s };
+export { FilesNotFoundError as F, GitNotFoundError as G, ThreadsPoolWorker as T, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, createMethodsRPC as d, escapeTestName as e, ForksPoolWorker as f, getFilePoolName as g, TypecheckPoolWorker as h, isValidApiRequest as i, VmForksPoolWorker as j, VmThreadsPoolWorker as k, experimental_getRunnerTask as l, registerConsoleShortcuts as m, isFileServingAllowed as n, createViteLogger as o, createDebugger as p, cliApi as q, resolveFsAllow as r, startVitest as s };