@vitest/browser 5.0.0-beta.7 → 5.0.0-rc.2

package/dist/index.js

@@ -6,7 +6,7 @@ import { distClientRoot } from '@vitest/ui';
 import { slash as slash$1, deepMerge, cleanUrl as cleanUrl$1, toArray } from '@vitest/utils/helpers';
 import sirv from 'sirv';
 import c from 'tinyrainbow';
-import { isFileLoadingAllowed, createDebugger, isValidApiRequest, isCSSRequest, distDir, rolldownVersion, isFileServingAllowed } from 'vitest/node';
+import { isFileLoadingAllowed, createDebugger, isValidApiRequest, BrowserConnectionError, isCSSRequest, distDir, rolldownVersion, isFileServingAllowed } from 'vitest/node';
 import { fileURLToPath } from 'node:url';
 import crypto from 'node:crypto';
 import MagicString from 'magic-string';
@@ -209,7 +209,7 @@ const basename = function(p, extension) {
   return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 };
 
-var version = "5.0.0-beta.7";
+var version = "5.0.0-rc.2";
 
 const pkgRoot = resolve(fileURLToPath(import.meta.url), "../..");
 const distRoot = resolve(pkgRoot, "dist");
@@ -509,11 +509,10 @@ var DOM_KEY_LOCATION = /*#__PURE__*/ function(DOM_KEY_LOCATION) {
     }
 ];
 
-var bracketDict = /*#__PURE__*/ function(bracketDict) {
-    bracketDict["{"] = "}";
-    bracketDict["["] = "]";
-    return bracketDict;
-}(bracketDict || {});
+const bracketDict = {
+    '{': '}',
+    '[': ']'
+};
 /**
  * Read the next key definition from user input
  *
@@ -548,16 +547,16 @@ function readPrintableChar(text, pos, context) {
     };
 }
 function readTag(text, pos, startBracket, context) {
+    var _ref;
     var _text_slice_match, _text_slice_match1;
     const releasePreviousModifier = text[pos] === '/' ? '/' : '';
     pos += releasePreviousModifier.length;
     const escapedDescriptor = startBracket === '{' && text[pos] === '\\';
     pos += Number(escapedDescriptor);
-    const descriptor = escapedDescriptor ? text[pos] : (_text_slice_match = text.slice(pos).match(startBracket === '{' ? /^\w+|^[^}>/]/ : /^\w+/)) === null || _text_slice_match === undefined ? undefined : _text_slice_match[0];
+    const descriptor = escapedDescriptor ? text[pos] : (_text_slice_match = text.slice(pos).match(startBracket === '{' ? /^\w+|^[^}>/]/ : /^\w+/)) === null || _text_slice_match === void 0 ? void 0 : _text_slice_match[0];
     assertDescriptor(descriptor, text, pos);
     pos += descriptor.length;
-    var _text_slice_match_;
-    const repeatModifier = (_text_slice_match_ = (_text_slice_match1 = text.slice(pos).match(/^>\d+/)) === null || _text_slice_match1 === undefined ? undefined : _text_slice_match1[0]) !== null && _text_slice_match_ !== undefined ? _text_slice_match_ : '';
+    const repeatModifier = (_ref = (_text_slice_match1 = text.slice(pos).match(/^>\d+/)) === null || _text_slice_match1 === void 0 ? void 0 : _text_slice_match1[0]) !== null && _ref !== void 0 ? _ref : '';
     pos += repeatModifier.length;
     const releaseSelfModifier = text[pos] === '/' || !repeatModifier && text[pos] === '>' ? text[pos] : '';
     pos += releaseSelfModifier.length;
@@ -593,7 +592,7 @@ function hasReleaseSelf(releaseSelfModifier, repeatModifier) {
     }
 }
 function getErrorMessage(expected, found, text, context) {
-    return `Expected ${expected} but found "${found !== null && found !== undefined ? found : ''}" in "${text}"
+    return `Expected ${expected} but found "${found !== null && found !== void 0 ? found : ''}" in "${text}"
     See ${`https://testing-library.com/docs/user-event/keyboard`}
     for more information about how userEvent parses your input.`;
 }
@@ -610,18 +609,18 @@ function getErrorMessage(expected, found, text, context) {
  */ function parseKeyDef$1(keyboardMap, text) {
     const defs = [];
     do {
-        const { type, descriptor, consumedLength, releasePrevious, releaseSelf = true, repeat } = readNextDescriptor(text);
         var _keyboardMap_find;
+        const { type, descriptor, consumedLength, releasePrevious, releaseSelf = true, repeat } = readNextDescriptor(text);
         const keyDef = (_keyboardMap_find = keyboardMap.find((def)=>{
             if (type === '[') {
                 var _def_code;
-                return ((_def_code = def.code) === null || _def_code === undefined ? undefined : _def_code.toLowerCase()) === descriptor.toLowerCase();
+                return ((_def_code = def.code) === null || _def_code === void 0 ? void 0 : _def_code.toLowerCase()) === descriptor.toLowerCase();
             } else if (type === '{') {
                 var _def_key;
-                return ((_def_key = def.key) === null || _def_key === undefined ? undefined : _def_key.toLowerCase()) === descriptor.toLowerCase();
+                return ((_def_key = def.key) === null || _def_key === void 0 ? void 0 : _def_key.toLowerCase()) === descriptor.toLowerCase();
             }
             return def.key === descriptor;
-        })) !== null && _keyboardMap_find !== undefined ? _keyboardMap_find : {
+        })) !== null && _keyboardMap_find !== void 0 ? _keyboardMap_find : {
             key: 'Unknown',
             code: 'Unknown',
             [type === '[' ? 'code' : 'key']: descriptor
@@ -968,6 +967,7 @@ var BrowserPlugin = (contribution) => {
 		BrowserContext(contribution),
 		dynamicImportPlugin({
 			globalThisAccessor: "\"__vitest_browser_runner__\"",
+			// injected only into the `client` environment via the browser contribution
 			filter(id) {
 				if (id.includes(distRoot)) {
 					return false;
@@ -1025,6 +1025,8 @@ function cleanUrl(url) {
 }
 
 class BrowserServerCDPHandler {
+	session;
+	tester;
 	listenerIds = {};
 	listeners = {};
 	constructor(session, tester) {
@@ -1668,6 +1670,7 @@ function getComparator(comparator, context) {
 
 const defaultOptions = {
 	comparatorName: "pixelmatch",
+	// these are handled by each comparator on its own
 	comparatorOptions: {},
 	screenshotOptions: {
 		animations: "disabled",
@@ -1722,6 +1725,7 @@ function resolveOptions({ context, name, options, testName }) {
 		resolvedOptions,
 		paths: {
 			reference: resolvedOptions.resolveScreenshotPath(resolvePathData),
+			// lazily initialize this, as it might not be needed at all
 			get diffs() {
 				const diffs = {
 					reference: resolvedOptions.resolveDiffPath({
@@ -1967,6 +1971,7 @@ async function determineOutcome({ comparator, comparatorOptions, paths, referenc
 		diff: comparisonResult.diff && {
 			image: {
 				data: comparisonResult.diff,
+				// `comparator` only returns pixel data; diff dimensions always match reference
 				metadata: reference.metadata
 			},
 			path: paths.diffs.diff
@@ -2202,6 +2207,7 @@ var builtinCommands = {
 	readFile,
 	removeFile,
 	writeFile,
+	// private commands
 	__vitest_markTrace: _markTrace,
 	__vitest_groupTraceStart: _groupTraceStart,
 	__vitest_groupTraceEnd: _groupTraceEnd,
@@ -2217,6 +2223,9 @@ class BrowserServerState {
 }
 
 class ProjectBrowser {
+	parent;
+	project;
+	base;
 	testerHtml;
 	testerFilepath;
 	// the tester template is read once per server, so the transformed HTML
@@ -2304,6 +2313,7 @@ function wrapConfig(config) {
 }
 
 class ParentBrowserProject {
+	base;
 	orchestratorScripts;
 	faviconUrl;
 	prefixOrchestratorUrl;
@@ -2486,11 +2496,348 @@ class ParentBrowserProject {
 	}
 }
 
-//#region src/messages.ts
-const TYPE_REQUEST = "q";
-const TYPE_RESPONSE = "s";
+function _mergeNamespaces$1(n, m) {
+	m.forEach(function(e) {
+		e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
+			if (k !== "default" && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function() {
+						return e[k];
+					}
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
+function getDefaultExportFromCjs(x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var reactIs$1 = { exports: {} };
+var reactIs_production = {};
+/**
+* @license React
+* react-is.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var hasRequiredReactIs_production;
+function requireReactIs_production() {
+	if (hasRequiredReactIs_production) return reactIs_production;
+	hasRequiredReactIs_production = 1;
+	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+	function typeOf(object) {
+		if ("object" === typeof object && null !== object) {
+			var $$typeof = object.$$typeof;
+			switch ($$typeof) {
+				case REACT_ELEMENT_TYPE: switch (object = object.type, object) {
+					case REACT_FRAGMENT_TYPE:
+					case REACT_PROFILER_TYPE:
+					case REACT_STRICT_MODE_TYPE:
+					case REACT_SUSPENSE_TYPE:
+					case REACT_SUSPENSE_LIST_TYPE:
+					case REACT_VIEW_TRANSITION_TYPE: return object;
+					default: switch (object = object && object.$$typeof, object) {
+						case REACT_CONTEXT_TYPE:
+						case REACT_FORWARD_REF_TYPE:
+						case REACT_LAZY_TYPE:
+						case REACT_MEMO_TYPE: return object;
+						case REACT_CONSUMER_TYPE: return object;
+						default: return $$typeof;
+					}
+				}
+				case REACT_PORTAL_TYPE: return $$typeof;
+			}
+		}
+	}
+	reactIs_production.ContextConsumer = REACT_CONSUMER_TYPE;
+	reactIs_production.ContextProvider = REACT_CONTEXT_TYPE;
+	reactIs_production.Element = REACT_ELEMENT_TYPE;
+	reactIs_production.ForwardRef = REACT_FORWARD_REF_TYPE;
+	reactIs_production.Fragment = REACT_FRAGMENT_TYPE;
+	reactIs_production.Lazy = REACT_LAZY_TYPE;
+	reactIs_production.Memo = REACT_MEMO_TYPE;
+	reactIs_production.Portal = REACT_PORTAL_TYPE;
+	reactIs_production.Profiler = REACT_PROFILER_TYPE;
+	reactIs_production.StrictMode = REACT_STRICT_MODE_TYPE;
+	reactIs_production.Suspense = REACT_SUSPENSE_TYPE;
+	reactIs_production.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+	reactIs_production.isContextConsumer = function(object) {
+		return typeOf(object) === REACT_CONSUMER_TYPE;
+	};
+	reactIs_production.isContextProvider = function(object) {
+		return typeOf(object) === REACT_CONTEXT_TYPE;
+	};
+	reactIs_production.isElement = function(object) {
+		return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+	};
+	reactIs_production.isForwardRef = function(object) {
+		return typeOf(object) === REACT_FORWARD_REF_TYPE;
+	};
+	reactIs_production.isFragment = function(object) {
+		return typeOf(object) === REACT_FRAGMENT_TYPE;
+	};
+	reactIs_production.isLazy = function(object) {
+		return typeOf(object) === REACT_LAZY_TYPE;
+	};
+	reactIs_production.isMemo = function(object) {
+		return typeOf(object) === REACT_MEMO_TYPE;
+	};
+	reactIs_production.isPortal = function(object) {
+		return typeOf(object) === REACT_PORTAL_TYPE;
+	};
+	reactIs_production.isProfiler = function(object) {
+		return typeOf(object) === REACT_PROFILER_TYPE;
+	};
+	reactIs_production.isStrictMode = function(object) {
+		return typeOf(object) === REACT_STRICT_MODE_TYPE;
+	};
+	reactIs_production.isSuspense = function(object) {
+		return typeOf(object) === REACT_SUSPENSE_TYPE;
+	};
+	reactIs_production.isSuspenseList = function(object) {
+		return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+	};
+	reactIs_production.isValidElementType = function(type) {
+		return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
+	};
+	reactIs_production.typeOf = typeOf;
+	return reactIs_production;
+}
+var hasRequiredReactIs$1;
+function requireReactIs$1() {
+	if (hasRequiredReactIs$1) return reactIs$1.exports;
+	hasRequiredReactIs$1 = 1;
+	{
+		reactIs$1.exports = requireReactIs_production();
+	}
+	return reactIs$1.exports;
+}
+var reactIsExports$1 = requireReactIs$1();
+var index$1 = /*@__PURE__*/ getDefaultExportFromCjs(reactIsExports$1);
+var ReactIs19 = /*#__PURE__*/ _mergeNamespaces$1({
+	__proto__: null,
+	default: index$1
+}, [reactIsExports$1]);
+var reactIs = { exports: {} };
+var reactIs_production_min = {};
+/**
+* @license React
+* react-is.production.min.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var hasRequiredReactIs_production_min;
+function requireReactIs_production_min() {
+	if (hasRequiredReactIs_production_min) return reactIs_production_min;
+	hasRequiredReactIs_production_min = 1;
+	var b = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u;
+	u = Symbol.for("react.module.reference");
+	function v(a) {
+		if ("object" === typeof a && null !== a) {
+			var r = a.$$typeof;
+			switch (r) {
+				case b: switch (a = a.type, a) {
+					case d:
+					case f:
+					case e:
+					case m:
+					case n: return a;
+					default: switch (a = a && a.$$typeof, a) {
+						case k:
+						case h:
+						case l:
+						case q:
+						case p:
+						case g: return a;
+						default: return r;
+					}
+				}
+				case c: return r;
+			}
+		}
+	}
+	reactIs_production_min.ContextConsumer = h;
+	reactIs_production_min.ContextProvider = g;
+	reactIs_production_min.Element = b;
+	reactIs_production_min.ForwardRef = l;
+	reactIs_production_min.Fragment = d;
+	reactIs_production_min.Lazy = q;
+	reactIs_production_min.Memo = p;
+	reactIs_production_min.Portal = c;
+	reactIs_production_min.Profiler = f;
+	reactIs_production_min.StrictMode = e;
+	reactIs_production_min.Suspense = m;
+	reactIs_production_min.SuspenseList = n;
+	reactIs_production_min.isAsyncMode = function() {
+		return false;
+	};
+	reactIs_production_min.isConcurrentMode = function() {
+		return false;
+	};
+	reactIs_production_min.isContextConsumer = function(a) {
+		return v(a) === h;
+	};
+	reactIs_production_min.isContextProvider = function(a) {
+		return v(a) === g;
+	};
+	reactIs_production_min.isElement = function(a) {
+		return "object" === typeof a && null !== a && a.$$typeof === b;
+	};
+	reactIs_production_min.isForwardRef = function(a) {
+		return v(a) === l;
+	};
+	reactIs_production_min.isFragment = function(a) {
+		return v(a) === d;
+	};
+	reactIs_production_min.isLazy = function(a) {
+		return v(a) === q;
+	};
+	reactIs_production_min.isMemo = function(a) {
+		return v(a) === p;
+	};
+	reactIs_production_min.isPortal = function(a) {
+		return v(a) === c;
+	};
+	reactIs_production_min.isProfiler = function(a) {
+		return v(a) === f;
+	};
+	reactIs_production_min.isStrictMode = function(a) {
+		return v(a) === e;
+	};
+	reactIs_production_min.isSuspense = function(a) {
+		return v(a) === m;
+	};
+	reactIs_production_min.isSuspenseList = function(a) {
+		return v(a) === n;
+	};
+	reactIs_production_min.isValidElementType = function(a) {
+		return "string" === typeof a || "function" === typeof a || a === d || a === f || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? true : false;
+	};
+	reactIs_production_min.typeOf = v;
+	return reactIs_production_min;
+}
+var hasRequiredReactIs;
+function requireReactIs() {
+	if (hasRequiredReactIs) return reactIs.exports;
+	hasRequiredReactIs = 1;
+	{
+		reactIs.exports = requireReactIs_production_min();
+	}
+	return reactIs.exports;
+}
+var reactIsExports = requireReactIs();
+var index = /*@__PURE__*/ getDefaultExportFromCjs(reactIsExports);
+var ReactIs18 = /*#__PURE__*/ _mergeNamespaces$1({
+	__proto__: null,
+	default: index
+}, [reactIsExports]);
+const reactIsMethods = [
+	"isAsyncMode",
+	"isConcurrentMode",
+	"isContextConsumer",
+	"isContextProvider",
+	"isElement",
+	"isForwardRef",
+	"isFragment",
+	"isLazy",
+	"isMemo",
+	"isPortal",
+	"isProfiler",
+	"isStrictMode",
+	"isSuspense",
+	"isSuspenseList",
+	"isValidElementType"
+];
+Object.fromEntries(reactIsMethods.map((m) => [m, (v) => ReactIs18[m](v) || ReactIs19[m](v)]));
+
+var naturalCompare = {exports: {}};
+
+var hasRequiredNaturalCompare;
+
+function requireNaturalCompare () {
+	if (hasRequiredNaturalCompare) return naturalCompare.exports;
+	hasRequiredNaturalCompare = 1;
+	/*
+	 * @version    1.4.0
+	 * @date       2015-10-26
+	 * @stability  3 - Stable
+	 * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
+	 * @license    MIT License
+	 */
+
+
+	var naturalCompare$1 = function(a, b) {
+		var i, codeA
+		, codeB = 1
+		, posA = 0
+		, posB = 0
+		, alphabet = String.alphabet;
+
+		function getCode(str, pos, code) {
+			if (code) {
+				for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
+				return +str.slice(pos - 1, i)
+			}
+			code = alphabet && alphabet.indexOf(str.charAt(pos));
+			return code > -1 ? code + 76 : ((code = str.charCodeAt(pos) || 0), code < 45 || code > 127) ? code
+				: code < 46 ? 65               // -
+				: code < 48 ? code - 1
+				: code < 58 ? code + 18        // 0-9
+				: code < 65 ? code - 11
+				: code < 91 ? code + 11        // A-Z
+				: code < 97 ? code - 37
+				: code < 123 ? code + 5        // a-z
+				: code - 63
+		}
+
+
+		if ((a+="") != (b+="")) for (;codeB;) {
+			codeA = getCode(a, posA++);
+			codeB = getCode(b, posB++);
+
+			if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+				codeA = getCode(a, posA, posA);
+				codeB = getCode(b, posB, posA = i);
+				posB = i;
+			}
+
+			if (codeA != codeB) return (codeA < codeB) ? -1 : 1
+		}
+		return 0
+	};
+
+	try {
+		naturalCompare.exports = naturalCompare$1;
+	} catch (e) {
+		String.naturalCompare = naturalCompare$1;
+	}
+	return naturalCompare.exports;
+}
+
+requireNaturalCompare();
+
+// Evaluate a snapshot file's content into its snapshot key/value pairs.
+function evaluateSnapshotFile(filepath, content) {
+	const data = Object.create(null);
+	try {
+		// eslint-disable-next-line no-new-func
+		const populate = new Function("exports", content);
+		populate(data);
+	} catch (cause) {
+		throw new Error(`Invalid snapshot file, please manually fix or delete it: ${filepath}`, { cause });
+	}
+	return data;
+}
 
-//#endregion
 //#region src/utils.ts
 function createPromiseWithResolvers() {
 	let resolve;
@@ -2513,7 +2860,6 @@ function nanoid(size = 21) {
 	return id;
 }
 
-//#endregion
 //#region src/main.ts
 const DEFAULT_TIMEOUT = 6e4;
 const defaultSerialize = (i) => i;
@@ -2530,7 +2876,7 @@ function createBirpc($functions, options) {
 		const req = {
 			m: method,
 			a: args,
-			t: TYPE_REQUEST
+			t: "q"
 		};
 		if (optional) req.o = true;
 		const send = async (_req) => post(serialize(_req));
@@ -2584,7 +2930,7 @@ function createBirpc($functions, options) {
 		$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),
+		$callRaw: (options) => _call(options.method, options.args, options.event, options.optional),
 		$rejectPendingCalls,
 		get $closed() {
 			return $closed;
@@ -2596,7 +2942,7 @@ function createBirpc($functions, options) {
 		$functions
 	};
 	if (proxify) rpc = new Proxy({}, { get(_, method) {
-		if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+		if (Object.hasOwn(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)) {
@@ -2640,7 +2986,7 @@ function createBirpc($functions, options) {
 			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
 			return;
 		}
-		if (msg.t === TYPE_REQUEST) {
+		if (msg.t === "q") {
 			const { m: method, a: args, o: optional } = msg;
 			let result, error;
 			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
@@ -2657,7 +3003,7 @@ function createBirpc($functions, options) {
 				}
 				if (!error) try {
 					await post(serialize({
-						t: TYPE_RESPONSE,
+						t: "s",
 						i: msg.i,
 						r: result
 					}), ...extra);
@@ -2668,7 +3014,7 @@ function createBirpc($functions, options) {
 				}
 				try {
 					await post(serialize({
-						t: TYPE_RESPONSE,
+						t: "s",
 						i: msg.i,
 						e: error
 					}), ...extra);
@@ -2693,6 +3039,24 @@ function createBirpc($functions, options) {
 
 const debug = createDebugger("vitest:browser:api");
 const BROWSER_API_PATH = "/__vitest_browser_api__";
+const DEFAULT_HEARTBEAT_INTERVAL = 15e3;
+const HEARTBEAT_MAX_MISSED = 2;
+let warnedInvalidHeartbeatInterval = false;
+function resolveHeartbeatInterval(vitest) {
+	const rawInterval = process.env.VITEST_BROWSER_HEARTBEAT_INTERVAL;
+	if (!rawInterval) {
+		return DEFAULT_HEARTBEAT_INTERVAL;
+	}
+	const interval = Number(rawInterval);
+	if (Number.isNaN(interval)) {
+		if (!warnedInvalidHeartbeatInterval) {
+			warnedInvalidHeartbeatInterval = true;
+			vitest.logger.warn(`VITEST_BROWSER_HEARTBEAT_INTERVAL is expected to be a number, received "${rawInterval}". Using the default interval of ${DEFAULT_HEARTBEAT_INTERVAL}ms instead.`);
+		}
+		return DEFAULT_HEARTBEAT_INTERVAL;
+	}
+	return interval;
+}
 function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 	const vite = globalServer.vite;
 	const vitest = globalServer.vitest;
@@ -2741,8 +3105,31 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 			const clients = type === "tester" ? state.testers : state.orchestrators;
 			clients.set(rpcId, rpc);
 			debug?.("[%s] Browser API connected to %s", rpcId, type);
+			// if the browser stops answering pings, terminate the socket so the
+			// "close" handler below rejects pending calls (like `createTesters`)
+			// instead of the run hanging forever; timeouts that live in the browser
+			// (`testTimeout`, iframe ack) cannot fire once its process is frozen
+			const heartbeatInterval = resolveHeartbeatInterval(vitest);
+			let missedPongs = 0;
+			ws.on("pong", () => {
+				missedPongs = 0;
+			});
+			const heartbeat = heartbeatInterval > 0 ? setInterval(() => {
+				if (ws.readyState !== ws.OPEN) {
+					return;
+				}
+				if (missedPongs >= HEARTBEAT_MAX_MISSED) {
+					debug?.("[%s] %s did not respond to %s heartbeat pings, terminating the connection", rpcId, type, missedPongs);
+					rpc.$close(new Error(`[vitest] The browser ${type} did not respond to a heartbeat ping for ${missedPongs * heartbeatInterval}ms. The browser process might be frozen or killed. Closing the connection.`));
+					ws.terminate();
+					return;
+				}
+				missedPongs++;
+				ws.ping();
+			}, heartbeatInterval).unref() : undefined;
 			ws.on("close", () => {
 				debug?.("[%s] Browser API disconnected from %s", rpcId, type);
+				clearInterval(heartbeat);
 				offCancel();
 				clients.delete(rpcId);
 				globalServer.removeCDPHandler(rpcId);
@@ -2750,7 +3137,7 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 					sessions.destroySession(sessionId);
 				}
 				// this will reject any hanging methods if there are any
-				rpc.$close(new Error(`[vitest] Browser connection was closed while running tests. Was the page closed unexpectedly?`));
+				rpc.$close(new BrowserConnectionError(`[vitest] Browser connection was closed while running tests. Was the page closed unexpectedly?`));
 			});
 		});
 	});
@@ -2767,8 +3154,11 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 	function canWrite(project) {
 		return project.config.api.allowWrite && project.vitest.config.api.allowWrite;
 	}
+	function canExec(project) {
+		return project.config.api.allowExec && project.vitest.config.api.allowExec;
+	}
 	function isCdpAllowed(project) {
-		return project.config.api.allowExec && project.vitest.config.api.allowExec && project.config.api.allowWrite && project.vitest.config.api.allowWrite;
+		return canExec(project) && canWrite(project);
 	}
 	function assertCdpAllowed(project) {
 		if (!isCdpAllowed(project)) {
@@ -2877,6 +3267,17 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 				}
 				return promises.readFile(snapshotPath, "utf-8");
 			},
+			async readSnapshotFileData(snapshotPath) {
+				checkFileAccess(snapshotPath);
+				if (!existsSync(snapshotPath)) {
+					return null;
+				}
+				if (!canExec(project)) {
+					throw new Error(`Cannot read snapshot file because browser API exec operations are disabled. See https://vitest.dev/config/api.`);
+				}
+				const content = await promises.readFile(snapshotPath, "utf-8");
+				return evaluateSnapshotFile(snapshotPath, content);
+			},
 			async saveSnapshotFile(id, content) {
 				checkFileAccess(id);
 				if (!canWrite(project)) {
@@ -2983,6 +3384,7 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 						if (module.type === "redirect") {
 							const redirectUrl = new URL(module.redirect);
 							module.redirect = join(vite.config.root, redirectUrl.pathname);
+							checkFileAccess(module.redirect);
 						}
 						defaultMockerRegistry.register(module);
 					}
@@ -3014,6 +3416,7 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 				}
 				return mocker.delete(sessionId, id);
 			},
+			// CDP
 			async sendCdpEvent(sessionId, event, payload) {
 				assertCdpAllowed(project);
 				const cdp = await globalServer.ensureCDPHandler(sessionId, rpcId);
@@ -3071,6 +3474,17 @@ function defineBrowserCommand(fn) {
 	return fn;
 }
 const versionRegexp = /(?:\?|&)v=\w{8}/;
+// pin a Cache-Control value and stop Vite's later middleware from overriding it
+function pinCacheControl(res, value) {
+	res.setHeader("Cache-Control", value);
+	const setHeader = res.setHeader.bind(res);
+	res.setHeader = function(name, ...args) {
+		if (name === "Cache-Control") {
+			return res;
+		}
+		return setHeader(name, ...args);
+	};
+}
 /**
 * The browser provider's `serverFactory`. Returns a `BrowserServerContribution`
 * that Vitest core uses to build the SINGLE Vite server shared by `project.vite`
@@ -3218,21 +3632,24 @@ body {
 					}
 				}));
 			}
+			// vitest's own dist files only change with the vitest version and
+			// browser contexts don't outlive the process, so there is no reason
+			// to revalidate them in every tester iframe. Skipped for persistent
+			// contexts and preview providers — their disk cache would survive a vitest upgrade
+			const persistentContext = (parentServer.config.browser.provider?.options)?.persistentContext;
+			const immutablePrefixes = persistentContext || parentServer.config.browser.provider?.name === "preview" ? [] : [
+				"/__vitest_browser__/",
+				`/@fs${distDir}`,
+				`/@fs${distRoot}`
+			];
 			server.middlewares.use((req, res, next) => {
-				// 9000 mega head move
-				// Vite always caches optimized dependencies, but users might mock
-				// them in _some_ tests, while keeping original modules in others
-				// there is no way to configure that in Vite, so we patch it here
-				// to always ignore the cache-control set by Vite in the next middleware
-				if (req.url && versionRegexp.test(req.url) && !req.url.includes("chunk-")) {
-					res.setHeader("Cache-Control", "no-cache");
-					const setHeader = res.setHeader.bind(res);
-					res.setHeader = function(name, value) {
-						if (name === "Cache-Control") {
-							return res;
-						}
-						return setHeader(name, value);
-					};
+				const url = req.url;
+				if (url) {
+					if (immutablePrefixes.some((prefix) => url.startsWith(prefix))) {
+						pinCacheControl(res, "public,max-age=31536000,immutable");
+					} else if (versionRegexp.test(url) && !url.includes("chunk-")) {
+						pinCacheControl(res, "no-cache");
+					}
 				}
 				next();
 			});
@@ -3268,6 +3685,9 @@ body {
 				server.middlewares.use("/__vitest__", sirv(distClientRoot));
 			}
 		},
+		// Resolution-time config: only what is derivable from the (partial) user
+		// config. The mocks / coverage / meta-env plugins come from the shared
+		// workspace plugin set, not from here.
 		async config(viteConfig) {
 			const testConfig = viteConfig.test || {};
 			const config = {
@@ -3279,6 +3699,9 @@ body {
 					fs: { allow: [distRoot] },
 					middlewareMode: false,
 					watch: null,
+					// Vitest forwards browser console logs and unhandled errors through its
+					// own RPC, so Vite's client forwarding (defaults on under agents) would
+					// double-report them and leak into stderr.
 					forwardConsole: false
 				}
 			};
@@ -3314,7 +3737,10 @@ body {
 	};
 	contribution.plugins = [
 		...BrowserPlugin(contribution),
-		interceptorPlugin({ registry: mockerRegistry }),
+		interceptorPlugin({
+			registry: mockerRegistry,
+			registerWebSocketEvents: false
+		}),
 		{
 			name: "vitest:browser:framework-sourcemaps",
 			enforce: "post",
@@ -3389,13 +3815,13 @@ function resolveBrowserOptimizeDeps(projectConfigs, testFiles, harness) {
 	// - vitest/browser, @vitest/browser/context, @vitest/browser/utils are
 	//   VIRTUAL modules generated per-server (see pluginContext.ts) — optimizer
 	//   cannot resolve/run their `load`, it would freeze stale/empty content.
-	// - vite/module-runner is small enough to not need pre-bundling.
 	// - msw is a large, side-effectful service-worker library.
 	const exclude = [
 		"vitest/browser",
-		"vite/module-runner",
 		"@vitest/browser/utils",
 		"@vitest/browser/context",
+		"@vitest/browser/locators",
+		"@vitest/browser/client",
 		"msw",
 		"msw/browser"
 	];
@@ -3422,19 +3848,20 @@ function resolveBrowserOptimizeDeps(projectConfigs, testFiles, harness) {
 	}
 	// Pre-bundle the vitest runtime so the browser fetches a few optimized
 	// chunks instead of ~20 separately-served dist chunks (faster startup).
-	// `vitest`, `vitest/internal/browser` and `@vitest/browser/client` are
-	// optimized together in a single pass, so esbuild dedupes their shared
-	// stateful chunks (the test collector, the runner, the RPC client) to a
-	// single instance — preserving module identity between the test files'
-	// `import 'vitest'` and the tester. Their transitive deps (@vitest/utils,
-	// @vitest/spy, pathe, tinyrainbow, …) are inlined into these bundles.
+	// `vitest` and `vitest/internal/browser` are optimized together in a single
+	// pass, so esbuild dedupes their shared stateful chunks (the test collector,
+	// the runner) to a single instance, preserving module identity between the
+	// test files' `import 'vitest'` and the tester. Their transitive deps
+	// (@vitest/utils, @vitest/spy, pathe, tinyrainbow, …) are inlined into
+	// these bundles.
 	const include = [
 		"vitest > expect-type",
 		"vitest > magic-string",
 		"vitest > chai",
+		"vitest > vite/module-runner",
 		"vitest",
 		"vitest/internal/browser",
-		"@vitest/browser/client"
+		"vitest/internal/traces"
 	];
 	const provider = testConfig.browser?.provider;
 	if (provider?.name === "preview") {