vitest 4.0.9 → 4.0.11

package/dist/chunks/traces.BVPrsYso.js

@@ -0,0 +1,151 @@
+class Traces {
+	/**
+	* otel stands for OpenTelemetry
+	*/
+	#otel = null;
+	#sdk = null;
+	#init = null;
+	#noopSpan = createNoopSpan();
+	#noopContext = createNoopContext();
+	constructor(options) {
+		if (options.enabled) {
+			const apiInit = import('@opentelemetry/api').then((api) => {
+				this.#otel = {
+					tracer: api.trace.getTracer(options.tracerName || "vitest"),
+					context: api.context,
+					propagation: api.propagation,
+					trace: api.trace,
+					SpanKind: api.SpanKind,
+					SpanStatusCode: api.SpanStatusCode
+				};
+			}).catch(() => {
+				throw new Error(`"@opentelemetry/api" is not installed locally. Make sure you have setup OpenTelemetry instrumentation: https://vitest.dev/guide/open-telemetry`);
+			});
+			const sdkInit = (options.sdkPath ? import(options.sdkPath) : Promise.resolve()).catch((cause) => {
+				throw new Error(`Failed to import custom OpenTelemetry SDK script (${options.sdkPath}): ${cause.message}`);
+			});
+			this.#init = Promise.all([sdkInit, apiInit]).then(([sdk]) => {
+				if (sdk != null) {
+					if (sdk.default != null && typeof sdk.default === "object" && typeof sdk.default.shutdown === "function") this.#sdk = sdk.default;
+					else if (options.watchMode !== true && process.env.VITEST_MODE !== "watch") console.warn(`OpenTelemetry instrumentation module (${options.sdkPath}) does not have a default export with a "shutdown" method. Vitest won't be able to ensure that all traces are processed in time. Try running Vitest in watch mode instead.`);
+				}
+			}).finally(() => {
+				this.#init = null;
+			});
+		}
+	}
+	isEnabled() {
+		return !!this.#otel;
+	}
+	async waitInit() {
+		if (this.#init) await this.#init;
+		return this;
+	}
+	startContextSpan(name, currentContext) {
+		if (!this.#otel) return {
+			span: this.#noopSpan,
+			context: this.#noopContext
+		};
+		const activeContext = currentContext || this.#otel.context.active();
+		const span = this.#otel.tracer.startSpan(name, {}, activeContext);
+		return {
+			span,
+			context: this.#otel.trace.setSpan(activeContext, span)
+		};
+	}
+	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);
+	}
+	getContextCarrier(context) {
+		if (!this.#otel) return;
+		const carrier = {};
+		this.#otel.propagation.inject(context || this.#otel.context.active(), carrier);
+		return carrier;
+	}
+	#callActiveSpan(span, callback) {
+		const otel = this.#otel;
+		let result;
+		try {
+			result = callback(span);
+			if (result instanceof Promise) return result.catch((error) => {
+				span.recordException({
+					name: error.name,
+					message: error.message,
+					stack: error.stack
+				});
+				span.setStatus({ code: otel.SpanStatusCode.ERROR });
+				throw error;
+			}).finally(() => span.end());
+			return result;
+		} catch (error) {
+			if (error instanceof Error) {
+				span.recordException({
+					name: error.name,
+					message: error.message,
+					stack: error.stack
+				});
+				span.setStatus({ code: otel.SpanStatusCode.ERROR });
+			}
+			throw error;
+		} finally {
+			// end sync callbcak
+			if (!(result instanceof Promise)) span.end();
+		}
+	}
+	$(name, optionsOrFn, fn) {
+		const callback = typeof optionsOrFn === "function" ? optionsOrFn : fn;
+		if (!this.#otel) return callback(this.#noopSpan);
+		const otel = this.#otel;
+		const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+		const context = options.context;
+		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));
+	}
+	startSpan(name, options, context) {
+		if (!this.#otel) return this.#noopSpan;
+		const { tracer } = this.#otel;
+		return tracer.startSpan(name, options, context);
+	}
+	async finish() {
+		await this.#sdk?.shutdown();
+	}
+}
+function noopSpan() {
+	return this;
+}
+function createNoopSpan() {
+	return {
+		setAttribute: noopSpan,
+		setStatus: noopSpan,
+		addEvent: noopSpan,
+		addLink: noopSpan,
+		addLinks: noopSpan,
+		setAttributes: noopSpan,
+		updateName: noopSpan,
+		end: () => {},
+		isRecording: () => false,
+		recordException: noopSpan,
+		spanContext() {
+			return {
+				spanId: "",
+				traceFlags: 0,
+				traceId: ""
+			};
+		}
+	};
+}
+function noopContext() {
+	return this;
+}
+function createNoopContext() {
+	return {
+		getValue: noopContext,
+		setValue: noopContext,
+		deleteValue: noopContext
+	};
+}
+
+export { Traces as T };

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

@@ -2,6 +2,7 @@ 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.
@@ -180,6 +181,9 @@ interface SerializedConfig {
 		includeSamples: boolean;
 	} | undefined;
 	serializedDefines: string;
+	experimental: {
+		fsModuleCache: boolean;
+	};
 }
 interface SerializedCoverageConfig {
 	provider: "istanbul" | "v8" | "custom" | undefined;
@@ -198,4 +202,35 @@ type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookT
 type RuntimeOptions = Partial<RuntimeConfig>;
 type BrowserTraceViewMode = "on" | "off" | "on-first-retry" | "on-all-retries" | "retain-on-failure";
 
-export type { BrowserTraceViewMode as B, FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedConfig as S, SerializedCoverageConfig as a, RuntimeConfig as b };
+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 };

package/dist/chunks/{vi.CyIUVSoU.js → vi.BiaV1qII.js}

@@ -9,7 +9,7 @@ import { assertTypes, createSimpleStackTrace } from '@vitest/utils/helpers';
 import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunction } from '@vitest/spy';
 import '@vitest/utils/offset';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
+import { c as commonjsGlobal } from './_commonjsHelpers.D26ty3Ew.js';
 import { R as RealDate, r as resetDate, m as mockDate } from './date.Bq6ZW5rf.js';
 
 // these matchers are not supported because they don't make sense with poll
@@ -3902,7 +3902,7 @@ function _mocker() {
 function getImporter(name) {
 	const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n");
 	return parseSingleStack(stackArray[stackArray.findLastIndex((stack) => {
-		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
+		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`) || stack.includes(` at ${name} (`);
 	}) + 1])?.file || "";
 }
 

package/dist/chunks/{vm.DXN8eCh2.js → vm.BKyGp1KW.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.BQhNfT0h.js';
+import { l as loadEnvironment } from './init.B3IeC_yW.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.DLjmA_wU.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.DaBMy1JT.js';
 import { p as provideWorkerState } from './utils.DvEY5TfP.js';
 
 function interopCommonJsModule(interopDefault, mod) {
@@ -671,17 +671,20 @@ class FileMap {
 const entryFile = pathToFileURL(resolve(distDir, "workers/runVmTests.js")).href;
 const fileMap = new FileMap();
 const packageCache = /* @__PURE__ */ new Map();
-async function runVmTests(method, state) {
+async function runVmTests(method, state, traces) {
 	const { ctx, rpc } = state;
 	const beforeEnvironmentTime = performance.now();
-	const { environment } = await loadEnvironment(ctx.environment.name, ctx.config.root, rpc);
+	const { environment } = await loadEnvironment(ctx.environment.name, ctx.config.root, rpc, traces);
 	state.environment = environment;
 	if (!environment.setupVM) {
 		const envName = ctx.environment.name;
 		const packageId = envName[0] === "." ? envName : `vitest-environment-${envName}`;
 		throw new TypeError(`Environment "${ctx.environment.name}" is not a valid environment. Path "${packageId}" doesn't support vm environment because it doesn't provide "setupVM" method.`);
 	}
-	const vm = await environment.setupVM(ctx.environment.options || ctx.config.environmentOptions || {});
+	const vm = await traces.$("vitest.runtime.environment.setup", { attributes: {
+		"vitest.environment": environment.name,
+		"vitest.environment.vite_environment": environment.viteEnvironment || environment.name
+	} }, () => environment.setupVM(ctx.environment.options || ctx.config.environmentOptions || {}));
 	state.durations.environment = performance.now() - beforeEnvironmentTime;
 	process.env.VITEST_VM_POOL = "1";
 	if (!vm.getVmContext) throw new TypeError(`Environment ${environment.name} doesn't provide "getVmContext" method. It should return a context created by "vm.createContext" method.`);
@@ -710,7 +713,8 @@ async function runVmTests(method, state) {
 		evaluatedModules: state.evaluatedModules,
 		state,
 		externalModulesExecutor,
-		createImportMeta: createNodeImportMeta
+		createImportMeta: createNodeImportMeta,
+		traces
 	});
 	Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
 		value: {
@@ -734,9 +738,9 @@ async function runVmTests(method, state) {
 		testLocations: void 0
 	} : f);
 	try {
-		await run(method, fileSpecs, ctx.config, moduleRunner);
+		await run(method, fileSpecs, ctx.config, moduleRunner, traces);
 	} finally {
-		await vm.teardown?.();
+		await traces.$("vitest.runtime.environment.teardown", () => vm.teardown?.());
 	}
 }
 

package/dist/chunks/{worker.d.ZGohxCEd.d.ts → worker.d.B_PZTrCQ.d.ts}

@@ -1,6 +1,6 @@
-import { CancelReason, File, TestAnnotation, TaskResultPack, TaskEventPack, FileSpecification, Task } from '@vitest/runner';
+import { CancelReason, File, TestArtifact, TaskResultPack, TaskEventPack, FileSpecification, Task } from '@vitest/runner';
 import { FetchFunctionOptions, FetchResult, EvaluatedModules } from 'vite/module-runner';
-import { S as SerializedConfig } from './config.d.BTfZNUu9.js';
+import { O as OTELCarrier, S as SerializedConfig, T as Traces } from './traces.d.B8ukBJqA.js';
 import { E as Environment } from './environment.d.CrsxCzP1.js';
 import { SnapshotResult } from '@vitest/snapshot';
 
@@ -208,7 +208,7 @@ interface Request {
 declare const setTimeout: typeof globalThis.setTimeout;
 
 interface RuntimeRPC {
-	fetch: (id: string, importer: string | undefined, environment: string, options?: FetchFunctionOptions) => Promise<FetchResult | FetchCachedFileSystemResult>;
+	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;
@@ -218,7 +218,7 @@ interface RuntimeRPC {
 	onQueued: (file: File) => void;
 	onCollected: (files: File[]) => Promise<void>;
 	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
-	onTaskAnnotate: (testId: string, annotation: TestAnnotation) => Promise<TestAnnotation>;
+	onTaskArtifactRecord: <Artifact extends TestArtifact>(testId: string, artifact: Artifact) => Promise<Artifact>;
 	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
 	onCancel: (reason: CancelReason) => void;
 	getCountOfFailedTests: () => number;
@@ -264,6 +264,7 @@ interface WorkerSetupContext {
 	config: SerializedConfig;
 	projectName: string;
 	rpc: WorkerRPC;
+	traces: Traces;
 }
 interface WorkerGlobalState {
 	ctx: ContextRPC;

package/dist/cli.js

@@ -1,10 +1,10 @@
-import { c as createCLI } from './chunks/cac.B_NTJoIH.js';
+import { c as createCLI } from './chunks/cac.aVhqBj0-.js';
 import '@vitest/utils/helpers';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
 import './chunks/constants.D_Q9UYh-.js';
-import './chunks/index.kotH7DY7.js';
+import './chunks/index.DWDW6mLz.js';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:perf_hooks';

package/dist/config.d.ts

@@ -1,12 +1,12 @@
 import { HookHandler, ConfigEnv, UserConfig } from 'vite';
 export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.BQ0wpUaj.js';
-export { a as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.BQ0wpUaj.js';
-import { V as VitestPluginContext } from './chunks/plugin.d.DevON6kQ.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d.BTfZNUu9.js';
+import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.DgZLBdyd.js';
+export { b as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.DgZLBdyd.js';
+import { V as VitestPluginContext } from './chunks/plugin.d.N8khPRFb.js';
+import { F as FakeTimerInstallOpts } from './chunks/traces.d.B8ukBJqA.js';
 import '@vitest/runner';
 import '@vitest/utils';
-import './chunks/worker.d.ZGohxCEd.js';
+import './chunks/worker.d.B_PZTrCQ.js';
 import 'vite/module-runner';
 import './chunks/environment.d.CrsxCzP1.js';
 import '@vitest/snapshot';
@@ -14,7 +14,7 @@ import 'node:stream';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
 import 'vitest/browser';
-import './chunks/browser.d.DnU_kh8a.js';
+import './chunks/browser.d.D-d8eZY4.js';
 import '@vitest/pretty-format';
 import '@vitest/utils/diff';
 import '@vitest/expect';
@@ -24,8 +24,9 @@ import '@vitest/runner/utils';
 import 'tinybench';
 import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
-import 'node:fs';
 import 'node:console';
+import 'node:fs';
+import '@opentelemetry/api';
 
 type VitestInlineConfig = InlineConfig;
 declare module "vite" {

package/dist/coverage.d.ts

@@ -1,17 +1,18 @@
-import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, b as ReportContext } from './chunks/reporters.d.BQ0wpUaj.js';
+import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, a as ReportContext } from './chunks/reporters.d.DgZLBdyd.js';
 import { TransformResult } from 'vite';
-import { A as AfterSuiteRunMeta } from './chunks/worker.d.ZGohxCEd.js';
+import { A as AfterSuiteRunMeta } from './chunks/worker.d.B_PZTrCQ.js';
 import '@vitest/runner';
 import '@vitest/utils';
 import 'node:stream';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
 import 'vitest/browser';
-import './chunks/config.d.BTfZNUu9.js';
+import './chunks/traces.d.B8ukBJqA.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
-import './chunks/browser.d.DnU_kh8a.js';
+import '@opentelemetry/api';
+import './chunks/browser.d.D-d8eZY4.js';
 import '@vitest/expect';
 import 'vitest/optional-types.js';
 import './chunks/benchmark.d.DAaHLpsq.js';
@@ -19,8 +20,8 @@ import '@vitest/runner/utils';
 import 'tinybench';
 import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
-import 'node:fs';
 import 'node:console';
+import 'node:fs';
 import 'vite/module-runner';
 import './chunks/environment.d.CrsxCzP1.js';
 

package/dist/coverage.js

@@ -1,4 +1,4 @@
-export { B as BaseCoverageProvider } from './chunks/coverage.BUlIqJrL.js';
+export { B as BaseCoverageProvider } from './chunks/coverage.CtyeYmKM.js';
 import 'node:fs';
 import 'node:path';
 import '@vitest/utils/helpers';
@@ -11,10 +11,10 @@ import 'node:os';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
 import 'node:crypto';
+import 'node:url';
 import 'node:module';
 import 'node:process';
 import 'node:fs/promises';
-import 'node:url';
 import 'node:assert';
 import 'node:v8';
 import 'node:util';

package/dist/environments.js

@@ -1,3 +1,3 @@
-export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.BfmpdV5p.js';
+export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.QWbK7rHY.js';
 import 'node:url';
 import 'node:console';

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { S as SerializedTestSpecification } from './chunks/browser.d.DnU_kh8a.js';
-export { B as BrowserTesterOptions } from './chunks/browser.d.DnU_kh8a.js';
-import './chunks/global.d.BQDgW9Pr.js';
-import { File, TestAnnotation, TaskResultPack, TaskEventPack, TaskPopulated } from '@vitest/runner';
-export { CancelReason, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import { S as SerializedTestSpecification } from './chunks/browser.d.D-d8eZY4.js';
+export { B as BrowserTesterOptions } from './chunks/browser.d.D-d8eZY4.js';
+import './chunks/global.d.uY4Q0M5z.js';
+import { File, TestAnnotation, TestArtifact, TaskResultPack, TaskEventPack, Test, TaskPopulated } from '@vitest/runner';
+export { CancelReason, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestAnnotationArtifact, TestArtifact, TestArtifactBase, TestArtifactLocation, TestArtifactRegistry, TestAttachment, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
 import { Awaitable } from '@vitest/utils';
 export { ParsedStack, SerializedError, TestError } from '@vitest/utils';
-import { U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, b as BirpcReturn, P as ProvidedContext } from './chunks/worker.d.ZGohxCEd.js';
-export { A as AfterSuiteRunMeta, C as ContextRPC, d as ContextTestEnvironment, c as RunnerRPC, R as RuntimeRPC, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.ZGohxCEd.js';
-import { S as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.BTfZNUu9.js';
-export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.d.BTfZNUu9.js';
+import { U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, b as BirpcReturn, P as ProvidedContext } from './chunks/worker.d.B_PZTrCQ.js';
+export { A as AfterSuiteRunMeta, C as ContextRPC, d as ContextTestEnvironment, c as RunnerRPC, R as RuntimeRPC, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.B_PZTrCQ.js';
+import { S as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/traces.d.B8ukBJqA.js';
+export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/traces.d.B8ukBJqA.js';
 import { ExpectStatic } from '@vitest/expect';
 export { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectPollOptions, ExpectStatic, JestAssertion, Matchers, chai } from '@vitest/expect';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
@@ -23,6 +23,7 @@ export { DiffOptions } from '@vitest/utils/diff';
 export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
 import '@vitest/pretty-format';
 import './chunks/environment.d.CrsxCzP1.js';
+import '@opentelemetry/api';
 import '@vitest/mocker';
 import '@vitest/runner/utils';
 
@@ -67,17 +68,18 @@ interface WebSocketHandlers {
 }
 interface WebSocketEvents {
 	onCollected?: (files?: File[]) => Awaitable<void>;
-	onFinished?: (files: File[], errors: unknown[], coverage?: unknown) => Awaitable<void>;
+	onFinished?: (files: File[], errors: unknown[], coverage?: unknown, executionTime?: number) => Awaitable<void>;
 	onTestAnnotate?: (testId: string, annotation: TestAnnotation) => Awaitable<void>;
+	onTestArtifactRecord?: (testId: string, artifact: TestArtifact) => Awaitable<void>;
 	onTaskUpdate?: (packs: TaskResultPack[], events: TaskEventPack[]) => Awaitable<void>;
 	onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
 	onPathsCollected?: (paths?: string[]) => Awaitable<void>;
-	onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable<void>;
+	onSpecsCollected?: (specs?: SerializedTestSpecification[], startTime?: number) => Awaitable<void>;
 	onFinishedReportCoverage: () => void;
 }
 type WebSocketRPC = BirpcReturn<WebSocketEvents, WebSocketHandlers>;
 
-declare function createExpect(test?: TaskPopulated): ExpectStatic;
+declare function createExpect(test?: Test | TaskPopulated): ExpectStatic;
 declare const globalExpect: ExpectStatic;
 declare const assert: Chai.Assert;
 declare const should: () => Chai.Should;

package/dist/index.js

@@ -1,9 +1,9 @@
-export { b as assert, c as createExpect, g as expect, i as inject, s as should, v as vi, d as vitest } from './chunks/vi.CyIUVSoU.js';
+export { b as assert, c as createExpect, g as expect, i as inject, s as should, v as vi, d as vitest } from './chunks/vi.BiaV1qII.js';
 export { b as bench } from './chunks/benchmark.B3N2zMcH.js';
 export { V as EvaluatedModules } from './chunks/evaluatedModules.Dg1zASAC.js';
-export { a as assertType } from './chunks/index.CGezRSGU.js';
+export { a as assertType } from './chunks/index.DBx1AtPJ.js';
 export { expectTypeOf } from 'expect-type';
-export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
 export { chai } from '@vitest/expect';
 import '@vitest/runner/utils';
 import './chunks/utils.DvEY5TfP.js';
@@ -14,7 +14,7 @@ import '@vitest/utils/helpers';
 import '@vitest/spy';
 import '@vitest/utils/offset';
 import '@vitest/utils/source-map';
-import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import './chunks/_commonjsHelpers.D26ty3Ew.js';
 import './chunks/date.Bq6ZW5rf.js';
 import 'pathe';
 import 'vite/module-runner';

package/dist/module-evaluator.d.ts

@@ -1,14 +1,15 @@
 import 'vite/module-runner';
-export { b as VitestModuleEvaluator, a as VitestModuleEvaluatorOptions, c as createImportMetaEnvProxy, g as getDefaultRequestStubs, i as isPrimitive, u as unwrapId, w as wrapId } from './chunks/moduleRunner.d.BxT-OjLR.js';
+export { b as VitestModuleEvaluator, a as VitestModuleEvaluatorOptions, c as createImportMetaEnvProxy, g as getDefaultRequestStubs, i as isPrimitive, u as unwrapId, w as wrapId } from './chunks/moduleRunner.d.B5SW5pMI.js';
 import 'node:vm';
+import './chunks/traces.d.B8ukBJqA.js';
 import '@vitest/spy';
-import './chunks/worker.d.ZGohxCEd.js';
+import './chunks/worker.d.B_PZTrCQ.js';
 import '@vitest/runner';
-import './chunks/config.d.BTfZNUu9.js';
-import '@vitest/pretty-format';
-import '@vitest/snapshot';
-import '@vitest/utils/diff';
 import './chunks/environment.d.CrsxCzP1.js';
 import '@vitest/utils';
+import '@vitest/snapshot';
 import '@vitest/mocker';
 import './chunks/mocker.d.BE_2ls6u.js';
+import '@vitest/pretty-format';
+import '@vitest/utils/diff';
+import '@opentelemetry/api';

package/dist/module-evaluator.js

@@ -3,6 +3,7 @@ import { pathToFileURL } from 'node:url';
 import vm from 'node:vm';
 import { isAbsolute } from 'pathe';
 import { ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey } from 'vite/module-runner';
+import { T as Traces } from './chunks/traces.BVPrsYso.js';
 
 const performanceNow = performance.now.bind(performance);
 class ModuleDebug {
@@ -38,8 +39,10 @@ class VitestModuleEvaluator {
 	compiledFunctionArgumentsValues = [];
 	primitives;
 	debug = new ModuleDebug();
+	_otel;
 	constructor(vmOptions, options = {}) {
 		this.options = options;
+		this._otel = options.traces || new Traces({ enabled: false });
 		this.vm = vmOptions;
 		this.stubs = getDefaultRequestStubs(vmOptions?.context);
 		if (options.compiledFunctionArgumentsNames) this.compiledFunctionArgumentsNames = options.compiledFunctionArgumentsNames;
@@ -53,6 +56,7 @@ class VitestModuleEvaluator {
 	}
 	convertIdToImportUrl(id) {
 		// TODO: vitest returns paths for external modules, but Vite returns file://
+		// REMOVE WHEN VITE 6 SUPPORT IS OVER
 		// unfortunetly, there is a bug in Vite where ID is resolved incorrectly, so we can't return files until the fix is merged
 		// https://github.com/vitejs/vite/pull/20449
 		if (!isWindows || isBuiltin(id) || /^(?:node:|data:|http:|https:|file:)/.test(id)) return id;
@@ -63,7 +67,7 @@ class VitestModuleEvaluator {
 	async runExternalModule(id) {
 		if (id in this.stubs) return this.stubs[id];
 		const file = this.convertIdToImportUrl(id);
-		const namespace = this.vm ? await this.vm.externalModulesExecutor.import(file) : await import(file);
+		const namespace = await this._otel.$("vitest.module.external", { attributes: { "code.file.path": file } }, () => this.vm ? this.vm.externalModulesExecutor.import(file) : import(file));
 		if (!this.shouldInterop(file, namespace)) return namespace;
 		const { mod, defaultExport } = interopModule(namespace);
 		const { Proxy, Reflect } = this.primitives;
@@ -88,6 +92,9 @@ class VitestModuleEvaluator {
 		});
 	}
 	async runInlinedModule(context, code, module) {
+		return this._otel.$("vitest.module.inline", (span) => this._runInlinedModule(context, code, module, span));
+	}
+	async _runInlinedModule(context, code, module, span) {
 		context.__vite_ssr_import_meta__.env = this.env;
 		const { Reflect, Proxy, Object } = this.primitives;
 		const exportsObject = context[ssrModuleExportsKey];
@@ -102,9 +109,11 @@ class VitestModuleEvaluator {
 			},
 			getPrototypeOf: () => Object.prototype,
 			set: (_, p, value) => {
+				span.addEvent(`cjs export proxy is triggered for ${String(p)}`);
 				// treat "module.exports =" the same as "exports.default =" to not have nested "default.default",
 				// so "exports.default" becomes the actual module
 				if (p === "default" && this.shouldInterop(module.file, { default: value }) && cjsExports !== value) {
+					span.addEvent("`exports.default` is assigned, copying values");
 					exportAll(cjsExports, value);
 					exportsObject.default = value;
 					return true;
@@ -113,6 +122,7 @@ class VitestModuleEvaluator {
 				// returns undefined, when accessing named exports, if default is not an object
 				// but is still present inside hasOwnKeys, this is Node behaviour for CJS
 				if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) {
+					span.addEvent(`\`exports.${String(p)}\` is assigned, but module.exports is a primitive. assigning "undefined" values instead to comply with ESM`);
 					defineExport(exportsObject, p, () => void 0);
 					return true;
 				}
@@ -123,6 +133,7 @@ class VitestModuleEvaluator {
 		});
 		const moduleProxy = {
 			set exports(value) {
+				span.addEvent("`module.exports` is assigned directly, copying all properties to `exports`");
 				exportAll(cjsExports, value);
 				exportsObject.default = value;
 				moduleExports = value;
@@ -138,6 +149,7 @@ class VitestModuleEvaluator {
 		}
 		const filename = meta.filename;
 		const dirname = meta.dirname;
+		span.setAttributes({ "code.file.path": filename });
 		const require = this.createRequire(filename);
 		const argumentsList = [
 			ssrModuleExportsKey,
@@ -153,6 +165,7 @@ class VitestModuleEvaluator {
 			"require"
 		];
 		if (this.compiledFunctionArgumentsNames) argumentsList.push(...this.compiledFunctionArgumentsNames);
+		span.setAttribute("vitest.module.arguments", argumentsList);
 		// add 'use strict' since ESM enables it by default
 		const codeDefinition = `'use strict';async (${argumentsList.join(",")})=>{{`;
 		const wrappedCode = `${codeDefinition}${code}\n}}`;

package/dist/module-runner.js

@@ -1,11 +1,12 @@
 export { VitestModuleEvaluator } from './module-evaluator.js';
-export { a as VITEST_VM_CONTEXT_SYMBOL, V as VitestModuleRunner, s as startVitestModuleRunner } from './chunks/startModuleRunner.DLjmA_wU.js';
+export { a as VITEST_VM_CONTEXT_SYMBOL, V as VitestModuleRunner, s as startVitestModuleRunner } from './chunks/startModuleRunner.DaBMy1JT.js';
 export { g as getWorkerState } from './chunks/utils.DvEY5TfP.js';
 import 'node:module';
 import 'node:url';
 import 'node:vm';
 import 'pathe';
 import 'vite/module-runner';
+import './chunks/traces.BVPrsYso.js';
 import 'node:fs';
 import '@vitest/utils/helpers';
 import './path.js';