vitest 4.0.14 → 4.0.15

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

@@ -6,16 +6,16 @@ import { noop, createDefer, slash, isExternalUrl, unwrapId, withTrailingSlash, c
 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, searchForWorkspaceRoot, fetchModule, version, mergeConfig, createServer } from 'vite';
+import { isFileServingAllowed, 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, 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.BNNpZQl7.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 { 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.DJPjQW6m.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(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(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);
@@ -6079,11 +6087,10 @@ 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;
 	}
@@ -6151,10 +6158,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 +6203,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 +6242,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 +6261,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 +6286,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;
@@ -6664,6 +6685,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 +7295,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 +7499,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 +7527,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 +7991,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 +8042,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 +8052,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 +8461,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 +9384,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 +9617,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 +9637,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 +9695,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 +9718,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 +9735,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;
@@ -10681,6 +10965,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 +10985,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 +12539,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));