vitest 4.0.11 → 4.0.13

package/dist/browser.d.ts

@@ -1,7 +1,6 @@
-import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/traces.d.B8ukBJqA.js';
+import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/config.d.g6OOauRt.js';
 import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.BZtK59WP.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { V as VitestModuleRunner } from './chunks/moduleRunner.d.B5SW5pMI.js';
 export { collectTests, startTests } from '@vitest/runner';
 import * as _vitest_spy from '@vitest/spy';
 export { _vitest_spy as SpyModule };
@@ -13,13 +12,6 @@ export { DecodedMap, getOriginalPosition } from '@vitest/utils/source-map';
 export { getSafeTimers, setSafeTimers } from '@vitest/utils/timers';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
-import '@opentelemetry/api';
-import 'node:vm';
-import 'vite/module-runner';
-import './chunks/worker.d.B_PZTrCQ.js';
-import './chunks/environment.d.CrsxCzP1.js';
-import '@vitest/mocker';
-import './chunks/mocker.d.BE_2ls6u.js';
 
 declare function startCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
 	isolate: boolean;
@@ -29,9 +21,13 @@ declare function stopCoverageInsideWorker(options: SerializedCoverageConfig | un
 	isolate: boolean;
 }): Promise<unknown>;
 
+interface PublicModuleRunner {
+	import: (id: string) => Promise<any>;
+}
+
 declare function setupCommonEnv(config: SerializedConfig): Promise<void>;
-declare function loadDiffConfig(config: SerializedConfig, moduleRunner: VitestModuleRunner): Promise<SerializedDiffOptions | undefined>;
-declare function loadSnapshotSerializers(config: SerializedConfig, moduleRunner: VitestModuleRunner): Promise<void>;
+declare function loadDiffConfig(config: SerializedConfig, moduleRunner: PublicModuleRunner): Promise<SerializedDiffOptions | undefined>;
+declare function loadSnapshotSerializers(config: SerializedConfig, moduleRunner: PublicModuleRunner): Promise<void>;
 
 interface FsOptions {
 	encoding?: BufferEncoding;

package/dist/chunks/{base.DiCUKpyF.js → base.Dqf2QAxh.js}

@@ -1,9 +1,9 @@
 import { runInThisContext } from 'node:vm';
 import * as spyModule from '@vitest/spy';
 import { r as resolveTestRunner, a as resolveSnapshotEnvironment, s as setupChaiConfig } from './index.CQwQ_SLL.js';
-import { l as loadEnvironment } from './init.B3IeC_yW.js';
+import { l as loadEnvironment } from './init.MkYs5nmh.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
-import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startModuleRunner.DaBMy1JT.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startModuleRunner.W28wBIgJ.js';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { startTests, collectTests } from '@vitest/runner';
 import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.DGHc_BUK.js';

package/dist/chunks/{browser.d.D-d8eZY4.d.ts → browser.d.CDvMh6F9.d.ts}

@@ -1,5 +1,5 @@
 import { FileSpecification } from '@vitest/runner';
-import { T as TestExecutionMethod } from './worker.d.B_PZTrCQ.js';
+import { T as TestExecutionMethod } from './worker.d.DCy61tzi.js';
 
 type SerializedTestSpecification = [project: {
 	name: string | undefined;

package/dist/chunks/{cac.aVhqBj0-.js → cac.L-UbQ_Ix.js}

@@ -619,7 +619,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "4.0.11";
+var version = "4.0.13";
 
 const apiConfig = (port) => ({
 	port: {
@@ -1371,7 +1371,7 @@ function normalizeCliOptions(cliFilters, argv) {
 }
 async function start(mode, cliFilters, options) {
 	try {
-		const { startVitest } = await import('./cli-api.-bIZD4XU.js').then(function (n) { return n.p; });
+		const { startVitest } = await import('./cli-api.CdZ6wo9-.js').then(function (n) { return n.p; });
 		const ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
 		if (!ctx.shouldKeepServer()) await ctx.exit();
 	} catch (e) {
@@ -1393,7 +1393,7 @@ async function init(project) {
 }
 async function collect(mode, cliFilters, options) {
 	try {
-		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.-bIZD4XU.js').then(function (n) { return n.p; });
+		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.CdZ6wo9-.js').then(function (n) { return n.p; });
 		const ctx = await prepareVitest(mode, {
 			...normalizeCliOptions(cliFilters, options),
 			watch: false,

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

@@ -12,7 +12,7 @@ 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.aVhqBj0-.js';
+import { v as version$1 } from './cac.L-UbQ_Ix.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.DWDW6mLz.js';
@@ -29,7 +29,7 @@ import require$$0$1 from 'buffer';
 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 { T as Traces } from './traces.U4xDYhzZ.js';
 import createDebug from 'debug';
 import { rm, readFile, writeFile, rename, stat, unlink, mkdir, copyFile } from 'node:fs/promises';
 import c from 'tinyrainbow';
@@ -5747,6 +5747,7 @@ const debugMemory = createDebugger("vitest:cache:memory");
 const cacheComment = "\n//# vitestCache=";
 const cacheCommentLength = 17;
 const METADATA_FILE = "_metadata.json";
+const parallelFsCacheRead = /* @__PURE__ */ new Map();
 /**
 * @experimental
 */
@@ -5786,25 +5787,30 @@ class FileSystemModuleCache {
 		})));
 		if (log) this.vitest.logger.log(`[cache] cleared fs module cache at ${uniquePaths.join(", ")}`);
 	}
+	readCachedFileConcurrently(cachedFilePath) {
+		if (!parallelFsCacheRead.has(cachedFilePath)) parallelFsCacheRead.set(cachedFilePath, readFile(cachedFilePath, "utf-8").then((code) => {
+			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;
+			}
+			return {
+				code,
+				meta: this.fromBase64(code.slice(matchIndex + cacheCommentLength))
+			};
+		}).finally(() => {
+			parallelFsCacheRead.delete(cachedFilePath);
+		}));
+		return parallelFsCacheRead.get(cachedFilePath);
+	}
 	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
-			};
-		}
+		const fileResult = await this.readCachedFileConcurrently(cachedFilePath);
+		if (!fileResult) return;
+		const { code, meta } = fileResult;
 		debugFs?.(`${c.green("[read]")} ${meta.id} is cached in ${cachedFilePath}`);
 		return {
 			id: meta.id,
@@ -5816,10 +5822,7 @@ class FileSystemModuleCache {
 		};
 	}
 	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) {
+		if ("code" in fetchResult) {
 			const result = {
 				file: fetchResult.file,
 				id: fetchResult.id,
@@ -5853,7 +5856,6 @@ class FileSystemModuleCache {
 		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(")) {
@@ -5861,6 +5863,7 @@ class FileSystemModuleCache {
 			debugMemory?.(`${c.yellow("[write]")} ${id} was bailed out`);
 			return null;
 		}
+		let hashString = "";
 		for (const generator of this.fsCacheKeyGenerators) {
 			const result = generator({
 				environment,
@@ -5889,13 +5892,7 @@ class FileSystemModuleCache {
 				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
-				}
+				css: vitestConfig.css
 			}, (_, value) => {
 				if (typeof value === "function" || value instanceof RegExp) return value.toString();
 				return value;
@@ -6156,7 +6153,7 @@ class ModuleFetcher {
 	}
 	recordResult(trace, result) {
 		if ("externalize" in result) trace.setAttributes({
-			"vitest.module.external": result.externalize,
+			"vitest.fetched_module.external": result.externalize,
 			"vitest.fetched_module.type": result.type
 		});
 		if ("id" in result) {
@@ -6191,35 +6188,40 @@ class ModuleFetcher {
 		return "";
 	}
 	async getCachedModule(cachePath, environment, moduleGraphModule) {
+		if (moduleGraphModule.transformResult?.__vitestTmp) return {
+			cached: true,
+			file: moduleGraphModule.file,
+			id: moduleGraphModule.id,
+			tmp: moduleGraphModule.transformResult.__vitestTmp,
+			url: moduleGraphModule.url,
+			invalidate: false
+		};
 		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
-			};
-		}
-		return cachedModule;
+		if (!cachedModule) return;
+		// keep the module graph in sync
+		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,
+			__vitestTmp: cachePath
+		};
+		// 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
+		};
 	}
 	async fetchAndProcess(environment, url, importer, moduleGraphModule, options) {
 		const externalize = await this.resolver.shouldExternalize(moduleGraphModule.id);
@@ -9249,6 +9251,10 @@ function WorkspaceVitestPlugin(project, options) {
 					vitestConfig.experimental ??= {};
 					vitestConfig.experimental.fsModuleCache = project.vitest.config.experimental.fsModuleCache;
 				}
+				if (testConfig.experimental?.fsModuleCachePath == null && project.vitest.config.experimental?.fsModuleCachePath !== null) {
+					vitestConfig.experimental ??= {};
+					vitestConfig.experimental.fsModuleCachePath = project.vitest.config.experimental.fsModuleCachePath;
+				}
 				return {
 					base: "/",
 					environments: { __vitest__: { dev: {} } },

package/dist/chunks/{traces.d.B8ukBJqA.d.ts → config.d.g6OOauRt.d.ts}

@@ -2,7 +2,6 @@ import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
 import { SnapshotUpdateState, SnapshotEnvironment } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { Context, Span, SpanOptions } from '@opentelemetry/api';
 
 /**
  * Names of clock methods that may be faked by install.
@@ -202,35 +201,4 @@ type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookT
 type RuntimeOptions = Partial<RuntimeConfig>;
 type BrowserTraceViewMode = "on" | "off" | "on-first-retry" | "on-all-retries" | "retain-on-failure";
 
-interface OTELCarrier {
-	traceparent?: string;
-	tracestate?: string;
-}
-interface TracesOptions {
-	enabled: boolean;
-	watchMode?: boolean;
-	sdkPath?: string;
-	tracerName?: string;
-}
-interface TracesSpanOptions extends SpanOptions {
-	context?: Context;
-}
-declare class Traces {
-	#private;
-	constructor(options: TracesOptions);
-	isEnabled(): boolean;
-	waitInit(): Promise<this>;
-	startContextSpan(name: string, currentContext?: Context): {
-		span: Span;
-		context: Context;
-	};
-	getContextFromCarrier(carrier: OTELCarrier | undefined): Context;
-	getContextCarrier(context?: Context): OTELCarrier | undefined;
-	$<T>(name: string, fn: (span: Span) => T): T;
-	$<T>(name: string, optionsOrFn: TracesSpanOptions, fn: (span: Span) => T): T;
-	startSpan(name: string, options?: SpanOptions, context?: Context): Span;
-	finish(): Promise<void>;
-}
-
-export { Traces as T };
-export type { BrowserTraceViewMode as B, FakeTimerInstallOpts as F, OTELCarrier as O, RuntimeOptions as R, SerializedConfig as S, SerializedCoverageConfig as a, RuntimeConfig as b };
+export type { BrowserTraceViewMode as B, FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedConfig as S, SerializedCoverageConfig as a, RuntimeConfig as b };

package/dist/chunks/{global.d.uY4Q0M5z.d.ts → global.d.B15mdLcR.d.ts}

@@ -2,7 +2,7 @@ import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
 import { Plugin } from '@vitest/pretty-format';
 import { SnapshotState } from '@vitest/snapshot';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
-import { U as UserConsoleLog } from './worker.d.B_PZTrCQ.js';
+import { U as UserConsoleLog } from './rpc.d.RH3apGEf.js';
 
 interface SnapshotMatcher<T> {
 	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;

package/dist/chunks/{init-forks.DIuGPyId.js → init-forks.CglOH45c.js}

@@ -1,4 +1,4 @@
-import { i as init } from './init.B3IeC_yW.js';
+import { i as init } from './init.MkYs5nmh.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them

package/dist/chunks/{init-threads.jC_8JdoN.js → init-threads.BuMdIy1r.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.B3IeC_yW.js';
+import { i as init } from './init.MkYs5nmh.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {

package/dist/chunks/{init.B3IeC_yW.js → init.MkYs5nmh.js}

@@ -3,10 +3,10 @@ import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
 import { ModuleRunner } from 'vite/module-runner';
-import { b as VitestTransport } from './startModuleRunner.DaBMy1JT.js';
+import { b as VitestTransport } from './startModuleRunner.W28wBIgJ.js';
 import { e as environments } from './index.QWbK7rHY.js';
 import { serializeError } from '@vitest/utils/error';
-import { T as Traces } from './traces.BVPrsYso.js';
+import { T as Traces } from './traces.U4xDYhzZ.js';
 import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BytlcPfC.js';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { s as setupInspect } from './inspector.CvyFGlXm.js';

package/dist/chunks/{plugin.d.N8khPRFb.d.ts → plugin.d.B4l3vYM_.d.ts}

@@ -1,5 +1,5 @@
 import { DevEnvironment } from 'vite';
-import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.DgZLBdyd.js';
+import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.J2RlBlp9.js';
 
 /**
 * Generate a unique cache identifier.

package/dist/chunks/{reporters.d.DgZLBdyd.d.ts → reporters.d.J2RlBlp9.d.ts}

@@ -1,18 +1,20 @@
 import { TaskMeta, Suite, File, TestAnnotation, TestArtifact, ImportDuration, Test, Task, TaskResultPack, FileSpecification, CancelReason, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
 import { TestError, SerializedError, Arrayable, ParsedStack, Awaitable } from '@vitest/utils';
-import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, d as ContextTestEnvironment, f as WorkerTestEnvironment, g as WorkerExecuteContext, L as LabelColor } from './worker.d.B_PZTrCQ.js';
+import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, L as LabelColor } from './rpc.d.RH3apGEf.js';
 import { Writable } from 'node:stream';
 import { TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { BrowserCommands } from 'vitest/browser';
-import { B as BrowserTraceViewMode, S as SerializedConfig, O as OTELCarrier, F as FakeTimerInstallOpts } from './traces.d.B8ukBJqA.js';
-import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.D-d8eZY4.js';
+import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.g6OOauRt.js';
+import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.CDvMh6F9.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
 import { chai } from '@vitest/expect';
 import { happyDomTypes, jsdomTypes } from 'vitest/optional-types.js';
+import { c as ContextTestEnvironment, d as WorkerTestEnvironment, e as WorkerExecuteContext } from './worker.d.DCy61tzi.js';
+import { O as OTELCarrier } from './traces.d.402V_yFI.js';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
 import { a as RuntimeCoverageProviderModule } from './coverage.d.BZtK59WP.js';
 import { SnapshotManager } from '@vitest/snapshot/manager';

package/dist/chunks/rpc.d.RH3apGEf.d.ts

@@ -0,0 +1,64 @@
+import { CancelReason, File, TestArtifact, TaskResultPack, TaskEventPack } from '@vitest/runner';
+import { SnapshotResult } from '@vitest/snapshot';
+import { FetchFunctionOptions, FetchResult } from 'vite/module-runner';
+import { O as OTELCarrier } from './traces.d.402V_yFI.js';
+
+interface AfterSuiteRunMeta {
+	coverage?: unknown;
+	testFiles: string[];
+	environment: string;
+	projectName?: string;
+}
+interface UserConsoleLog {
+	content: string;
+	origin?: string;
+	browser?: boolean;
+	type: "stdout" | "stderr";
+	taskId?: string;
+	time: number;
+	size: number;
+}
+interface ModuleGraphData {
+	graph: Record<string, string[]>;
+	externalized: string[];
+	inlined: string[];
+}
+interface ProvidedContext {}
+interface ResolveFunctionResult {
+	id: string;
+	file: string;
+	url: string;
+}
+interface FetchCachedFileSystemResult {
+	cached: true;
+	tmp: string;
+	id: string;
+	file: string | null;
+	url: string;
+	invalidate: boolean;
+}
+type LabelColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+
+interface RuntimeRPC {
+	fetch: (id: string, importer: string | undefined, environment: string, options?: FetchFunctionOptions, otelCarrier?: OTELCarrier) => Promise<FetchResult | FetchCachedFileSystemResult>;
+	resolve: (id: string, importer: string | undefined, environment: string) => Promise<ResolveFunctionResult | null>;
+	transform: (id: string) => Promise<{
+		code?: string;
+	}>;
+	onUserConsoleLog: (log: UserConsoleLog) => void;
+	onUnhandledError: (err: unknown, type: string) => void;
+	onQueued: (file: File) => void;
+	onCollected: (files: File[]) => Promise<void>;
+	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+	onTaskArtifactRecord: <Artifact extends TestArtifact>(testId: string, artifact: Artifact) => Promise<Artifact>;
+	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	onCancel: (reason: CancelReason) => void;
+	getCountOfFailedTests: () => number;
+	snapshotSaved: (snapshot: SnapshotResult) => void;
+	resolveSnapshotPath: (testPath: string) => string;
+}
+interface RunnerRPC {
+	onCancel: (reason: CancelReason) => void;
+}
+
+export type { AfterSuiteRunMeta as A, LabelColor as L, ModuleGraphData as M, ProvidedContext as P, RuntimeRPC as R, UserConsoleLog as U, RunnerRPC as a };

package/dist/chunks/{startModuleRunner.DaBMy1JT.js → startModuleRunner.W28wBIgJ.js}

@@ -10,7 +10,7 @@ import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
 import vm from 'node:vm';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
 import * as viteModuleRunner from 'vite/module-runner';
-import { T as Traces } from './traces.BVPrsYso.js';
+import { T as Traces } from './traces.U4xDYhzZ.js';
 
 class VitestTransport {
 	constructor(options) {
@@ -821,6 +821,9 @@ function startVitestModuleRunner(options) {
 						externalize: toBuiltin(rawId),
 						type: "builtin"
 					};
+					// if module is invalidated, the worker will be recreated,
+					// so cached is always true in a single worker
+					if (options?.cached) return { cache: true };
 					const otelCarrier = traces?.getContextCarrier();
 					const result = await rpc().fetch(id, importer, environment(), options, otelCarrier);
 					if ("cached" in result) return {

package/dist/chunks/{traces.BVPrsYso.js → traces.U4xDYhzZ.js}

@@ -37,10 +37,16 @@ class Traces {
 	isEnabled() {
 		return !!this.#otel;
 	}
+	/**
+	* @internal
+	*/
 	async waitInit() {
 		if (this.#init) await this.#init;
 		return this;
 	}
+	/**
+	* @internal
+	*/
 	startContextSpan(name, currentContext) {
 		if (!this.#otel) return {
 			span: this.#noopSpan,
@@ -53,12 +59,18 @@ class Traces {
 			context: this.#otel.trace.setSpan(activeContext, span)
 		};
 	}
+	/**
+	* @internal
+	*/
 	getContextFromCarrier(carrier) {
 		if (!this.#otel) return this.#noopContext;
 		const activeContext = this.#otel.context.active();
 		if (!carrier) return activeContext;
 		return this.#otel.propagation.extract(activeContext, carrier);
 	}
+	/**
+	* @internal
+	*/
 	getContextCarrier(context) {
 		if (!this.#otel) return;
 		const carrier = {};
@@ -95,6 +107,9 @@ class Traces {
 			if (!(result instanceof Promise)) span.end();
 		}
 	}
+	/**
+	* @internal
+	*/
 	$(name, optionsOrFn, fn) {
 		const callback = typeof optionsOrFn === "function" ? optionsOrFn : fn;
 		if (!this.#otel) return callback(this.#noopSpan);
@@ -104,11 +119,17 @@ class Traces {
 		if (context) return otel.tracer.startActiveSpan(name, options, context, (span) => this.#callActiveSpan(span, callback));
 		return otel.tracer.startActiveSpan(name, options, (span) => this.#callActiveSpan(span, callback));
 	}
+	/**
+	* @internal
+	*/
 	startSpan(name, options, context) {
 		if (!this.#otel) return this.#noopSpan;
 		const { tracer } = this.#otel;
 		return tracer.startSpan(name, options, context);
 	}
+	/**
+	* @internal
+	*/
 	async finish() {
 		await this.#sdk?.shutdown();
 	}

package/dist/chunks/traces.d.402V_yFI.d.ts

@@ -0,0 +1,18 @@
+interface OTELCarrier {
+	traceparent?: string;
+	tracestate?: string;
+}
+interface TracesOptions {
+	enabled: boolean;
+	watchMode?: boolean;
+	sdkPath?: string;
+	tracerName?: string;
+}
+declare class Traces {
+	#private;
+	constructor(options: TracesOptions);
+	isEnabled(): boolean;
+}
+
+export { Traces as T };
+export type { OTELCarrier as O };

package/dist/chunks/{vm.BKyGp1KW.js → vm.Y19jrZy2.js}

@@ -1,7 +1,7 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import vm, { isContext, runInContext } from 'node:vm';
 import { dirname, basename, extname, normalize, resolve } from 'pathe';
-import { l as loadEnvironment } from './init.B3IeC_yW.js';
+import { l as loadEnvironment } from './init.MkYs5nmh.js';
 import { distDir } from '../path.js';
 import { createCustomConsole } from './console.Cf-YriPC.js';
 import fs from 'node:fs';
@@ -11,7 +11,7 @@ import { findNearestPackageData } from '@vitest/utils/resolver';
 import { dirname as dirname$1 } from 'node:path';
 import { CSS_LANGS_RE, KNOWN_ASSET_RE } from '@vitest/utils/constants';
 import { getDefaultRequestStubs } from '../module-evaluator.js';
-import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.DaBMy1JT.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.W28wBIgJ.js';
 import { p as provideWorkerState } from './utils.DvEY5TfP.js';
 
 function interopCommonJsModule(interopDefault, mod) {