vitest 4.0.15 → 4.0.17

package/dist/chunks/{index.Drsj_6e7.js → index.C5r1PdPD.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.456_DGfR.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.M8mOzt4Y.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils/helpers';
 

package/dist/chunks/index.Chj8NDwU.js

@@ -0,0 +1,206 @@
+//#region src/messages.ts
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+
+//#endregion
+//#region src/utils.ts
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+
+//#endregion
+//#region src/main.ts
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: TYPE_REQUEST
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options$1) => _call(options$1.method, options$1.args, options$1.event, options$1.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ??= error;
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === TYPE_REQUEST) {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn ||= () => void 0;
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+
+export { createBirpc as c };

package/dist/chunks/{index.BspFP3mn.js → index.CyBMJtT7.js}

@@ -603,7 +603,7 @@ function patchAddEventListener(window) {
 		return abortControllers.get(signal);
 	}
 	window.EventTarget.prototype.addEventListener = function addEventListener(type, callback, options) {
-		if (typeof options === "object" && options.signal != null) {
+		if (typeof options === "object" && options?.signal != null) {
 			const { signal, ...otherOptions } = options;
 			// - this happens because AbortSignal is provided by Node.js,
 			// but jsdom APIs require jsdom's AbortSignal, while Node APIs

package/dist/chunks/{index.456_DGfR.js → index.M8mOzt4Y.js}

@@ -2714,6 +2714,17 @@ class Typechecker {
 		markTasks(file.tasks);
 	}
 	async prepareResults(output) {
+		// Detect if tsc output is help text instead of error output
+		// This happens when tsconfig.json is missing and tsc can't find any config
+		if (output.includes("The TypeScript Compiler - Version") || output.includes("COMMON COMMANDS")) {
+			const { typecheck } = this.project.config;
+			const msg = `TypeScript compiler returned help text instead of type checking results.
+This usually means the tsconfig file was not found.
+
+Possible solutions:
+  1. Ensure '${typecheck.tsconfig || "tsconfig.json"}' exists in your project root\n  2. If using a custom tsconfig, verify the path in your Vitest config:\n     test: { typecheck: { tsconfig: 'path/to/tsconfig.json' } }\n  3. Check that the tsconfig file is valid JSON`;
+			throw new Error(msg);
+		}
 		const typeErrors = await this.parseTscLikeOutput(output);
 		const testFiles = new Set(this.getFiles());
 		if (!this._tests) this._tests = await this.collectTests();
@@ -2847,6 +2858,7 @@ class Typechecker {
 				reject(/* @__PURE__ */ new Error(`Failed to initialize ${typecheck.checker}. This is a bug in Vitest - please, open an issue with reproduction.`));
 				return;
 			}
+			let resolved = false;
 			child.process.stdout.on("data", (chunk) => {
 				dataReceived = true;
 				this._output += chunk;
@@ -2868,9 +2880,17 @@ class Typechecker {
 					this._output = "";
 				}
 			});
+			// Also capture stderr for configuration errors like missing tsconfig
+			child.process.stderr?.on("data", (chunk) => {
+				this._output += chunk;
+			});
 			const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`${typecheck.checker} spawn timed out`)), this.project.config.typecheck.spawnTimeout);
+			let winTimeout;
 			function onError(cause) {
+				if (resolved) return;
 				clearTimeout(timeout);
+				clearTimeout(winTimeout);
+				resolved = true;
 				reject(new Error("Spawning typechecker failed - is typescript installed?", { cause }));
 			}
 			child.process.once("spawn", () => {
@@ -2881,10 +2901,14 @@ class Typechecker {
  // on Windows, the process might be spawned but fail to start
 				// we wait for a potential error here. if "close" event didn't trigger,
 				// we resolve the promise
-				setTimeout(() => {
+				winTimeout = setTimeout(() => {
+					resolved = true;
 					resolve({ result: child });
 				}, 200);
-				else resolve({ result: child });
+				else {
+					resolved = true;
+					resolve({ result: child });
+				}
 			});
 			if (process.platform === "win32") child.process.once("close", (code) => {
 				if (code != null && code !== 0 && !dataReceived) onError(/* @__PURE__ */ new Error(`The ${typecheck.checker} command exited with code ${code}.`));

package/dist/chunks/{init-forks.CKEYp90N.js → init-forks.BC6ZwHQN.js}

@@ -1,4 +1,4 @@
-import { i as init } from './init.B04saIIg.js';
+import { i as init } from './init.C9kljSTm.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.D8Ok07M7.js → init-threads.CxSxLC0N.js}

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

package/dist/chunks/{init.B04saIIg.js → init.C9kljSTm.js}

@@ -3,11 +3,11 @@ 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.Iz2V0ESw.js';
-import { e as environments } from './index.BspFP3mn.js';
+import { b as VitestTransport } from './startModuleRunner.DEj0jb3e.js';
+import { e as environments } from './index.CyBMJtT7.js';
 import { serializeError } from '@vitest/utils/error';
-import { T as Traces } from './traces.U4xDYhzZ.js';
-import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BytlcPfC.js';
+import { T as Traces } from './traces.CCmnQaNT.js';
+import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BoxB0q7B.js';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { s as setupInspect } from './inspector.CvyFGlXm.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
@@ -161,16 +161,14 @@ function init(worker) {
 				process.env.VITEST_POOL_ID = String(message.poolId);
 				process.env.VITEST_WORKER_ID = String(message.workerId);
 				reportMemory = message.options.reportMemory;
-				const tracesStart = performance.now();
 				traces ??= await new Traces({
 					enabled: message.traces.enabled,
 					sdkPath: message.traces.sdkPath
 				}).waitInit();
-				const tracesEnd = performance.now();
 				const { environment, config, pool } = message.context;
 				const context = traces.getContextFromCarrier(message.traces.otelCarrier);
 				// record telemetry as part of "start"
-				traces.startSpan("vitest.runtime.traces", { startTime: tracesStart }, context).end(tracesEnd);
+				traces.recordInitSpan(context);
 				try {
 					setupContext = {
 						environment,

package/dist/chunks/{modules.DJPjQW6m.js → modules.BJuCwlRJ.js}

@@ -10,10 +10,11 @@ const NPM_BUILTIN_NAMESPACE = "npm:";
 const BUN_BUILTIN_NAMESPACE = "bun:";
 // Some runtimes like Bun injects namespaced modules here, which is not a node builtin
 const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
+const { bun: isBun, deno: isDeno } = process.versions;
 // TODO: Use `isBuiltin` from `node:module`, but Deno doesn't support it
 function isBuiltin(id) {
-	if (process.versions.deno && id.startsWith(NPM_BUILTIN_NAMESPACE)) return true;
-	if (process.versions.bun && id.startsWith(BUN_BUILTIN_NAMESPACE)) return true;
+	if (isDeno && id.startsWith(NPM_BUILTIN_NAMESPACE)) return true;
+	if (isBun && id.startsWith(BUN_BUILTIN_NAMESPACE)) return true;
 	return isNodeBuiltin(id);
 }
 function isNodeBuiltin(id) {
@@ -28,7 +29,7 @@ function isBrowserExternal(id) {
 function toBuiltin(id) {
 	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);
 	if (id.startsWith(NPM_BUILTIN_NAMESPACE) || id.startsWith(BUN_BUILTIN_NAMESPACE) || id.startsWith(NODE_BUILTIN_NAMESPACE)) return id;
-	if (process.versions.deno || process.versions.bun) return id;
+	if (isDeno || isBun) return id;
 	return `node:${id}`;
 }
 

package/dist/chunks/{plugin.d.CY7CUjf-.d.ts → plugin.d.CtqpEehP.d.ts}

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

package/dist/chunks/{reporters.d.OXEK7y4s.d.ts → reporters.d.CWXNI2jG.d.ts}

@@ -3,17 +3,17 @@ import { TestError, SerializedError, Arrayable, ParsedStack, Awaitable } from '@
 import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, L as LabelColor } from './rpc.d.RH3apGEf.js';
 import { Writable } from 'node:stream';
 import { DevEnvironment, TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
-import { S as SerializedTestSpecification, c as SourceModuleDiagnostic, B as BrowserTesterOptions } from './browser.d.DBzUq_Na.js';
+import { S as SerializedTestSpecification, c as SourceModuleDiagnostic, B as BrowserTesterOptions } from './browser.d.ChKACdzH.js';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { BrowserCommands } from 'vitest/browser';
-import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.CzIjkicf.js';
+import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.Cy95HiCx.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 WorkerExecuteContext, e as WorkerTestEnvironment } from './worker.d.B4A26qg6.js';
+import { c as ContextTestEnvironment, d as WorkerExecuteContext, e as WorkerTestEnvironment } from './worker.d.Dyxm8DEL.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';
@@ -1924,8 +1924,8 @@ interface PoolWorker {
 	stop: () => Promise<void>;
 	/**
 	* This is called on workers that already satisfy certain constraints:
+	* - The task has the same worker name
 	* - The task has the same project
-	* - The task has the same environment
 	*/
 	canReuse?: (task: PoolTask) => boolean;
 }
@@ -1944,7 +1944,6 @@ interface PoolTask {
 	*/
 	execArgv: string[];
 	context: WorkerExecuteContext;
-	environment: ContextTestEnvironment;
 	memoryLimit: number | null;
 }
 type WorkerRequest = {
@@ -3035,6 +3034,7 @@ interface InlineConfig {
 		openTelemetry?: {
 			enabled: boolean;
 			sdkPath?: string;
+			browserSdkPath?: string;
 		};
 		/**
 		* Show imports (top 10) that take a long time.
@@ -3187,6 +3187,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config"
 	poolRunner?: PoolRunnerInitializer;
 	reporters: (InlineReporter | ReporterWithOptions)[];
 	defines: Record<string, any>;
+	viteDefine: Record<string, any>;
 	api: ApiConfig & {
 		token: string;
 	};

package/dist/chunks/{rpc.BytlcPfC.js → rpc.BoxB0q7B.js}

@@ -1,5 +1,5 @@
 import { getSafeTimers } from '@vitest/utils/timers';
-import { c as createBirpc } from './index.0kCJoeWi.js';
+import { c as createBirpc } from './index.Chj8NDwU.js';
 import { g as getWorkerState } from './utils.DvEY5TfP.js';
 
 const { get } = Reflect;

package/dist/chunks/{startModuleRunner.Iz2V0ESw.js → startModuleRunner.DEj0jb3e.js}

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import { isBareImport } from '@vitest/utils/helpers';
-import { i as isBuiltin, a as isBrowserExternal, t as toBuiltin } from './modules.DJPjQW6m.js';
+import { i as isBuiltin, a as isBrowserExternal, t as toBuiltin } from './modules.BJuCwlRJ.js';
 import { pathToFileURL } from 'node:url';
 import { normalize as normalize$1, join as join$1 } from 'pathe';
 import { distDir } from '../path.js';
@@ -11,7 +11,7 @@ import vm from 'node:vm';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
 import nodeModule from 'node:module';
 import * as viteModuleRunner from 'vite/module-runner';
-import { T as Traces } from './traces.U4xDYhzZ.js';
+import { T as Traces } from './traces.CCmnQaNT.js';
 
 class VitestTransport {
 	constructor(options) {

package/dist/chunks/{test.BT8LKgU9.js → test.B8ej_ZHS.js}

@@ -8,7 +8,7 @@ import { getTests, getNames, getTestName } from '@vitest/runner/utils';
 import { processError } from '@vitest/utils/error';
 import { normalize } from 'pathe';
 import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.2VT5v0um.js';
-import { r as rpc } from './rpc.BytlcPfC.js';
+import { r as rpc } from './rpc.BoxB0q7B.js';
 
 function createBenchmarkResult(name) {
 	return {

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

@@ -7,6 +7,9 @@ class Traces {
 	#init = null;
 	#noopSpan = createNoopSpan();
 	#noopContext = createNoopContext();
+	#initStartTime = performance.now();
+	#initEndTime = 0;
+	#initRecorded = false;
 	constructor(options) {
 		if (options.enabled) {
 			const apiInit = import('@opentelemetry/api').then((api) => {
@@ -21,7 +24,10 @@ class Traces {
 			}).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) => {
+			const sdkInit = (options.sdkPath ? import(
+				/* @vite-ignore */
+				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]) => {
@@ -30,6 +36,7 @@ class Traces {
 					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.#initEndTime = performance.now();
 				this.#init = null;
 			});
 		}
@@ -47,6 +54,14 @@ class Traces {
 	/**
 	* @internal
 	*/
+	recordInitSpan(context) {
+		if (this.#initRecorded) return;
+		this.#initRecorded = true;
+		this.startSpan("vitest.runtime.traces", { startTime: this.#initStartTime }, context).end(this.#initEndTime);
+	}
+	/**
+	* @internal
+	*/
 	startContextSpan(name, currentContext) {
 		if (!this.#otel) return {
 			span: this.#noopSpan,
@@ -71,6 +86,18 @@ class Traces {
 	/**
 	* @internal
 	*/
+	getContextFromEnv(env) {
+		if (!this.#otel) return this.#noopContext;
+		// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/context/env-carriers.md
+		// some tools sets only `TRACEPARENT` but not `TRACESTATE`
+		const carrier = {};
+		if (typeof env.TRACEPARENT === "string") carrier.traceparent = env.TRACEPARENT;
+		if (typeof env.TRACESTATE === "string") carrier.tracestate = env.TRACESTATE;
+		return this.getContextFromCarrier(carrier);
+	}
+	/**
+	* @internal
+	*/
 	getContextCarrier(context) {
 		if (!this.#otel) return;
 		const carrier = {};
@@ -127,12 +154,30 @@ class Traces {
 		const { tracer } = this.#otel;
 		return tracer.startSpan(name, options, context);
 	}
+	// On browser mode, async context is not automatically propagated,
+	// so we manually bind the `$` calls to the provided context.
+	// TODO: this doesn't bind to user land's `@optelemetry/api` calls
+	/**
+	* @internal
+	*/
+	bind(context) {
+		if (!this.#otel) return;
+		const original = this.$.__original ?? this.$;
+		this.$ = this.#otel.context.bind(context, original);
+		this.$.__original = original;
+	}
 	/**
 	* @internal
 	*/
 	async finish() {
 		await this.#sdk?.shutdown();
 	}
+	/**
+	* @internal
+	*/
+	async flush() {
+		await this.#sdk?.forceFlush?.();
+	}
 }
 function noopSpan() {
 	return this;

package/dist/chunks/{vm.BwmD1Rql.js → vm.CMjifoPa.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.B04saIIg.js';
+import { l as loadEnvironment } from './init.C9kljSTm.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.Iz2V0ESw.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.DEj0jb3e.js';
 import { p as provideWorkerState } from './utils.DvEY5TfP.js';
 
 function interopCommonJsModule(interopDefault, mod) {