@vitest/browser 4.0.0-beta.3 → 4.0.0-beta.4

package/dist/index.js

@@ -1,25 +1,28 @@
 import { ManualMockedModule, RedirectedModule, AutomockedModule, AutospiedModule, MockerRegistry } from '@vitest/mocker';
 import { dynamicImportPlugin, ServerMockResolver, interceptorPlugin } from '@vitest/mocker/node';
 import c from 'tinyrainbow';
-import { distDir, resolveApiServerConfig, resolveFsAllow, isFileServingAllowed, createDebugger, isValidApiRequest, createViteLogger, createViteServer } from 'vitest/node';
-import fs, { readFileSync, lstatSync, promises, existsSync } from 'node:fs';
+import { isValidApiRequest, isFileServingAllowed, distDir, resolveApiServerConfig, resolveFsAllow, createDebugger, createViteLogger, createViteServer } from 'vitest/node';
+import fs, { readFileSync, lstatSync, createReadStream, promises, existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { slash as slash$1, toArray, createDefer } from '@vitest/utils';
+import { slash as slash$1, toArray, deepMerge, createDefer } from '@vitest/utils';
 import MagicString from 'magic-string';
 import sirv from 'sirv';
 import * as vite from 'vite';
 import { coverageConfigDefaults } from 'vitest/config';
 import { fileURLToPath } from 'node:url';
 import crypto from 'node:crypto';
-import { mkdir, rm, readFile as readFile$1 } from 'node:fs/promises';
+import { mkdir, rm, readFile as readFile$1, writeFile as writeFile$1 } from 'node:fs/promises';
 import { parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
-import { P as PlaywrightBrowserProvider, W as WebdriverBrowserProvider } from './webdriver-KA1WiV0q.js';
+import { P as PlaywrightBrowserProvider, W as WebdriverBrowserProvider } from './webdriver-AHRa6U3j.js';
 import { resolve as resolve$1, basename as basename$1, dirname as dirname$1, normalize as normalize$1 } from 'node:path';
-import { WebSocketServer } from 'ws';
 import * as nodeos from 'node:os';
+import { platform } from 'node:os';
+import { PNG } from 'pngjs';
+import pm from 'pixelmatch';
+import { WebSocketServer } from 'ws';
 import { performance } from 'node:perf_hooks';
 
-var version = "4.0.0-beta.3";
+var version = "4.0.0-beta.4";
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -671,6 +674,31 @@ var BrowserPlugin = (parentServer, base = "/") => {
 					}
 					next();
 				});
+				// handle attachments the same way as in packages/ui/node/index.ts
+				server.middlewares.use((req, res, next) => {
+					if (!req.url) {
+						return next();
+					}
+					const url = new URL(req.url, "http://localhost");
+					if (url.pathname !== "/__vitest_attachment__") {
+						return next();
+					}
+					const path = url.searchParams.get("path");
+					const contentType = url.searchParams.get("contentType");
+					if (!isValidApiRequest(parentServer.config, req) || !contentType || !path) {
+						return next();
+					}
+					const fsPath = decodeURIComponent(path);
+					if (!isFileServingAllowed(parentServer.vite.config, fsPath)) {
+						return next();
+					}
+					try {
+						res.setHeader("content-type", contentType);
+						return createReadStream(fsPath).pipe(res).on("close", () => res.end());
+					} catch (err) {
+						return next(err);
+					}
+				});
 			}
 		},
 		{
@@ -834,7 +862,7 @@ var BrowserPlugin = (parentServer, base = "/") => {
 					viteConfig.esbuild ||= {};
 					viteConfig.esbuild.legalComments = "inline";
 				}
-				const defaultPort = parentServer.vitest._browserLastPort++;
+				const defaultPort = parentServer.vitest.state._data.browserLastPort++;
 				const api = resolveApiServerConfig(viteConfig.test?.browser || {}, defaultPort);
 				viteConfig.server = {
 					...viteConfig.server,
@@ -2352,14 +2380,26 @@ function selectAll() {
 }
 
 const screenshot = async (context, name, options = {}) => {
-	if (!context.testPath) {
-		throw new Error(`Cannot take a screenshot without a test path`);
-	}
 	options.save ??= true;
 	if (!options.save) {
 		options.base64 = true;
 	}
-	const path = options.path ? resolve(dirname(context.testPath), options.path) : resolveScreenshotPath(context.testPath, name, context.project.config);
+	const { buffer, path } = await takeScreenshot(context, name, options);
+	return returnResult(options, path, buffer);
+};
+/**
+* Takes a screenshot using the provided browser context and returns a buffer and the expected screenshot path.
+*
+* **Note**: the returned `path` indicates where the screenshot *might* be found.
+* It is not guaranteed to exist, especially if `options.save` is `false`.
+*
+* @throws {Error} If the function is not called within a test or if the browser provider does not support screenshots.
+*/
+async function takeScreenshot(context, name, options) {
+	if (!context.testPath) {
+		throw new Error(`Cannot take a screenshot without a test path`);
+	}
+	const path = resolveScreenshotPath(context.testPath, name, context.project.config, options.path);
 	const savePath = normalize$1(path);
 	await mkdir(dirname(path), { recursive: true });
 	if (context.provider instanceof PlaywrightBrowserProvider) {
@@ -2370,26 +2410,40 @@ const screenshot = async (context, name, options = {}) => {
 				...config,
 				path: options.save ? savePath : undefined
 			});
-			return returnResult(options, path, buffer);
+			return {
+				buffer,
+				path
+			};
 		}
 		const buffer = await context.iframe.locator("body").screenshot({
 			...options,
 			path: options.save ? savePath : undefined
 		});
-		return returnResult(options, path, buffer);
+		return {
+			buffer,
+			path
+		};
 	}
 	if (context.provider instanceof WebdriverBrowserProvider) {
 		const page = context.provider.browser;
 		const element = !options.element ? await page.$("body") : await page.$(`${options.element}`);
-		const buffer = await element.saveScreenshot(savePath);
+		// webdriverio expects the path to contain the extension and only works with PNG files
+		const savePathWithExtension = savePath.endsWith(".png") ? savePath : `${savePath}.png`;
+		const buffer = await element.saveScreenshot(savePathWithExtension);
 		if (!options.save) {
-			await rm(savePath, { force: true });
+			await rm(savePathWithExtension, { force: true });
 		}
-		return returnResult(options, path, buffer);
+		return {
+			buffer,
+			path
+		};
 	}
 	throw new Error(`Provider "${context.provider.name}" does not support screenshots`);
-};
-function resolveScreenshotPath(testPath, name, config) {
+}
+function resolveScreenshotPath(testPath, name, config, customPath) {
+	if (customPath) {
+		return resolve(dirname(testPath), customPath);
+	}
 	const dir = dirname(testPath);
 	const base = basename(testPath);
 	if (config.browser.screenshotDirectory) {
@@ -2410,6 +2464,401 @@ function returnResult(options, path, buffer) {
 	return path;
 }
 
+const codec = {
+	decode: (buffer, options) => {
+		const { data, alpha, bpp, color, colorType, depth, height, interlace, palette, width } = PNG.sync.read(Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer), options);
+		return {
+			metadata: {
+				alpha,
+				bpp,
+				color,
+				colorType,
+				depth,
+				height,
+				interlace,
+				palette,
+				width
+			},
+			data
+		};
+	},
+	encode: ({ data, metadata: { height, width } }, options) => {
+		const png = new PNG({
+			height,
+			width
+		});
+		png.data = Buffer.isBuffer(data) ? data : Buffer.from(data);
+		return PNG.sync.write(png, options);
+	}
+};
+
+function getCodec(type) {
+	switch (type) {
+		case "png": return codec;
+		default: throw new Error(`No codec found for type ${type}`);
+	}
+}
+
+const defaultOptions$1 = {
+	allowedMismatchedPixelRatio: undefined,
+	allowedMismatchedPixels: undefined,
+	threshold: .1,
+	includeAA: false,
+	alpha: .1,
+	aaColor: [
+		255,
+		255,
+		0
+	],
+	diffColor: [
+		255,
+		0,
+		0
+	],
+	diffColorAlt: undefined,
+	diffMask: false
+};
+const pixelmatch = (reference, actual, { createDiff,...options }) => {
+	if (reference.metadata.height !== actual.metadata.height || reference.metadata.width !== actual.metadata.width) {
+		return {
+			pass: false,
+			diff: null,
+			message: `Expected image dimensions to be ${reference.metadata.width}×${reference.metadata.height}px, but received ${actual.metadata.width}×${actual.metadata.height}px.`
+		};
+	}
+	const optionsWithDefaults = {
+		...defaultOptions$1,
+		...options
+	};
+	const diffBuffer = createDiff ? new Uint8Array(reference.data.length) : undefined;
+	const mismatchedPixels = pm(reference.data, actual.data, diffBuffer, reference.metadata.width, reference.metadata.height, optionsWithDefaults);
+	const imageArea = reference.metadata.width * reference.metadata.height;
+	let allowedMismatchedPixels = Math.min(optionsWithDefaults.allowedMismatchedPixels ?? Number.POSITIVE_INFINITY, (optionsWithDefaults.allowedMismatchedPixelRatio ?? Number.POSITIVE_INFINITY) * imageArea);
+	if (allowedMismatchedPixels === Number.POSITIVE_INFINITY) {
+		allowedMismatchedPixels = 0;
+	}
+	const pass = mismatchedPixels <= allowedMismatchedPixels;
+	return {
+		pass,
+		diff: diffBuffer ?? null,
+		message: pass ? null : `${mismatchedPixels} pixels (ratio ${(Math.ceil(mismatchedPixels / imageArea * 100) / 100).toFixed(2)}) differ.`
+	};
+};
+
+const comparators = new Map(Object.entries({ pixelmatch }));
+function getComparator(comparator) {
+	if (comparators.has(comparator)) {
+		return comparators.get(comparator);
+	}
+	throw new Error(`Unrecognized comparator ${comparator}`);
+}
+
+const defaultOptions = {
+	comparatorName: "pixelmatch",
+	comparatorOptions: {},
+	screenshotOptions: {
+		animations: "disabled",
+		caret: "hide",
+		fullPage: false,
+		maskColor: "#ff00ff",
+		omitBackground: false,
+		scale: "device"
+	},
+	timeout: 5e3,
+	resolveDiffPath: ({ arg, ext, root, attachmentsDir, browserName, platform, testFileDirectory, testFileName }) => resolve(root, attachmentsDir, testFileDirectory, testFileName, `${arg}-${browserName}-${platform}${ext}`),
+	resolveScreenshotPath: ({ arg, ext, root, screenshotDirectory, testFileDirectory, testFileName, browserName }) => resolve(root, testFileDirectory, screenshotDirectory, testFileName, `${arg}-${browserName}-${platform}${ext}`)
+};
+const supportedExtensions = ["png"];
+function resolveOptions({ context, name, options, testName }) {
+	if (context.testPath === undefined) {
+		throw new Error("`resolveOptions` has to be used in a test file");
+	}
+	const resolvedOptions = deepMerge(Object.create(null), defaultOptions, context.project.config.browser.expect?.toMatchScreenshot ?? {}, options);
+	const extensionFromName = extname(name);
+	// technically the type is a lie, but we check beneath and reassign otherwise
+	let extension = extensionFromName.replace(/^\./, "");
+	// when `type` will be supported in `screenshotOptions`:
+	// - `'png'` should end up in `defaultOptions.screenshotOptions.type`
+	// - this condition should be switched around
+	// - the assignment should be `resolvedOptions.screenshotOptions.type = extension`
+	// - everything using `extension` should use `resolvedOptions.screenshotOptions.type`
+	if (supportedExtensions.includes(extension) === false) {
+		extension = "png";
+	}
+	const { root } = context.project.serializedConfig;
+	const resolvePathData = {
+		arg: sanitizeArg(
+			// remove the extension only if it ends up being used
+			extensionFromName.endsWith(extension) ? basename(name, extensionFromName) : name
+		),
+		ext: `.${extension}`,
+		platform: platform(),
+		root,
+		screenshotDirectory: relative(root, join(root, context.project.config.browser.screenshotDirectory ?? "__screenshots__")),
+		attachmentsDir: relative(root, context.project.config.attachmentsDir),
+		testFileDirectory: relative(root, dirname(context.testPath)),
+		testFileName: basename(context.testPath),
+		testName: sanitize(testName, false),
+		browserName: context.project.config.browser.name
+	};
+	return {
+		codec: getCodec(extension),
+		comparator: getComparator(resolvedOptions.comparatorName),
+		resolvedOptions,
+		paths: {
+			reference: resolvedOptions.resolveScreenshotPath(resolvePathData),
+			get diffs() {
+				const diffs = {
+					reference: resolvedOptions.resolveDiffPath({
+						...resolvePathData,
+						arg: `${resolvePathData.arg}-reference`
+					}),
+					actual: resolvedOptions.resolveDiffPath({
+						...resolvePathData,
+						arg: `${resolvePathData.arg}-actual`
+					}),
+					diff: resolvedOptions.resolveDiffPath({
+						...resolvePathData,
+						arg: `${resolvePathData.arg}-diff`
+					})
+				};
+				Object.defineProperty(this, "diffs", { value: diffs });
+				return diffs;
+			}
+		}
+	};
+}
+/**
+* Sanitizes a string by removing or transforming characters to ensure it is
+* safe for use as a filename or path segment. It supports two modes:
+*
+* 1. Non-path mode (`keepPaths === false`):
+*    - Replaces one or more whitespace characters (`\s+`) with a single hyphen (`-`).
+*    - Removes any character that is not a word character (`\w`) or a hyphen (`-`).
+*    - Collapses multiple consecutive hyphens (`-{2,}`) into a single hyphen.
+*
+* 2. Path-preserving mode (`keepPaths === true`):
+*    - Splits the input string on the path separator.
+*    - Sanitizes each path segment individually in non-path mode.
+*    - Joins the sanitized segments back together.
+*
+* @param input - The raw string to sanitize.
+* @param keepPaths - If `false`, performs a flat sanitization (drops path segments).
+* If `true`, treats `input` as a path: each segment is sanitized independently,
+* preserving separators.
+*/
+function sanitize(input, keepPaths) {
+	if (keepPaths === false) {
+		return input.replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/-{2,}/g, "-");
+	}
+	return input.split("/").map((path) => sanitize(path, false)).join("/");
+}
+/**
+* Takes a string, treats it as a potential path or filename, and ensures it cannot
+* escape the root directory or contain invalid characters. Internally, it:
+*
+* 1. Prepends the path separator to the raw input to form a path-like string.
+* 2. Uses {@linkcode relative|relative('/', <that-path>)} to compute a relative
+* path from the root, which effectively strips any leading separators and prevents
+* traversal above the root.
+* 3. Passes the resulting relative path into {@linkcode sanitize|sanitize(..., true)},
+* preserving any path separators but sanitizing each segment.
+*
+* @param input - The raw string to clean.
+*/
+function sanitizeArg(input) {
+	return sanitize(relative("/", join("/", input)), true);
+}
+/**
+* Takes a screenshot and decodes it using the provided codec.
+*
+* The screenshot is taken as a base64 string and then decoded into the format
+* expected by the comparator.
+*
+* @returns `Promise` resolving to the decoded screenshot data
+*/
+function takeDecodedScreenshot({ codec, context, element, name, screenshotOptions }) {
+	return takeScreenshot(context, name, {
+		...screenshotOptions,
+		save: false,
+		element
+	}).then(({ buffer }) => codec.decode(buffer, {}));
+}
+/**
+* Creates a promise that resolves to `null` after the specified timeout.
+* If the timeout is `0`, the promise resolves immediately.
+*
+* @param timeout - The delay in milliseconds before the promise resolves
+* @returns `Promise` that resolves to `null` after the timeout
+*/
+function asyncTimeout(timeout) {
+	return new Promise((resolve) => {
+		if (timeout === 0) {
+			resolve(null);
+		} else {
+			setTimeout(() => resolve(null), timeout);
+		}
+	});
+}
+
+const screenshotMatcher = async (context, name, testName, options) => {
+	if (!context.testPath) {
+		throw new Error(`Cannot compare screenshots without a test path`);
+	}
+	const { element } = options;
+	const { codec, comparator, paths, resolvedOptions: { comparatorOptions, screenshotOptions, timeout } } = resolveOptions({
+		context,
+		name,
+		testName,
+		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({
+		codec,
+		comparator,
+		comparatorOptions,
+		context,
+		element,
+		name: `${Date.now()}-${basename(paths.reference)}`,
+		reference,
+		screenshotOptions,
+		signal: abortController.signal
+	});
+	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) {
+		return {
+			pass: false,
+			reference: referenceFile && paths.reference,
+			actual: null,
+			diff: null,
+			message: `Could not capture a stable screenshot within ${timeout}ms.`
+		};
+	}
+	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
+	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") {
+			return {
+				pass: false,
+				reference: referencePath,
+				actual: null,
+				diff: null,
+				message: `No existing reference screenshot found${shouldCreateReference ? "; a new one was created. Review it before running tests again." : "."}`
+			};
+		}
+		// 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, {
+		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
+	return {
+		pass: false,
+		reference: paths.reference,
+		actual: paths.diffs.actual,
+		diff: finalResult.diff && paths.diffs.diff,
+		message: `Screenshot does not match the stored reference.${finalResult.message === null ? "" : `\n${finalResult.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");
+	}
+}
+/**
+* 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.
+*
+* The process works as follows:
+*
+* 1. Uses as baseline an optional reference screenshot or takes a new screenshot
+* 2. Takes a screenshot and compares with baseline
+* 3. If they match, the page is considered stable and the function returns
+* 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
+*/
+async function getStableScreenshots({ codec, context, comparator, comparatorOptions, element, name, reference, screenshotOptions, signal }) {
+	const screenshotArgument = {
+		codec,
+		context,
+		element,
+		name,
+		screenshotOptions
+	};
+	let retries = 0;
+	let decodedBaseline = reference;
+	while (signal.aborted === false) {
+		if (decodedBaseline === null) {
+			decodedBaseline = takeDecodedScreenshot(screenshotArgument);
+		}
+		const [image1, image2] = await Promise.all([decodedBaseline, takeDecodedScreenshot(screenshotArgument)]);
+		const comparatorResult = (await comparator(image1, image2, {
+			...comparatorOptions,
+			createDiff: false
+		})).pass;
+		decodedBaseline = image2;
+		if (comparatorResult) {
+			break;
+		}
+		retries += 1;
+	}
+	return {
+		retries,
+		actual: await decodedBaseline
+	};
+}
+
 const selectOptions = async (context, selector, userValues, options = {}) => {
 	if (context.provider instanceof PlaywrightBrowserProvider) {
 		const value = userValues;
@@ -2550,7 +2999,8 @@ var builtinCommands = {
 	__vitest_dragAndDrop: dragAndDrop,
 	__vitest_hover: hover,
 	__vitest_cleanup: keyboardCleanup,
-	__vitest_viewport: viewport
+	__vitest_viewport: viewport,
+	__vitest_screenshotMatcher: screenshotMatcher
 };
 
 class BrowserServerState {
@@ -2840,7 +3290,7 @@ function defaultSerialize(i) {
   return i;
 }
 const defaultDeserialize = defaultSerialize;
-const { clearTimeout, setTimeout } = globalThis;
+const { clearTimeout, setTimeout: setTimeout$1 } = globalThis;
 const random = Math.random.bind(Math);
 function createBirpc(functions, options) {
   const {
@@ -2864,10 +3314,13 @@ function createBirpc(functions, options) {
         return functions;
       if (method === "$close")
         return close;
+      if (method === "$rejectPendingCalls") {
+        return rejectPendingCalls;
+      }
       if (method === "$closed")
         return closed;
       if (method === "then" && !eventNames.includes("then") && !("then" in functions))
-        return undefined;
+        return void 0;
       const sendEvent = (...args) => {
         post(serialize({ m: method, a: args, t: TYPE_REQUEST }));
       };
@@ -2882,14 +3335,14 @@ function createBirpc(functions, options) {
           try {
             await _promise;
           } finally {
-            _promise = undefined;
+            _promise = void 0;
           }
         }
         return new Promise((resolve, reject) => {
           const id = nanoid();
           let timeoutId;
           if (timeout >= 0) {
-            timeoutId = setTimeout(() => {
+            timeoutId = setTimeout$1(() => {
               try {
                 const handleResult = options.onTimeoutError?.(method, args);
                 if (handleResult !== true)
@@ -2910,14 +3363,30 @@ function createBirpc(functions, options) {
       return sendCall;
     }
   });
-  function close(error) {
+  function close(customError) {
     closed = true;
     rpcPromiseMap.forEach(({ reject, method }) => {
-      reject(error || new Error(`[birpc] rpc is closed, cannot call "${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 {
@@ -3017,12 +3486,13 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 		if (!sessionId || !rpcId || projectName == null) {
 			return error(new Error(`[vitest] Invalid URL ${request.url}. "projectName", "sessionId" and "rpcId" queries are required.`));
 		}
-		if (!vitest._browserSessions.sessionIds.has(sessionId)) {
-			const ids = [...vitest._browserSessions.sessionIds].join(", ");
+		const sessions = vitest._browserSessions;
+		if (!sessions.sessionIds.has(sessionId)) {
+			const ids = [...sessions.sessionIds].join(", ");
 			return error(new Error(`[vitest] Unknown session id "${sessionId}". Expected one of ${ids}.`));
 		}
 		if (type === "orchestrator") {
-			const session = vitest._browserSessions.getSession(sessionId);
+			const session = sessions.getSession(sessionId);
 			// it's possible the session was already resolved by the preview provider
 			session?.connected();
 		}
@@ -3042,7 +3512,7 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 				clients.delete(rpcId);
 				globalServer.removeCDPHandler(rpcId);
 				if (type === "orchestrator") {
-					vitest._browserSessions.destroySession(sessionId);
+					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?`));
@@ -3251,11 +3721,8 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 			on: (fn) => ws.on("message", fn),
 			eventNames: ["onCancel", "cdpEvent"],
 			serialize: (data) => stringify(data, stringifyReplace),
-			timeout: -1,
 			deserialize: parse,
-			onTimeoutError(functionName) {
-				throw new Error(`[vitest-api]: Timeout calling "${functionName}"`);
-			}
+			timeout: -1
 		});
 		vitest.onCancel((reason) => rpc.onCancel(reason));
 		return rpc;
@@ -3348,14 +3815,15 @@ function createBrowserPool(vitest) {
 		}
 		const parallelPools = [];
 		const nonParallelPools = [];
-		for (const result of initialisedPools) {
-			if (!result) {
+		for (const pool of initialisedPools) {
+			if (!pool) {
+				// this means it was cancelled
 				return;
 			}
-			if (result.provider.mocker && result.provider.supportsParallelism) {
-				parallelPools.push(result.runTests);
+			if (pool.provider.mocker && pool.provider.supportsParallelism) {
+				parallelPools.push(pool.runTests);
 			} else {
-				nonParallelPools.push(result.runTests);
+				nonParallelPools.push(pool.runTests);
 			}
 		}
 		await Promise.all(parallelPools.map((runTests) => runTests()));