@vitest/browser 3.1.1 → 3.1.3

package/dist/index.js

@@ -4,7 +4,7 @@ import c from 'tinyrainbow';
 import { getFilePoolName, distDir, resolveApiServerConfig, resolveFsAllow, isFileServingAllowed, createDebugger, isValidApiRequest, createViteLogger, createViteServer } from 'vitest/node';
 import fs, { readFileSync, lstatSync, promises, existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { slash as slash$1, toArray } from '@vitest/utils';
+import { slash as slash$1, toArray, createDefer } from '@vitest/utils';
 import MagicString from 'magic-string';
 import sirv from 'sirv';
 import * as vite from 'vite';
@@ -13,12 +13,12 @@ import { fileURLToPath } from 'node:url';
 import crypto from 'node:crypto';
 import { mkdir, readFile as readFile$1 } from 'node:fs/promises';
 import { parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
-import { P as PlaywrightBrowserProvider, W as WebdriverBrowserProvider } from './webdriver-2iYWIzBv.js';
+import { P as PlaywrightBrowserProvider, W as WebdriverBrowserProvider } from './webdriver-BH7t2pDp.js';
 import { resolve as resolve$1, dirname as dirname$1, basename as basename$1, normalize as normalize$1 } from 'node:path';
 import { WebSocketServer } from 'ws';
 import * as nodeos from 'node:os';
 
-var version = "3.1.1";
+var version = "3.1.3";
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -213,6 +213,113 @@ const basename = function(p, extension) {
 const pkgRoot = resolve(fileURLToPath(import.meta.url), "../..");
 const distRoot = resolve(pkgRoot, "dist");
 
+/// <reference types="../types/index.d.ts" />
+
+// (c) 2020-present Andrea Giammarchi
+
+const {parse: $parse, stringify: $stringify} = JSON;
+const {keys} = Object;
+
+const Primitive = String;   // it could be Number
+const primitive = 'string'; // it could be 'number'
+
+const ignore = {};
+const object = 'object';
+
+const noop = (_, value) => value;
+
+const primitives = value => (
+  value instanceof Primitive ? Primitive(value) : value
+);
+
+const Primitives = (_, value) => (
+  typeof value === primitive ? new Primitive(value) : value
+);
+
+const revive = (input, parsed, output, $) => {
+  const lazy = [];
+  for (let ke = keys(output), {length} = ke, y = 0; y < length; y++) {
+    const k = ke[y];
+    const value = output[k];
+    if (value instanceof Primitive) {
+      const tmp = input[value];
+      if (typeof tmp === object && !parsed.has(tmp)) {
+        parsed.add(tmp);
+        output[k] = ignore;
+        lazy.push({k, a: [input, parsed, tmp, $]});
+      }
+      else
+        output[k] = $.call(output, k, tmp);
+    }
+    else if (output[k] !== ignore)
+      output[k] = $.call(output, k, value);
+  }
+  for (let {length} = lazy, i = 0; i < length; i++) {
+    const {k, a} = lazy[i];
+    output[k] = $.call(output, k, revive.apply(null, a));
+  }
+  return output;
+};
+
+const set = (known, input, value) => {
+  const index = Primitive(input.push(value) - 1);
+  known.set(value, index);
+  return index;
+};
+
+/**
+ * Converts a specialized flatted string into a JS value.
+ * @param {string} text
+ * @param {(this: any, key: string, value: any) => any} [reviver]
+ * @returns {any}
+ */
+const parse = (text, reviver) => {
+  const input = $parse(text, Primitives).map(primitives);
+  const value = input[0];
+  const $ = reviver || noop;
+  const tmp = typeof value === object && value ?
+              revive(input, new Set, value, $) :
+              value;
+  return $.call({'': tmp}, '', tmp);
+};
+
+/**
+ * Converts a JS value into a specialized flatted string.
+ * @param {any} value
+ * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
+ * @param {string | number | undefined} [space]
+ * @returns {string}
+ */
+const stringify = (value, replacer, space) => {
+  const $ = replacer && typeof replacer === object ?
+            (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) :
+            (replacer || noop);
+  const known = new Map;
+  const input = [];
+  const output = [];
+  let i = +set(known, input, $.call({'': value}, '', value));
+  let firstRun = !i;
+  while (i < input.length) {
+    firstRun = true;
+    output[i] = $stringify(input[i++], replace, space);
+  }
+  return '[' + output.join(',') + ']';
+  function replace(key, value) {
+    if (firstRun) {
+      firstRun = !firstRun;
+      return value;
+    }
+    const after = $.call(this, key, value);
+    switch (typeof after) {
+      case object:
+        if (after === null) return after;
+      case primitive:
+        return known.get(after) || set(known, input, after);
+    }
+    return after;
+  }
+};
+
 function replacer(code, values) {
 	return code.replace(/\{\s*(\w+)\s*\}/g, (_, key) => values[key] ?? _);
 }
@@ -249,22 +356,23 @@ async function resolveOrchestrator(globalServer, url, res) {
 		sessionId = contexts[contexts.length - 1] ?? "none";
 	}
 	const session = globalServer.vitest._browserSessions.getSession(sessionId);
-	const files = session?.files ?? [];
 	const browserProject = session?.project.browser || [...globalServer.children][0];
 	if (!browserProject) {
 		return;
 	}
+	if (sessionId && sessionId !== "none" && !globalServer.vitest._browserSessions.sessionIds.has(sessionId)) {
+		return;
+	}
 	const injectorJs = typeof globalServer.injectorJs === "string" ? globalServer.injectorJs : await globalServer.injectorJs;
 	const injector = replacer(injectorJs, {
 		__VITEST_PROVIDER__: JSON.stringify(browserProject.config.browser.provider || "preview"),
 		__VITEST_CONFIG__: JSON.stringify(browserProject.wrapSerializedConfig()),
 		__VITEST_VITE_CONFIG__: JSON.stringify({ root: browserProject.vite.config.root }),
-		__VITEST_METHOD__: JSON.stringify(session?.method || "run"),
-		__VITEST_FILES__: JSON.stringify(files),
+		__VITEST_METHOD__: JSON.stringify("orchestrate"),
 		__VITEST_TYPE__: "\"orchestrator\"",
 		__VITEST_SESSION_ID__: JSON.stringify(sessionId),
 		__VITEST_TESTER_ID__: "\"none\"",
-		__VITEST_PROVIDED_CONTEXT__: "{}",
+		__VITEST_PROVIDED_CONTEXT__: JSON.stringify(stringify(browserProject.project.getProvidedContext())),
 		__VITEST_API_TOKEN__: JSON.stringify(globalServer.vitest.config.api.token)
 	});
 	res.removeHeader("Content-Security-Policy");
@@ -327,119 +435,12 @@ function createOrchestratorMiddleware(parentServer) {
 	};
 }
 
-/// <reference types="../types/index.d.ts" />
-
-// (c) 2020-present Andrea Giammarchi
-
-const {parse: $parse, stringify: $stringify} = JSON;
-const {keys} = Object;
-
-const Primitive = String;   // it could be Number
-const primitive = 'string'; // it could be 'number'
-
-const ignore = {};
-const object = 'object';
-
-const noop = (_, value) => value;
-
-const primitives = value => (
-  value instanceof Primitive ? Primitive(value) : value
-);
-
-const Primitives = (_, value) => (
-  typeof value === primitive ? new Primitive(value) : value
-);
-
-const revive = (input, parsed, output, $) => {
-  const lazy = [];
-  for (let ke = keys(output), {length} = ke, y = 0; y < length; y++) {
-    const k = ke[y];
-    const value = output[k];
-    if (value instanceof Primitive) {
-      const tmp = input[value];
-      if (typeof tmp === object && !parsed.has(tmp)) {
-        parsed.add(tmp);
-        output[k] = ignore;
-        lazy.push({k, a: [input, parsed, tmp, $]});
-      }
-      else
-        output[k] = $.call(output, k, tmp);
-    }
-    else if (output[k] !== ignore)
-      output[k] = $.call(output, k, value);
-  }
-  for (let {length} = lazy, i = 0; i < length; i++) {
-    const {k, a} = lazy[i];
-    output[k] = $.call(output, k, revive.apply(null, a));
-  }
-  return output;
-};
-
-const set = (known, input, value) => {
-  const index = Primitive(input.push(value) - 1);
-  known.set(value, index);
-  return index;
-};
-
-/**
- * Converts a specialized flatted string into a JS value.
- * @param {string} text
- * @param {(this: any, key: string, value: any) => any} [reviver]
- * @returns {any}
- */
-const parse = (text, reviver) => {
-  const input = $parse(text, Primitives).map(primitives);
-  const value = input[0];
-  const $ = reviver || noop;
-  const tmp = typeof value === object && value ?
-              revive(input, new Set, value, $) :
-              value;
-  return $.call({'': tmp}, '', tmp);
-};
-
-/**
- * Converts a JS value into a specialized flatted string.
- * @param {any} value
- * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
- * @param {string | number | undefined} [space]
- * @returns {string}
- */
-const stringify = (value, replacer, space) => {
-  const $ = replacer && typeof replacer === object ?
-            (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) :
-            (replacer || noop);
-  const known = new Map;
-  const input = [];
-  const output = [];
-  let i = +set(known, input, $.call({'': value}, '', value));
-  let firstRun = !i;
-  while (i < input.length) {
-    firstRun = true;
-    output[i] = $stringify(input[i++], replace, space);
-  }
-  return '[' + output.join(',') + ']';
-  function replace(key, value) {
-    if (firstRun) {
-      firstRun = !firstRun;
-      return value;
-    }
-    const after = $.call(this, key, value);
-    switch (typeof after) {
-      case object:
-        if (after === null) return after;
-      case primitive:
-        return known.get(after) || set(known, input, after);
-    }
-    return after;
-  }
-};
-
 async function resolveTester(globalServer, url, res, next) {
 	const csp = res.getHeader("Content-Security-Policy");
 	if (typeof csp === "string") {
 		res.setHeader("Content-Security-Policy", csp.replace(/frame-ancestors [^;]+/, "frame-ancestors *"));
 	}
-	const { sessionId, testFile } = globalServer.resolveTesterUrl(url.pathname);
+	const sessionId = url.searchParams.get("sessionId") || "none";
 	const session = globalServer.vitest._browserSessions.getSession(sessionId);
 	if (!session) {
 		res.statusCode = 400;
@@ -447,11 +448,6 @@ async function resolveTester(globalServer, url, res, next) {
 		return;
 	}
 	const project = globalServer.vitest.getProjectByName(session.project.name || "");
-	const { testFiles } = await project.globTestFiles();
-	const tests = testFile === "__vitest_all__" || !testFiles.includes(testFile) ? "__vitest_browser_runner__.files" : JSON.stringify([testFile]);
-	const iframeId = JSON.stringify(testFile);
-	const files = session.files ?? [];
-	const method = session.method ?? "run";
 	const browserProject = project.browser || [...globalServer.children][0];
 	if (!browserProject) {
 		res.statusCode = 400;
@@ -462,13 +458,12 @@ async function resolveTester(globalServer, url, res, next) {
 	const injector = replacer(injectorJs, {
 		__VITEST_PROVIDER__: JSON.stringify(project.browser.provider.name),
 		__VITEST_CONFIG__: JSON.stringify(browserProject.wrapSerializedConfig()),
-		__VITEST_FILES__: JSON.stringify(files),
 		__VITEST_VITE_CONFIG__: JSON.stringify({ root: browserProject.vite.config.root }),
 		__VITEST_TYPE__: "\"tester\"",
-		__VITEST_METHOD__: JSON.stringify(method),
+		__VITEST_METHOD__: JSON.stringify("none"),
 		__VITEST_SESSION_ID__: JSON.stringify(sessionId),
 		__VITEST_TESTER_ID__: JSON.stringify(crypto.randomUUID()),
-		__VITEST_PROVIDED_CONTEXT__: JSON.stringify(stringify(project.getProvidedContext())),
+		__VITEST_PROVIDED_CONTEXT__: "{}",
 		__VITEST_API_TOKEN__: JSON.stringify(globalServer.vitest.config.api.token)
 	});
 	const testerHtml = typeof browserProject.testerHtml === "string" ? browserProject.testerHtml : await browserProject.testerHtml;
@@ -477,17 +472,11 @@ async function resolveTester(globalServer, url, res, next) {
 		const indexhtml = await browserProject.vite.transformIndexHtml(url, testerHtml);
 		const html = replacer(indexhtml, {
 			__VITEST_FAVICON__: globalServer.faviconUrl,
-			__VITEST_INJECTOR__: injector,
-			__VITEST_APPEND__: `
-    __vitest_browser_runner__.runningFiles = ${tests}
-    __vitest_browser_runner__.iframeId = ${iframeId}
-    __vitest_browser_runner__.${method === "run" ? "runTests" : "collectTests"}(__vitest_browser_runner__.runningFiles)
-    document.querySelector('script[data-vitest-append]').remove()
-    `
+			__VITEST_INJECTOR__: injector
 		});
 		return html;
 	} catch (err) {
-		session.reject(err);
+		session.fail(err);
 		next(err);
 	}
 }
@@ -498,7 +487,7 @@ function createTesterMiddleware(browserServer) {
 			return next();
 		}
 		const url = new URL(req.url, "http://localhost");
-		if (!url.pathname.startsWith(browserServer.prefixTesterUrl)) {
+		if (!url.pathname.startsWith(browserServer.prefixTesterUrl) || !url.searchParams.has("sessionId")) {
 			return next();
 		}
 		const html = await resolveTester(browserServer, url, res, next);
@@ -961,16 +950,7 @@ body {
 						injectTo: "head"
 					} : null,
 					...parentServer.testerScripts,
-					...testerTags,
-					{
-						tag: "script",
-						attrs: {
-							"type": "module",
-							"data-vitest-append": ""
-						},
-						children: "{__VITEST_APPEND__}",
-						injectTo: "body"
-					}
+					...testerTags
 				].filter((s) => s != null);
 			}
 		},
@@ -1216,6 +1196,7 @@ const types = {
     'application/dash+xml': ['mpd'],
     'application/dash-patch+xml': ['mpp'],
     'application/davmount+xml': ['davmount'],
+    'application/dicom': ['dcm'],
     'application/docbook+xml': ['dbk'],
     'application/dssc+der': ['dssc'],
     'application/dssc+xml': ['xdssc'],
@@ -1302,7 +1283,14 @@ const types = {
     'application/oebps-package+xml': ['opf'],
     'application/ogg': ['ogx'],
     'application/omdoc+xml': ['omdoc'],
-    'application/onenote': ['onetoc', 'onetoc2', 'onetmp', 'onepkg'],
+    'application/onenote': [
+        'onetoc',
+        'onetoc2',
+        'onetmp',
+        'onepkg',
+        'one',
+        'onea',
+    ],
     'application/oxps': ['oxps'],
     'application/p2p-overlay+xml': ['relo'],
     'application/patch-ops-error+xml': ['xer'],
@@ -1398,6 +1386,7 @@ const types = {
     'application/yang': ['yang'],
     'application/yin+xml': ['yin'],
     'application/zip': ['zip'],
+    'application/zip+dotlottie': ['lottie'],
     'audio/3gpp': ['*3gpp'],
     'audio/aac': ['adts', 'aac'],
     'audio/adpcm': ['adp'],
@@ -1406,7 +1395,7 @@ const types = {
     'audio/midi': ['mid', 'midi', 'kar', 'rmi'],
     'audio/mobile-xmf': ['mxmf'],
     'audio/mp3': ['*mp3'],
-    'audio/mp4': ['m4a', 'mp4a'],
+    'audio/mp4': ['m4a', 'mp4a', 'm4b'],
     'audio/mpeg': ['mpga', 'mp2', 'mp2a', 'mp3', 'm2a', 'm3a'],
     'audio/ogg': ['oga', 'ogg', 'spx', 'opus'],
     'audio/s3m': ['s3m'],
@@ -1438,11 +1427,12 @@ const types = {
     'image/heif': ['heif'],
     'image/heif-sequence': ['heifs'],
     'image/hej2k': ['hej2'],
-    'image/hsj2': ['hsj2'],
     'image/ief': ['ief'],
+    'image/jaii': ['jaii'],
+    'image/jais': ['jais'],
     'image/jls': ['jls'],
     'image/jp2': ['jp2', 'jpg2'],
-    'image/jpeg': ['jpeg', 'jpg', 'jpe'],
+    'image/jpeg': ['jpg', 'jpeg', 'jpe'],
     'image/jph': ['jph'],
     'image/jphc': ['jhc'],
     'image/jpm': ['jpm', 'jpgm'],
@@ -1457,6 +1447,7 @@ const types = {
     'image/jxss': ['jxss'],
     'image/ktx': ['ktx'],
     'image/ktx2': ['ktx2'],
+    'image/pjpeg': ['jfif'],
     'image/png': ['png'],
     'image/sgi': ['sgi'],
     'image/svg+xml': ['svg', 'svgz'],
@@ -1470,7 +1461,7 @@ const types = {
     'message/global-delivery-status': ['u8dsn'],
     'message/global-disposition-notification': ['u8mdn'],
     'message/global-headers': ['u8hdr'],
-    'message/rfc822': ['eml', 'mime'],
+    'message/rfc822': ['eml', 'mime', 'mht', 'mhtml'],
     'model/3mf': ['3mf'],
     'model/gltf+json': ['gltf'],
     'model/gltf-binary': ['glb'],
@@ -1480,6 +1471,7 @@ const types = {
     'model/mtl': ['mtl'],
     'model/obj': ['obj'],
     'model/prc': ['prc'],
+    'model/step': ['step', 'stp', 'stpnc', 'p21', '210'],
     'model/step+xml': ['stpx'],
     'model/step+zip': ['stpz'],
     'model/step-xml+zip': ['stpxz'],
@@ -1586,8 +1578,8 @@ class Mime {
     getType(path) {
         if (typeof path !== 'string')
             return null;
-        const last = path.replace(/^.*[/\\]/, '').toLowerCase();
-        const ext = last.replace(/^.*\./, '').toLowerCase();
+        const last = path.replace(/^.*[/\\]/s, '').toLowerCase();
+        const ext = last.replace(/^.*\./s, '').toLowerCase();
         const hasPath = last.length < path.length;
         const hasDot = ext.length < last.length - 1;
         if (!hasDot && hasPath)
@@ -2453,7 +2445,7 @@ const type = async (context, selector, text, options = {}) => {
 	return { unreleased: Array.from(unreleased) };
 };
 
-const upload = async (context, selector, files) => {
+const upload = async (context, selector, files, options) => {
 	const testPath = context.testPath;
 	if (!testPath) {
 		throw new Error(`Cannot upload files outside of a test`);
@@ -2471,7 +2463,7 @@ const upload = async (context, selector, files) => {
 				buffer: Buffer.from(file.base64, "base64")
 			};
 		});
-		await iframe.locator(selector).setInputFiles(playwrightFiles);
+		await iframe.locator(selector).setInputFiles(playwrightFiles, options);
 	} else if (context.provider instanceof WebdriverBrowserProvider) {
 		for (const file of files) {
 			if (typeof file !== "string") {
@@ -2634,7 +2626,7 @@ class ParentBrowserProject {
 				if (mod) {
 					return id;
 				}
-				const resolvedPath = resolve(project.config.root, id.slice(1));
+				const resolvedPath = resolve(this.vite.config.root, id.slice(1));
 				const modUrl = this.vite.moduleGraph.getModuleById(resolvedPath);
 				if (modUrl) {
 					return resolvedPath;
@@ -2718,14 +2710,13 @@ class ParentBrowserProject {
 		if (!provider.getCDPSession) {
 			throw new Error(`CDP is not supported by the provider "${provider.name}".`);
 		}
-		const promise = this.cdpSessionsPromises.get(rpcId) ?? await (async () => {
+		const session = await this.cdpSessionsPromises.get(rpcId) ?? await (async () => {
 			const promise = provider.getCDPSession(sessionId).finally(() => {
 				this.cdpSessionsPromises.delete(rpcId);
 			});
 			this.cdpSessionsPromises.set(rpcId, promise);
 			return promise;
 		})();
-		const session = await promise;
 		const rpc = browser.state.testers.get(rpcId);
 		if (!rpc) {
 			throw new Error(`Tester RPC "${rpcId}" was not established.`);
@@ -2781,6 +2772,8 @@ class ParentBrowserProject {
 	}
 }
 
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
 const DEFAULT_TIMEOUT = 6e4;
 function defaultSerialize(i) {
   return i;
@@ -2813,7 +2806,7 @@ function createBirpc(functions, options) {
       if (method === "then" && !eventNames.includes("then") && !("then" in functions))
         return void 0;
       const sendEvent = (...args) => {
-        post(serialize({ m: method, a: args, t: "q" }));
+        post(serialize({ m: method, a: args, t: TYPE_REQUEST }));
       };
       if (eventNames.includes(method)) {
         sendEvent.asEvent = sendEvent;
@@ -2835,8 +2828,9 @@ function createBirpc(functions, options) {
           if (timeout >= 0) {
             timeoutId = setTimeout(() => {
               try {
-                options.onTimeoutError?.(method, args);
-                throw new Error(`[birpc] timeout on calling "${method}"`);
+                const handleResult = options.onTimeoutError?.(method, args);
+                if (handleResult !== true)
+                  throw new Error(`[birpc] timeout on calling "${method}"`);
               } catch (e) {
                 reject(e);
               }
@@ -2853,17 +2847,24 @@ function createBirpc(functions, options) {
       return sendCall;
     }
   });
-  function close() {
+  function close(error) {
     closed = true;
     rpcPromiseMap.forEach(({ reject, method }) => {
-      reject(new Error(`[birpc] rpc is closed, cannot call "${method}"`));
+      reject(error || new Error(`[birpc] rpc is closed, cannot call "${method}"`));
     });
     rpcPromiseMap.clear();
     off(onMessage);
   }
   async function onMessage(data, ...extra) {
-    const msg = deserialize(data);
-    if (msg.t === "q") {
+    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 } = msg;
       let result, error;
       const fn = resolver ? resolver(method, functions[method]) : functions[method];
@@ -2879,7 +2880,26 @@ function createBirpc(functions, options) {
       if (msg.i) {
         if (error && options.onError)
           options.onError(error, method, args);
-        post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);
+        if (error && options.onFunctionError) {
+          if (options.onFunctionError(error, method, args) === true)
+            return;
+        }
+        if (!error) {
+          try {
+            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 {
+          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;
@@ -2934,9 +2954,9 @@ 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.`));
 		}
-		const method = searchParams.get("method");
-		if (method !== "run" && method !== "collect") {
-			return error(new Error(`[vitest] Method query in ${request.url} is invalid. Method should be either "run" or "collect".`));
+		if (!vitest._browserSessions.sessionIds.has(sessionId)) {
+			const ids = [...vitest._browserSessions.sessionIds].join(", ");
+			return error(new Error(`[vitest] Unknown session id "${sessionId}". Expected one of ${ids}.`));
 		}
 		if (type === "orchestrator") {
 			const session = vitest._browserSessions.getSession(sessionId);
@@ -2948,7 +2968,7 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 		}
 		wss.handleUpgrade(request, socket, head, (ws) => {
 			wss.emit("connection", ws, request);
-			const rpc = setupClient(project, rpcId, ws, method);
+			const rpc = setupClient(project, rpcId, ws);
 			const state = project.browser.state;
 			const clients = type === "tester" ? state.testers : state.orchestrators;
 			clients.set(rpcId, rpc);
@@ -2957,6 +2977,10 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 				debug$1?.("[%s] Browser API disconnected from %s", rpcId, type);
 				clients.delete(rpcId);
 				globalServer.removeCDPHandler(rpcId);
+				if (type === "orchestrator") {
+					vitest._browserSessions.destroySession(sessionId);
+				}
+				rpc.$close(new Error(`[vitest] Browser connection was closed while running tests. Was the page closed unexpectedly?`));
 			});
 		});
 	});
@@ -2969,7 +2993,7 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 			throw new Error(`Access denied to "${path}". See Vite config documentation for "server.fs": https://vitejs.dev/config/server-options.html#server-fs-strict.`);
 		}
 	}
-	function setupClient(project, rpcId, ws, method) {
+	function setupClient(project, rpcId, ws) {
 		const mockResolver = new ServerMockResolver(globalServer.vite, { moduleDirectories: project.config.server?.deps?.moduleDirectories });
 		const mocker = project.browser?.provider.mocker;
 		const rpc = createBirpc({
@@ -2980,21 +3004,21 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 				}
 				vitest.state.catchError(error, type);
 			},
-			async onQueued(file) {
+			async onQueued(method, file) {
 				if (method === "collect") {
 					vitest.state.collectFiles(project, [file]);
 				} else {
 					await vitest._testRun.enqueued(project, file);
 				}
 			},
-			async onCollected(files) {
+			async onCollected(method, files) {
 				if (method === "collect") {
 					vitest.state.collectFiles(project, files);
 				} else {
 					await vitest._testRun.collected(project, files);
 				}
 			},
-			async onTaskUpdate(packs, events) {
+			async onTaskUpdate(method, packs, events) {
 				if (method === "collect") {
 					vitest.state.updateTasks(packs);
 				} else {
@@ -3004,7 +3028,7 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 			onAfterSuiteRun(meta) {
 				vitest.coverageProvider?.onAfterSuiteRun(meta);
 			},
-			async sendLog(log) {
+			async sendLog(method, log) {
 				if (method === "collect") {
 					vitest.state.updateUserLog(log);
 				} else {
@@ -3088,10 +3112,6 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 				}, provider.getCommandsContext(sessionId));
 				return await commands[command](context, ...payload);
 			},
-			finishBrowserTests(sessionId) {
-				debug$1?.("[%s] Finishing browser tests for session", sessionId);
-				return vitest._browserSessions.getSession(sessionId)?.resolve();
-			},
 			resolveMock(rawId, importer, options) {
 				return mockResolver.resolveMock(rawId, importer, options);
 			},
@@ -3160,6 +3180,7 @@ 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}"`);
@@ -3194,69 +3215,30 @@ function stringifyReplace(key, value) {
 }
 
 const debug = createDebugger("vitest:browser:pool");
-async function waitForTests(method, sessionId, project, files) {
-	const context = project.vitest._browserSessions.createAsyncSession(method, sessionId, files, project);
-	return await context;
-}
 function createBrowserPool(vitest) {
 	const providers = new Set();
-	const executeTests = async (method, project, files) => {
-		vitest.state.clearFiles(project, files);
-		const browser = project.browser;
-		const threadsCount = getThreadsCount(project);
-		const provider = browser.provider;
-		providers.add(provider);
-		const resolvedUrls = browser.vite.resolvedUrls;
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
+	const threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const projectPools = new WeakMap();
+	const ensurePool = (project) => {
+		if (projectPools.has(project)) {
+			return projectPools.get(project);
+		}
+		debug?.("creating pool for project %s", project.name);
+		const resolvedUrls = project.browser.vite.resolvedUrls;
 		const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
 		if (!origin) {
-			throw new Error(`Can't find browser origin URL for project "${project.name}" when running tests for files "${files.join("\", \"")}"`);
+			throw new Error(`Can't find browser origin URL for project "${project.name}"`);
 		}
-		async function setBreakpoint(sessionId, file) {
-			if (!project.config.inspector.waitForDebugger) {
-				return;
-			}
-			if (!provider.getCDPSession) {
-				throw new Error("Unable to set breakpoint, CDP not supported");
-			}
-			const session = await provider.getCDPSession(sessionId);
-			await session.send("Debugger.enable", {});
-			await session.send("Debugger.setBreakpointByUrl", {
-				lineNumber: 0,
-				urlRegex: escapePathToRegexp(file)
-			});
-		}
-		const filesPerThread = Math.ceil(files.length / threadsCount);
-		const chunks = [];
-		for (let i = 0; i < files.length; i += filesPerThread) {
-			const chunk = files.slice(i, i + filesPerThread);
-			chunks.push(chunk);
-		}
-		debug?.(`[%s] Running %s tests in %s chunks (%s threads)`, project.name || "core", files.length, chunks.length, threadsCount);
-		const orchestrators = [...browser.state.orchestrators.entries()];
-		const promises = [];
-		chunks.forEach((files, index) => {
-			if (orchestrators[index]) {
-				const [sessionId, orchestrator] = orchestrators[index];
-				debug?.("Reusing orchestrator (session %s) for files: %s", sessionId, [...files.map((f) => relative(project.config.root, f))].join(", "));
-				const promise = waitForTests(method, sessionId, project, files);
-				const tester = orchestrator.createTesters(files).catch((error) => {
-					if (error instanceof Error && error.message.startsWith("[birpc] rpc is closed")) {
-						return;
-					}
-					return Promise.reject(error);
-				});
-				promises.push(promise, tester);
-			} else {
-				const sessionId = crypto.randomUUID();
-				const waitPromise = waitForTests(method, sessionId, project, files);
-				debug?.("Opening a new session %s for files: %s", sessionId, [...files.map((f) => relative(project.config.root, f))].join(", "));
-				const url = new URL("/", origin);
-				url.searchParams.set("sessionId", sessionId);
-				const page = provider.openPage(sessionId, url.toString(), () => setBreakpoint(sessionId, files[0]));
-				promises.push(page, waitPromise);
-			}
+		const pool = new BrowserPool(project, {
+			maxWorkers: getThreadsCount(project),
+			origin
 		});
-		await Promise.all(promises);
+		projectPools.set(project, pool);
+		vitest.onCancel(() => {
+			pool.cancel();
+		});
+		return pool;
 	};
 	const runWorkspaceTests = async (method, specs) => {
 		const groupedFiles = new Map();
@@ -3269,41 +3251,43 @@ function createBrowserPool(vitest) {
 		vitest.onCancel(() => {
 			isCancelled = true;
 		});
-		for (const [project, files] of groupedFiles.entries()) {
-			if (isCancelled) {
-				break;
-			}
+		await Promise.all([...groupedFiles.entries()].map(async ([project, files]) => {
 			await project._initBrowserProvider();
 			if (!project.browser) {
 				throw new TypeError(`The browser server was not initialized${project.name ? ` for the "${project.name}" project` : ""}. This is a bug in Vitest. Please, open a new issue with reproduction.`);
 			}
-			await executeTests(method, project, files);
-		}
+			if (isCancelled) {
+				return;
+			}
+			debug?.("provider is ready for %s project", project.name);
+			const pool = ensurePool(project);
+			vitest.state.clearFiles(project, files);
+			providers.add(project.browser.provider);
+			await pool.runTests(method, files);
+		}));
 	};
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
 	function getThreadsCount(project) {
 		const config = project.config.browser;
-		if (!config.headless || !project.browser.provider.supportsParallelism) {
-			return 1;
-		}
-		if (!config.fileParallelism) {
+		if (!config.headless || !config.fileParallelism || !project.browser.provider.supportsParallelism) {
 			return 1;
 		}
 		if (project.config.maxWorkers) {
 			return project.config.maxWorkers;
 		}
-		return vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+		return threadsCount;
 	}
 	return {
 		name: "browser",
 		async close() {
 			await Promise.all([...providers].map((provider) => provider.close()));
+			vitest._browserSessions.sessionIds.clear();
 			providers.clear();
 			vitest.projects.forEach((project) => {
 				project.browser?.state.orchestrators.forEach((orchestrator) => {
 					orchestrator.$close();
 				});
 			});
+			debug?.("browser pool closed all providers");
 		},
 		runTests: (files) => runWorkspaceTests("run", files),
 		collectTests: (files) => runWorkspaceTests("collect", files)
@@ -3312,6 +3296,141 @@ function createBrowserPool(vitest) {
 function escapePathToRegexp(path) {
 	return path.replace(/[/\\.?*()^${}|[\]+]/g, "\\$&");
 }
+class BrowserPool {
+	_queue = [];
+	_promise;
+	_providedContext;
+	readySessions = new Set();
+	constructor(project, options) {
+		this.project = project;
+		this.options = options;
+	}
+	cancel() {
+		this._queue = [];
+	}
+	reject(error) {
+		this._promise?.reject(error);
+		this._promise = undefined;
+		this.cancel();
+	}
+	get orchestrators() {
+		return this.project.browser.state.orchestrators;
+	}
+	async runTests(method, files) {
+		this._promise ??= createDefer();
+		if (!files.length) {
+			debug?.("no tests found, finishing test run immediately");
+			this._promise.resolve();
+			return this._promise;
+		}
+		this._providedContext = stringify(this.project.getProvidedContext());
+		this._queue.push(...files);
+		this.readySessions.forEach((sessionId) => {
+			if (this._queue.length) {
+				this.readySessions.delete(sessionId);
+				this.runNextTest(method, sessionId);
+			}
+		});
+		if (this.orchestrators.size >= this.options.maxWorkers) {
+			debug?.("all orchestrators are ready, not creating more");
+			return this._promise;
+		}
+		const workerCount = Math.min(this.options.maxWorkers - this.orchestrators.size, files.length);
+		const promises = [];
+		for (let i = 0; i < workerCount; i++) {
+			const sessionId = crypto.randomUUID();
+			this.project.vitest._browserSessions.sessionIds.add(sessionId);
+			const project = this.project.name;
+			debug?.("[%s] creating session for %s", sessionId, project);
+			const page = this.openPage(sessionId).then(() => {
+				this.runNextTest(method, sessionId);
+			});
+			promises.push(page);
+		}
+		await Promise.all(promises);
+		debug?.("all sessions are created");
+		return this._promise;
+	}
+	async openPage(sessionId) {
+		const sessionPromise = this.project.vitest._browserSessions.createSession(sessionId, this.project, this);
+		const url = new URL("/", this.options.origin);
+		url.searchParams.set("sessionId", sessionId);
+		const pagePromise = this.project.browser.provider.openPage(sessionId, url.toString());
+		await Promise.all([sessionPromise, pagePromise]);
+	}
+	getOrchestrator(sessionId) {
+		const orchestrator = this.orchestrators.get(sessionId);
+		if (!orchestrator) {
+			throw new Error(`Orchestrator not found for session ${sessionId}. This is a bug in Vitest. Please, open a new issue with reproduction.`);
+		}
+		return orchestrator;
+	}
+	finishSession(sessionId) {
+		this.readySessions.add(sessionId);
+		if (this.readySessions.size === this.orchestrators.size) {
+			this._promise?.resolve();
+			this._promise = undefined;
+			debug?.("[%s] all tests finished running", sessionId);
+		} else {
+			debug?.(`did not finish sessions for ${sessionId}: |ready - %s| |overall - %s|`, [...this.readySessions].join(", "), [...this.orchestrators.keys()].join(", "));
+		}
+	}
+	runNextTest(method, sessionId) {
+		const file = this._queue.shift();
+		if (!file) {
+			debug?.("[%s] no more tests to run", sessionId);
+			const isolate = this.project.config.browser.isolate;
+			if (isolate) {
+				this.finishSession(sessionId);
+				return;
+			}
+			const orchestrator = this.getOrchestrator(sessionId);
+			orchestrator.cleanupTesters().catch((error) => this.reject(error)).finally(() => this.finishSession(sessionId));
+			return;
+		}
+		if (!this._promise) {
+			throw new Error(`Unexpected empty queue`);
+		}
+		const orchestrator = this.getOrchestrator(sessionId);
+		debug?.("[%s] run test %s", sessionId, file);
+		this.setBreakpoint(sessionId, file).then(() => {
+			orchestrator.createTesters({
+				method,
+				files: [file],
+				providedContext: this._providedContext || "[{}]"
+			}).then(() => {
+				debug?.("[%s] test %s finished running", sessionId, file);
+				this.runNextTest(method, sessionId);
+			}).catch((error) => {
+				if (this.project.vitest.isCancelling && error instanceof Error && error.message.startsWith("Browser connection was closed while running tests")) {
+					this.cancel();
+					this._promise?.resolve();
+					this._promise = undefined;
+					debug?.("[%s] browser connection was closed", sessionId);
+					return;
+				}
+				debug?.("[%s] error during %s test run: %s", sessionId, file, error);
+				this.reject(error);
+			});
+		}).catch((err) => this.reject(err));
+	}
+	async setBreakpoint(sessionId, file) {
+		if (!this.project.config.inspector.waitForDebugger) {
+			return;
+		}
+		const provider = this.project.browser.provider;
+		if (!provider.getCDPSession) {
+			throw new Error("Unable to set breakpoint, CDP not supported");
+		}
+		debug?.("[%s] set breakpoint for %s", sessionId, file);
+		const session = await provider.getCDPSession(sessionId);
+		await session.send("Debugger.enable", {});
+		await session.send("Debugger.setBreakpointByUrl", {
+			lineNumber: 0,
+			urlRegex: escapePathToRegexp(file)
+		});
+	}
+}
 
 async function createBrowserServer(project, configFile, prePlugins = [], postPlugins = []) {
 	if (project.vitest.version !== version) {
@@ -3325,6 +3444,7 @@ async function createBrowserServer(project, configFile, prePlugins = [], postPlu
 	const vite = await createViteServer({
 		...project.options,
 		base: "/",
+		root: project.config.root,
 		logLevel,
 		customLogger: {
 			...logger,