@vitest/browser 4.0.15 → 4.0.17

package/dist/index.js

@@ -18,7 +18,7 @@ import { PNG } from 'pngjs';
 import pm from 'pixelmatch';
 import { WebSocketServer } from 'ws';
 
-var version = "4.0.15";
+var version = "4.0.17";
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -695,6 +695,7 @@ async function resolveOrchestrator(globalServer, url, res) {
 		__VITEST_TYPE__: "\"orchestrator\"",
 		__VITEST_SESSION_ID__: JSON.stringify(sessionId),
 		__VITEST_TESTER_ID__: "\"none\"",
+		__VITEST_OTEL_CARRIER__: url.searchParams.get("otelCarrier") ?? "null",
 		__VITEST_PROVIDED_CONTEXT__: JSON.stringify(stringify(browserProject.project.getProvidedContext())),
 		__VITEST_API_TOKEN__: JSON.stringify(globalServer.vitest.config.api.token)
 	});
@@ -790,6 +791,7 @@ async function resolveTester(globalServer, url, res, next) {
 		__VITEST_TYPE__: "\"tester\"",
 		__VITEST_METHOD__: JSON.stringify("none"),
 		__VITEST_SESSION_ID__: JSON.stringify(sessionId),
+		__VITEST_OTEL_CARRIER__: JSON.stringify(null),
 		__VITEST_TESTER_ID__: JSON.stringify(crypto.randomUUID()),
 		__VITEST_PROVIDED_CONTEXT__: "{}",
 		__VITEST_API_TOKEN__: JSON.stringify(globalServer.vitest.config.api.token)
@@ -1139,6 +1141,11 @@ var BrowserPlugin = (parentServer, base = "/") => {
 				if (vueTestUtils) {
 					include.push("@vue/test-utils");
 				}
+				const otelConfig = project.config.experimental.openTelemetry;
+				if (otelConfig?.enabled && otelConfig.browserSdkPath) {
+					entries.push(otelConfig.browserSdkPath);
+					include.push("@opentelemetry/api");
+				}
 				return {
 					define,
 					resolve: { dedupe: ["vitest"] },
@@ -1378,6 +1385,16 @@ body {
 				};
 				return { optimizeDeps: rolldownVersion ? { rolldownOptions: { plugins: [rolldownPlugin] } } : { esbuildOptions: { plugins: [esbuildPlugin] } } };
 			}
+		},
+		{
+			name: "vitest:browser:__vitest_browser_import_meta_env_init__",
+			transform: { handler(code) {
+				// this transform runs after `vitest:meta-env-replacer` so that
+				// `import.meta.env` will be handled by Vite import analysis to match behavior.
+				if (code.includes("__vitest_browser_import_meta_env_init__")) {
+					return code.replace("__vitest_browser_import_meta_env_init__", "import.meta.env");
+				}
+			} }
 		}
 	];
 };
@@ -2214,9 +2231,20 @@ function asyncTimeout(timeout) {
 	});
 }
 
+/**
+* Browser command that compares a screenshot against a stored reference.
+*
+* The comparison workflow is organized as follows:
+*
+* 1. Load existing reference (if any)
+* 2. Capture a stable screenshot (retrying until the page stops changing)
+* 3. Determine the outcome based on capture results and update settings
+* 4. Write any necessary files (new references, diffs)
+* 5. Return result for the test runner
+*/
 const screenshotMatcher = async (context, name, testName, options) => {
 	if (!context.testPath) {
-		throw new Error(`Cannot compare screenshots without a test path`);
+		throw new Error("Cannot compare screenshots without a test path");
 	}
 	const { element } = options;
 	const { codec, comparator, paths, resolvedOptions: { comparatorOptions, screenshotOptions, timeout } } = resolveOptions({
@@ -2226,9 +2254,8 @@ const screenshotMatcher = async (context, name, testName, options) => {
 		options
 	});
 	const referenceFile = await readFile$1(paths.reference).catch(() => null);
-	const reference = referenceFile && await codec.decode(await readFile$1(paths.reference), {});
-	const abortController = new AbortController();
-	const stableScreenshot = getStableScreenshots({
+	const reference = referenceFile && await codec.decode(referenceFile, {});
+	const screenshotResult = await waitForStableScreenshot({
 		codec,
 		comparator,
 		comparatorOptions,
@@ -2236,115 +2263,189 @@ const screenshotMatcher = async (context, name, testName, options) => {
 		element,
 		name: `${Date.now()}-${basename(paths.reference)}`,
 		reference,
-		screenshotOptions,
-		signal: abortController.signal
+		screenshotOptions
+	}, timeout);
+	const outcome = await determineOutcome({
+		reference,
+		screenshot: screenshotResult && screenshotResult.actual,
+		retries: screenshotResult?.retries ?? 0,
+		updateSnapshot: context.project.serializedConfig.snapshotOptions.updateSnapshot,
+		paths,
+		comparator,
+		comparatorOptions
 	});
-	const value = await (timeout === 0 ? stableScreenshot : Promise.race([stableScreenshot, asyncTimeout(timeout).finally(() => {
-		abortController.abort();
-	})]));
-	// case #01
-	//  - impossible to get a stable screenshot to compare against
-	//  - fail
-	if (value === null || value.actual === null) {
+	await performSideEffects(outcome, codec);
+	return buildOutput(outcome, timeout);
+};
+/**
+* Core comparison logic that produces a {@linkcode MatchOutcome}.
+*
+* All branching logic lives here. This is the single source of truth for "what happened".
+*
+* The outcome carries all data needed by {@linkcode performSideEffects} and {@linkcode buildOutput}.
+*/
+async function determineOutcome({ comparator, comparatorOptions, paths, reference, retries, screenshot, updateSnapshot }) {
+	if (screenshot === null) {
 		return {
-			pass: false,
-			reference: referenceFile && {
-				path: paths.reference,
-				width: reference.metadata.width,
-				height: reference.metadata.height
-			},
-			actual: null,
-			diff: null,
-			message: `Could not capture a stable screenshot within ${timeout}ms.`
+			type: "unstable-screenshot",
+			reference: reference && {
+				image: reference,
+				path: paths.reference
+			}
 		};
 	}
-	const { updateSnapshot } = context.project.serializedConfig.snapshotOptions;
-	// if there's no reference or if we want to update snapshots, we have to finish the comparison early
+	// no reference to compare against - create one based on update settings
 	if (reference === null || updateSnapshot === "all") {
-		const shouldCreateReference = updateSnapshot !== "none";
-		const referencePath = shouldCreateReference ? paths.reference : paths.diffs.reference;
-		await writeScreenshot(referencePath, await codec.encode(value.actual, {}));
-		// case #02
-		//  - got a stable screenshot, but there is no reference and we don't want to update screenshots
-		//  - fail
-		if (updateSnapshot !== "all") {
+		if (updateSnapshot === "all") {
 			return {
-				pass: false,
+				type: "update-reference",
 				reference: {
-					path: referencePath,
-					width: value.actual.metadata.width,
-					height: value.actual.metadata.height
-				},
-				actual: null,
-				diff: null,
-				message: `No existing reference screenshot found${shouldCreateReference ? "; a new one was created. Review it before running tests again." : "."}`
+					image: screenshot,
+					path: paths.reference
+				}
 			};
 		}
-		// case #03
-		//  - got a stable screenshot, there is no reference, but we want to update screenshots
-		//  - pass
-		return { pass: true };
-	}
-	// case #04
-	//  - got a stable screenshot with no retries and there's a reference
-	//  - pass
-	if (referenceFile && value.retries === 0) {
-		return { pass: true };
-	}
-	const finalResult = await comparator(reference, value.actual, {
+		const location = updateSnapshot === "none" ? "diffs" : "reference";
+		return {
+			type: "missing-reference",
+			location,
+			reference: {
+				image: screenshot,
+				path: location === "reference" ? paths.reference : paths.diffs.reference
+			}
+		};
+	}
+	// first capture matched reference (used as baseline) - no further comparison needed
+	if (retries === 0) {
+		return { type: "matched-immediately" };
+	}
+	const comparisonResult = await comparator(reference, screenshot, {
 		createDiff: true,
 		...comparatorOptions
 	});
-	if (finalResult.pass === false && finalResult.diff !== null) {
-		const diff = await codec.encode({
-			data: finalResult.diff,
-			metadata: {
-				height: reference.metadata.height,
-				width: reference.metadata.width
-			}
-		}, {});
-		await writeScreenshot(paths.diffs.diff, diff);
-	}
-	// case #05
-	//  - reference matches stable screenshot
-	//  - pass
-	if (finalResult.pass === true) {
-		return { pass: true };
-	}
-	const actual = await codec.encode(value.actual, {});
-	await writeScreenshot(paths.diffs.actual, actual);
-	// case #06
-	//  - fallback, reference does NOT match stable screenshot
-	//  - fail
+	if (comparisonResult.pass) {
+		return { type: "matched-after-comparison" };
+	}
 	return {
-		pass: false,
+		type: "mismatch",
 		reference: {
-			path: paths.reference,
-			width: reference.metadata.width,
-			height: reference.metadata.height
+			image: reference,
+			path: paths.reference
 		},
 		actual: {
-			path: paths.diffs.actual,
-			width: value.actual.metadata.width,
-			height: value.actual.metadata.height
+			image: screenshot,
+			path: paths.diffs.actual
 		},
-		diff: finalResult.diff && paths.diffs.diff,
-		message: `Screenshot does not match the stored reference.${finalResult.message === null ? "" : `\n${finalResult.message}`}`
+		diff: comparisonResult.diff && {
+			image: {
+				data: comparisonResult.diff,
+				metadata: reference.metadata
+			},
+			path: paths.diffs.diff
+		},
+		message: comparisonResult.message
 	};
-};
-async function writeScreenshot(path, image) {
-	try {
-		await mkdir(dirname(path), { recursive: true });
-		await writeFile$1(path, image);
-	} catch {
-		throw new Error("Couldn't write file to fs");
+}
+/**
+* Writes files to disk based on the outcome.
+*
+* Only `missing-reference`, `update-reference`, and `mismatch` write files. Successful matches produce no side effects.
+*/
+async function performSideEffects(outcome, codec) {
+	switch (outcome.type) {
+		case "missing-reference":
+		case "update-reference": {
+			await writeScreenshot(outcome.reference.path, await codec.encode(outcome.reference.image, {}));
+			break;
+		}
+		case "mismatch": {
+			await writeScreenshot(outcome.actual.path, await codec.encode(outcome.actual.image, {}));
+			if (outcome.diff) {
+				await writeScreenshot(outcome.diff.path, await codec.encode(outcome.diff.image, {}));
+			}
+			break;
+		}
 	}
 }
 /**
+* Transforms a {@linkcode MatchOutcome} into the output format expected by the test runner.
+*
+* Maps each outcome to a pass/fail result with metadata and error messages.
+*/
+function buildOutput(outcome, timeout) {
+	switch (outcome.type) {
+		case "unstable-screenshot": return {
+			pass: false,
+			reference: outcome.reference && {
+				path: outcome.reference.path,
+				width: outcome.reference.image.metadata.width,
+				height: outcome.reference.image.metadata.height
+			},
+			actual: null,
+			diff: null,
+			message: `Could not capture a stable screenshot within ${timeout}ms.`
+		};
+		case "missing-reference": {
+			return {
+				pass: false,
+				reference: {
+					path: outcome.reference.path,
+					width: outcome.reference.image.metadata.width,
+					height: outcome.reference.image.metadata.height
+				},
+				actual: null,
+				diff: null,
+				message: outcome.location === "reference" ? "No existing reference screenshot found; a new one was created. Review it before running tests again." : "No existing reference screenshot found."
+			};
+		}
+		case "update-reference":
+		case "matched-immediately":
+		case "matched-after-comparison": return { pass: true };
+		case "mismatch": return {
+			pass: false,
+			reference: {
+				path: outcome.reference.path,
+				width: outcome.reference.image.metadata.width,
+				height: outcome.reference.image.metadata.height
+			},
+			actual: {
+				path: outcome.actual.path,
+				width: outcome.actual.image.metadata.width,
+				height: outcome.actual.image.metadata.height
+			},
+			diff: outcome.diff && {
+				path: outcome.diff.path,
+				width: outcome.diff.image.metadata.width,
+				height: outcome.diff.image.metadata.height
+			},
+			message: `Screenshot does not match the stored reference.${outcome.message ? `\n${outcome.message}` : ""}`
+		};
+		default: {
+			return {
+				pass: false,
+				actual: null,
+				reference: null,
+				diff: null,
+				message: `Outcome (${outcome.type}) not handled. This is a bug in Vitest. Please, open an issue with reproduction.`
+			};
+		}
+	}
+}
+/**
+* Captures a stable screenshot with timeout handling.
+*
+* Wraps {@linkcode getStableScreenshot} with an abort controller that triggers when the timeout expires. Returns `null` if the page never stabilizes.
+*/
+async function waitForStableScreenshot(options, timeout) {
+	const abortController = new AbortController();
+	const stableScreenshot = getStableScreenshot(options, abortController.signal);
+	const result = await (timeout === 0 ? stableScreenshot : Promise.race([stableScreenshot, asyncTimeout(timeout).finally(() => abortController.abort())]));
+	return result;
+}
+/**
 * Takes screenshots repeatedly until the page reaches a visually stable state.
 *
-* This function compares consecutive screenshots and continues taking new ones
-* until two consecutive screenshots match according to the provided comparator.
+* This function compares consecutive screenshots and continues taking new ones until two consecutive screenshots match according to the provided comparator.
 *
 * The process works as follows:
 *
@@ -2354,10 +2455,9 @@ async function writeScreenshot(path, image) {
 * 4. If they don't match, it continues with the newer screenshot as the baseline
 * 5. Repeats until stability is achieved or the operation is aborted
 *
-* @returns `Promise` resolving to an object containing the retry count and
-* final screenshot
+* @returns `Promise` resolving to an object containing the retry count and final screenshot
 */
-async function getStableScreenshots({ codec, context, comparator, comparatorOptions, element, name, reference, screenshotOptions, signal }) {
+async function getStableScreenshot({ codec, context, comparator, comparatorOptions, element, name, reference, screenshotOptions }, signal) {
 	const screenshotArgument = {
 		codec,
 		context,
@@ -2372,12 +2472,12 @@ async function getStableScreenshots({ codec, context, comparator, comparatorOpti
 			decodedBaseline = takeDecodedScreenshot(screenshotArgument);
 		}
 		const [image1, image2] = await Promise.all([decodedBaseline, takeDecodedScreenshot(screenshotArgument)]);
-		const comparatorResult = (await comparator(image1, image2, {
+		const isStable = (await comparator(image1, image2, {
 			...comparatorOptions,
 			createDiff: false
 		})).pass;
 		decodedBaseline = image2;
-		if (comparatorResult) {
+		if (isStable) {
 			break;
 		}
 		retries += 1;
@@ -2387,6 +2487,15 @@ async function getStableScreenshots({ codec, context, comparator, comparatorOpti
 		actual: await decodedBaseline
 	};
 }
+/** Writes encoded images to disk, creating parent directories as needed. */
+async function writeScreenshot(path, image) {
+	try {
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile$1(path, image);
+	} catch (cause) {
+		throw new Error("Couldn't write file to fs", { cause });
+	}
+}
 
 var builtinCommands = {
 	readFile,
@@ -2680,223 +2789,209 @@ class ParentBrowserProject {
 	}
 }
 
+//#region src/messages.ts
 const TYPE_REQUEST = "q";
 const TYPE_RESPONSE = "s";
-const DEFAULT_TIMEOUT = 6e4;
-function defaultSerialize(i) {
-  return i;
-}
-const defaultDeserialize = defaultSerialize;
-const { clearTimeout, setTimeout: setTimeout$1 } = globalThis;
-const random = Math.random.bind(Math);
-function createBirpc($functions, options) {
-  const {
-    post,
-    on,
-    off = () => {
-    },
-    eventNames = [],
-    serialize = defaultSerialize,
-    deserialize = defaultDeserialize,
-    resolver,
-    bind = "rpc",
-    timeout = DEFAULT_TIMEOUT
-  } = options;
-  let $closed = false;
-  const _rpcPromiseMap = /* @__PURE__ */ new Map();
-  let _promiseInit;
-  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$1(() => {
-          try {
-            const handleResult = options.onTimeoutError?.(method, args);
-            if (handleResult !== 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(req, handler, resolve);
-      else
-        await handler();
-    } catch (e) {
-      if (options.onGeneralError?.(e) !== true)
-        throw e;
-      return;
-    } finally {
-      clearTimeout(timeoutId);
-      _rpcPromiseMap.delete(id);
-    }
-    return promise;
-  }
-  const $call = (method, ...args) => _call(method, args, false);
-  const $callOptional = (method, ...args) => _call(method, args, false, true);
-  const $callEvent = (method, ...args) => _call(method, args, true);
-  const $callRaw = (options2) => _call(options2.method, options2.args, options2.event, options2.optional);
-  const builtinMethods = {
-    $call,
-    $callOptional,
-    $callEvent,
-    $callRaw,
-    $rejectPendingCalls,
-    get $closed() {
-      return $closed;
-    },
-    $close,
-    $functions
-  };
-  const 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;
-    }
-  });
-  function $close(customError) {
-    $closed = true;
-    _rpcPromiseMap.forEach(({ reject, method }) => {
-      const error = 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 entries = Array.from(_rpcPromiseMap.values());
-    const handlerResults = entries.map(({ method, reject }) => {
-      if (!handler) {
-        return reject(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?.(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(method, $functions[method]) : $functions[method]);
-      if (optional)
-        fn ||= () => void 0;
-      if (!fn) {
-        error = 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.onError)
-          options.onError(error, method, args);
-        if (error && options.onFunctionError) {
-          if (options.onFunctionError(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?.(e, method, args) !== true)
-              throw e;
-          }
-        }
-        try {
-          await post(serialize({ t: TYPE_RESPONSE, i: msg.i, e: error }), ...extra);
-        } catch (e) {
-          if (options.onGeneralError?.(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;
-}
+
+//#endregion
+//#region src/utils.ts
 function createPromiseWithResolvers() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
+	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;
+	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: setTimeout$1 } = 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$1(() => {
+					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;
 }
 
 const debug = createDebugger("vitest:browser:api");
@@ -3246,6 +3341,7 @@ const createBrowserServer = async (options) => {
 	let cacheDir;
 	const vite = await createViteServer({
 		...project.options,
+		define: project.config.viteDefine,
 		base: "/",
 		root: project.config.root,
 		logLevel,