@vitest/browser 3.1.0-beta.1 → 3.1.0

package/dist/index.js

@@ -1,22 +1,24 @@
+import { ManualMockedModule, RedirectedModule, AutomockedModule, AutospiedModule, MockerRegistry } from '@vitest/mocker';
+import { dynamicImportPlugin, ServerMockResolver, interceptorPlugin } from '@vitest/mocker/node';
 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 { dynamicImportPlugin, ServerMockResolver } from '@vitest/mocker/node';
 import { slash as slash$1, toArray } 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, 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-C5-VI7VH.js';
+import { P as PlaywrightBrowserProvider, W as WebdriverBrowserProvider } from './webdriver-2iYWIzBv.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.0-beta.1";
+var version = "3.1.0";
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -212,130 +214,117 @@ const pkgRoot = resolve(fileURLToPath(import.meta.url), "../..");
 const distRoot = resolve(pkgRoot, "dist");
 
 function replacer(code, values) {
-  return code.replace(/\{\s*(\w+)\s*\}/g, (_, key) => values[key] ?? _);
+	return code.replace(/\{\s*(\w+)\s*\}/g, (_, key) => values[key] ?? _);
 }
-const builtinProviders = ["webdriverio", "playwright", "preview"];
+const builtinProviders = [
+	"webdriverio",
+	"playwright",
+	"preview"
+];
 async function getBrowserProvider(options, project) {
-  if (options.provider == null || builtinProviders.includes(options.provider)) {
-    const providers = await import('./providers.js');
-    const provider = options.provider || "preview";
-    return providers[provider];
-  }
-  let customProviderModule;
-  try {
-    customProviderModule = await project.import(
-      options.provider
-    );
-  } catch (error) {
-    throw new Error(
-      `Failed to load custom BrowserProvider from ${options.provider}`,
-      { cause: error }
-    );
-  }
-  if (customProviderModule.default == null) {
-    throw new Error(
-      `Custom BrowserProvider loaded from ${options.provider} was not the default export`
-    );
-  }
-  return customProviderModule.default;
+	if (options.provider == null || builtinProviders.includes(options.provider)) {
+		const providers = await import('./providers.js');
+		const provider = options.provider || "preview";
+		return providers[provider];
+	}
+	let customProviderModule;
+	try {
+		customProviderModule = await project.import(options.provider);
+	} catch (error) {
+		throw new Error(`Failed to load custom BrowserProvider from ${options.provider}`, { cause: error });
+	}
+	if (customProviderModule.default == null) {
+		throw new Error(`Custom BrowserProvider loaded from ${options.provider} was not the default export`);
+	}
+	return customProviderModule.default;
 }
 function slash(path) {
-  return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+	return path.replace(/\\/g, "/").replace(/\/+/g, "/");
 }
 
 async function resolveOrchestrator(globalServer, url, res) {
-  let sessionId = url.searchParams.get("sessionId");
-  if (!sessionId) {
-    const contexts = [...globalServer.children].flatMap((p) => [...p.state.orchestrators.keys()]);
-    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;
-  }
-  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_TYPE__: '"orchestrator"',
-    __VITEST_SESSION_ID__: JSON.stringify(sessionId),
-    __VITEST_TESTER_ID__: '"none"',
-    __VITEST_PROVIDED_CONTEXT__: "{}",
-    __VITEST_API_TOKEN__: JSON.stringify(globalServer.vitest.config.api.token)
-  });
-  res.removeHeader("Content-Security-Policy");
-  if (!globalServer.orchestratorScripts) {
-    globalServer.orchestratorScripts = (await globalServer.formatScripts(
-      globalServer.config.browser.orchestratorScripts
-    )).map((script) => {
-      let html = "<script ";
-      for (const attr in script.attrs || {}) {
-        html += `${attr}="${script.attrs[attr]}" `;
-      }
-      html += `>${script.children}<\/script>`;
-      return html;
-    }).join("\n");
-  }
-  let baseHtml = typeof globalServer.orchestratorHtml === "string" ? globalServer.orchestratorHtml : await globalServer.orchestratorHtml;
-  if (globalServer.config.browser.ui) {
-    const manifestContent = globalServer.manifest instanceof Promise ? await globalServer.manifest : globalServer.manifest;
-    const jsEntry = manifestContent["orchestrator.html"].file;
-    const base = browserProject.parent.vite.config.base || "/";
-    baseHtml = baseHtml.replaceAll("./assets/", `${base}__vitest__/assets/`).replace(
-      "<!-- !LOAD_METADATA! -->",
-      [
-        "{__VITEST_INJECTOR__}",
-        "{__VITEST_ERROR_CATCHER__}",
-        "{__VITEST_SCRIPTS__}",
-        `<script type="module" crossorigin src="${base}${jsEntry}"><\/script>`
-      ].join("\n")
-    );
-  }
-  return replacer(baseHtml, {
-    __VITEST_FAVICON__: globalServer.faviconUrl,
-    __VITEST_TITLE__: "Vitest Browser Runner",
-    __VITEST_SCRIPTS__: globalServer.orchestratorScripts,
-    __VITEST_INJECTOR__: `<script type="module">${injector}<\/script>`,
-    __VITEST_ERROR_CATCHER__: `<script type="module" src="${globalServer.errorCatcherUrl}"><\/script>`,
-    __VITEST_SESSION_ID__: JSON.stringify(sessionId)
-  });
+	let sessionId = url.searchParams.get("sessionId");
+	if (!sessionId) {
+		const contexts = [...globalServer.children].flatMap((p) => [...p.state.orchestrators.keys()]);
+		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;
+	}
+	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_TYPE__: "\"orchestrator\"",
+		__VITEST_SESSION_ID__: JSON.stringify(sessionId),
+		__VITEST_TESTER_ID__: "\"none\"",
+		__VITEST_PROVIDED_CONTEXT__: "{}",
+		__VITEST_API_TOKEN__: JSON.stringify(globalServer.vitest.config.api.token)
+	});
+	res.removeHeader("Content-Security-Policy");
+	if (!globalServer.orchestratorScripts) {
+		globalServer.orchestratorScripts = (await globalServer.formatScripts(globalServer.config.browser.orchestratorScripts)).map((script) => {
+			let html = "<script ";
+			for (const attr in script.attrs || {}) {
+				html += `${attr}="${script.attrs[attr]}" `;
+			}
+			html += `>${script.children}</script>`;
+			return html;
+		}).join("\n");
+	}
+	let baseHtml = typeof globalServer.orchestratorHtml === "string" ? globalServer.orchestratorHtml : await globalServer.orchestratorHtml;
+	if (globalServer.config.browser.ui) {
+		const manifestContent = globalServer.manifest instanceof Promise ? await globalServer.manifest : globalServer.manifest;
+		const jsEntry = manifestContent["orchestrator.html"].file;
+		const base = browserProject.parent.vite.config.base || "/";
+		baseHtml = baseHtml.replaceAll("./assets/", `${base}__vitest__/assets/`).replace("<!-- !LOAD_METADATA! -->", [
+			"{__VITEST_INJECTOR__}",
+			"{__VITEST_ERROR_CATCHER__}",
+			"{__VITEST_SCRIPTS__}",
+			`<script type="module" crossorigin src="${base}${jsEntry}"></script>`
+		].join("\n"));
+	}
+	return replacer(baseHtml, {
+		__VITEST_FAVICON__: globalServer.faviconUrl,
+		__VITEST_TITLE__: "Vitest Browser Runner",
+		__VITEST_SCRIPTS__: globalServer.orchestratorScripts,
+		__VITEST_INJECTOR__: `<script type="module">${injector}</script>`,
+		__VITEST_ERROR_CATCHER__: `<script type="module" src="${globalServer.errorCatcherUrl}"></script>`,
+		__VITEST_SESSION_ID__: JSON.stringify(sessionId)
+	});
 }
 
 function disableCache(res) {
-  res.setHeader(
-    "Cache-Control",
-    "no-cache, max-age=0, must-revalidate"
-  );
-  res.setHeader("Content-Type", "text/html; charset=utf-8");
+	res.setHeader("Cache-Control", "no-cache, max-age=0, must-revalidate");
+	res.setHeader("Content-Type", "text/html; charset=utf-8");
 }
 function allowIframes(res) {
-  res.removeHeader("X-Frame-Options");
+	res.removeHeader("X-Frame-Options");
 }
 
 function createOrchestratorMiddleware(parentServer) {
-  return async function vitestOrchestratorMiddleware(req, res, next) {
-    if (!req.url) {
-      return next();
-    }
-    const url = new URL(req.url, "http://localhost");
-    if (url.pathname !== parentServer.base) {
-      return next();
-    }
-    const html = await resolveOrchestrator(parentServer, url, res);
-    if (html) {
-      disableCache(res);
-      allowIframes(res);
-      res.write(html, "utf-8");
-      res.end();
-    }
-  };
+	return async function vitestOrchestratorMiddleware(req, res, next) {
+		if (!req.url) {
+			return next();
+		}
+		const url = new URL(req.url, "http://localhost");
+		if (url.pathname !== parentServer.base) {
+			return next();
+		}
+		const html = await resolveOrchestrator(parentServer, url, res);
+		if (html) {
+			disableCache(res);
+			allowIframes(res);
+			res.write(html, "utf-8");
+			res.end();
+		}
+	};
 }
 
 /// <reference types="../types/index.d.ts" />
@@ -446,119 +435,111 @@ const stringify = (value, replacer, space) => {
 };
 
 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 session = globalServer.vitest._browserSessions.getSession(sessionId);
-  if (!session) {
-    res.statusCode = 400;
-    res.end("Invalid session ID");
-    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;
-    res.end("Invalid session ID");
-    return;
-  }
-  const injectorJs = typeof globalServer.injectorJs === "string" ? globalServer.injectorJs : await globalServer.injectorJs;
-  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_SESSION_ID__: JSON.stringify(sessionId),
-    __VITEST_TESTER_ID__: JSON.stringify(crypto.randomUUID()),
-    __VITEST_PROVIDED_CONTEXT__: JSON.stringify(stringify(project.getProvidedContext())),
-    __VITEST_API_TOKEN__: JSON.stringify(globalServer.vitest.config.api.token)
-  });
-  const testerHtml = typeof browserProject.testerHtml === "string" ? browserProject.testerHtml : await browserProject.testerHtml;
-  try {
-    const url2 = join("/@fs/", browserProject.testerFilepath);
-    const indexhtml = await browserProject.vite.transformIndexHtml(url2, testerHtml);
-    const html = replacer(indexhtml, {
-      __VITEST_FAVICON__: globalServer.faviconUrl,
-      __VITEST_INJECTOR__: injector,
-      __VITEST_APPEND__: `
+	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 session = globalServer.vitest._browserSessions.getSession(sessionId);
+	if (!session) {
+		res.statusCode = 400;
+		res.end("Invalid session ID");
+		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;
+		res.end("Invalid session ID");
+		return;
+	}
+	const injectorJs = typeof globalServer.injectorJs === "string" ? globalServer.injectorJs : await globalServer.injectorJs;
+	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_SESSION_ID__: JSON.stringify(sessionId),
+		__VITEST_TESTER_ID__: JSON.stringify(crypto.randomUUID()),
+		__VITEST_PROVIDED_CONTEXT__: JSON.stringify(stringify(project.getProvidedContext())),
+		__VITEST_API_TOKEN__: JSON.stringify(globalServer.vitest.config.api.token)
+	});
+	const testerHtml = typeof browserProject.testerHtml === "string" ? browserProject.testerHtml : await browserProject.testerHtml;
+	try {
+		const url = join("/@fs/", browserProject.testerFilepath);
+		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()
     `
-    });
-    return html;
-  } catch (err) {
-    session.reject(err);
-    next(err);
-  }
+		});
+		return html;
+	} catch (err) {
+		session.reject(err);
+		next(err);
+	}
 }
 
 function createTesterMiddleware(browserServer) {
-  return async function vitestTesterMiddleware(req, res, next) {
-    if (!req.url) {
-      return next();
-    }
-    const url = new URL(req.url, "http://localhost");
-    if (!url.pathname.startsWith(browserServer.prefixTesterUrl)) {
-      return next();
-    }
-    const html = await resolveTester(browserServer, url, res, next);
-    if (html) {
-      disableCache(res);
-      allowIframes(res);
-      res.write(html, "utf-8");
-      res.end();
-    }
-  };
+	return async function vitestTesterMiddleware(req, res, next) {
+		if (!req.url) {
+			return next();
+		}
+		const url = new URL(req.url, "http://localhost");
+		if (!url.pathname.startsWith(browserServer.prefixTesterUrl)) {
+			return next();
+		}
+		const html = await resolveTester(browserServer, url, res, next);
+		if (html) {
+			disableCache(res);
+			allowIframes(res);
+			res.write(html, "utf-8");
+			res.end();
+		}
+	};
 }
 
 const VIRTUAL_ID_CONTEXT = "\0@vitest/browser/context";
 const ID_CONTEXT = "@vitest/browser/context";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function BrowserContext(globalServer) {
-  return {
-    name: "vitest:browser:virtual-module:context",
-    enforce: "pre",
-    resolveId(id) {
-      if (id === ID_CONTEXT) {
-        return VIRTUAL_ID_CONTEXT;
-      }
-    },
-    load(id) {
-      if (id === VIRTUAL_ID_CONTEXT) {
-        return generateContextFile.call(this, globalServer);
-      }
-    }
-  };
+	return {
+		name: "vitest:browser:virtual-module:context",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === ID_CONTEXT) {
+				return VIRTUAL_ID_CONTEXT;
+			}
+		},
+		load(id) {
+			if (id === VIRTUAL_ID_CONTEXT) {
+				return generateContextFile.call(this, globalServer);
+			}
+		}
+	};
 }
 async function generateContextFile(globalServer) {
-  const commands = Object.keys(globalServer.commands);
-  const provider = [...globalServer.children][0].provider || { name: "preview" };
-  const providerName = provider.name;
-  const commandsCode = commands.filter((command) => !command.startsWith("__vitest")).map((command) => {
-    return `    ["${command}"]: (...args) => __vitest_browser_runner__.commands.triggerCommand("${command}", args),`;
-  }).join("\n");
-  const userEventNonProviderImport = await getUserEventImport(
-    providerName,
-    this.resolve.bind(this)
-  );
-  const distContextPath = slash$1(`/@fs/${resolve(__dirname, "context.js")}`);
-  return `
+	const commands = Object.keys(globalServer.commands);
+	const provider = [...globalServer.children][0].provider || { name: "preview" };
+	const providerName = provider.name;
+	const commandsCode = commands.filter((command) => !command.startsWith("__vitest")).map((command) => {
+		return `    ["${command}"]: (...args) => __vitest_browser_runner__.commands.triggerCommand("${command}", args),`;
+	}).join("\n");
+	const userEventNonProviderImport = await getUserEventImport(providerName, this.resolve.bind(this));
+	const distContextPath = slash$1(`/@fs/${resolve(__dirname, "context.js")}`);
+	return `
 import { page, createUserEvent, cdp } from '${distContextPath}'
 ${userEventNonProviderImport}
 
@@ -577,410 +558,361 @@ export const userEvent = createUserEvent(_userEventSetup)
 export { page, cdp }
 `;
 }
-async function getUserEventImport(provider, resolve2) {
-  if (provider !== "preview") {
-    return "const _userEventSetup = undefined";
-  }
-  const resolved = await resolve2("@testing-library/user-event", __dirname);
-  if (!resolved) {
-    throw new Error(`Failed to resolve user-event package from ${__dirname}`);
-  }
-  return `import { userEvent as __vitest_user_event__ } from '${slash$1(`/@fs/${resolved.id}`)}'
+async function getUserEventImport(provider, resolve) {
+	if (provider !== "preview") {
+		return "const _userEventSetup = undefined";
+	}
+	const resolved = await resolve("@testing-library/user-event", __dirname);
+	if (!resolved) {
+		throw new Error(`Failed to resolve user-event package from ${__dirname}`);
+	}
+	return `\
+import { userEvent as __vitest_user_event__ } from '${slash$1(`/@fs/${resolved.id}`)}'
 const _userEventSetup = __vitest_user_event__
 `;
 }
 
 const versionRegexp = /(?:\?|&)v=\w{8}/;
 var BrowserPlugin = (parentServer, base = "/") => {
-  function isPackageExists(pkg, root) {
-    return parentServer.vitest.packageInstaller.isPackageExists?.(pkg, {
-      paths: [root]
-    });
-  }
-  return [
-    {
-      enforce: "pre",
-      name: "vitest:browser",
-      async configureServer(server) {
-        parentServer.setServer(server);
-        server.middlewares.use(function vitestHeaders(_req, res, next) {
-          const headers = server.config.server.headers;
-          if (headers) {
-            for (const name in headers) {
-              res.setHeader(name, headers[name]);
-            }
-          }
-          next();
-        });
-        server.middlewares.use(createOrchestratorMiddleware(parentServer));
-        server.middlewares.use(createTesterMiddleware(parentServer));
-        server.middlewares.use(
-          `${base}favicon.svg`,
-          (_, res) => {
-            const content = readFileSync(resolve(distRoot, "client/favicon.svg"));
-            res.write(content, "utf-8");
-            res.end();
-          }
-        );
-        const coverageFolder = resolveCoverageFolder(parentServer.vitest);
-        const coveragePath = coverageFolder ? coverageFolder[1] : void 0;
-        if (coveragePath && base === coveragePath) {
-          throw new Error(
-            `The ui base path and the coverage path cannot be the same: ${base}, change coverage.reportsDirectory`
-          );
-        }
-        if (coverageFolder) {
-          server.middlewares.use(
-            coveragePath,
-            sirv(coverageFolder[0], {
-              single: true,
-              dev: true,
-              setHeaders: (res) => {
-                res.setHeader(
-                  "Cache-Control",
-                  "public,max-age=0,must-revalidate"
-                );
-              }
-            })
-          );
-        }
-        const uiEnabled = parentServer.config.browser.ui;
-        if (uiEnabled) {
-          server.middlewares.use(`${base}__screenshot-error`, function vitestBrowserScreenshotError(req, res) {
-            if (!req.url) {
-              res.statusCode = 404;
-              res.end();
-              return;
-            }
-            const url = new URL(req.url, "http://localhost");
-            const id = url.searchParams.get("id");
-            if (!id) {
-              res.statusCode = 404;
-              res.end();
-              return;
-            }
-            const task = parentServer.vitest.state.idMap.get(id);
-            const file = task?.meta.failScreenshotPath;
-            if (!file) {
-              res.statusCode = 404;
-              res.end();
-              return;
-            }
-            let stat;
-            try {
-              stat = lstatSync(file);
-            } catch {
-            }
-            if (!stat?.isFile()) {
-              res.statusCode = 404;
-              res.end();
-              return;
-            }
-            const ext = extname(file);
-            const buffer = readFileSync(file);
-            res.setHeader(
-              "Cache-Control",
-              "public,max-age=0,must-revalidate"
-            );
-            res.setHeader("Content-Length", buffer.length);
-            res.setHeader("Content-Type", ext === "jpeg" || ext === "jpg" ? "image/jpeg" : ext === "webp" ? "image/webp" : "image/png");
-            res.end(buffer);
-          });
-        }
-        server.middlewares.use((req, res, next) => {
-          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);
-            };
-          }
-          next();
-        });
-      }
-    },
-    {
-      name: "vitest:browser:tests",
-      enforce: "pre",
-      async config() {
-        const project = parentServer.project;
-        const { testFiles: allTestFiles } = await project.globTestFiles();
-        const browserTestFiles = allTestFiles.filter(
-          (file) => getFilePoolName(project, file) === "browser"
-        );
-        const setupFiles = toArray(project.config.setupFiles);
-        const define = {};
-        for (const env in project.config.env || {}) {
-          const stringValue = JSON.stringify(project.config.env[env]);
-          define[`import.meta.env.${env}`] = stringValue;
-        }
-        const entries = [
-          ...browserTestFiles,
-          ...setupFiles,
-          resolve(distDir, "index.js"),
-          resolve(distDir, "browser.js"),
-          resolve(distDir, "runners.js"),
-          resolve(distDir, "utils.js"),
-          ...project.config.snapshotSerializers || []
-        ];
-        const exclude = [
-          "vitest",
-          "vitest/utils",
-          "vitest/browser",
-          "vitest/runners",
-          "@vitest/browser",
-          "@vitest/browser/client",
-          "@vitest/utils",
-          "@vitest/utils/source-map",
-          "@vitest/runner",
-          "@vitest/spy",
-          "@vitest/utils/error",
-          "@vitest/snapshot",
-          "@vitest/expect",
-          "std-env",
-          "tinybench",
-          "tinyspy",
-          "tinyrainbow",
-          "pathe",
-          "msw",
-          "msw/browser"
-        ];
-        if (typeof project.config.diff === "string") {
-          entries.push(project.config.diff);
-        }
-        if (parentServer.vitest.coverageProvider) {
-          const coverage = parentServer.vitest.config.coverage;
-          const provider = coverage.provider;
-          if (provider === "v8") {
-            const path = tryResolve("@vitest/coverage-v8", [parentServer.config.root]);
-            if (path) {
-              entries.push(path);
-              exclude.push("@vitest/coverage-v8/browser");
-            }
-          } else if (provider === "istanbul") {
-            const path = tryResolve("@vitest/coverage-istanbul", [parentServer.config.root]);
-            if (path) {
-              entries.push(path);
-              exclude.push("@vitest/coverage-istanbul");
-            }
-          } else if (provider === "custom" && coverage.customProviderModule) {
-            entries.push(coverage.customProviderModule);
-          }
-        }
-        const include = [
-          "vitest > expect-type",
-          "vitest > @vitest/snapshot > magic-string",
-          "vitest > chai",
-          "vitest > chai > loupe",
-          "vitest > @vitest/utils > loupe",
-          "@vitest/browser > @testing-library/user-event",
-          "@vitest/browser > @testing-library/dom"
-        ];
-        const fileRoot = browserTestFiles[0] ? dirname(browserTestFiles[0]) : project.config.root;
-        const svelte = isPackageExists("vitest-browser-svelte", fileRoot);
-        if (svelte) {
-          exclude.push("vitest-browser-svelte");
-        }
-        const vue = isPackageExists("vitest-browser-vue", fileRoot);
-        if (vue) {
-          include.push(
-            "vitest-browser-vue",
-            "vitest-browser-vue > @vue/test-utils",
-            "vitest-browser-vue > @vue/test-utils > @vue/compiler-core"
-          );
-        }
-        const vueTestUtils = isPackageExists("@vue/test-utils", fileRoot);
-        if (vueTestUtils) {
-          include.push("@vue/test-utils");
-        }
-        return {
-          define,
-          resolve: {
-            dedupe: ["vitest"]
-          },
-          optimizeDeps: {
-            entries,
-            exclude,
-            include
-          }
-        };
-      },
-      async resolveId(id) {
-        if (!/\?browserv=\w+$/.test(id)) {
-          return;
-        }
-        let useId = id.slice(0, id.lastIndexOf("?"));
-        if (useId.startsWith("/@fs/")) {
-          useId = useId.slice(5);
-        }
-        if (/^\w:/.test(useId)) {
-          useId = useId.replace(/\\/g, "/");
-        }
-        return useId;
-      }
-    },
-    {
-      name: "vitest:browser:resolve-virtual",
-      async resolveId(rawId) {
-        if (rawId === "/mockServiceWorker.js") {
-          return this.resolve("msw/mockServiceWorker.js", distRoot, {
-            skipSelf: true
-          });
-        }
-      }
-    },
-    {
-      name: "vitest:browser:assets",
-      configureServer(server) {
-        server.middlewares.use(
-          "/__vitest__",
-          sirv(resolve(distRoot, "client/__vitest__"))
-        );
-      },
-      resolveId(id) {
-        if (id.startsWith("/__vitest_browser__/")) {
-          return resolve(distRoot, "client", id.slice(1));
-        }
-      },
-      transform(code, id) {
-        if (id.includes(parentServer.vite.config.cacheDir) && id.includes("loupe.js")) {
-          const utilRequire = "nodeUtil = require_util();";
-          return code.replace(utilRequire, " ".repeat(utilRequire.length));
-        }
-      }
-    },
-    BrowserContext(parentServer),
-    dynamicImportPlugin({
-      globalThisAccessor: '"__vitest_browser_runner__"',
-      filter(id) {
-        if (id.includes(distRoot)) {
-          return false;
-        }
-        return true;
-      }
-    }),
-    {
-      name: "vitest:browser:config",
-      enforce: "post",
-      async config(viteConfig) {
-        // Enables using ignore hint for coverage providers with @preserve keyword
-        if (viteConfig.esbuild !== false) {
-          viteConfig.esbuild ||= {};
-          viteConfig.esbuild.legalComments = "inline";
-        }
-        const defaultPort = parentServer.vitest._browserLastPort++;
-        const api = resolveApiServerConfig(
-          viteConfig.test?.browser || {},
-          defaultPort
-        );
-        viteConfig.server = {
-          ...viteConfig.server,
-          port: defaultPort,
-          ...api,
-          middlewareMode: false,
-          open: false
-        };
-        viteConfig.server.fs ??= {};
-        viteConfig.server.fs.allow = viteConfig.server.fs.allow || [];
-        viteConfig.server.fs.allow.push(
-          ...resolveFsAllow(
-            parentServer.vitest.config.root,
-            parentServer.vitest.vite.config.configFile
-          ),
-          distRoot
-        );
-        return {
-          resolve: {
-            alias: viteConfig.test?.alias
-          }
-        };
-      }
-    },
-    {
-      name: "vitest:browser:in-source-tests",
-      transform(code, id) {
-        const project = parentServer.vitest.getProjectByName(parentServer.config.name);
-        if (!project._isCachedTestFile(id) || !code.includes("import.meta.vitest")) {
-          return;
-        }
-        const s = new MagicString(code, { filename: cleanUrl(id) });
-        s.prepend(
-          `import.meta.vitest = __vitest_index__;
-`
-        );
-        return {
-          code: s.toString(),
-          map: s.generateMap({ hires: true })
-        };
-      }
-    },
-    {
-      name: "vitest:browser:worker",
-      transform(code, id, _options) {
-        if (/(?:\?|&)worker_file&type=\w+(?:&|$)/.test(id)) {
-          const s = new MagicString(code);
-          s.prepend("globalThis.__vitest_browser_runner__ = { wrapDynamicImport: f => f() };\n");
-          return {
-            code: s.toString(),
-            map: s.generateMap({ hires: "boundary" })
-          };
-        }
-      }
-    },
-    {
-      name: "vitest:browser:transform-tester-html",
-      enforce: "pre",
-      async transformIndexHtml(html, ctx) {
-        const projectBrowser = [...parentServer.children].find((server) => {
-          return ctx.filename === server.testerFilepath;
-        });
-        if (!projectBrowser) {
-          return;
-        }
-        if (!parentServer.testerScripts) {
-          const testerScripts = await parentServer.formatScripts(
-            parentServer.config.browser.testerScripts
-          );
-          parentServer.testerScripts = testerScripts;
-        }
-        const stateJs = typeof parentServer.stateJs === "string" ? parentServer.stateJs : await parentServer.stateJs;
-        const testerTags = [];
-        const isDefaultTemplate = resolve(distRoot, "client/tester/tester.html") === projectBrowser.testerFilepath;
-        if (!isDefaultTemplate) {
-          const manifestContent = parentServer.manifest instanceof Promise ? await parentServer.manifest : parentServer.manifest;
-          const testerEntry = manifestContent["tester/tester.html"];
-          testerTags.push({
-            tag: "script",
-            attrs: {
-              type: "module",
-              crossorigin: "",
-              src: `${parentServer.base}${testerEntry.file}`
-            },
-            injectTo: "head"
-          });
-          for (const importName of testerEntry.imports || []) {
-            const entryManifest = manifestContent[importName];
-            if (entryManifest) {
-              testerTags.push(
-                {
-                  tag: "link",
-                  attrs: {
-                    href: `${parentServer.base}${entryManifest.file}`,
-                    rel: "modulepreload",
-                    crossorigin: ""
-                  },
-                  injectTo: "head"
-                }
-              );
-            }
-          }
-        } else {
-          testerTags.push({
-            tag: "style",
-            children: `
+	function isPackageExists(pkg, root) {
+		return parentServer.vitest.packageInstaller.isPackageExists?.(pkg, { paths: [root] });
+	}
+	return [
+		{
+			enforce: "pre",
+			name: "vitest:browser",
+			async configureServer(server) {
+				parentServer.setServer(server);
+				server.middlewares.use(function vitestHeaders(_req, res, next) {
+					const headers = server.config.server.headers;
+					if (headers) {
+						for (const name in headers) {
+							res.setHeader(name, headers[name]);
+						}
+					}
+					next();
+				});
+				server.middlewares.use(createOrchestratorMiddleware(parentServer));
+				server.middlewares.use(createTesterMiddleware(parentServer));
+				server.middlewares.use(`${base}favicon.svg`, (_, res) => {
+					const content = readFileSync(resolve(distRoot, "client/favicon.svg"));
+					res.write(content, "utf-8");
+					res.end();
+				});
+				const coverageFolder = resolveCoverageFolder(parentServer.vitest);
+				const coveragePath = coverageFolder ? coverageFolder[1] : undefined;
+				if (coveragePath && base === coveragePath) {
+					throw new Error(`The ui base path and the coverage path cannot be the same: ${base}, change coverage.reportsDirectory`);
+				}
+				if (coverageFolder) {
+					server.middlewares.use(coveragePath, sirv(coverageFolder[0], {
+						single: true,
+						dev: true,
+						setHeaders: (res) => {
+							res.setHeader("Cache-Control", "public,max-age=0,must-revalidate");
+						}
+					}));
+				}
+				const uiEnabled = parentServer.config.browser.ui;
+				if (uiEnabled) {
+					server.middlewares.use(`${base}__screenshot-error`, function vitestBrowserScreenshotError(req, res) {
+						if (!req.url) {
+							res.statusCode = 404;
+							res.end();
+							return;
+						}
+						const url = new URL(req.url, "http://localhost");
+						const id = url.searchParams.get("id");
+						if (!id) {
+							res.statusCode = 404;
+							res.end();
+							return;
+						}
+						const task = parentServer.vitest.state.idMap.get(id);
+						const file = task?.meta.failScreenshotPath;
+						if (!file) {
+							res.statusCode = 404;
+							res.end();
+							return;
+						}
+						let stat;
+						try {
+							stat = lstatSync(file);
+						} catch {}
+						if (!stat?.isFile()) {
+							res.statusCode = 404;
+							res.end();
+							return;
+						}
+						const ext = extname(file);
+						const buffer = readFileSync(file);
+						res.setHeader("Cache-Control", "public,max-age=0,must-revalidate");
+						res.setHeader("Content-Length", buffer.length);
+						res.setHeader("Content-Type", ext === "jpeg" || ext === "jpg" ? "image/jpeg" : ext === "webp" ? "image/webp" : "image/png");
+						res.end(buffer);
+					});
+				}
+				server.middlewares.use((req, res, next) => {
+					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);
+						};
+					}
+					next();
+				});
+			}
+		},
+		{
+			name: "vitest:browser:tests",
+			enforce: "pre",
+			async config() {
+				const project = parentServer.project;
+				const { testFiles: allTestFiles } = await project.globTestFiles();
+				const browserTestFiles = allTestFiles.filter((file) => getFilePoolName(project, file) === "browser");
+				const setupFiles = toArray(project.config.setupFiles);
+				const define = {};
+				for (const env in project.config.env || {}) {
+					const stringValue = JSON.stringify(project.config.env[env]);
+					define[`import.meta.env.${env}`] = stringValue;
+				}
+				const entries = [
+					...browserTestFiles,
+					...setupFiles,
+					resolve(distDir, "index.js"),
+					resolve(distDir, "browser.js"),
+					resolve(distDir, "runners.js"),
+					resolve(distDir, "utils.js"),
+					...project.config.snapshotSerializers || []
+				];
+				const exclude = [
+					"vitest",
+					"vitest/utils",
+					"vitest/browser",
+					"vitest/runners",
+					"@vitest/browser",
+					"@vitest/browser/client",
+					"@vitest/utils",
+					"@vitest/utils/source-map",
+					"@vitest/runner",
+					"@vitest/spy",
+					"@vitest/utils/error",
+					"@vitest/snapshot",
+					"@vitest/expect",
+					"std-env",
+					"tinybench",
+					"tinyspy",
+					"tinyrainbow",
+					"pathe",
+					"msw",
+					"msw/browser"
+				];
+				if (typeof project.config.diff === "string") {
+					entries.push(project.config.diff);
+				}
+				if (parentServer.vitest.coverageProvider) {
+					const coverage = parentServer.vitest.config.coverage;
+					const provider = coverage.provider;
+					if (provider === "v8") {
+						const path = tryResolve("@vitest/coverage-v8", [parentServer.config.root]);
+						if (path) {
+							entries.push(path);
+							exclude.push("@vitest/coverage-v8/browser");
+						}
+					} else if (provider === "istanbul") {
+						const path = tryResolve("@vitest/coverage-istanbul", [parentServer.config.root]);
+						if (path) {
+							entries.push(path);
+							exclude.push("@vitest/coverage-istanbul");
+						}
+					} else if (provider === "custom" && coverage.customProviderModule) {
+						entries.push(coverage.customProviderModule);
+					}
+				}
+				const include = [
+					"vitest > expect-type",
+					"vitest > @vitest/snapshot > magic-string",
+					"vitest > chai",
+					"vitest > chai > loupe",
+					"vitest > @vitest/utils > loupe",
+					"@vitest/browser > @testing-library/user-event",
+					"@vitest/browser > @testing-library/dom"
+				];
+				const fileRoot = browserTestFiles[0] ? dirname(browserTestFiles[0]) : project.config.root;
+				const svelte = isPackageExists("vitest-browser-svelte", fileRoot);
+				if (svelte) {
+					exclude.push("vitest-browser-svelte");
+				}
+				const vue = isPackageExists("vitest-browser-vue", fileRoot);
+				if (vue) {
+					include.push("vitest-browser-vue", "vitest-browser-vue > @vue/test-utils", "vitest-browser-vue > @vue/test-utils > @vue/compiler-core");
+				}
+				const vueTestUtils = isPackageExists("@vue/test-utils", fileRoot);
+				if (vueTestUtils) {
+					include.push("@vue/test-utils");
+				}
+				return {
+					define,
+					resolve: { dedupe: ["vitest"] },
+					optimizeDeps: {
+						entries,
+						exclude,
+						include
+					}
+				};
+			},
+			async resolveId(id) {
+				if (!/\?browserv=\w+$/.test(id)) {
+					return;
+				}
+				let useId = id.slice(0, id.lastIndexOf("?"));
+				if (useId.startsWith("/@fs/")) {
+					useId = useId.slice(5);
+				}
+				if (/^\w:/.test(useId)) {
+					useId = useId.replace(/\\/g, "/");
+				}
+				return useId;
+			}
+		},
+		{
+			name: "vitest:browser:resolve-virtual",
+			async resolveId(rawId) {
+				if (rawId === "/mockServiceWorker.js") {
+					return this.resolve("msw/mockServiceWorker.js", distRoot, { skipSelf: true });
+				}
+			}
+		},
+		{
+			name: "vitest:browser:assets",
+			configureServer(server) {
+				server.middlewares.use("/__vitest__", sirv(resolve(distRoot, "client/__vitest__")));
+			},
+			resolveId(id) {
+				if (id.startsWith("/__vitest_browser__/")) {
+					return resolve(distRoot, "client", id.slice(1));
+				}
+			},
+			transform(code, id) {
+				if (id.includes(parentServer.vite.config.cacheDir) && id.includes("loupe.js")) {
+					const utilRequire = "nodeUtil = require_util();";
+					return code.replace(utilRequire, " ".repeat(utilRequire.length));
+				}
+			}
+		},
+		BrowserContext(parentServer),
+		dynamicImportPlugin({
+			globalThisAccessor: "\"__vitest_browser_runner__\"",
+			filter(id) {
+				if (id.includes(distRoot)) {
+					return false;
+				}
+				return true;
+			}
+		}),
+		{
+			name: "vitest:browser:config",
+			enforce: "post",
+			async config(viteConfig) {
+				// Enables using ignore hint for coverage providers with @preserve keyword
+				if (viteConfig.esbuild !== false) {
+					viteConfig.esbuild ||= {};
+					viteConfig.esbuild.legalComments = "inline";
+				}
+				const defaultPort = parentServer.vitest._browserLastPort++;
+				const api = resolveApiServerConfig(viteConfig.test?.browser || {}, defaultPort);
+				viteConfig.server = {
+					...viteConfig.server,
+					port: defaultPort,
+					...api,
+					middlewareMode: false,
+					open: false
+				};
+				viteConfig.server.fs ??= {};
+				viteConfig.server.fs.allow = viteConfig.server.fs.allow || [];
+				viteConfig.server.fs.allow.push(...resolveFsAllow(parentServer.vitest.config.root, parentServer.vitest.vite.config.configFile), distRoot);
+				return { resolve: { alias: viteConfig.test?.alias } };
+			}
+		},
+		{
+			name: "vitest:browser:in-source-tests",
+			transform(code, id) {
+				const project = parentServer.vitest.getProjectByName(parentServer.config.name);
+				if (!project._isCachedTestFile(id) || !code.includes("import.meta.vitest")) {
+					return;
+				}
+				const s = new MagicString(code, { filename: cleanUrl(id) });
+				s.prepend(`import.meta.vitest = __vitest_index__;\n`);
+				return {
+					code: s.toString(),
+					map: s.generateMap({ hires: true })
+				};
+			}
+		},
+		{
+			name: "vitest:browser:worker",
+			transform(code, id, _options) {
+				if (/(?:\?|&)worker_file&type=\w+(?:&|$)/.test(id)) {
+					const s = new MagicString(code);
+					s.prepend("globalThis.__vitest_browser_runner__ = { wrapDynamicImport: f => f() };\n");
+					return {
+						code: s.toString(),
+						map: s.generateMap({ hires: "boundary" })
+					};
+				}
+			}
+		},
+		{
+			name: "vitest:browser:transform-tester-html",
+			enforce: "pre",
+			async transformIndexHtml(html, ctx) {
+				const projectBrowser = [...parentServer.children].find((server) => {
+					return ctx.filename === server.testerFilepath;
+				});
+				if (!projectBrowser) {
+					return;
+				}
+				if (!parentServer.testerScripts) {
+					const testerScripts = await parentServer.formatScripts(parentServer.config.browser.testerScripts);
+					parentServer.testerScripts = testerScripts;
+				}
+				const stateJs = typeof parentServer.stateJs === "string" ? parentServer.stateJs : await parentServer.stateJs;
+				const testerTags = [];
+				const isDefaultTemplate = resolve(distRoot, "client/tester/tester.html") === projectBrowser.testerFilepath;
+				if (!isDefaultTemplate) {
+					const manifestContent = parentServer.manifest instanceof Promise ? await parentServer.manifest : parentServer.manifest;
+					const testerEntry = manifestContent["tester/tester.html"];
+					testerTags.push({
+						tag: "script",
+						attrs: {
+							type: "module",
+							crossorigin: "",
+							src: `${parentServer.base}${testerEntry.file}`
+						},
+						injectTo: "head"
+					});
+					for (const importName of testerEntry.imports || []) {
+						const entryManifest = manifestContent[importName];
+						if (entryManifest) {
+							testerTags.push({
+								tag: "link",
+								attrs: {
+									href: `${parentServer.base}${entryManifest.file}`,
+									rel: "modulepreload",
+									crossorigin: ""
+								},
+								injectTo: "head"
+							});
+						}
+					}
+				} else {
+					testerTags.push({
+						tag: "style",
+						children: `
 html {
   padding: 0;
   margin: 0;
@@ -990,244 +922,268 @@ body {
   margin: 0;
   min-height: 100vh;
 }`,
-            injectTo: "head"
-          });
-        }
-        return [
-          {
-            tag: "script",
-            children: "{__VITEST_INJECTOR__}",
-            injectTo: "head-prepend"
-          },
-          {
-            tag: "script",
-            children: stateJs,
-            injectTo: "head-prepend"
-          },
-          {
-            tag: "script",
-            attrs: {
-              type: "module",
-              src: parentServer.errorCatcherUrl
-            },
-            injectTo: "head"
-          },
-          parentServer.locatorsUrl ? {
-            tag: "script",
-            attrs: {
-              type: "module",
-              src: parentServer.locatorsUrl
-            },
-            injectTo: "head"
-          } : null,
-          ...parentServer.testerScripts,
-          ...testerTags,
-          {
-            tag: "script",
-            attrs: {
-              "type": "module",
-              "data-vitest-append": ""
-            },
-            children: "{__VITEST_APPEND__}",
-            injectTo: "body"
-          }
-        ].filter((s) => s != null);
-      }
-    },
-    {
-      name: "vitest:browser:support-testing-library",
-      config() {
-        return {
-          optimizeDeps: {
-            esbuildOptions: {
-              plugins: [
-                {
-                  name: "test-utils-rewrite",
-                  setup(build) {
-                    build.onResolve({ filter: /^@vue\/(test-utils|compiler-core)$/ }, (args) => {
-                      const resolved = getRequire().resolve(args.path, {
-                        paths: [args.importer]
-                      });
-                      return { path: resolved };
-                    });
-                  }
-                }
-              ]
-            }
-          }
-        };
-      }
-    }
-  ];
+						injectTo: "head"
+					});
+				}
+				return [
+					{
+						tag: "script",
+						children: "{__VITEST_INJECTOR__}",
+						injectTo: "head-prepend"
+					},
+					{
+						tag: "script",
+						children: stateJs,
+						injectTo: "head-prepend"
+					},
+					{
+						tag: "script",
+						attrs: {
+							type: "module",
+							src: parentServer.errorCatcherUrl
+						},
+						injectTo: "head"
+					},
+					{
+						tag: "script",
+						attrs: {
+							type: "module",
+							src: parentServer.matchersUrl
+						},
+						injectTo: "head"
+					},
+					parentServer.locatorsUrl ? {
+						tag: "script",
+						attrs: {
+							type: "module",
+							src: parentServer.locatorsUrl
+						},
+						injectTo: "head"
+					} : null,
+					...parentServer.testerScripts,
+					...testerTags,
+					{
+						tag: "script",
+						attrs: {
+							"type": "module",
+							"data-vitest-append": ""
+						},
+						children: "{__VITEST_APPEND__}",
+						injectTo: "body"
+					}
+				].filter((s) => s != null);
+			}
+		},
+		{
+			name: "vitest:browser:support-testing-library",
+			config() {
+				const rolldownPlugin = {
+					name: "vue-test-utils-rewrite",
+					resolveId: {
+						filter: { id: /^@vue\/(test-utils|compiler-core)$/ },
+						handler(source, importer) {
+							const resolved = getRequire().resolve(source, { paths: [importer] });
+							return resolved;
+						}
+					}
+				};
+				const esbuildPlugin = {
+					name: "test-utils-rewrite",
+					setup(build) {
+						build.onResolve({ filter: /^@vue\/(test-utils|compiler-core)$/ }, (args) => {
+							const resolved = getRequire().resolve(args.path, { paths: [args.importer] });
+							return { path: resolved };
+						});
+					}
+				};
+				return { optimizeDeps: "rolldownVersion" in vite ? { rollupOptions: { plugins: [rolldownPlugin] } } : { esbuildOptions: { plugins: [esbuildPlugin] } } };
+			}
+		}
+	];
 };
 function tryResolve(path, paths) {
-  try {
-    const _require2 = getRequire();
-    return _require2.resolve(path, { paths });
-  } catch {
-    return void 0;
-  }
+	try {
+		const _require = getRequire();
+		return _require.resolve(path, { paths });
+	} catch {
+		return undefined;
+	}
 }
 let _require;
 function getRequire() {
-  if (!_require) {
-    _require = createRequire(import.meta.url);
-  }
-  return _require;
+	if (!_require) {
+		_require = createRequire(import.meta.url);
+	}
+	return _require;
 }
 function resolveCoverageFolder(vitest) {
-  const options = vitest.config;
-  const htmlReporter = options.coverage?.enabled ? toArray(options.coverage.reporter).find((reporter) => {
-    if (typeof reporter === "string") {
-      return reporter === "html";
-    }
-    return reporter[0] === "html";
-  }) : void 0;
-  if (!htmlReporter) {
-    return void 0;
-  }
-  const root = resolve(
-    options.root || process.cwd(),
-    options.coverage.reportsDirectory || coverageConfigDefaults.reportsDirectory
-  );
-  const subdir = Array.isArray(htmlReporter) && htmlReporter.length > 1 && "subdir" in htmlReporter[1] ? htmlReporter[1].subdir : void 0;
-  if (!subdir || typeof subdir !== "string") {
-    return [root, `/${basename(root)}/`];
-  }
-  return [resolve(root, subdir), `/${basename(root)}/${subdir}/`];
+	const options = vitest.config;
+	const htmlReporter = options.coverage?.enabled ? toArray(options.coverage.reporter).find((reporter) => {
+		if (typeof reporter === "string") {
+			return reporter === "html";
+		}
+		return reporter[0] === "html";
+	}) : undefined;
+	if (!htmlReporter) {
+		return undefined;
+	}
+	const root = resolve(options.root || process.cwd(), options.coverage.reportsDirectory || coverageConfigDefaults.reportsDirectory);
+	const subdir = Array.isArray(htmlReporter) && htmlReporter.length > 1 && "subdir" in htmlReporter[1] ? htmlReporter[1].subdir : undefined;
+	if (!subdir || typeof subdir !== "string") {
+		return [root, `/${basename(root)}/`];
+	}
+	return [resolve(root, subdir), `/${basename(root)}/${subdir}/`];
 }
 const postfixRE = /[?#].*$/;
 function cleanUrl(url) {
-  return url.replace(postfixRE, "");
+	return url.replace(postfixRE, "");
 }
 
 class BrowserServerCDPHandler {
-  constructor(session, tester) {
-    this.session = session;
-    this.tester = tester;
-  }
-  listenerIds = {};
-  listeners = {};
-  send(method, params) {
-    return this.session.send(method, params);
-  }
-  on(event, id, once = false) {
-    if (!this.listenerIds[event]) {
-      this.listenerIds[event] = [];
-    }
-    this.listenerIds[event].push(id);
-    if (!this.listeners[event]) {
-      this.listeners[event] = (payload) => {
-        this.tester.cdpEvent(
-          event,
-          payload
-        );
-        if (once) {
-          this.off(event, id);
-        }
-      };
-      this.session.on(event, this.listeners[event]);
-    }
-  }
-  off(event, id) {
-    if (!this.listenerIds[event]) {
-      this.listenerIds[event] = [];
-    }
-    this.listenerIds[event] = this.listenerIds[event].filter((l) => l !== id);
-    if (!this.listenerIds[event].length) {
-      this.session.off(event, this.listeners[event]);
-      delete this.listeners[event];
-    }
-  }
-  once(event, listener) {
-    this.on(event, listener, true);
-  }
+	listenerIds = {};
+	listeners = {};
+	constructor(session, tester) {
+		this.session = session;
+		this.tester = tester;
+	}
+	send(method, params) {
+		return this.session.send(method, params);
+	}
+	on(event, id, once = false) {
+		if (!this.listenerIds[event]) {
+			this.listenerIds[event] = [];
+		}
+		this.listenerIds[event].push(id);
+		if (!this.listeners[event]) {
+			this.listeners[event] = (payload) => {
+				this.tester.cdpEvent(event, payload);
+				if (once) {
+					this.off(event, id);
+				}
+			};
+			this.session.on(event, this.listeners[event]);
+		}
+	}
+	off(event, id) {
+		if (!this.listenerIds[event]) {
+			this.listenerIds[event] = [];
+		}
+		this.listenerIds[event] = this.listenerIds[event].filter((l) => l !== id);
+		if (!this.listenerIds[event].length) {
+			this.session.off(event, this.listeners[event]);
+			delete this.listeners[event];
+		}
+	}
+	once(event, listener) {
+		this.on(event, listener, true);
+	}
 }
 
 const clear = async (context, selector) => {
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    const { iframe } = context;
-    const element = iframe.locator(selector);
-    await element.clear();
-  } else if (context.provider instanceof WebdriverBrowserProvider) {
-    const browser = context.browser;
-    const element = await browser.$(selector);
-    await element.clearValue();
-  } else {
-    throw new TypeError(`Provider "${context.provider.name}" does not support clearing elements`);
-  }
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		const { iframe } = context;
+		const element = iframe.locator(selector);
+		await element.clear();
+	} else if (context.provider instanceof WebdriverBrowserProvider) {
+		const browser = context.browser;
+		const element = await browser.$(selector);
+		await element.clearValue();
+	} else {
+		throw new TypeError(`Provider "${context.provider.name}" does not support clearing elements`);
+	}
 };
 
 const click = async (context, selector, options = {}) => {
-  const provider = context.provider;
-  if (provider instanceof PlaywrightBrowserProvider) {
-    const tester = context.iframe;
-    await tester.locator(selector).click(options);
-  } else if (provider instanceof WebdriverBrowserProvider) {
-    const browser = context.browser;
-    await browser.$(selector).click(options);
-  } else {
-    throw new TypeError(`Provider "${provider.name}" doesn't support click command`);
-  }
+	const provider = context.provider;
+	if (provider instanceof PlaywrightBrowserProvider) {
+		const tester = context.iframe;
+		await tester.locator(selector).click(options);
+	} else if (provider instanceof WebdriverBrowserProvider) {
+		const browser = context.browser;
+		await browser.$(selector).click(options);
+	} else {
+		throw new TypeError(`Provider "${provider.name}" doesn't support click command`);
+	}
 };
 const dblClick = async (context, selector, options = {}) => {
-  const provider = context.provider;
-  if (provider instanceof PlaywrightBrowserProvider) {
-    const tester = context.iframe;
-    await tester.locator(selector).dblclick(options);
-  } else if (provider instanceof WebdriverBrowserProvider) {
-    const browser = context.browser;
-    await browser.$(selector).doubleClick();
-  } else {
-    throw new TypeError(`Provider "${provider.name}" doesn't support dblClick command`);
-  }
+	const provider = context.provider;
+	if (provider instanceof PlaywrightBrowserProvider) {
+		const tester = context.iframe;
+		await tester.locator(selector).dblclick(options);
+	} else if (provider instanceof WebdriverBrowserProvider) {
+		const browser = context.browser;
+		await browser.$(selector).doubleClick();
+	} else {
+		throw new TypeError(`Provider "${provider.name}" doesn't support dblClick command`);
+	}
 };
 const tripleClick = async (context, selector, options = {}) => {
-  const provider = context.provider;
-  if (provider instanceof PlaywrightBrowserProvider) {
-    const tester = context.iframe;
-    await tester.locator(selector).click({
-      ...options,
-      clickCount: 3
-    });
-  } else if (provider instanceof WebdriverBrowserProvider) {
-    const browser = context.browser;
-    await browser.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: browser.$(selector) }).down().up().pause(50).down().up().pause(50).down().up().pause(50).perform();
-  } else {
-    throw new TypeError(`Provider "${provider.name}" doesn't support tripleClick command`);
-  }
+	const provider = context.provider;
+	if (provider instanceof PlaywrightBrowserProvider) {
+		const tester = context.iframe;
+		await tester.locator(selector).click({
+			...options,
+			clickCount: 3
+		});
+	} else if (provider instanceof WebdriverBrowserProvider) {
+		const browser = context.browser;
+		await browser.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: browser.$(selector) }).down().up().pause(50).down().up().pause(50).down().up().pause(50).perform();
+	} else {
+		throw new TypeError(`Provider "${provider.name}" doesn't support tripleClick command`);
+	}
 };
 
 const dragAndDrop = async (context, source, target, options_) => {
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    const frame = await context.frame();
-    await frame.dragAndDrop(
-      source,
-      target,
-      options_
-    );
-  } else if (context.provider instanceof WebdriverBrowserProvider) {
-    const $source = context.browser.$(source);
-    const $target = context.browser.$(target);
-    const options = options_ || {};
-    const duration = options.duration ?? 10;
-    await context.browser.action("pointer").move({ duration: 0, origin: $source, x: options.sourceX ?? 0, y: options.sourceY ?? 0 }).down({ button: 0 }).move({ duration: 0, origin: "pointer", x: 0, y: 0 }).pause(duration).move({ duration: 0, origin: $target, x: options.targetX ?? 0, y: options.targetY ?? 0 }).move({ duration: 0, origin: "pointer", x: 1, y: 0 }).move({ duration: 0, origin: "pointer", x: -1, y: 0 }).up({ button: 0 }).perform();
-  } else {
-    throw new TypeError(`Provider "${context.provider.name}" does not support dragging elements`);
-  }
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		const frame = await context.frame();
+		await frame.dragAndDrop(source, target, options_);
+	} else if (context.provider instanceof WebdriverBrowserProvider) {
+		const $source = context.browser.$(source);
+		const $target = context.browser.$(target);
+		const options = options_ || {};
+		const duration = options.duration ?? 10;
+		await context.browser.action("pointer").move({
+			duration: 0,
+			origin: $source,
+			x: options.sourceX ?? 0,
+			y: options.sourceY ?? 0
+		}).down({ button: 0 }).move({
+			duration: 0,
+			origin: "pointer",
+			x: 0,
+			y: 0
+		}).pause(duration).move({
+			duration: 0,
+			origin: $target,
+			x: options.targetX ?? 0,
+			y: options.targetY ?? 0
+		}).move({
+			duration: 0,
+			origin: "pointer",
+			x: 1,
+			y: 0
+		}).move({
+			duration: 0,
+			origin: "pointer",
+			x: -1,
+			y: 0
+		}).up({ button: 0 }).perform();
+	} else {
+		throw new TypeError(`Provider "${context.provider.name}" does not support dragging elements`);
+	}
 };
 
 const fill = async (context, selector, text, options = {}) => {
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    const { iframe } = context;
-    const element = iframe.locator(selector);
-    await element.fill(text, options);
-  } else if (context.provider instanceof WebdriverBrowserProvider) {
-    const browser = context.browser;
-    await browser.$(selector).setValue(text);
-  } else {
-    throw new TypeError(`Provider "${context.provider.name}" does not support filling inputs`);
-  }
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		const { iframe } = context;
+		const element = iframe.locator(selector);
+		await element.fill(text, options);
+	} else if (context.provider instanceof WebdriverBrowserProvider) {
+		const browser = context.browser;
+		await browser.$(selector).setValue(text);
+	} else {
+		throw new TypeError(`Provider "${context.provider.name}" does not support filling inputs`);
+	}
 };
 
 const types = {
@@ -1671,54 +1627,52 @@ _Mime_extensionToType = new WeakMap(), _Mime_typeToExtension = new WeakMap(), _M
 var mime = new Mime(types)._freeze();
 
 function assertFileAccess(path, project) {
-  if (!isFileServingAllowed(path, project.vite) && !isFileServingAllowed(path, project.vitest.server)) {
-    throw new Error(
-      `Access denied to "${path}". See Vite config documentation for "server.fs": https://vitejs.dev/config/server-options.html#server-fs-strict.`
-    );
-  }
+	if (!isFileServingAllowed(path, project.vite) && !isFileServingAllowed(path, project.vitest.server)) {
+		throw new Error(`Access denied to "${path}". See Vite config documentation for "server.fs": https://vitejs.dev/config/server-options.html#server-fs-strict.`);
+	}
 }
 const readFile = async ({ project, testPath = process.cwd() }, path, options = {}) => {
-  const filepath = resolve$1(dirname$1(testPath), path);
-  assertFileAccess(filepath, project);
-  if (typeof options === "object" && !options.encoding) {
-    options.encoding = "utf-8";
-  }
-  return promises.readFile(filepath, options);
+	const filepath = resolve$1(dirname$1(testPath), path);
+	assertFileAccess(filepath, project);
+	if (typeof options === "object" && !options.encoding) {
+		options.encoding = "utf-8";
+	}
+	return promises.readFile(filepath, options);
 };
 const writeFile = async ({ project, testPath = process.cwd() }, path, data, options) => {
-  const filepath = resolve$1(dirname$1(testPath), path);
-  assertFileAccess(filepath, project);
-  const dir = dirname$1(filepath);
-  if (!fs.existsSync(dir)) {
-    await promises.mkdir(dir, { recursive: true });
-  }
-  await promises.writeFile(filepath, data, options);
+	const filepath = resolve$1(dirname$1(testPath), path);
+	assertFileAccess(filepath, project);
+	const dir = dirname$1(filepath);
+	if (!fs.existsSync(dir)) {
+		await promises.mkdir(dir, { recursive: true });
+	}
+	await promises.writeFile(filepath, data, options);
 };
 const removeFile = async ({ project, testPath = process.cwd() }, path) => {
-  const filepath = resolve$1(dirname$1(testPath), path);
-  assertFileAccess(filepath, project);
-  await promises.rm(filepath);
+	const filepath = resolve$1(dirname$1(testPath), path);
+	assertFileAccess(filepath, project);
+	await promises.rm(filepath);
 };
 const _fileInfo = async ({ project, testPath = process.cwd() }, path, encoding) => {
-  const filepath = resolve$1(dirname$1(testPath), path);
-  assertFileAccess(filepath, project);
-  const content = await promises.readFile(filepath, encoding || "base64");
-  return {
-    content,
-    basename: basename$1(filepath),
-    mime: mime.getType(filepath)
-  };
+	const filepath = resolve$1(dirname$1(testPath), path);
+	assertFileAccess(filepath, project);
+	const content = await promises.readFile(filepath, encoding || "base64");
+	return {
+		content,
+		basename: basename$1(filepath),
+		mime: mime.getType(filepath)
+	};
 };
 
 const hover = async (context, selector, options = {}) => {
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    await context.iframe.locator(selector).hover(options);
-  } else if (context.provider instanceof WebdriverBrowserProvider) {
-    const browser = context.browser;
-    await browser.$(selector).moveTo(options);
-  } else {
-    throw new TypeError(`Provider "${context.provider.name}" does not support hover`);
-  }
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		await context.iframe.locator(selector).hover(options);
+	} else if (context.provider instanceof WebdriverBrowserProvider) {
+		const browser = context.browser;
+		await browser.$(selector).moveTo(options);
+	} else {
+		throw new TypeError(`Provider "${context.provider.name}" does not support hover`);
+	}
 };
 
 var DOM_KEY_LOCATION = /*#__PURE__*/ function(DOM_KEY_LOCATION) {
@@ -2031,648 +1985,800 @@ function getErrorMessage(expected, found, text, context) {
 }
 
 const keyboard = async (context, text, state) => {
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    const frame = await context.frame();
-    await frame.evaluate(focusIframe);
-  } else if (context.provider instanceof WebdriverBrowserProvider) {
-    await context.browser.execute(focusIframe);
-  }
-  const pressed = new Set(state.unreleased);
-  await keyboardImplementation(
-    pressed,
-    context.provider,
-    context.sessionId,
-    text,
-    async () => {
-      if (context.provider instanceof PlaywrightBrowserProvider) {
-        const frame = await context.frame();
-        await frame.evaluate(selectAll);
-      } else if (context.provider instanceof WebdriverBrowserProvider) {
-        await context.browser.execute(selectAll);
-      } else {
-        throw new TypeError(`Provider "${context.provider.name}" does not support selecting all text`);
-      }
-    },
-    true
-  );
-  return {
-    unreleased: Array.from(pressed)
-  };
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		const frame = await context.frame();
+		await frame.evaluate(focusIframe);
+	} else if (context.provider instanceof WebdriverBrowserProvider) {
+		await context.browser.execute(focusIframe);
+	}
+	const pressed = new Set(state.unreleased);
+	await keyboardImplementation(pressed, context.provider, context.sessionId, text, async () => {
+		if (context.provider instanceof PlaywrightBrowserProvider) {
+			const frame = await context.frame();
+			await frame.evaluate(selectAll);
+		} else if (context.provider instanceof WebdriverBrowserProvider) {
+			await context.browser.execute(selectAll);
+		} else {
+			throw new TypeError(`Provider "${context.provider.name}" does not support selecting all text`);
+		}
+	}, true);
+	return { unreleased: Array.from(pressed) };
 };
 const keyboardCleanup = async (context, state) => {
-  const { provider, sessionId } = context;
-  if (!state.unreleased) {
-    return;
-  }
-  if (provider instanceof PlaywrightBrowserProvider) {
-    const page = provider.getPage(sessionId);
-    for (const key of state.unreleased) {
-      await page.keyboard.up(key);
-    }
-  } else if (provider instanceof WebdriverBrowserProvider) {
-    const keyboard2 = provider.browser.action("key");
-    for (const key of state.unreleased) {
-      keyboard2.up(key);
-    }
-    await keyboard2.perform();
-  } else {
-    throw new TypeError(`Provider "${context.provider.name}" does not support keyboard api`);
-  }
+	const { provider, sessionId } = context;
+	if (!state.unreleased) {
+		return;
+	}
+	if (provider instanceof PlaywrightBrowserProvider) {
+		const page = provider.getPage(sessionId);
+		for (const key of state.unreleased) {
+			await page.keyboard.up(key);
+		}
+	} else if (provider instanceof WebdriverBrowserProvider) {
+		const keyboard = provider.browser.action("key");
+		for (const key of state.unreleased) {
+			keyboard.up(key);
+		}
+		await keyboard.perform();
+	} else {
+		throw new TypeError(`Provider "${context.provider.name}" does not support keyboard api`);
+	}
 };
-const VALID_KEYS = /* @__PURE__ */ new Set(["Escape", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "Backquote", "`", "~", "Digit1", "1", "!", "Digit2", "2", "@", "Digit3", "3", "#", "Digit4", "4", "$", "Digit5", "5", "%", "Digit6", "6", "^", "Digit7", "7", "&", "Digit8", "8", "*", "Digit9", "9", "(", "Digit0", "0", ")", "Minus", "-", "_", "Equal", "=", "+", "Backslash", "\\", "|", "Backspace", "Tab", "KeyQ", "q", "Q", "KeyW", "w", "W", "KeyE", "e", "E", "KeyR", "r", "R", "KeyT", "t", "T", "KeyY", "y", "Y", "KeyU", "u", "U", "KeyI", "i", "I", "KeyO", "o", "O", "KeyP", "p", "P", "BracketLeft", "[", "{", "BracketRight", "]", "}", "CapsLock", "KeyA", "a", "A", "KeyS", "s", "S", "KeyD", "d", "D", "KeyF", "f", "F", "KeyG", "g", "G", "KeyH", "h", "H", "KeyJ", "j", "J", "KeyK", "k", "K", "KeyL", "l", "L", "Semicolon", ";", ":", "Quote", "'", '"', "Enter", "\n", "\r", "ShiftLeft", "Shift", "KeyZ", "z", "Z", "KeyX", "x", "X", "KeyC", "c", "C", "KeyV", "v", "V", "KeyB", "b", "B", "KeyN", "n", "N", "KeyM", "m", "M", "Comma", ",", "<", "Period", ".", ">", "Slash", "/", "?", "ShiftRight", "ControlLeft", "Control", "MetaLeft", "Meta", "AltLeft", "Alt", "Space", " ", "AltRight", "AltGraph", "MetaRight", "ContextMenu", "ControlRight", "PrintScreen", "ScrollLock", "Pause", "PageUp", "PageDown", "Insert", "Delete", "Home", "End", "ArrowLeft", "ArrowUp", "ArrowRight", "ArrowDown", "NumLock", "NumpadDivide", "NumpadMultiply", "NumpadSubtract", "Numpad7", "Numpad8", "Numpad9", "Numpad4", "Numpad5", "Numpad6", "NumpadAdd", "Numpad1", "Numpad2", "Numpad3", "Numpad0", "NumpadDecimal", "NumpadEnter", "ControlOrMeta"]);
-async function keyboardImplementation(pressed, provider, sessionId, text, selectAll2, skipRelease) {
-  if (provider instanceof PlaywrightBrowserProvider) {
-    const page = provider.getPage(sessionId);
-    const actions = parseKeyDef(defaultKeyMap, text);
-    for (const { releasePrevious, releaseSelf, repeat, keyDef } of actions) {
-      const key = keyDef.key;
-      if (pressed.has(key)) {
-        if (VALID_KEYS.has(key)) {
-          await page.keyboard.up(key);
-        }
-        pressed.delete(key);
-      }
-      if (!releasePrevious) {
-        if (key === "selectall") {
-          await selectAll2();
-          continue;
-        }
-        for (let i = 1; i <= repeat; i++) {
-          if (VALID_KEYS.has(key)) {
-            await page.keyboard.down(key);
-          } else {
-            await page.keyboard.insertText(key);
-          }
-        }
-        if (releaseSelf) {
-          if (VALID_KEYS.has(key)) {
-            await page.keyboard.up(key);
-          }
-        } else {
-          pressed.add(key);
-        }
-      }
-    }
-    if (!skipRelease && pressed.size) {
-      for (const key of pressed) {
-        if (VALID_KEYS.has(key)) {
-          await page.keyboard.up(key);
-        }
-      }
-    }
-  } else if (provider instanceof WebdriverBrowserProvider) {
-    const { Key } = await import('webdriverio');
-    const browser = provider.browser;
-    const actions = parseKeyDef(defaultKeyMap, text);
-    let keyboard2 = browser.action("key");
-    for (const { releasePrevious, releaseSelf, repeat, keyDef } of actions) {
-      let key = keyDef.key;
-      const special = Key[key];
-      if (special) {
-        key = special;
-      }
-      if (pressed.has(key)) {
-        keyboard2.up(key);
-        pressed.delete(key);
-      }
-      if (!releasePrevious) {
-        if (key === "selectall") {
-          await keyboard2.perform();
-          keyboard2 = browser.action("key");
-          await selectAll2();
-          continue;
-        }
-        for (let i = 1; i <= repeat; i++) {
-          keyboard2.down(key);
-        }
-        if (releaseSelf) {
-          keyboard2.up(key);
-        } else {
-          pressed.add(key);
-        }
-      }
-    }
-    const allRelease = keyboard2.toJSON().actions.every((action) => action.type === "keyUp");
-    await keyboard2.perform(allRelease ? false : skipRelease);
-  }
-  return {
-    pressed
-  };
+const VALID_KEYS = new Set([
+	"Escape",
+	"F1",
+	"F2",
+	"F3",
+	"F4",
+	"F5",
+	"F6",
+	"F7",
+	"F8",
+	"F9",
+	"F10",
+	"F11",
+	"F12",
+	"Backquote",
+	"`",
+	"~",
+	"Digit1",
+	"1",
+	"!",
+	"Digit2",
+	"2",
+	"@",
+	"Digit3",
+	"3",
+	"#",
+	"Digit4",
+	"4",
+	"$",
+	"Digit5",
+	"5",
+	"%",
+	"Digit6",
+	"6",
+	"^",
+	"Digit7",
+	"7",
+	"&",
+	"Digit8",
+	"8",
+	"*",
+	"Digit9",
+	"9",
+	"(",
+	"Digit0",
+	"0",
+	")",
+	"Minus",
+	"-",
+	"_",
+	"Equal",
+	"=",
+	"+",
+	"Backslash",
+	"\\",
+	"|",
+	"Backspace",
+	"Tab",
+	"KeyQ",
+	"q",
+	"Q",
+	"KeyW",
+	"w",
+	"W",
+	"KeyE",
+	"e",
+	"E",
+	"KeyR",
+	"r",
+	"R",
+	"KeyT",
+	"t",
+	"T",
+	"KeyY",
+	"y",
+	"Y",
+	"KeyU",
+	"u",
+	"U",
+	"KeyI",
+	"i",
+	"I",
+	"KeyO",
+	"o",
+	"O",
+	"KeyP",
+	"p",
+	"P",
+	"BracketLeft",
+	"[",
+	"{",
+	"BracketRight",
+	"]",
+	"}",
+	"CapsLock",
+	"KeyA",
+	"a",
+	"A",
+	"KeyS",
+	"s",
+	"S",
+	"KeyD",
+	"d",
+	"D",
+	"KeyF",
+	"f",
+	"F",
+	"KeyG",
+	"g",
+	"G",
+	"KeyH",
+	"h",
+	"H",
+	"KeyJ",
+	"j",
+	"J",
+	"KeyK",
+	"k",
+	"K",
+	"KeyL",
+	"l",
+	"L",
+	"Semicolon",
+	";",
+	":",
+	"Quote",
+	"'",
+	"\"",
+	"Enter",
+	"\n",
+	"\r",
+	"ShiftLeft",
+	"Shift",
+	"KeyZ",
+	"z",
+	"Z",
+	"KeyX",
+	"x",
+	"X",
+	"KeyC",
+	"c",
+	"C",
+	"KeyV",
+	"v",
+	"V",
+	"KeyB",
+	"b",
+	"B",
+	"KeyN",
+	"n",
+	"N",
+	"KeyM",
+	"m",
+	"M",
+	"Comma",
+	",",
+	"<",
+	"Period",
+	".",
+	">",
+	"Slash",
+	"/",
+	"?",
+	"ShiftRight",
+	"ControlLeft",
+	"Control",
+	"MetaLeft",
+	"Meta",
+	"AltLeft",
+	"Alt",
+	"Space",
+	" ",
+	"AltRight",
+	"AltGraph",
+	"MetaRight",
+	"ContextMenu",
+	"ControlRight",
+	"PrintScreen",
+	"ScrollLock",
+	"Pause",
+	"PageUp",
+	"PageDown",
+	"Insert",
+	"Delete",
+	"Home",
+	"End",
+	"ArrowLeft",
+	"ArrowUp",
+	"ArrowRight",
+	"ArrowDown",
+	"NumLock",
+	"NumpadDivide",
+	"NumpadMultiply",
+	"NumpadSubtract",
+	"Numpad7",
+	"Numpad8",
+	"Numpad9",
+	"Numpad4",
+	"Numpad5",
+	"Numpad6",
+	"NumpadAdd",
+	"Numpad1",
+	"Numpad2",
+	"Numpad3",
+	"Numpad0",
+	"NumpadDecimal",
+	"NumpadEnter",
+	"ControlOrMeta"
+]);
+async function keyboardImplementation(pressed, provider, sessionId, text, selectAll, skipRelease) {
+	if (provider instanceof PlaywrightBrowserProvider) {
+		const page = provider.getPage(sessionId);
+		const actions = parseKeyDef(defaultKeyMap, text);
+		for (const { releasePrevious, releaseSelf, repeat, keyDef } of actions) {
+			const key = keyDef.key;
+			if (pressed.has(key)) {
+				if (VALID_KEYS.has(key)) {
+					await page.keyboard.up(key);
+				}
+				pressed.delete(key);
+			}
+			if (!releasePrevious) {
+				if (key === "selectall") {
+					await selectAll();
+					continue;
+				}
+				for (let i = 1; i <= repeat; i++) {
+					if (VALID_KEYS.has(key)) {
+						await page.keyboard.down(key);
+					} else {
+						await page.keyboard.insertText(key);
+					}
+				}
+				if (releaseSelf) {
+					if (VALID_KEYS.has(key)) {
+						await page.keyboard.up(key);
+					}
+				} else {
+					pressed.add(key);
+				}
+			}
+		}
+		if (!skipRelease && pressed.size) {
+			for (const key of pressed) {
+				if (VALID_KEYS.has(key)) {
+					await page.keyboard.up(key);
+				}
+			}
+		}
+	} else if (provider instanceof WebdriverBrowserProvider) {
+		const { Key } = await import('webdriverio');
+		const browser = provider.browser;
+		const actions = parseKeyDef(defaultKeyMap, text);
+		let keyboard = browser.action("key");
+		for (const { releasePrevious, releaseSelf, repeat, keyDef } of actions) {
+			let key = keyDef.key;
+			const special = Key[key];
+			if (special) {
+				key = special;
+			}
+			if (pressed.has(key)) {
+				keyboard.up(key);
+				pressed.delete(key);
+			}
+			if (!releasePrevious) {
+				if (key === "selectall") {
+					await keyboard.perform();
+					keyboard = browser.action("key");
+					await selectAll();
+					continue;
+				}
+				for (let i = 1; i <= repeat; i++) {
+					keyboard.down(key);
+				}
+				if (releaseSelf) {
+					keyboard.up(key);
+				} else {
+					pressed.add(key);
+				}
+			}
+		}
+		const allRelease = keyboard.toJSON().actions.every((action) => action.type === "keyUp");
+		await keyboard.perform(allRelease ? false : skipRelease);
+	}
+	return { pressed };
 }
 function focusIframe() {
-  if (!document.activeElement || document.activeElement.ownerDocument !== document || document.activeElement === document.body) {
-    window.focus();
-  }
+	if (!document.activeElement || document.activeElement.ownerDocument !== document || document.activeElement === document.body) {
+		window.focus();
+	}
 }
 function selectAll() {
-  const element = document.activeElement;
-  if (element && typeof element.select === "function") {
-    element.select();
-  }
+	const element = document.activeElement;
+	if (element && typeof element.select === "function") {
+		element.select();
+	}
 }
 
 const screenshot = async (context, name, options = {}) => {
-  if (!context.testPath) {
-    throw new Error(`Cannot take a screenshot without a test path`);
-  }
-  const path = options.path ? resolve(dirname(context.testPath), options.path) : resolveScreenshotPath(
-    context.testPath,
-    name,
-    context.project.config
-  );
-  const savePath = normalize$1(path);
-  await mkdir(dirname(path), { recursive: true });
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    if (options.element) {
-      const { element: selector, ...config } = options;
-      const element = context.iframe.locator(`${selector}`);
-      const buffer2 = await element.screenshot({
-        ...config,
-        path: savePath
-      });
-      return returnResult(options, path, buffer2);
-    }
-    const buffer = await context.iframe.locator("body").screenshot({
-      ...options,
-      path: savePath
-    });
-    return returnResult(options, path, buffer);
-  }
-  if (context.provider instanceof WebdriverBrowserProvider) {
-    const page = context.provider.browser;
-    if (!options.element) {
-      const body = await page.$("body");
-      const buffer2 = await body.saveScreenshot(savePath);
-      return returnResult(options, path, buffer2);
-    }
-    const element = await page.$(`${options.element}`);
-    const buffer = await element.saveScreenshot(savePath);
-    return returnResult(options, path, buffer);
-  }
-  throw new Error(
-    `Provider "${context.provider.name}" does not support screenshots`
-  );
+	if (!context.testPath) {
+		throw new Error(`Cannot take a screenshot without a test path`);
+	}
+	const path = options.path ? resolve(dirname(context.testPath), options.path) : resolveScreenshotPath(context.testPath, name, context.project.config);
+	const savePath = normalize$1(path);
+	await mkdir(dirname(path), { recursive: true });
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		if (options.element) {
+			const { element: selector,...config } = options;
+			const element = context.iframe.locator(`${selector}`);
+			const buffer = await element.screenshot({
+				...config,
+				path: savePath
+			});
+			return returnResult(options, path, buffer);
+		}
+		const buffer = await context.iframe.locator("body").screenshot({
+			...options,
+			path: savePath
+		});
+		return returnResult(options, path, buffer);
+	}
+	if (context.provider instanceof WebdriverBrowserProvider) {
+		const page = context.provider.browser;
+		if (!options.element) {
+			const body = await page.$("body");
+			const buffer = await body.saveScreenshot(savePath);
+			return returnResult(options, path, buffer);
+		}
+		const element = await page.$(`${options.element}`);
+		const buffer = await element.saveScreenshot(savePath);
+		return returnResult(options, path, buffer);
+	}
+	throw new Error(`Provider "${context.provider.name}" does not support screenshots`);
 };
 function resolveScreenshotPath(testPath, name, config) {
-  const dir = dirname(testPath);
-  const base = basename(testPath);
-  if (config.browser.screenshotDirectory) {
-    return resolve(
-      config.browser.screenshotDirectory,
-      relative(config.root, dir),
-      base,
-      name
-    );
-  }
-  return resolve(dir, "__screenshots__", base, name);
+	const dir = dirname(testPath);
+	const base = basename(testPath);
+	if (config.browser.screenshotDirectory) {
+		return resolve(config.browser.screenshotDirectory, relative(config.root, dir), base, name);
+	}
+	return resolve(dir, "__screenshots__", base, name);
 }
 function returnResult(options, path, buffer) {
-  if (options.base64) {
-    return { path, base64: buffer.toString("base64") };
-  }
-  return path;
+	if (options.base64) {
+		return {
+			path,
+			base64: buffer.toString("base64")
+		};
+	}
+	return path;
 }
 
 const selectOptions = async (context, selector, userValues, options = {}) => {
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    const value = userValues;
-    const { iframe } = context;
-    const selectElement = iframe.locator(selector);
-    const values = await Promise.all(value.map(async (v) => {
-      if (typeof v === "string") {
-        return v;
-      }
-      const elementHandler = await iframe.locator(v.element).elementHandle();
-      if (!elementHandler) {
-        throw new Error(`Element not found: ${v.element}`);
-      }
-      return elementHandler;
-    }));
-    await selectElement.selectOption(values, options);
-  } else if (context.provider instanceof WebdriverBrowserProvider) {
-    const values = userValues;
-    if (!values.length) {
-      return;
-    }
-    const browser = context.browser;
-    if (values.length === 1 && "index" in values[0]) {
-      const selectElement = browser.$(selector);
-      await selectElement.selectByIndex(values[0].index);
-    } else {
-      throw new Error(`Provider "webdriverio" doesn't support selecting multiple values at once`);
-    }
-  } else {
-    throw new TypeError(`Provider "${context.provider.name}" doesn't support selectOptions command`);
-  }
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		const value = userValues;
+		const { iframe } = context;
+		const selectElement = iframe.locator(selector);
+		const values = await Promise.all(value.map(async (v) => {
+			if (typeof v === "string") {
+				return v;
+			}
+			const elementHandler = await iframe.locator(v.element).elementHandle();
+			if (!elementHandler) {
+				throw new Error(`Element not found: ${v.element}`);
+			}
+			return elementHandler;
+		}));
+		await selectElement.selectOption(values, options);
+	} else if (context.provider instanceof WebdriverBrowserProvider) {
+		const values = userValues;
+		if (!values.length) {
+			return;
+		}
+		const browser = context.browser;
+		if (values.length === 1 && "index" in values[0]) {
+			const selectElement = browser.$(selector);
+			await selectElement.selectByIndex(values[0].index);
+		} else {
+			throw new Error("Provider \"webdriverio\" doesn't support selecting multiple values at once");
+		}
+	} else {
+		throw new TypeError(`Provider "${context.provider.name}" doesn't support selectOptions command`);
+	}
 };
 
 const tab = async (context, options = {}) => {
-  const provider = context.provider;
-  if (provider instanceof PlaywrightBrowserProvider) {
-    const page = context.page;
-    await page.keyboard.press(options.shift === true ? "Shift+Tab" : "Tab");
-    return;
-  }
-  if (provider instanceof WebdriverBrowserProvider) {
-    const { Key } = await import('webdriverio');
-    const browser = context.browser;
-    await browser.keys(options.shift === true ? [Key.Shift, Key.Tab] : [Key.Tab]);
-    return;
-  }
-  throw new Error(`Provider "${provider.name}" doesn't support tab command`);
+	const provider = context.provider;
+	if (provider instanceof PlaywrightBrowserProvider) {
+		const page = context.page;
+		await page.keyboard.press(options.shift === true ? "Shift+Tab" : "Tab");
+		return;
+	}
+	if (provider instanceof WebdriverBrowserProvider) {
+		const { Key } = await import('webdriverio');
+		const browser = context.browser;
+		await browser.keys(options.shift === true ? [Key.Shift, Key.Tab] : [Key.Tab]);
+		return;
+	}
+	throw new Error(`Provider "${provider.name}" doesn't support tab command`);
 };
 
 const type = async (context, selector, text, options = {}) => {
-  const { skipClick = false, skipAutoClose = false } = options;
-  const unreleased = new Set(Reflect.get(options, "unreleased") ?? []);
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    const { iframe } = context;
-    const element = iframe.locator(selector);
-    if (!skipClick) {
-      await element.focus();
-    }
-    await keyboardImplementation(
-      unreleased,
-      context.provider,
-      context.sessionId,
-      text,
-      () => element.selectText(),
-      skipAutoClose
-    );
-  } else if (context.provider instanceof WebdriverBrowserProvider) {
-    const browser = context.browser;
-    const element = browser.$(selector);
-    if (!skipClick && !await element.isFocused()) {
-      await element.click();
-    }
-    await keyboardImplementation(
-      unreleased,
-      context.provider,
-      context.sessionId,
-      text,
-      () => browser.execute(() => {
-        const element2 = document.activeElement;
-        if (element2 && typeof element2.select === "function") {
-          element2.select();
-        }
-      }),
-      skipAutoClose
-    );
-  } else {
-    throw new TypeError(`Provider "${context.provider.name}" does not support typing`);
-  }
-  return {
-    unreleased: Array.from(unreleased)
-  };
+	const { skipClick = false, skipAutoClose = false } = options;
+	const unreleased = new Set(Reflect.get(options, "unreleased") ?? []);
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		const { iframe } = context;
+		const element = iframe.locator(selector);
+		if (!skipClick) {
+			await element.focus();
+		}
+		await keyboardImplementation(unreleased, context.provider, context.sessionId, text, () => element.selectText(), skipAutoClose);
+	} else if (context.provider instanceof WebdriverBrowserProvider) {
+		const browser = context.browser;
+		const element = browser.$(selector);
+		if (!skipClick && !await element.isFocused()) {
+			await element.click();
+		}
+		await keyboardImplementation(unreleased, context.provider, context.sessionId, text, () => browser.execute(() => {
+			const element = document.activeElement;
+			if (element && typeof element.select === "function") {
+				element.select();
+			}
+		}), skipAutoClose);
+	} else {
+		throw new TypeError(`Provider "${context.provider.name}" does not support typing`);
+	}
+	return { unreleased: Array.from(unreleased) };
 };
 
 const upload = async (context, selector, files) => {
-  const testPath = context.testPath;
-  if (!testPath) {
-    throw new Error(`Cannot upload files outside of a test`);
-  }
-  const testDir = dirname(testPath);
-  if (context.provider instanceof PlaywrightBrowserProvider) {
-    const { iframe } = context;
-    const playwrightFiles = files.map((file) => {
-      if (typeof file === "string") {
-        return resolve(testDir, file);
-      }
-      return {
-        name: file.name,
-        mimeType: file.mimeType,
-        buffer: Buffer.from(file.base64, "base64")
-      };
-    });
-    await iframe.locator(selector).setInputFiles(playwrightFiles);
-  } else if (context.provider instanceof WebdriverBrowserProvider) {
-    for (const file of files) {
-      if (typeof file !== "string") {
-        throw new TypeError(`The "${context.provider.name}" provider doesn't support uploading files objects. Provide a file path instead.`);
-      }
-    }
-    const element = context.browser.$(selector);
-    for (const file of files) {
-      const filepath = resolve(testDir, file);
-      const remoteFilePath = await context.browser.uploadFile(filepath);
-      await element.addValue(remoteFilePath);
-    }
-  } else {
-    throw new TypeError(`Provider "${context.provider.name}" does not support uploading files via userEvent.upload`);
-  }
+	const testPath = context.testPath;
+	if (!testPath) {
+		throw new Error(`Cannot upload files outside of a test`);
+	}
+	const testDir = dirname(testPath);
+	if (context.provider instanceof PlaywrightBrowserProvider) {
+		const { iframe } = context;
+		const playwrightFiles = files.map((file) => {
+			if (typeof file === "string") {
+				return resolve(testDir, file);
+			}
+			return {
+				name: file.name,
+				mimeType: file.mimeType,
+				buffer: Buffer.from(file.base64, "base64")
+			};
+		});
+		await iframe.locator(selector).setInputFiles(playwrightFiles);
+	} else if (context.provider instanceof WebdriverBrowserProvider) {
+		for (const file of files) {
+			if (typeof file !== "string") {
+				throw new TypeError(`The "${context.provider.name}" provider doesn't support uploading files objects. Provide a file path instead.`);
+			}
+		}
+		const element = context.browser.$(selector);
+		for (const file of files) {
+			const filepath = resolve(testDir, file);
+			const remoteFilePath = await context.browser.uploadFile(filepath);
+			await element.addValue(remoteFilePath);
+		}
+	} else {
+		throw new TypeError(`Provider "${context.provider.name}" does not support uploading files via userEvent.upload`);
+	}
 };
 
 var builtinCommands = {
-  readFile,
-  removeFile,
-  writeFile,
-  __vitest_fileInfo: _fileInfo,
-  __vitest_upload: upload,
-  __vitest_click: click,
-  __vitest_dblClick: dblClick,
-  __vitest_tripleClick: tripleClick,
-  __vitest_screenshot: screenshot,
-  __vitest_type: type,
-  __vitest_clear: clear,
-  __vitest_fill: fill,
-  __vitest_tab: tab,
-  __vitest_keyboard: keyboard,
-  __vitest_selectOptions: selectOptions,
-  __vitest_dragAndDrop: dragAndDrop,
-  __vitest_hover: hover,
-  __vitest_cleanup: keyboardCleanup
+	readFile,
+	removeFile,
+	writeFile,
+	__vitest_fileInfo: _fileInfo,
+	__vitest_upload: upload,
+	__vitest_click: click,
+	__vitest_dblClick: dblClick,
+	__vitest_tripleClick: tripleClick,
+	__vitest_screenshot: screenshot,
+	__vitest_type: type,
+	__vitest_clear: clear,
+	__vitest_fill: fill,
+	__vitest_tab: tab,
+	__vitest_keyboard: keyboard,
+	__vitest_selectOptions: selectOptions,
+	__vitest_dragAndDrop: dragAndDrop,
+	__vitest_hover: hover,
+	__vitest_cleanup: keyboardCleanup
 };
 
 class BrowserServerState {
-  orchestrators = /* @__PURE__ */ new Map();
-  testers = /* @__PURE__ */ new Map();
+	orchestrators = new Map();
+	testers = new Map();
 }
 
 class ProjectBrowser {
-  constructor(project, base) {
-    this.project = project;
-    this.base = base;
-    this.vitest = project.vitest;
-    this.config = project.config;
-    const pkgRoot = resolve(fileURLToPath(import.meta.url), "../..");
-    const distRoot = resolve(pkgRoot, "dist");
-    const testerHtmlPath = project.config.browser.testerHtmlPath ? resolve(project.config.root, project.config.browser.testerHtmlPath) : resolve(distRoot, "client/tester/tester.html");
-    if (!existsSync(testerHtmlPath)) {
-      throw new Error(`Tester HTML file "${testerHtmlPath}" doesn't exist.`);
-    }
-    this.testerFilepath = testerHtmlPath;
-    this.testerHtml = readFile$1(
-      testerHtmlPath,
-      "utf8"
-    ).then((html) => this.testerHtml = html);
-  }
-  testerHtml;
-  testerFilepath;
-  locatorsUrl;
-  provider;
-  vitest;
-  config;
-  children = /* @__PURE__ */ new Set();
-  parent;
-  state = new BrowserServerState();
-  get vite() {
-    return this.parent.vite;
-  }
-  wrapSerializedConfig() {
-    const config = wrapConfig(this.project.serializedConfig);
-    config.env ??= {};
-    config.env.VITEST_BROWSER_DEBUG = process.env.VITEST_BROWSER_DEBUG || "";
-    return config;
-  }
-  async initBrowserProvider(project) {
-    if (this.provider) {
-      return;
-    }
-    const Provider = await getBrowserProvider(project.config.browser, project);
-    this.provider = new Provider();
-    const browser = project.config.browser.name;
-    const name = project.name ? `[${project.name}] ` : "";
-    if (!browser) {
-      throw new Error(
-        `${name}Browser name is required. Please, set \`test.browser.instances[].browser\` option manually.`
-      );
-    }
-    const supportedBrowsers = this.provider.getSupportedBrowsers();
-    if (supportedBrowsers.length && !supportedBrowsers.includes(browser)) {
-      throw new Error(
-        `${name}Browser "${browser}" is not supported by the browser provider "${this.provider.name}". Supported browsers: ${supportedBrowsers.join(", ")}.`
-      );
-    }
-    const providerOptions = project.config.browser.providerOptions;
-    await this.provider.initialize(project, {
-      browser,
-      options: providerOptions
-    });
-  }
-  parseErrorStacktrace(e, options = {}) {
-    return this.parent.parseErrorStacktrace(e, options);
-  }
-  parseStacktrace(trace, options = {}) {
-    return this.parent.parseStacktrace(trace, options);
-  }
-  async close() {
-    await this.parent.vite.close();
-  }
+	testerHtml;
+	testerFilepath;
+	provider;
+	vitest;
+	config;
+	children = new Set();
+	parent;
+	state = new BrowserServerState();
+	constructor(project, base) {
+		this.project = project;
+		this.base = base;
+		this.vitest = project.vitest;
+		this.config = project.config;
+		const pkgRoot = resolve(fileURLToPath(import.meta.url), "../..");
+		const distRoot = resolve(pkgRoot, "dist");
+		const testerHtmlPath = project.config.browser.testerHtmlPath ? resolve(project.config.root, project.config.browser.testerHtmlPath) : resolve(distRoot, "client/tester/tester.html");
+		if (!existsSync(testerHtmlPath)) {
+			throw new Error(`Tester HTML file "${testerHtmlPath}" doesn't exist.`);
+		}
+		this.testerFilepath = testerHtmlPath;
+		this.testerHtml = readFile$1(testerHtmlPath, "utf8").then((html) => this.testerHtml = html);
+	}
+	get vite() {
+		return this.parent.vite;
+	}
+	wrapSerializedConfig() {
+		const config = wrapConfig(this.project.serializedConfig);
+		config.env ??= {};
+		config.env.VITEST_BROWSER_DEBUG = process.env.VITEST_BROWSER_DEBUG || "";
+		return config;
+	}
+	async initBrowserProvider(project) {
+		if (this.provider) {
+			return;
+		}
+		const Provider = await getBrowserProvider(project.config.browser, project);
+		this.provider = new Provider();
+		const browser = project.config.browser.name;
+		const name = project.name ? `[${project.name}] ` : "";
+		if (!browser) {
+			throw new Error(`${name}Browser name is required. Please, set \`test.browser.instances[].browser\` option manually.`);
+		}
+		const supportedBrowsers = this.provider.getSupportedBrowsers();
+		if (supportedBrowsers.length && !supportedBrowsers.includes(browser)) {
+			throw new Error(`${name}Browser "${browser}" is not supported by the browser provider "${this.provider.name}". Supported browsers: ${supportedBrowsers.join(", ")}.`);
+		}
+		const providerOptions = project.config.browser.providerOptions;
+		await this.provider.initialize(project, {
+			browser,
+			options: providerOptions
+		});
+	}
+	parseErrorStacktrace(e, options = {}) {
+		return this.parent.parseErrorStacktrace(e, options);
+	}
+	parseStacktrace(trace, options = {}) {
+		return this.parent.parseStacktrace(trace, options);
+	}
+	async close() {
+		await this.parent.vite.close();
+	}
 }
 function wrapConfig(config) {
-  return {
-    ...config,
-    // workaround RegExp serialization
-    testNamePattern: config.testNamePattern ? config.testNamePattern.toString() : void 0
-  };
+	return {
+		...config,
+		testNamePattern: config.testNamePattern ? config.testNamePattern.toString() : undefined
+	};
 }
 
 class ParentBrowserProject {
-  constructor(project, base) {
-    this.project = project;
-    this.base = base;
-    this.vitest = project.vitest;
-    this.config = project.config;
-    this.stackTraceOptions = {
-      frameFilter: project.config.onStackTrace,
-      getSourceMap: (id) => {
-        if (this.sourceMapCache.has(id)) {
-          return this.sourceMapCache.get(id);
-        }
-        const result = this.vite.moduleGraph.getModuleById(id)?.transformResult;
-        if (result && !result.map) {
-          const sourceMapUrl = this.retrieveSourceMapURL(result.code);
-          if (!sourceMapUrl) {
-            return null;
-          }
-          const filepathDir = dirname(id);
-          const sourceMapPath = resolve(filepathDir, sourceMapUrl);
-          const map = JSON.parse(readFileSync(sourceMapPath, "utf-8"));
-          this.sourceMapCache.set(id, map);
-          return map;
-        }
-        return result?.map;
-      },
-      getUrlId: (id) => {
-        const mod = this.vite.moduleGraph.getModuleById(id);
-        if (mod) {
-          return id;
-        }
-        const resolvedPath = resolve(project.config.root, id.slice(1));
-        const modUrl = this.vite.moduleGraph.getModuleById(resolvedPath);
-        if (modUrl) {
-          return resolvedPath;
-        }
-        const files = this.vite.moduleGraph.getModulesByFile(resolvedPath);
-        if (files && files.size) {
-          return files.values().next().value.id;
-        }
-        return id;
-      }
-    };
-    for (const [name, command] of Object.entries(builtinCommands)) {
-      this.commands[name] ??= command;
-    }
-    for (const command in project.config.browser.commands) {
-      if (!/^[a-z_$][\w$]*$/i.test(command)) {
-        throw new Error(
-          `Invalid command name "${command}". Only alphanumeric characters, $ and _ are allowed.`
-        );
-      }
-      this.commands[command] = project.config.browser.commands[command];
-    }
-    this.prefixTesterUrl = `${base}__vitest_test__/__test__/`;
-    this.faviconUrl = `${base}__vitest__/favicon.svg`;
-    this.manifest = (async () => {
-      return JSON.parse(
-        await readFile$1(`${distRoot}/client/.vite/manifest.json`, "utf8")
-      );
-    })().then((manifest) => this.manifest = manifest);
-    this.orchestratorHtml = (project.config.browser.ui ? readFile$1(resolve(distRoot, "client/__vitest__/index.html"), "utf8") : readFile$1(resolve(distRoot, "client/orchestrator.html"), "utf8")).then((html) => this.orchestratorHtml = html);
-    this.injectorJs = readFile$1(
-      resolve(distRoot, "client/esm-client-injector.js"),
-      "utf8"
-    ).then((js) => this.injectorJs = js);
-    this.errorCatcherUrl = join("/@fs/", resolve(distRoot, "client/error-catcher.js"));
-    const builtinProviders = ["playwright", "webdriverio", "preview"];
-    const providerName = project.config.browser.provider || "preview";
-    if (builtinProviders.includes(providerName)) {
-      this.locatorsUrl = join("/@fs/", distRoot, "locators", `${providerName}.js`);
-    }
-    this.stateJs = readFile$1(
-      resolve(distRoot, "state.js"),
-      "utf-8"
-    ).then((js) => this.stateJs = js);
-  }
-  orchestratorScripts;
-  testerScripts;
-  faviconUrl;
-  prefixTesterUrl;
-  manifest;
-  vite;
-  stackTraceOptions;
-  orchestratorHtml;
-  injectorJs;
-  errorCatcherUrl;
-  locatorsUrl;
-  stateJs;
-  commands = {};
-  children = /* @__PURE__ */ new Set();
-  vitest;
-  config;
-  // cache for non-vite source maps
-  sourceMapCache = /* @__PURE__ */ new Map();
-  setServer(vite) {
-    this.vite = vite;
-  }
-  spawn(project) {
-    if (!this.vite) {
-      throw new Error(`Cannot spawn child server without a parent dev server.`);
-    }
-    const clone = new ProjectBrowser(
-      project,
-      "/"
-    );
-    clone.parent = this;
-    this.children.add(clone);
-    return clone;
-  }
-  parseErrorStacktrace(e, options = {}) {
-    return parseErrorStacktrace(e, {
-      ...this.stackTraceOptions,
-      ...options
-    });
-  }
-  parseStacktrace(trace, options = {}) {
-    return parseStacktrace(trace, {
-      ...this.stackTraceOptions,
-      ...options
-    });
-  }
-  cdps = /* @__PURE__ */ new Map();
-  cdpSessionsPromises = /* @__PURE__ */ new Map();
-  async ensureCDPHandler(sessionId, rpcId) {
-    const cachedHandler = this.cdps.get(rpcId);
-    if (cachedHandler) {
-      return cachedHandler;
-    }
-    const browserSession = this.vitest._browserSessions.getSession(sessionId);
-    if (!browserSession) {
-      throw new Error(`Session "${sessionId}" not found.`);
-    }
-    const browser = browserSession.project.browser;
-    const provider = browser.provider;
-    if (!provider) {
-      throw new Error(`Browser provider is not defined for the project "${browserSession.project.name}".`);
-    }
-    if (!provider.getCDPSession) {
-      throw new Error(`CDP is not supported by the provider "${provider.name}".`);
-    }
-    const promise = this.cdpSessionsPromises.get(rpcId) ?? await (async () => {
-      const promise2 = provider.getCDPSession(sessionId).finally(() => {
-        this.cdpSessionsPromises.delete(rpcId);
-      });
-      this.cdpSessionsPromises.set(rpcId, promise2);
-      return promise2;
-    })();
-    const session = await promise;
-    const rpc = browser.state.testers.get(rpcId);
-    if (!rpc) {
-      throw new Error(`Tester RPC "${rpcId}" was not established.`);
-    }
-    const handler = new BrowserServerCDPHandler(session, rpc);
-    this.cdps.set(
-      rpcId,
-      handler
-    );
-    return handler;
-  }
-  removeCDPHandler(sessionId) {
-    this.cdps.delete(sessionId);
-  }
-  async formatScripts(scripts) {
-    if (!scripts?.length) {
-      return [];
-    }
-    const server = this.vite;
-    const promises = scripts.map(
-      async ({ content, src, async, id, type = "module" }, index) => {
-        const srcLink = (src ? (await server.pluginContainer.resolveId(src))?.id : void 0) || src;
-        const transformId = srcLink || join(server.config.root, `virtual__${id || `injected-${index}.js`}`);
-        await server.moduleGraph.ensureEntryFromUrl(transformId);
-        const contentProcessed = content && type === "module" ? (await server.pluginContainer.transform(content, transformId)).code : content;
-        return {
-          tag: "script",
-          attrs: {
-            type,
-            ...async ? { async: "" } : {},
-            ...srcLink ? {
-              src: srcLink.startsWith("http") ? srcLink : slash(`/@fs/${srcLink}`)
-            } : {}
-          },
-          injectTo: "head",
-          children: contentProcessed || ""
-        };
-      }
-    );
-    return await Promise.all(promises);
-  }
-  resolveTesterUrl(pathname) {
-    const [sessionId, testFile] = pathname.slice(this.prefixTesterUrl.length).split("/");
-    const decodedTestFile = decodeURIComponent(testFile);
-    return { sessionId, testFile: decodedTestFile };
-  }
-  retrieveSourceMapURL(source) {
-    const re = /\/\/[@#]\s*sourceMappingURL=([^\s'"]+)\s*$|\/\*[@#]\s*sourceMappingURL=[^\s*'"]+\s*\*\/\s*$/gm;
-    let lastMatch, match;
-    while (match = re.exec(source)) {
-      lastMatch = match;
-    }
-    if (!lastMatch) {
-      return null;
-    }
-    return lastMatch[1];
-  }
+	orchestratorScripts;
+	testerScripts;
+	faviconUrl;
+	prefixTesterUrl;
+	manifest;
+	vite;
+	stackTraceOptions;
+	orchestratorHtml;
+	injectorJs;
+	errorCatcherUrl;
+	locatorsUrl;
+	matchersUrl;
+	stateJs;
+	commands = {};
+	children = new Set();
+	vitest;
+	config;
+	sourceMapCache = new Map();
+	constructor(project, base) {
+		this.project = project;
+		this.base = base;
+		this.vitest = project.vitest;
+		this.config = project.config;
+		this.stackTraceOptions = {
+			frameFilter: project.config.onStackTrace,
+			getSourceMap: (id) => {
+				if (this.sourceMapCache.has(id)) {
+					return this.sourceMapCache.get(id);
+				}
+				const result = this.vite.moduleGraph.getModuleById(id)?.transformResult;
+				if (result && !result.map) {
+					const sourceMapUrl = this.retrieveSourceMapURL(result.code);
+					if (!sourceMapUrl) {
+						return null;
+					}
+					const filepathDir = dirname(id);
+					const sourceMapPath = resolve(filepathDir, sourceMapUrl);
+					const map = JSON.parse(readFileSync(sourceMapPath, "utf-8"));
+					this.sourceMapCache.set(id, map);
+					return map;
+				}
+				return result?.map;
+			},
+			getUrlId: (id) => {
+				const mod = this.vite.moduleGraph.getModuleById(id);
+				if (mod) {
+					return id;
+				}
+				const resolvedPath = resolve(project.config.root, id.slice(1));
+				const modUrl = this.vite.moduleGraph.getModuleById(resolvedPath);
+				if (modUrl) {
+					return resolvedPath;
+				}
+				const files = this.vite.moduleGraph.getModulesByFile(resolvedPath);
+				if (files && files.size) {
+					return files.values().next().value.id;
+				}
+				return id;
+			}
+		};
+		for (const [name, command] of Object.entries(builtinCommands)) {
+			this.commands[name] ??= command;
+		}
+		for (const command in project.config.browser.commands) {
+			if (!/^[a-z_$][\w$]*$/i.test(command)) {
+				throw new Error(`Invalid command name "${command}". Only alphanumeric characters, $ and _ are allowed.`);
+			}
+			this.commands[command] = project.config.browser.commands[command];
+		}
+		this.prefixTesterUrl = `${base}__vitest_test__/__test__/`;
+		this.faviconUrl = `${base}__vitest__/favicon.svg`;
+		this.manifest = (async () => {
+			return JSON.parse(await readFile$1(`${distRoot}/client/.vite/manifest.json`, "utf8"));
+		})().then((manifest) => this.manifest = manifest);
+		this.orchestratorHtml = (project.config.browser.ui ? readFile$1(resolve(distRoot, "client/__vitest__/index.html"), "utf8") : readFile$1(resolve(distRoot, "client/orchestrator.html"), "utf8")).then((html) => this.orchestratorHtml = html);
+		this.injectorJs = readFile$1(resolve(distRoot, "client/esm-client-injector.js"), "utf8").then((js) => this.injectorJs = js);
+		this.errorCatcherUrl = join("/@fs/", resolve(distRoot, "client/error-catcher.js"));
+		const builtinProviders = [
+			"playwright",
+			"webdriverio",
+			"preview"
+		];
+		const providerName = project.config.browser.provider || "preview";
+		if (builtinProviders.includes(providerName)) {
+			this.locatorsUrl = join("/@fs/", distRoot, "locators", `${providerName}.js`);
+		}
+		this.matchersUrl = join("/@fs/", distRoot, "expect-element.js");
+		this.stateJs = readFile$1(resolve(distRoot, "state.js"), "utf-8").then((js) => this.stateJs = js);
+	}
+	setServer(vite) {
+		this.vite = vite;
+	}
+	spawn(project) {
+		if (!this.vite) {
+			throw new Error(`Cannot spawn child server without a parent dev server.`);
+		}
+		const clone = new ProjectBrowser(project, "/");
+		clone.parent = this;
+		this.children.add(clone);
+		return clone;
+	}
+	parseErrorStacktrace(e, options = {}) {
+		return parseErrorStacktrace(e, {
+			...this.stackTraceOptions,
+			...options
+		});
+	}
+	parseStacktrace(trace, options = {}) {
+		return parseStacktrace(trace, {
+			...this.stackTraceOptions,
+			...options
+		});
+	}
+	cdps = new Map();
+	cdpSessionsPromises = new Map();
+	async ensureCDPHandler(sessionId, rpcId) {
+		const cachedHandler = this.cdps.get(rpcId);
+		if (cachedHandler) {
+			return cachedHandler;
+		}
+		const browserSession = this.vitest._browserSessions.getSession(sessionId);
+		if (!browserSession) {
+			throw new Error(`Session "${sessionId}" not found.`);
+		}
+		const browser = browserSession.project.browser;
+		const provider = browser.provider;
+		if (!provider) {
+			throw new Error(`Browser provider is not defined for the project "${browserSession.project.name}".`);
+		}
+		if (!provider.getCDPSession) {
+			throw new Error(`CDP is not supported by the provider "${provider.name}".`);
+		}
+		const promise = 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.`);
+		}
+		const handler = new BrowserServerCDPHandler(session, rpc);
+		this.cdps.set(rpcId, handler);
+		return handler;
+	}
+	removeCDPHandler(sessionId) {
+		this.cdps.delete(sessionId);
+	}
+	async formatScripts(scripts) {
+		if (!scripts?.length) {
+			return [];
+		}
+		const server = this.vite;
+		const promises = scripts.map(async ({ content, src, async, id, type = "module" }, index) => {
+			const srcLink = (src ? (await server.pluginContainer.resolveId(src))?.id : undefined) || src;
+			const transformId = srcLink || join(server.config.root, `virtual__${id || `injected-${index}.js`}`);
+			await server.moduleGraph.ensureEntryFromUrl(transformId);
+			const contentProcessed = content && type === "module" ? (await server.pluginContainer.transform(content, transformId)).code : content;
+			return {
+				tag: "script",
+				attrs: {
+					type,
+					...async ? { async: "" } : {},
+					...srcLink ? { src: srcLink.startsWith("http") ? srcLink : slash(`/@fs/${srcLink}`) } : {}
+				},
+				injectTo: "head",
+				children: contentProcessed || ""
+			};
+		});
+		return await Promise.all(promises);
+	}
+	resolveTesterUrl(pathname) {
+		const [sessionId, testFile] = pathname.slice(this.prefixTesterUrl.length).split("/");
+		const decodedTestFile = decodeURIComponent(testFile);
+		return {
+			sessionId,
+			testFile: decodedTestFile
+		};
+	}
+	retrieveSourceMapURL(source) {
+		const re = /\/\/[@#]\s*sourceMappingURL=([^\s'"]+)\s*$|\/\*[@#]\s*sourceMappingURL=[^\s*'"]+\s*\*\/\s*$/gm;
+		let lastMatch, match;
+		while (match = re.exec(source)) {
+			lastMatch = match;
+		}
+		if (!lastMatch) {
+			return null;
+		}
+		return lastMatch[1];
+	}
 }
 
 const DEFAULT_TIMEOUT = 6e4;
@@ -2802,453 +2908,451 @@ function nanoid(size = 21) {
 
 const debug$1 = createDebugger("vitest:browser:api");
 const BROWSER_API_PATH = "/__vitest_browser_api__";
-function setupBrowserRpc(globalServer) {
-  const vite = globalServer.vite;
-  const vitest = globalServer.vitest;
-  const wss = new WebSocketServer({ noServer: true });
-  vite.httpServer?.on("upgrade", (request, socket, head) => {
-    if (!request.url) {
-      return;
-    }
-    const { pathname, searchParams } = new URL(request.url, "http://localhost");
-    if (pathname !== BROWSER_API_PATH) {
-      return;
-    }
-    if (!isValidApiRequest(vitest.config, request)) {
-      socket.destroy();
-      return;
-    }
-    const type = searchParams.get("type");
-    const rpcId = searchParams.get("rpcId");
-    const sessionId = searchParams.get("sessionId");
-    const projectName = searchParams.get("projectName");
-    if (type !== "tester" && type !== "orchestrator") {
-      return error(
-        new Error(`[vitest] Type query in ${request.url} is invalid. Type should be either "tester" or "orchestrator".`)
-      );
-    }
-    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 (type === "orchestrator") {
-      const session = vitest._browserSessions.getSession(sessionId);
-      session?.connected();
-    }
-    const project = vitest.getProjectByName(projectName);
-    if (!project) {
-      return error(
-        new Error(`[vitest] Project "${projectName}" not found.`)
-      );
-    }
-    wss.handleUpgrade(request, socket, head, (ws) => {
-      wss.emit("connection", ws, request);
-      const rpc = setupClient(project, rpcId, ws, method);
-      const state = project.browser.state;
-      const clients = type === "tester" ? state.testers : state.orchestrators;
-      clients.set(rpcId, rpc);
-      debug$1?.("[%s] Browser API connected to %s", rpcId, type);
-      ws.on("close", () => {
-        debug$1?.("[%s] Browser API disconnected from %s", rpcId, type);
-        clients.delete(rpcId);
-        globalServer.removeCDPHandler(rpcId);
-      });
-    });
-  });
-  function error(err) {
-    console.error(err);
-    vitest.state.catchError(err, "RPC Error");
-  }
-  function checkFileAccess(path) {
-    if (!isFileServingAllowed(path, vite)) {
-      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) {
-    const mockResolver = new ServerMockResolver(globalServer.vite, {
-      moduleDirectories: project.config.server?.deps?.moduleDirectories
-    });
-    const rpc = createBirpc(
-      {
-        async onUnhandledError(error2, type) {
-          if (error2 && typeof error2 === "object") {
-            const _error = error2;
-            _error.stacks = globalServer.parseErrorStacktrace(_error);
-          }
-          vitest.state.catchError(error2, type);
-        },
-        async onQueued(file) {
-          if (method === "collect") {
-            vitest.state.collectFiles(project, [file]);
-          } else {
-            await vitest._testRun.enqueued(project, file);
-          }
-        },
-        async onCollected(files) {
-          if (method === "collect") {
-            vitest.state.collectFiles(project, files);
-          } else {
-            await vitest._testRun.collected(project, files);
-          }
-        },
-        async onTaskUpdate(packs, events) {
-          if (method === "collect") {
-            vitest.state.updateTasks(packs);
-          } else {
-            await vitest._testRun.updated(packs, events);
-          }
-        },
-        onAfterSuiteRun(meta) {
-          vitest.coverageProvider?.onAfterSuiteRun(meta);
-        },
-        async sendLog(log) {
-          if (method === "collect") {
-            vitest.state.updateUserLog(log);
-          } else {
-            await vitest._testRun.log(log);
-          }
-        },
-        resolveSnapshotPath(testPath) {
-          return vitest.snapshot.resolvePath(testPath, {
-            config: project.serializedConfig
-          });
-        },
-        resolveSnapshotRawPath(testPath, rawPath) {
-          return vitest.snapshot.resolveRawPath(testPath, rawPath);
-        },
-        snapshotSaved(snapshot) {
-          vitest.snapshot.add(snapshot);
-        },
-        async readSnapshotFile(snapshotPath) {
-          checkFileAccess(snapshotPath);
-          if (!existsSync(snapshotPath)) {
-            return null;
-          }
-          return promises.readFile(snapshotPath, "utf-8");
-        },
-        async saveSnapshotFile(id, content) {
-          checkFileAccess(id);
-          await promises.mkdir(dirname(id), { recursive: true });
-          return promises.writeFile(id, content, "utf-8");
-        },
-        async removeSnapshotFile(id) {
-          checkFileAccess(id);
-          if (!existsSync(id)) {
-            throw new Error(`Snapshot file "${id}" does not exist.`);
-          }
-          return promises.unlink(id);
-        },
-        getBrowserFileSourceMap(id) {
-          const mod = globalServer.vite.moduleGraph.getModuleById(id);
-          return mod?.transformResult?.map;
-        },
-        onCancel(reason) {
-          vitest.cancelCurrentRun(reason);
-        },
-        async resolveId(id, importer) {
-          return mockResolver.resolveId(id, importer);
-        },
-        debug(...args) {
-          vitest.logger.console.debug(...args);
-        },
-        getCountOfFailedTests() {
-          return vitest.state.getCountOfFailedTests();
-        },
-        async wdioSwitchContext(direction) {
-          const provider = project.browser.provider;
-          if (!provider) {
-            throw new Error("Commands are only available for browser tests.");
-          }
-          if (provider.name !== "webdriverio") {
-            throw new Error("Switch context is only available for WebDriverIO provider.");
-          }
-          if (direction === "iframe") {
-            await provider.switchToTestFrame();
-          } else {
-            await provider.switchToMainFrame();
-          }
-        },
-        async triggerCommand(sessionId, command, testPath, payload) {
-          debug$1?.('[%s] Triggering command "%s"', sessionId, command);
-          const provider = project.browser.provider;
-          if (!provider) {
-            throw new Error("Commands are only available for browser tests.");
-          }
-          const commands = globalServer.commands;
-          if (!commands || !commands[command]) {
-            throw new Error(`Unknown command "${command}".`);
-          }
-          const context = Object.assign(
-            {
-              testPath,
-              project,
-              provider,
-              contextId: sessionId,
-              sessionId
-            },
-            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);
-        },
-        invalidate(ids) {
-          return mockResolver.invalidate(ids);
-        },
-        // CDP
-        async sendCdpEvent(sessionId, event, payload) {
-          const cdp = await globalServer.ensureCDPHandler(sessionId, rpcId);
-          return cdp.send(event, payload);
-        },
-        async trackCdpEvent(sessionId, type, event, listenerId) {
-          const cdp = await globalServer.ensureCDPHandler(sessionId, rpcId);
-          cdp[type](event, listenerId);
-        }
-      },
-      {
-        post: (msg) => ws.send(msg),
-        on: (fn) => ws.on("message", fn),
-        eventNames: ["onCancel", "cdpEvent"],
-        serialize: (data) => stringify(data, stringifyReplace),
-        deserialize: parse,
-        onTimeoutError(functionName) {
-          throw new Error(`[vitest-api]: Timeout calling "${functionName}"`);
-        }
-      }
-    );
-    vitest.onCancel((reason) => rpc.onCancel(reason));
-    return rpc;
-  }
+function setupBrowserRpc(globalServer, defaultMockerRegistry) {
+	const vite = globalServer.vite;
+	const vitest = globalServer.vitest;
+	const wss = new WebSocketServer({ noServer: true });
+	vite.httpServer?.on("upgrade", (request, socket, head) => {
+		if (!request.url) {
+			return;
+		}
+		const { pathname, searchParams } = new URL(request.url, "http://localhost");
+		if (pathname !== BROWSER_API_PATH) {
+			return;
+		}
+		if (!isValidApiRequest(vitest.config, request)) {
+			socket.destroy();
+			return;
+		}
+		const type = searchParams.get("type");
+		const rpcId = searchParams.get("rpcId");
+		const sessionId = searchParams.get("sessionId");
+		const projectName = searchParams.get("projectName");
+		if (type !== "tester" && type !== "orchestrator") {
+			return error(new Error(`[vitest] Type query in ${request.url} is invalid. Type should be either "tester" or "orchestrator".`));
+		}
+		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 (type === "orchestrator") {
+			const session = vitest._browserSessions.getSession(sessionId);
+			session?.connected();
+		}
+		const project = vitest.getProjectByName(projectName);
+		if (!project) {
+			return error(new Error(`[vitest] Project "${projectName}" not found.`));
+		}
+		wss.handleUpgrade(request, socket, head, (ws) => {
+			wss.emit("connection", ws, request);
+			const rpc = setupClient(project, rpcId, ws, method);
+			const state = project.browser.state;
+			const clients = type === "tester" ? state.testers : state.orchestrators;
+			clients.set(rpcId, rpc);
+			debug$1?.("[%s] Browser API connected to %s", rpcId, type);
+			ws.on("close", () => {
+				debug$1?.("[%s] Browser API disconnected from %s", rpcId, type);
+				clients.delete(rpcId);
+				globalServer.removeCDPHandler(rpcId);
+			});
+		});
+	});
+	function error(err) {
+		console.error(err);
+		vitest.state.catchError(err, "RPC Error");
+	}
+	function checkFileAccess(path) {
+		if (!isFileServingAllowed(path, vite)) {
+			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) {
+		const mockResolver = new ServerMockResolver(globalServer.vite, { moduleDirectories: project.config.server?.deps?.moduleDirectories });
+		const mocker = project.browser?.provider.mocker;
+		const rpc = createBirpc({
+			async onUnhandledError(error, type) {
+				if (error && typeof error === "object") {
+					const _error = error;
+					_error.stacks = globalServer.parseErrorStacktrace(_error);
+				}
+				vitest.state.catchError(error, type);
+			},
+			async onQueued(file) {
+				if (method === "collect") {
+					vitest.state.collectFiles(project, [file]);
+				} else {
+					await vitest._testRun.enqueued(project, file);
+				}
+			},
+			async onCollected(files) {
+				if (method === "collect") {
+					vitest.state.collectFiles(project, files);
+				} else {
+					await vitest._testRun.collected(project, files);
+				}
+			},
+			async onTaskUpdate(packs, events) {
+				if (method === "collect") {
+					vitest.state.updateTasks(packs);
+				} else {
+					await vitest._testRun.updated(packs, events);
+				}
+			},
+			onAfterSuiteRun(meta) {
+				vitest.coverageProvider?.onAfterSuiteRun(meta);
+			},
+			async sendLog(log) {
+				if (method === "collect") {
+					vitest.state.updateUserLog(log);
+				} else {
+					await vitest._testRun.log(log);
+				}
+			},
+			resolveSnapshotPath(testPath) {
+				return vitest.snapshot.resolvePath(testPath, { config: project.serializedConfig });
+			},
+			resolveSnapshotRawPath(testPath, rawPath) {
+				return vitest.snapshot.resolveRawPath(testPath, rawPath);
+			},
+			snapshotSaved(snapshot) {
+				vitest.snapshot.add(snapshot);
+			},
+			async readSnapshotFile(snapshotPath) {
+				checkFileAccess(snapshotPath);
+				if (!existsSync(snapshotPath)) {
+					return null;
+				}
+				return promises.readFile(snapshotPath, "utf-8");
+			},
+			async saveSnapshotFile(id, content) {
+				checkFileAccess(id);
+				await promises.mkdir(dirname(id), { recursive: true });
+				return promises.writeFile(id, content, "utf-8");
+			},
+			async removeSnapshotFile(id) {
+				checkFileAccess(id);
+				if (!existsSync(id)) {
+					throw new Error(`Snapshot file "${id}" does not exist.`);
+				}
+				return promises.unlink(id);
+			},
+			getBrowserFileSourceMap(id) {
+				const mod = globalServer.vite.moduleGraph.getModuleById(id);
+				return mod?.transformResult?.map;
+			},
+			onCancel(reason) {
+				vitest.cancelCurrentRun(reason);
+			},
+			async resolveId(id, importer) {
+				return mockResolver.resolveId(id, importer);
+			},
+			debug(...args) {
+				vitest.logger.console.debug(...args);
+			},
+			getCountOfFailedTests() {
+				return vitest.state.getCountOfFailedTests();
+			},
+			async wdioSwitchContext(direction) {
+				const provider = project.browser.provider;
+				if (!provider) {
+					throw new Error("Commands are only available for browser tests.");
+				}
+				if (provider.name !== "webdriverio") {
+					throw new Error("Switch context is only available for WebDriverIO provider.");
+				}
+				if (direction === "iframe") {
+					await provider.switchToTestFrame();
+				} else {
+					await provider.switchToMainFrame();
+				}
+			},
+			async triggerCommand(sessionId, command, testPath, payload) {
+				debug$1?.("[%s] Triggering command \"%s\"", sessionId, command);
+				const provider = project.browser.provider;
+				if (!provider) {
+					throw new Error("Commands are only available for browser tests.");
+				}
+				const commands = globalServer.commands;
+				if (!commands || !commands[command]) {
+					throw new Error(`Unknown command "${command}".`);
+				}
+				const context = Object.assign({
+					testPath,
+					project,
+					provider,
+					contextId: sessionId,
+					sessionId
+				}, 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);
+			},
+			invalidate(ids) {
+				return mockResolver.invalidate(ids);
+			},
+			async registerMock(sessionId, module) {
+				if (!mocker) {
+					mockResolver.invalidate([module.id]);
+					if (module.type === "manual") {
+						const mock = ManualMockedModule.fromJSON(module, async () => {
+							try {
+								const { keys } = await rpc.resolveManualMock(module.url);
+								return Object.fromEntries(keys.map((key) => [key, null]));
+							} catch (err) {
+								vitest.state.catchError(err, "Manual Mock Resolver Error");
+								return {};
+							}
+						});
+						defaultMockerRegistry.add(mock);
+					} else {
+						if (module.type === "redirect") {
+							const redirectUrl = new URL(module.redirect);
+							module.redirect = join(vite.config.root, redirectUrl.pathname);
+						}
+						defaultMockerRegistry.register(module);
+					}
+					return;
+				}
+				if (module.type === "manual") {
+					const manualModule = ManualMockedModule.fromJSON(module, async () => {
+						const { keys } = await rpc.resolveManualMock(module.url);
+						return Object.fromEntries(keys.map((key) => [key, null]));
+					});
+					await mocker.register(sessionId, manualModule);
+				} else if (module.type === "redirect") {
+					await mocker.register(sessionId, RedirectedModule.fromJSON(module));
+				} else if (module.type === "automock") {
+					await mocker.register(sessionId, AutomockedModule.fromJSON(module));
+				} else if (module.type === "autospy") {
+					await mocker.register(sessionId, AutospiedModule.fromJSON(module));
+				}
+			},
+			clearMocks(sessionId) {
+				if (!mocker) {
+					return defaultMockerRegistry.clear();
+				}
+				return mocker.clear(sessionId);
+			},
+			unregisterMock(sessionId, id) {
+				if (!mocker) {
+					return defaultMockerRegistry.delete(id);
+				}
+				return mocker.delete(sessionId, id);
+			},
+			async sendCdpEvent(sessionId, event, payload) {
+				const cdp = await globalServer.ensureCDPHandler(sessionId, rpcId);
+				return cdp.send(event, payload);
+			},
+			async trackCdpEvent(sessionId, type, event, listenerId) {
+				const cdp = await globalServer.ensureCDPHandler(sessionId, rpcId);
+				cdp[type](event, listenerId);
+			}
+		}, {
+			post: (msg) => ws.send(msg),
+			on: (fn) => ws.on("message", fn),
+			eventNames: ["onCancel", "cdpEvent"],
+			serialize: (data) => stringify(data, stringifyReplace),
+			deserialize: parse,
+			onTimeoutError(functionName) {
+				throw new Error(`[vitest-api]: Timeout calling "${functionName}"`);
+			}
+		});
+		vitest.onCancel((reason) => rpc.onCancel(reason));
+		return rpc;
+	}
 }
 function cloneByOwnProperties(value) {
-  return Object.getOwnPropertyNames(value).reduce(
-    (clone, prop) => ({
-      ...clone,
-      [prop]: value[prop]
-    }),
-    {}
-  );
+	return Object.getOwnPropertyNames(value).reduce((clone, prop) => ({
+		...clone,
+		[prop]: value[prop]
+	}), {});
 }
+/**
+* Replacer function for serialization methods such as JS.stringify() or
+* flatted.stringify().
+*/
 function stringifyReplace(key, value) {
-  if (value instanceof Error) {
-    const cloned = cloneByOwnProperties(value);
-    return {
-      name: value.name,
-      message: value.message,
-      stack: value.stack,
-      ...cloned
-    };
-  } else {
-    return value;
-  }
+	if (value instanceof Error) {
+		const cloned = cloneByOwnProperties(value);
+		return {
+			name: value.name,
+			message: value.message,
+			stack: value.stack,
+			...cloned
+		};
+	} else {
+		return 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;
+	const context = project.vitest._browserSessions.createAsyncSession(method, sessionId, files, project);
+	return await context;
 }
 function createBrowserPool(vitest) {
-  const providers = /* @__PURE__ */ 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 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('", "')}"`
-      );
-    }
-    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((files2, index) => {
-      if (orchestrators[index]) {
-        const [sessionId, orchestrator] = orchestrators[index];
-        debug?.(
-          "Reusing orchestrator (session %s) for files: %s",
-          sessionId,
-          [...files2.map((f) => relative(project.config.root, f))].join(", ")
-        );
-        const promise = waitForTests(method, sessionId, project, files2);
-        const tester = orchestrator.createTesters(files2).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, files2);
-        debug?.(
-          "Opening a new session %s for files: %s",
-          sessionId,
-          [...files2.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, files2[0]));
-        promises.push(page, waitPromise);
-      }
-    });
-    await Promise.all(promises);
-  };
-  const runWorkspaceTests = async (method, specs) => {
-    const groupedFiles = /* @__PURE__ */ new Map();
-    for (const { project, moduleId } of specs) {
-      const files = groupedFiles.get(project) || [];
-      files.push(moduleId);
-      groupedFiles.set(project, files);
-    }
-    let isCancelled = false;
-    vitest.onCancel(() => {
-      isCancelled = true;
-    });
-    for (const [project, files] of groupedFiles.entries()) {
-      if (isCancelled) {
-        break;
-      }
-      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);
-    }
-  };
-  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) {
-      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 {
-    name: "browser",
-    async close() {
-      await Promise.all([...providers].map((provider) => provider.close()));
-      providers.clear();
-      vitest.resolvedProjects.forEach((project) => {
-        project.browser?.state.orchestrators.forEach((orchestrator) => {
-          orchestrator.$close();
-        });
-      });
-    },
-    runTests: (files) => runWorkspaceTests("run", files),
-    collectTests: (files) => runWorkspaceTests("collect", files)
-  };
+	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 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("\", \"")}"`);
+		}
+		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);
+			}
+		});
+		await Promise.all(promises);
+	};
+	const runWorkspaceTests = async (method, specs) => {
+		const groupedFiles = new Map();
+		for (const { project, moduleId } of specs) {
+			const files = groupedFiles.get(project) || [];
+			files.push(moduleId);
+			groupedFiles.set(project, files);
+		}
+		let isCancelled = false;
+		vitest.onCancel(() => {
+			isCancelled = true;
+		});
+		for (const [project, files] of groupedFiles.entries()) {
+			if (isCancelled) {
+				break;
+			}
+			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);
+		}
+	};
+	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) {
+			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 {
+		name: "browser",
+		async close() {
+			await Promise.all([...providers].map((provider) => provider.close()));
+			providers.clear();
+			vitest.projects.forEach((project) => {
+				project.browser?.state.orchestrators.forEach((orchestrator) => {
+					orchestrator.$close();
+				});
+			});
+		},
+		runTests: (files) => runWorkspaceTests("run", files),
+		collectTests: (files) => runWorkspaceTests("collect", files)
+	};
 }
 function escapePathToRegexp(path) {
-  return path.replace(/[/\\.?*()^${}|[\]+]/g, "\\$&");
+	return path.replace(/[/\\.?*()^${}|[\]+]/g, "\\$&");
 }
 
 async function createBrowserServer(project, configFile, prePlugins = [], postPlugins = []) {
-  if (project.vitest.version !== version) {
-    project.vitest.logger.warn(
-      c.yellow(
-        `Loaded ${c.inverse(c.yellow(` vitest@${project.vitest.version} `))} and ${c.inverse(c.yellow(` @vitest/browser@${version} `))}.
-Running mixed versions is not supported and may lead into bugs
-Update your dependencies and make sure the versions match.`
-      )
-    );
-  }
-  const server = new ParentBrowserProject(project, "/");
-  const configPath = typeof configFile === "string" ? configFile : false;
-  const logLevel = process.env.VITEST_BROWSER_DEBUG ?? "info";
-  const logger = createViteLogger(project.vitest.logger, logLevel, {
-    allowClearScreen: false
-  });
-  const vite = await createViteServer({
-    ...project.options,
-    // spread project config inlined in root workspace config
-    base: "/",
-    logLevel,
-    customLogger: {
-      ...logger,
-      info(msg, options) {
-        logger.info(msg, options);
-        if (msg.includes("optimized dependencies changed. reloading")) {
-          logger.warn(
-            [
-              c.yellow(`
-${c.bold("[vitest]")} Vite unexpectedly reloaded a test. This may cause tests to fail, lead to flaky behaviour or duplicated test runs.
-`),
-              c.yellow(`For a stable experience, please add mentioned dependencies to your config's ${c.bold("`optimizeDeps.include`")} field manually.
-
-`)
-            ].join("")
-          );
-        }
-      }
-    },
-    mode: project.config.mode,
-    configFile: configPath,
-    // watch is handled by Vitest
-    server: {
-      hmr: false,
-      watch: null
-    },
-    plugins: [
-      ...prePlugins,
-      ...project.options?.plugins || [],
-      BrowserPlugin(server),
-      ...postPlugins
-    ]
-  });
-  await vite.listen();
-  setupBrowserRpc(server);
-  return server;
+	if (project.vitest.version !== version) {
+		project.vitest.logger.warn(c.yellow(`Loaded ${c.inverse(c.yellow(` vitest@${project.vitest.version} `))} and ${c.inverse(c.yellow(` @vitest/browser@${version} `))}.` + "\nRunning mixed versions is not supported and may lead into bugs" + "\nUpdate your dependencies and make sure the versions match."));
+	}
+	const server = new ParentBrowserProject(project, "/");
+	const configPath = typeof configFile === "string" ? configFile : false;
+	const logLevel = process.env.VITEST_BROWSER_DEBUG ?? "info";
+	const logger = createViteLogger(project.vitest.logger, logLevel, { allowClearScreen: false });
+	const mockerRegistry = new MockerRegistry();
+	const vite = await createViteServer({
+		...project.options,
+		base: "/",
+		logLevel,
+		customLogger: {
+			...logger,
+			info(msg, options) {
+				logger.info(msg, options);
+				if (msg.includes("optimized dependencies changed. reloading")) {
+					logger.warn([c.yellow(`\n${c.bold("[vitest]")} Vite unexpectedly reloaded a test. This may cause tests to fail, lead to flaky behaviour or duplicated test runs.\n`), c.yellow(`For a stable experience, please add mentioned dependencies to your config\'s ${c.bold("`optimizeDeps.include`")} field manually.\n\n`)].join(""));
+				}
+			}
+		},
+		mode: project.config.mode,
+		configFile: configPath,
+		configLoader: project.vite.config.inlineConfig.configLoader,
+		server: {
+			hmr: false,
+			watch: null
+		},
+		plugins: [
+			...prePlugins,
+			...project.options?.plugins || [],
+			BrowserPlugin(server),
+			interceptorPlugin({ registry: mockerRegistry }),
+			...postPlugins
+		]
+	});
+	await vite.listen();
+	setupBrowserRpc(server, mockerRegistry);
+	return server;
 }
 
 export { createBrowserPool, createBrowserServer, distRoot };