@vitest/browser 4.0.0-beta.13 → 4.0.0-beta.14

package/dist/index.js

@@ -2,27 +2,23 @@ import { ManualMockedModule, RedirectedModule, AutomockedModule, AutospiedModule
 import { dynamicImportPlugin, ServerMockResolver, interceptorPlugin } from '@vitest/mocker/node';
 import c from 'tinyrainbow';
 import { isValidApiRequest, isFileServingAllowed, distDir, resolveApiServerConfig, resolveFsAllow, rolldownVersion, createDebugger, createViteLogger, createViteServer } from 'vitest/node';
+import { fileURLToPath } from 'node:url';
 import fs, { readFileSync, lstatSync, createReadStream, promises, existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { slash as slash$1, toArray, nanoid as nanoid$1, deepMerge, createDefer } from '@vitest/utils/helpers';
+import { slash as slash$1, toArray, deepMerge } from '@vitest/utils/helpers';
 import MagicString from 'magic-string';
 import sirv from 'sirv';
 import { coverageConfigDefaults } from 'vitest/config';
-import { fileURLToPath } from 'node:url';
 import crypto from 'node:crypto';
-import { mkdir, rm, readFile as readFile$1, writeFile as writeFile$1, unlink } from 'node:fs/promises';
+import { readFile as readFile$1, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
 import { parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
-import { PlaywrightBrowserProvider } from './providers/playwright.js';
-import { WebdriverBrowserProvider } from './providers/webdriverio.js';
-import { resolve as resolve$1, basename as basename$1, dirname as dirname$1, normalize as normalize$1 } from 'node:path';
-import * as nodeos from 'node:os';
+import { resolve as resolve$1, basename as basename$1, dirname as dirname$1 } from 'node:path';
 import { platform } from 'node:os';
 import { PNG } from 'pngjs';
 import pm from 'pixelmatch';
 import { WebSocketServer } from 'ws';
-import { performance } from 'node:perf_hooks';
 
-var version = "4.0.0-beta.13";
+var version = "4.0.0-beta.14";
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -324,54 +320,372 @@ const stringify = (value, replacer, space) => {
   }
 };
 
-function replacer(code, values) {
-	return code.replace(/\{\s*(\w+)\s*\}/g, (_, key) => values[key] ?? _);
-}
-async function getBrowserProvider(options, project) {
-	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.`);
-	}
-	if (options.provider == null || "_cli" in options.provider && typeof options.provider.factory !== "function") {
-		const providers = await import('./index-CwoiDq7G.js');
-		const name = options.provider?.name || "preview";
-		if (!(name in providers)) {
-			throw new Error(`Unknown browser provider "${name}". Available providers: ${Object.keys(providers).join(", ")}.`);
-		}
-		return providers[name](options.provider?.options).factory(project);
-	}
-	const supportedBrowsers = options.provider.supportedBrowser || [];
-	if (supportedBrowsers.length && !supportedBrowsers.includes(browser)) {
-		throw new Error(`${name}Browser "${browser}" is not supported by the browser provider "${options.provider.name}". Supported browsers: ${supportedBrowsers.join(", ")}.`);
-	}
-	if (typeof options.provider.factory !== "function") {
-		throw new TypeError(`The "${name}" browser provider does not provide a "factory" function. Received ${typeof options.provider.factory}.`);
-	}
-	return options.provider.factory(project);
+var DOM_KEY_LOCATION = /*#__PURE__*/ function(DOM_KEY_LOCATION) {
+    DOM_KEY_LOCATION[DOM_KEY_LOCATION["STANDARD"] = 0] = "STANDARD";
+    DOM_KEY_LOCATION[DOM_KEY_LOCATION["LEFT"] = 1] = "LEFT";
+    DOM_KEY_LOCATION[DOM_KEY_LOCATION["RIGHT"] = 2] = "RIGHT";
+    DOM_KEY_LOCATION[DOM_KEY_LOCATION["NUMPAD"] = 3] = "NUMPAD";
+    return DOM_KEY_LOCATION;
+}({});
+
+/**
+ * Mapping for a default US-104-QWERTY keyboard
+ */ const defaultKeyMap = [
+    // alphanumeric block - writing system
+    ...'0123456789'.split('').map((c)=>({
+            code: `Digit${c}`,
+            key: c
+        })),
+    ...')!@#$%^&*('.split('').map((c, i)=>({
+            code: `Digit${i}`,
+            key: c,
+            shiftKey: true
+        })),
+    ...'abcdefghijklmnopqrstuvwxyz'.split('').map((c)=>({
+            code: `Key${c.toUpperCase()}`,
+            key: c
+        })),
+    ...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map((c)=>({
+            code: `Key${c}`,
+            key: c,
+            shiftKey: true
+        })),
+    {
+        code: 'BracketLeft',
+        key: '['
+    },
+    {
+        code: 'BracketLeft',
+        key: '{',
+        shiftKey: true
+    },
+    {
+        code: 'BracketRight',
+        key: ']'
+    },
+    {
+        code: 'BracketRight',
+        key: '}',
+        shiftKey: true
+    },
+    // alphanumeric block - functional
+    {
+        code: 'Space',
+        key: ' '
+    },
+    {
+        code: 'AltLeft',
+        key: 'Alt',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'AltRight',
+        key: 'Alt',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ShiftLeft',
+        key: 'Shift',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'ShiftRight',
+        key: 'Shift',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ControlLeft',
+        key: 'Control',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'ControlRight',
+        key: 'Control',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'MetaLeft',
+        key: 'Meta',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'MetaRight',
+        key: 'Meta',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'OSLeft',
+        key: 'OS',
+        location: DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'OSRight',
+        key: 'OS',
+        location: DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ContextMenu',
+        key: 'ContextMenu'
+    },
+    {
+        code: 'Tab',
+        key: 'Tab'
+    },
+    {
+        code: 'CapsLock',
+        key: 'CapsLock'
+    },
+    {
+        code: 'Backspace',
+        key: 'Backspace'
+    },
+    {
+        code: 'Enter',
+        key: 'Enter'
+    },
+    // function
+    {
+        code: 'Escape',
+        key: 'Escape'
+    },
+    // arrows
+    {
+        code: 'ArrowUp',
+        key: 'ArrowUp'
+    },
+    {
+        code: 'ArrowDown',
+        key: 'ArrowDown'
+    },
+    {
+        code: 'ArrowLeft',
+        key: 'ArrowLeft'
+    },
+    {
+        code: 'ArrowRight',
+        key: 'ArrowRight'
+    },
+    // control pad
+    {
+        code: 'Home',
+        key: 'Home'
+    },
+    {
+        code: 'End',
+        key: 'End'
+    },
+    {
+        code: 'Delete',
+        key: 'Delete'
+    },
+    {
+        code: 'PageUp',
+        key: 'PageUp'
+    },
+    {
+        code: 'PageDown',
+        key: 'PageDown'
+    },
+    // Special keys that are not part of a default US-layout but included for specific behavior
+    {
+        code: 'Fn',
+        key: 'Fn'
+    },
+    {
+        code: 'Symbol',
+        key: 'Symbol'
+    },
+    {
+        code: 'AltRight',
+        key: 'AltGraph'
+    }
+];
+
+var bracketDict = /*#__PURE__*/ function(bracketDict) {
+    bracketDict["{"] = "}";
+    bracketDict["["] = "]";
+    return bracketDict;
+}(bracketDict || {});
+/**
+ * Read the next key definition from user input
+ *
+ * Describe key per `{descriptor}` or `[descriptor]`.
+ * Everything else will be interpreted as a single character as descriptor - e.g. `a`.
+ * Brackets `{` and `[` can be escaped by doubling - e.g. `foo[[bar` translates to `foo[bar`.
+ * A previously pressed key can be released per `{/descriptor}`.
+ * Keeping the key pressed can be written as `{descriptor>}`.
+ * When keeping the key pressed you can choose how long the key is pressed `{descriptor>3}`.
+ * You can then release the key per `{descriptor>3/}` or keep it pressed and continue with the next key.
+ */ function readNextDescriptor(text, context) {
+    let pos = 0;
+    const startBracket = text[pos] in bracketDict ? text[pos] : '';
+    pos += startBracket.length;
+    const isEscapedChar = new RegExp(`^\\${startBracket}{2}`).test(text);
+    const type = isEscapedChar ? '' : startBracket;
+    return {
+        type,
+        ...type === '' ? readPrintableChar(text, pos) : readTag(text, pos, type)
+    };
 }
-function slash(path) {
-	return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+function readPrintableChar(text, pos, context) {
+    const descriptor = text[pos];
+    assertDescriptor(descriptor, text, pos);
+    pos += descriptor.length;
+    return {
+        consumedLength: pos,
+        descriptor,
+        releasePrevious: false,
+        releaseSelf: true,
+        repeat: 1
+    };
 }
-
-async function resolveOrchestrator(globalServer, url, res) {
-	let sessionId = url.searchParams.get("sessionId");
-	// it's possible to open the page without a context
-	if (!sessionId) {
-		const contexts = [...globalServer.children].flatMap((p) => [...p.state.orchestrators.keys()]);
-		sessionId = contexts.at(-1) ?? "none";
-	}
-	// it's ok to not have a session here, especially in the preview provider
-	// because the user could refresh the page which would remove the session id from the url
-	const session = globalServer.vitest._browserSessions.getSession(sessionId);
-	const browserProject = session?.project.browser || [...globalServer.children][0];
-	if (!browserProject) {
-		return;
-	}
-	// ignore unknown pages
-	if (sessionId && sessionId !== "none" && !globalServer.vitest._browserSessions.sessionIds.has(sessionId)) {
-		return;
-	}
+function readTag(text, pos, startBracket, context) {
+    var _text_slice_match, _text_slice_match1;
+    const releasePreviousModifier = text[pos] === '/' ? '/' : '';
+    pos += releasePreviousModifier.length;
+    const escapedDescriptor = startBracket === '{' && text[pos] === '\\';
+    pos += Number(escapedDescriptor);
+    const descriptor = escapedDescriptor ? text[pos] : (_text_slice_match = text.slice(pos).match(startBracket === '{' ? /^\w+|^[^}>/]/ : /^\w+/)) === null || _text_slice_match === undefined ? undefined : _text_slice_match[0];
+    assertDescriptor(descriptor, text, pos);
+    pos += descriptor.length;
+    var _text_slice_match_;
+    const repeatModifier = (_text_slice_match_ = (_text_slice_match1 = text.slice(pos).match(/^>\d+/)) === null || _text_slice_match1 === undefined ? undefined : _text_slice_match1[0]) !== null && _text_slice_match_ !== undefined ? _text_slice_match_ : '';
+    pos += repeatModifier.length;
+    const releaseSelfModifier = text[pos] === '/' || !repeatModifier && text[pos] === '>' ? text[pos] : '';
+    pos += releaseSelfModifier.length;
+    const expectedEndBracket = bracketDict[startBracket];
+    const endBracket = text[pos] === expectedEndBracket ? expectedEndBracket : '';
+    if (!endBracket) {
+        throw new Error(getErrorMessage([
+            !repeatModifier && 'repeat modifier',
+            !releaseSelfModifier && 'release modifier',
+            `"${expectedEndBracket}"`
+        ].filter(Boolean).join(' or '), text[pos], text));
+    }
+    pos += endBracket.length;
+    return {
+        consumedLength: pos,
+        descriptor,
+        releasePrevious: !!releasePreviousModifier,
+        repeat: repeatModifier ? Math.max(Number(repeatModifier.substr(1)), 1) : 1,
+        releaseSelf: hasReleaseSelf(releaseSelfModifier, repeatModifier)
+    };
+}
+function assertDescriptor(descriptor, text, pos, context) {
+    if (!descriptor) {
+        throw new Error(getErrorMessage('key descriptor', text[pos], text));
+    }
+}
+function hasReleaseSelf(releaseSelfModifier, repeatModifier) {
+    if (releaseSelfModifier) {
+        return releaseSelfModifier === '/';
+    }
+    if (repeatModifier) {
+        return false;
+    }
+}
+function getErrorMessage(expected, found, text, context) {
+    return `Expected ${expected} but found "${found !== null && found !== undefined ? found : ''}" in "${text}"
+    See ${`https://testing-library.com/docs/user-event/keyboard`}
+    for more information about how userEvent parses your input.`;
+}
+
+/**
+ * Parse key definitions per `keyboardMap`
+ *
+ * Keys can be referenced by `{key}` or `{special}` as well as physical locations per `[code]`.
+ * Everything else will be interpreted as a typed character - e.g. `a`.
+ * Brackets `{` and `[` can be escaped by doubling - e.g. `foo[[bar` translates to `foo[bar`.
+ * Keeping the key pressed can be written as `{key>}`.
+ * When keeping the key pressed you can choose how long (how many keydown and keypress) the key is pressed `{key>3}`.
+ * You can then release the key per `{key>3/}` or keep it pressed and continue with the next key.
+ */ function parseKeyDef$1(keyboardMap, text) {
+    const defs = [];
+    do {
+        const { type, descriptor, consumedLength, releasePrevious, releaseSelf = true, repeat } = readNextDescriptor(text);
+        var _keyboardMap_find;
+        const keyDef = (_keyboardMap_find = keyboardMap.find((def)=>{
+            if (type === '[') {
+                var _def_code;
+                return ((_def_code = def.code) === null || _def_code === undefined ? undefined : _def_code.toLowerCase()) === descriptor.toLowerCase();
+            } else if (type === '{') {
+                var _def_key;
+                return ((_def_key = def.key) === null || _def_key === undefined ? undefined : _def_key.toLowerCase()) === descriptor.toLowerCase();
+            }
+            return def.key === descriptor;
+        })) !== null && _keyboardMap_find !== undefined ? _keyboardMap_find : {
+            key: 'Unknown',
+            code: 'Unknown',
+            [type === '[' ? 'code' : 'key']: descriptor
+        };
+        defs.push({
+            keyDef,
+            releasePrevious,
+            releaseSelf,
+            repeat
+        });
+        text = text.slice(consumedLength);
+    }while (text)
+    return defs;
+}
+
+function parseKeyDef(text) {
+	return parseKeyDef$1(defaultKeyMap, text);
+}
+function replacer(code, values) {
+	return code.replace(/\{\s*(\w+)\s*\}/g, (_, key) => values[key] ?? _);
+}
+function resolveScreenshotPath(testPath, name, config, customPath) {
+	if (customPath) {
+		return resolve(dirname(testPath), customPath);
+	}
+	const dir = dirname(testPath);
+	const base = basename(testPath);
+	if (config.browser.screenshotDirectory) {
+		return resolve(config.browser.screenshotDirectory, relative(config.root, dir), base, name);
+	}
+	return resolve(dir, "__screenshots__", base, name);
+}
+async function getBrowserProvider(options, project) {
+	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.`);
+	}
+	if (options.provider == null) {
+		throw new Error(`Browser Mode requires the "provider" to always be specified.`);
+	}
+	const supportedBrowsers = options.provider.supportedBrowser || [];
+	if (supportedBrowsers.length && !supportedBrowsers.includes(browser)) {
+		throw new Error(`${name}Browser "${browser}" is not supported by the browser provider "${options.provider.name}". Supported browsers: ${supportedBrowsers.join(", ")}.`);
+	}
+	if (typeof options.provider.providerFactory !== "function") {
+		throw new TypeError(`The "${name}" browser provider does not provide a "providerFactory" function. Received ${typeof options.provider.providerFactory}.`);
+	}
+	return options.provider.providerFactory(project);
+}
+function slash(path) {
+	return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+
+async function resolveOrchestrator(globalServer, url, res) {
+	let sessionId = url.searchParams.get("sessionId");
+	// it's possible to open the page without a context
+	if (!sessionId) {
+		const contexts = [...globalServer.children].flatMap((p) => [...p.state.orchestrators.keys()]);
+		sessionId = contexts.at(-1) ?? "none";
+	}
+	// it's ok to not have a session here, especially in the preview provider
+	// because the user could refresh the page which would remove the session id from the url
+	const session = globalServer.vitest._browserSessions.getSession(sessionId);
+	const browserProject = session?.project.browser || [...globalServer.children][0];
+	if (!browserProject) {
+		return;
+	}
+	// ignore unknown pages
+	if (sessionId && sessionId !== "none" && !globalServer.vitest._browserSessions.sessionIds.has(sessionId)) {
+		return;
+	}
 	const injectorJs = typeof globalServer.injectorJs === "string" ? globalServer.injectorJs : await globalServer.injectorJs;
 	const injector = replacer(injectorJs, {
 		__VITEST_PROVIDER__: JSON.stringify(browserProject.config.browser.provider?.name || "preview"),
@@ -514,36 +828,58 @@ function createTesterMiddleware(browserServer) {
 	};
 }
 
-const VIRTUAL_ID_CONTEXT = "\0@vitest/browser/context";
-const ID_CONTEXT = "@vitest/browser/context";
+const VIRTUAL_ID_CONTEXT = "\0vitest/browser";
+const ID_CONTEXT = "vitest/browser";
+// for libraries that use an older import but are not type checked
+const DEPRECATED_ID_CONTEXT = "@vitest/browser/context";
+const DEPRECATED_VIRTUAL_ID_UTILS = "\0@vitest/browser/utils";
+const DEPRECATED_ID_UTILS = "@vitest/browser/utils";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function BrowserContext(globalServer) {
 	return {
 		name: "vitest:browser:virtual-module:context",
 		enforce: "pre",
-		resolveId(id) {
+		resolveId(id, importer) {
 			if (id === ID_CONTEXT) {
 				return VIRTUAL_ID_CONTEXT;
 			}
+			if (id === DEPRECATED_ID_CONTEXT) {
+				if (importer) {
+					globalServer.vitest.logger.deprecate(`${importer} tries to load a deprecated "${id}" module. ` + `This import will stop working in the next major version. ` + `Please, use "vitest/browser" instead.`);
+				}
+				return VIRTUAL_ID_CONTEXT;
+			}
+			if (id === DEPRECATED_ID_UTILS) {
+				return DEPRECATED_VIRTUAL_ID_UTILS;
+			}
 		},
 		load(id) {
 			if (id === VIRTUAL_ID_CONTEXT) {
 				return generateContextFile.call(this, globalServer);
 			}
+			if (id === DEPRECATED_VIRTUAL_ID_UTILS) {
+				return `
+import { utils } from 'vitest/browser'
+export const getElementLocatorSelectors = utils.getElementLocatorSelectors
+export const debug = utils.debug
+export const prettyDOM = utils.prettyDOM
+export const getElementError = utils.getElementError
+        `;
+			}
 		}
 	};
 }
 async function generateContextFile(globalServer) {
 	const commands = Object.keys(globalServer.commands);
-	const provider = [...globalServer.children][0].provider || { name: "preview" };
-	const providerName = provider.name;
+	const provider = [...globalServer.children][0].provider;
+	const providerName = provider?.name || "preview";
 	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 userEventNonProviderImport = await getUserEventImport(provider, this.resolve.bind(this));
 	const distContextPath = slash$1(`/@fs/${resolve(__dirname, "context.js")}`);
 	return `
-import { page, createUserEvent, cdp, locators } from '${distContextPath}'
+import { page, createUserEvent, cdp, locators, utils } from '${distContextPath}'
 ${userEventNonProviderImport}
 
 export const server = {
@@ -558,16 +894,17 @@ export const server = {
 }
 export const commands = server.commands
 export const userEvent = createUserEvent(_userEventSetup)
-export { page, cdp, locators }
+export { page, cdp, locators, utils }
 `;
 }
 async function getUserEventImport(provider, resolve) {
-	if (provider !== "preview") {
+	if (!provider || provider.name !== "preview") {
 		return "const _userEventSetup = undefined";
 	}
-	const resolved = await resolve("@testing-library/user-event", __dirname);
+	const previewDistRoot = provider.distRoot;
+	const resolved = await resolve("@testing-library/user-event", previewDistRoot);
 	if (!resolved) {
-		throw new Error(`Failed to resolve user-event package from ${__dirname}`);
+		throw new Error(`Failed to resolve user-event package from ${previewDistRoot}`);
 	}
 	return `\
 import { userEvent as __vitest_user_event__ } from '${slash$1(`/@fs/${resolved.id}`)}'
@@ -728,9 +1065,9 @@ var BrowserPlugin = (parentServer, base = "/") => {
 				];
 				const exclude = [
 					"vitest",
+					"vitest/browser",
 					"vitest/internal/browser",
 					"vitest/runners",
-					"@vitest/browser",
 					"@vitest/browser/client",
 					"@vitest/utils",
 					"@vitest/utils/source-map",
@@ -772,10 +1109,12 @@ var BrowserPlugin = (parentServer, base = "/") => {
 				const include = [
 					"vitest > expect-type",
 					"vitest > @vitest/snapshot > magic-string",
-					"vitest > @vitest/expect > chai",
-					"@vitest/browser > @testing-library/user-event",
-					"@vitest/browser > @testing-library/dom"
+					"vitest > @vitest/expect > chai"
 				];
+				const provider = parentServer.config.browser.provider || [...parentServer.children][0]?.provider;
+				if (provider?.name === "preview") {
+					include.push("@vitest/browser-preview > @testing-library/user-event", "@vitest/browser-preview > @testing-library/dom");
+				}
 				const fileRoot = browserTestFiles[0] ? dirname(browserTestFiles[0]) : project.config.root;
 				const svelte = isPackageExists("vitest-browser-svelte", fileRoot);
 				if (svelte) {
@@ -989,14 +1328,14 @@ body {
 						},
 						injectTo: "head"
 					},
-					parentServer.locatorsUrl ? {
+					...parentServer.initScripts.map((script) => ({
 						tag: "script",
 						attrs: {
 							type: "module",
-							src: parentServer.locatorsUrl
+							src: join("/@fs/", script)
 						},
 						injectTo: "head"
-					} : null,
+					})),
 					...testerTags
 				].filter((s) => s != null);
 			}
@@ -1110,114 +1449,6 @@ class BrowserServerCDPHandler {
 	}
 }
 
-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`);
-	}
-};
-
-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 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 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 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;
-		// https://github.com/webdriverio/webdriverio/issues/8022#issuecomment-1700919670
-		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`);
-	}
-};
-
 const types = {
     'application/andrew-inset': ['ez'],
     'application/appinstaller': ['appinstaller'],
@@ -1668,796 +1899,55 @@ class Mime {
 }
 _Mime_extensionToType = new WeakMap(), _Mime_typeToExtension = new WeakMap(), _Mime_typeToExtensions = new WeakMap();
 
-var mime = new Mime(types)._freeze();
-
-function assertFileAccess(path, project) {
-	if (!isFileServingAllowed(path, project.vite) && !isFileServingAllowed(path, project.vitest.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.`);
-	}
-}
-const readFile = async ({ project }, path, options = {}) => {
-	const filepath = resolve$1(project.config.root, path);
-	assertFileAccess(filepath, project);
-	// never return a Buffer
-	if (typeof options === "object" && !options.encoding) {
-		options.encoding = "utf-8";
-	}
-	return promises.readFile(filepath, options);
-};
-const writeFile = async ({ project }, path, data, options) => {
-	const filepath = resolve$1(project.config.root, 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 }, path) => {
-	const filepath = resolve$1(project.config.root, path);
-	assertFileAccess(filepath, project);
-	await promises.rm(filepath);
-};
-const _fileInfo = async ({ project }, path, encoding) => {
-	const filepath = resolve$1(project.config.root, 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`);
-	}
-};
-
-var DOM_KEY_LOCATION = /*#__PURE__*/ function(DOM_KEY_LOCATION) {
-    DOM_KEY_LOCATION[DOM_KEY_LOCATION["STANDARD"] = 0] = "STANDARD";
-    DOM_KEY_LOCATION[DOM_KEY_LOCATION["LEFT"] = 1] = "LEFT";
-    DOM_KEY_LOCATION[DOM_KEY_LOCATION["RIGHT"] = 2] = "RIGHT";
-    DOM_KEY_LOCATION[DOM_KEY_LOCATION["NUMPAD"] = 3] = "NUMPAD";
-    return DOM_KEY_LOCATION;
-}({});
-
-/**
- * Mapping for a default US-104-QWERTY keyboard
- */ const defaultKeyMap = [
-    // alphanumeric block - writing system
-    ...'0123456789'.split('').map((c)=>({
-            code: `Digit${c}`,
-            key: c
-        })),
-    ...')!@#$%^&*('.split('').map((c, i)=>({
-            code: `Digit${i}`,
-            key: c,
-            shiftKey: true
-        })),
-    ...'abcdefghijklmnopqrstuvwxyz'.split('').map((c)=>({
-            code: `Key${c.toUpperCase()}`,
-            key: c
-        })),
-    ...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map((c)=>({
-            code: `Key${c}`,
-            key: c,
-            shiftKey: true
-        })),
-    {
-        code: 'BracketLeft',
-        key: '['
-    },
-    {
-        code: 'BracketLeft',
-        key: '{',
-        shiftKey: true
-    },
-    {
-        code: 'BracketRight',
-        key: ']'
-    },
-    {
-        code: 'BracketRight',
-        key: '}',
-        shiftKey: true
-    },
-    // alphanumeric block - functional
-    {
-        code: 'Space',
-        key: ' '
-    },
-    {
-        code: 'AltLeft',
-        key: 'Alt',
-        location: DOM_KEY_LOCATION.LEFT
-    },
-    {
-        code: 'AltRight',
-        key: 'Alt',
-        location: DOM_KEY_LOCATION.RIGHT
-    },
-    {
-        code: 'ShiftLeft',
-        key: 'Shift',
-        location: DOM_KEY_LOCATION.LEFT
-    },
-    {
-        code: 'ShiftRight',
-        key: 'Shift',
-        location: DOM_KEY_LOCATION.RIGHT
-    },
-    {
-        code: 'ControlLeft',
-        key: 'Control',
-        location: DOM_KEY_LOCATION.LEFT
-    },
-    {
-        code: 'ControlRight',
-        key: 'Control',
-        location: DOM_KEY_LOCATION.RIGHT
-    },
-    {
-        code: 'MetaLeft',
-        key: 'Meta',
-        location: DOM_KEY_LOCATION.LEFT
-    },
-    {
-        code: 'MetaRight',
-        key: 'Meta',
-        location: DOM_KEY_LOCATION.RIGHT
-    },
-    {
-        code: 'OSLeft',
-        key: 'OS',
-        location: DOM_KEY_LOCATION.LEFT
-    },
-    {
-        code: 'OSRight',
-        key: 'OS',
-        location: DOM_KEY_LOCATION.RIGHT
-    },
-    {
-        code: 'ContextMenu',
-        key: 'ContextMenu'
-    },
-    {
-        code: 'Tab',
-        key: 'Tab'
-    },
-    {
-        code: 'CapsLock',
-        key: 'CapsLock'
-    },
-    {
-        code: 'Backspace',
-        key: 'Backspace'
-    },
-    {
-        code: 'Enter',
-        key: 'Enter'
-    },
-    // function
-    {
-        code: 'Escape',
-        key: 'Escape'
-    },
-    // arrows
-    {
-        code: 'ArrowUp',
-        key: 'ArrowUp'
-    },
-    {
-        code: 'ArrowDown',
-        key: 'ArrowDown'
-    },
-    {
-        code: 'ArrowLeft',
-        key: 'ArrowLeft'
-    },
-    {
-        code: 'ArrowRight',
-        key: 'ArrowRight'
-    },
-    // control pad
-    {
-        code: 'Home',
-        key: 'Home'
-    },
-    {
-        code: 'End',
-        key: 'End'
-    },
-    {
-        code: 'Delete',
-        key: 'Delete'
-    },
-    {
-        code: 'PageUp',
-        key: 'PageUp'
-    },
-    {
-        code: 'PageDown',
-        key: 'PageDown'
-    },
-    // Special keys that are not part of a default US-layout but included for specific behavior
-    {
-        code: 'Fn',
-        key: 'Fn'
-    },
-    {
-        code: 'Symbol',
-        key: 'Symbol'
-    },
-    {
-        code: 'AltRight',
-        key: 'AltGraph'
-    }
-];
-
-var bracketDict = /*#__PURE__*/ function(bracketDict) {
-    bracketDict["{"] = "}";
-    bracketDict["["] = "]";
-    return bracketDict;
-}(bracketDict || {});
-/**
- * Read the next key definition from user input
- *
- * Describe key per `{descriptor}` or `[descriptor]`.
- * Everything else will be interpreted as a single character as descriptor - e.g. `a`.
- * Brackets `{` and `[` can be escaped by doubling - e.g. `foo[[bar` translates to `foo[bar`.
- * A previously pressed key can be released per `{/descriptor}`.
- * Keeping the key pressed can be written as `{descriptor>}`.
- * When keeping the key pressed you can choose how long the key is pressed `{descriptor>3}`.
- * You can then release the key per `{descriptor>3/}` or keep it pressed and continue with the next key.
- */ function readNextDescriptor(text, context) {
-    let pos = 0;
-    const startBracket = text[pos] in bracketDict ? text[pos] : '';
-    pos += startBracket.length;
-    const isEscapedChar = new RegExp(`^\\${startBracket}{2}`).test(text);
-    const type = isEscapedChar ? '' : startBracket;
-    return {
-        type,
-        ...type === '' ? readPrintableChar(text, pos) : readTag(text, pos, type)
-    };
-}
-function readPrintableChar(text, pos, context) {
-    const descriptor = text[pos];
-    assertDescriptor(descriptor, text, pos);
-    pos += descriptor.length;
-    return {
-        consumedLength: pos,
-        descriptor,
-        releasePrevious: false,
-        releaseSelf: true,
-        repeat: 1
-    };
-}
-function readTag(text, pos, startBracket, context) {
-    var _text_slice_match, _text_slice_match1;
-    const releasePreviousModifier = text[pos] === '/' ? '/' : '';
-    pos += releasePreviousModifier.length;
-    const escapedDescriptor = startBracket === '{' && text[pos] === '\\';
-    pos += Number(escapedDescriptor);
-    const descriptor = escapedDescriptor ? text[pos] : (_text_slice_match = text.slice(pos).match(startBracket === '{' ? /^\w+|^[^}>/]/ : /^\w+/)) === null || _text_slice_match === undefined ? undefined : _text_slice_match[0];
-    assertDescriptor(descriptor, text, pos);
-    pos += descriptor.length;
-    var _text_slice_match_;
-    const repeatModifier = (_text_slice_match_ = (_text_slice_match1 = text.slice(pos).match(/^>\d+/)) === null || _text_slice_match1 === undefined ? undefined : _text_slice_match1[0]) !== null && _text_slice_match_ !== undefined ? _text_slice_match_ : '';
-    pos += repeatModifier.length;
-    const releaseSelfModifier = text[pos] === '/' || !repeatModifier && text[pos] === '>' ? text[pos] : '';
-    pos += releaseSelfModifier.length;
-    const expectedEndBracket = bracketDict[startBracket];
-    const endBracket = text[pos] === expectedEndBracket ? expectedEndBracket : '';
-    if (!endBracket) {
-        throw new Error(getErrorMessage([
-            !repeatModifier && 'repeat modifier',
-            !releaseSelfModifier && 'release modifier',
-            `"${expectedEndBracket}"`
-        ].filter(Boolean).join(' or '), text[pos], text));
-    }
-    pos += endBracket.length;
-    return {
-        consumedLength: pos,
-        descriptor,
-        releasePrevious: !!releasePreviousModifier,
-        repeat: repeatModifier ? Math.max(Number(repeatModifier.substr(1)), 1) : 1,
-        releaseSelf: hasReleaseSelf(releaseSelfModifier, repeatModifier)
-    };
-}
-function assertDescriptor(descriptor, text, pos, context) {
-    if (!descriptor) {
-        throw new Error(getErrorMessage('key descriptor', text[pos], text));
-    }
-}
-function hasReleaseSelf(releaseSelfModifier, repeatModifier) {
-    if (releaseSelfModifier) {
-        return releaseSelfModifier === '/';
-    }
-    if (repeatModifier) {
-        return false;
-    }
-}
-function getErrorMessage(expected, found, text, context) {
-    return `Expected ${expected} but found "${found !== null && found !== undefined ? found : ''}" in "${text}"
-    See ${`https://testing-library.com/docs/user-event/keyboard`}
-    for more information about how userEvent parses your input.`;
-}
-
-/**
- * Parse key definitions per `keyboardMap`
- *
- * Keys can be referenced by `{key}` or `{special}` as well as physical locations per `[code]`.
- * Everything else will be interpreted as a typed character - e.g. `a`.
- * Brackets `{` and `[` can be escaped by doubling - e.g. `foo[[bar` translates to `foo[bar`.
- * Keeping the key pressed can be written as `{key>}`.
- * When keeping the key pressed you can choose how long (how many keydown and keypress) the key is pressed `{key>3}`.
- * You can then release the key per `{key>3/}` or keep it pressed and continue with the next key.
- */ function parseKeyDef(keyboardMap, text) {
-    const defs = [];
-    do {
-        const { type, descriptor, consumedLength, releasePrevious, releaseSelf = true, repeat } = readNextDescriptor(text);
-        var _keyboardMap_find;
-        const keyDef = (_keyboardMap_find = keyboardMap.find((def)=>{
-            if (type === '[') {
-                var _def_code;
-                return ((_def_code = def.code) === null || _def_code === undefined ? undefined : _def_code.toLowerCase()) === descriptor.toLowerCase();
-            } else if (type === '{') {
-                var _def_key;
-                return ((_def_key = def.key) === null || _def_key === undefined ? undefined : _def_key.toLowerCase()) === descriptor.toLowerCase();
-            }
-            return def.key === descriptor;
-        })) !== null && _keyboardMap_find !== undefined ? _keyboardMap_find : {
-            key: 'Unknown',
-            code: 'Unknown',
-            [type === '[' ? 'code' : 'key']: descriptor
-        };
-        defs.push({
-            keyDef,
-            releasePrevious,
-            releaseSelf,
-            repeat
-        });
-        text = text.slice(consumedLength);
-    }while (text)
-    return defs;
-}
-
-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) };
-};
-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 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`);
-	}
-};
-// fallback to insertText for non US key
-// https://github.com/microsoft/playwright/blob/50775698ae13642742f2a1e8983d1d686d7f192d/packages/playwright-core/src/server/input.ts#L95
-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;
-			// TODO: instead of calling down/up for each key, join non special
-			// together, and call `type` once for all non special keys,
-			// and then `press` for special keys
-			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);
-				}
-			}
-		}
-		// seems like webdriverio doesn't release keys automatically if skipRelease is true and all events are keyUp
-		const allRelease = keyboard.toJSON().actions.every((action) => action.type === "keyUp");
-		await keyboard.perform(allRelease ? false : skipRelease);
+var mime = new Mime(types)._freeze();
+
+function assertFileAccess(path, project) {
+	if (!isFileServingAllowed(path, project.vite) && !isFileServingAllowed(path, project.vitest.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.`);
 	}
-	return { pressed };
 }
-function focusIframe() {
-	if (!document.activeElement || document.activeElement.ownerDocument !== document || document.activeElement === document.body) {
-		window.focus();
+const readFile = async ({ project }, path, options = {}) => {
+	const filepath = resolve$1(project.config.root, path);
+	assertFileAccess(filepath, project);
+	// never return a Buffer
+	if (typeof options === "object" && !options.encoding) {
+		options.encoding = "utf-8";
 	}
-}
-function selectAll() {
-	const element = document.activeElement;
-	if (element && typeof element.select === "function") {
-		element.select();
+	return promises.readFile(filepath, options);
+};
+const writeFile = async ({ project }, path, data, options) => {
+	const filepath = resolve$1(project.config.root, 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 }, path) => {
+	const filepath = resolve$1(project.config.root, path);
+	assertFileAccess(filepath, project);
+	await promises.rm(filepath);
+};
+const _fileInfo = async ({ project }, path, encoding) => {
+	const filepath = resolve$1(project.config.root, path);
+	assertFileAccess(filepath, project);
+	const content = await promises.readFile(filepath, encoding || "base64");
+	return {
+		content,
+		basename: basename$1(filepath),
+		mime: mime.getType(filepath)
+	};
+};
 
 const screenshot = async (context, name, options = {}) => {
 	options.save ??= true;
 	if (!options.save) {
 		options.base64 = true;
 	}
-	const { buffer, path } = await takeScreenshot(context, name, options);
+	const { buffer, path } = await context.triggerCommand("__vitest_takeScreenshot", name, options);
 	return returnResult(options, path, buffer);
 };
-/**
-* Takes a screenshot using the provided browser context and returns a buffer and the expected screenshot path.
-*
-* **Note**: the returned `path` indicates where the screenshot *might* be found.
-* It is not guaranteed to exist, especially if `options.save` is `false`.
-*
-* @throws {Error} If the function is not called within a test or if the browser provider does not support screenshots.
-*/
-async function takeScreenshot(context, name, options) {
-	if (!context.testPath) {
-		throw new Error(`Cannot take a screenshot without a test path`);
-	}
-	const path = resolveScreenshotPath(context.testPath, name, context.project.config, options.path);
-	// playwright does not need a screenshot path if we don't intend to save it
-	let savePath;
-	if (options.save) {
-		savePath = normalize(path);
-		await mkdir(dirname(savePath), { recursive: true });
-	}
-	if (context.provider instanceof PlaywrightBrowserProvider) {
-		const mask = options.mask?.map((selector) => context.iframe.locator(selector));
-		if (options.element) {
-			const { element: selector,...config } = options;
-			const element = context.iframe.locator(selector);
-			const buffer = await element.screenshot({
-				...config,
-				mask,
-				path: savePath
-			});
-			return {
-				buffer,
-				path
-			};
-		}
-		const buffer = await context.iframe.locator("body").screenshot({
-			...options,
-			mask,
-			path: savePath
-		});
-		return {
-			buffer,
-			path
-		};
-	}
-	if (context.provider instanceof WebdriverBrowserProvider) {
-		// webdriverio needs a path, so if one is not already set we create a temporary one
-		if (savePath === undefined) {
-			savePath = resolve(context.project.tmpDir, nanoid$1());
-			await mkdir(context.project.tmpDir, { recursive: true });
-		}
-		const page = context.provider.browser;
-		const element = !options.element ? await page.$("body") : await page.$(`${options.element}`);
-		// webdriverio expects the path to contain the extension and only works with PNG files
-		const savePathWithExtension = savePath.endsWith(".png") ? savePath : `${savePath}.png`;
-		// there seems to be a bug in webdriverio, `X:/` gets appended to cwd, so we convert to `X:\`
-		const buffer = await element.saveScreenshot(normalize$1(savePathWithExtension));
-		if (!options.save) {
-			await rm(savePathWithExtension, { force: true });
-		}
-		return {
-			buffer,
-			path
-		};
-	}
-	throw new Error(`Provider "${context.provider.name}" does not support screenshots`);
-}
-function resolveScreenshotPath(testPath, name, config, customPath) {
-	if (customPath) {
-		return resolve(dirname(testPath), customPath);
-	}
-	const dir = dirname(testPath);
-	const base = basename(testPath);
-	if (config.browser.screenshotDirectory) {
-		return resolve(config.browser.screenshotDirectory, relative(config.root, dir), base, name);
-	}
-	return resolve(dir, "__screenshots__", base, name);
-}
 function returnResult(options, path, buffer) {
 	if (!options.save) {
 		return buffer.toString("base64");
@@ -2685,7 +2175,7 @@ function sanitizeArg(input) {
 * @returns `Promise` resolving to the decoded screenshot data
 */
 function takeDecodedScreenshot({ codec, context, element, name, screenshotOptions }) {
-	return takeScreenshot(context, name, {
+	return context.triggerCommand("__vitest_takeScreenshot", name, {
 		...screenshotOptions,
 		save: false,
 		element
@@ -2866,248 +2356,13 @@ async function getStableScreenshots({ codec, context, comparator, comparatorOpti
 	};
 }
 
-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`);
-	}
-};
-
-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 startTracing = async ({ context, project, provider, sessionId }) => {
-	if (provider instanceof PlaywrightBrowserProvider) {
-		if (provider.tracingContexts.has(sessionId)) {
-			return;
-		}
-		provider.tracingContexts.add(sessionId);
-		const options = project.config.browser.trace;
-		await context.tracing.start({
-			screenshots: options.screenshots ?? true,
-			snapshots: options.snapshots ?? true,
-			sources: false
-		}).catch(() => {
-			provider.tracingContexts.delete(sessionId);
-		});
-		return;
-	}
-	throw new TypeError(`The ${provider.name} provider does not support tracing.`);
-};
-const startChunkTrace = async (command, { name, title }) => {
-	const { provider, sessionId, testPath, context } = command;
-	if (!testPath) {
-		throw new Error(`stopChunkTrace cannot be called outside of the test file.`);
-	}
-	if (provider instanceof PlaywrightBrowserProvider) {
-		if (!provider.tracingContexts.has(sessionId)) {
-			await startTracing(command);
-		}
-		const path = resolveTracesPath(command, name);
-		provider.pendingTraces.set(path, sessionId);
-		await context.tracing.startChunk({
-			name,
-			title
-		});
-		return;
-	}
-	throw new TypeError(`The ${provider.name} provider does not support tracing.`);
-};
-const stopChunkTrace = async (context, { name }) => {
-	if (context.provider instanceof PlaywrightBrowserProvider) {
-		const path = resolveTracesPath(context, name);
-		context.provider.pendingTraces.delete(path);
-		await context.context.tracing.stopChunk({ path });
-		return { tracePath: path };
-	}
-	throw new TypeError(`The ${context.provider.name} provider does not support tracing.`);
-};
-function resolveTracesPath({ testPath, project }, name) {
-	if (!testPath) {
-		throw new Error(`This command can only be called inside a test file.`);
-	}
-	const options = project.config.browser.trace;
-	const sanitizedName = `${project.name.replace(/[^a-z0-9]/gi, "-")}-${name}.trace.zip`;
-	if (options.tracesDir) {
-		return resolve(options.tracesDir, sanitizedName);
-	}
-	const dir = dirname(testPath);
-	const base = basename(testPath);
-	return resolve(dir, "__traces__", base, `${project.name.replace(/[^a-z0-9]/gi, "-")}-${name}.trace.zip`);
-}
-const deleteTracing = async (context, { traces }) => {
-	if (!context.testPath) {
-		throw new Error(`stopChunkTrace cannot be called outside of the test file.`);
-	}
-	if (context.provider instanceof PlaywrightBrowserProvider) {
-		return Promise.all(traces.map((trace) => unlink(trace).catch((err) => {
-			if (err.code === "ENOENT") {
-				// Ignore the error if the file doesn't exist
-				return;
-			}
-			// Re-throw other errors
-			throw err;
-		})));
-	}
-	throw new Error(`provider ${context.provider.name} is not supported`);
-};
-const annotateTraces = async ({ project }, { testId, traces }) => {
-	const vitest = project.vitest;
-	await Promise.all(traces.map((trace) => {
-		const entity = vitest.state.getReportedEntityById(testId);
-		return vitest._testRun.annotate(testId, {
-			message: relative(project.config.root, trace),
-			type: "traces",
-			attachment: {
-				path: trace,
-				contentType: "application/octet-stream"
-			},
-			location: entity?.location ? {
-				file: entity.module.moduleId,
-				line: entity.location.line,
-				column: entity.location.column
-			} : undefined
-		});
-	}));
-};
-
-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 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, options) => {
-	const testPath = context.testPath;
-	if (!testPath) {
-		throw new Error(`Cannot upload files outside of a test`);
-	}
-	const root = context.project.config.root;
-	if (context.provider instanceof PlaywrightBrowserProvider) {
-		const { iframe } = context;
-		const playwrightFiles = files.map((file) => {
-			if (typeof file === "string") {
-				return resolve(root, file);
-			}
-			return {
-				name: file.name,
-				mimeType: file.mimeType,
-				buffer: Buffer.from(file.base64, "base64")
-			};
-		});
-		await iframe.locator(selector).setInputFiles(playwrightFiles, options);
-	} 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(root, 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 viewport = async (context, options) => {
-	if (context.provider instanceof WebdriverBrowserProvider) {
-		await context.provider.setViewport(options);
-	} else {
-		throw new TypeError(`Provider ${context.provider.name} doesn't support "viewport" command`);
-	}
-};
-
 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,
-	__vitest_viewport: viewport,
-	__vitest_screenshotMatcher: screenshotMatcher,
-	__vitest_deleteTracing: deleteTracing,
-	__vitest_startChunkTrace: startChunkTrace,
-	__vitest_startTracing: startTracing,
-	__vitest_stopChunkTrace: stopChunkTrace,
-	__vitest_annotateTraces: annotateTraces
+	__vitest_screenshotMatcher: screenshotMatcher
 };
 
 class BrowserServerState {
@@ -3141,6 +2396,22 @@ class ProjectBrowser {
 	get vite() {
 		return this.parent.vite;
 	}
+	commands = {};
+	registerCommand(name, cb) {
+		if (!/^[a-z_$][\w$]*$/i.test(name)) {
+			throw new Error(`Invalid command name "${name}". Only alphanumeric characters, $ and _ are allowed.`);
+		}
+		this.commands[name] = cb;
+	}
+	triggerCommand = ((name, context, ...args) => {
+		if (name in this.commands) {
+			return this.commands[name](context, ...args);
+		}
+		if (name in this.parent.commands) {
+			return this.parent.commands[name](context, ...args);
+		}
+		throw new Error(`Provider ${this.provider.name} does not support command "${name}".`);
+	});
 	wrapSerializedConfig() {
 		const config = wrapConfig(this.project.serializedConfig);
 		config.env ??= {};
@@ -3152,6 +2423,16 @@ class ProjectBrowser {
 			return;
 		}
 		this.provider = await getBrowserProvider(project.config.browser, project);
+		if (this.provider.initScripts) {
+			this.parent.initScripts = this.provider.initScripts;
+			// make sure the script can be imported
+			this.provider.initScripts.forEach((script) => {
+				const allow = this.parent.vite.config.server.fs.allow;
+				if (!allow.includes(script)) {
+					allow.push(script);
+				}
+			});
+		}
 	}
 	parseErrorStacktrace(e, options = {}) {
 		return this.parent.parseErrorStacktrace(e, options);
@@ -3184,6 +2465,7 @@ class ParentBrowserProject {
 	locatorsUrl;
 	matchersUrl;
 	stateJs;
+	initScripts = [];
 	commands = {};
 	children = new Set();
 	vitest;
@@ -3255,15 +2537,6 @@ class ParentBrowserProject {
 		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?.name || "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);
 	}
@@ -3550,7 +2823,7 @@ function nanoid(size = 21) {
   return id;
 }
 
-const debug$1 = createDebugger("vitest:browser:api");
+const debug = createDebugger("vitest:browser:api");
 const BROWSER_API_PATH = "/__vitest_browser_api__";
 function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 	const vite = globalServer.vite;
@@ -3598,9 +2871,9 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 			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);
+			debug?.("[%s] Browser API connected to %s", rpcId, type);
 			ws.on("close", () => {
-				debug$1?.("[%s] Browser API disconnected from %s", rpcId, type);
+				debug?.("[%s] Browser API disconnected from %s", rpcId, type);
 				clients.delete(rpcId);
 				globalServer.removeCDPHandler(rpcId);
 				if (type === "orchestrator") {
@@ -3725,23 +2998,22 @@ function setupBrowserRpc(globalServer, defaultMockerRegistry) {
 				}
 			},
 			async triggerCommand(sessionId, command, testPath, payload) {
-				debug$1?.("[%s] Triggering command \"%s\"", sessionId, command);
+				debug?.("[%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
+					sessionId,
+					triggerCommand: (name, ...args) => {
+						return project.browser.triggerCommand(name, context, ...args);
+					}
 				}, provider.getCommandsContext(sessionId));
-				return await commands[command](context, ...payload);
+				return await project.browser.triggerCommand(command, context, ...payload);
 			},
 			resolveMock(rawId, importer, options) {
 				return mockResolver.resolveMock(rawId, importer, options);
@@ -3847,276 +3119,12 @@ function stringifyReplace(key, value) {
 	}
 }
 
-const debug = createDebugger("vitest:browser:pool");
-function createBrowserPool(vitest) {
-	const providers = new Set();
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	const threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-	const projectPools = new WeakMap();
-	const ensurePool = (project) => {
-		if (projectPools.has(project)) {
-			return projectPools.get(project);
-		}
-		debug?.("creating pool for project %s", project.name);
-		const resolvedUrls = project.browser.vite.resolvedUrls;
-		const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
-		if (!origin) {
-			throw new Error(`Can't find browser origin URL for project "${project.name}"`);
-		}
-		const pool = new BrowserPool(project, {
-			maxWorkers: getThreadsCount(project),
-			origin
-		});
-		projectPools.set(project, pool);
-		vitest.onCancel(() => {
-			pool.cancel();
-		});
-		return pool;
-	};
-	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;
-		});
-		const initialisedPools = await Promise.all([...groupedFiles.entries()].map(async ([project, files]) => {
-			await project._initBrowserProvider();
-			if (!project.browser) {
-				throw new TypeError(`The browser server was not initialized${project.name ? ` for the "${project.name}" project` : ""}. This is a bug in Vitest. Please, open a new issue with reproduction.`);
-			}
-			if (isCancelled) {
-				return;
-			}
-			debug?.("provider is ready for %s project", project.name);
-			const pool = ensurePool(project);
-			vitest.state.clearFiles(project, files);
-			providers.add(project.browser.provider);
-			return {
-				pool,
-				provider: project.browser.provider,
-				runTests: () => pool.runTests(method, files)
-			};
-		}));
-		if (isCancelled) {
-			return;
-		}
-		const parallelPools = [];
-		const nonParallelPools = [];
-		for (const pool of initialisedPools) {
-			if (!pool) {
-				// this means it was cancelled
-				return;
-			}
-			if (pool.provider.mocker && pool.provider.supportsParallelism) {
-				parallelPools.push(pool.runTests);
-			} else {
-				nonParallelPools.push(pool.runTests);
-			}
-		}
-		await Promise.all(parallelPools.map((runTests) => runTests()));
-		for (const runTests of nonParallelPools) {
-			if (isCancelled) {
-				return;
-			}
-			await runTests();
-		}
-	};
-	function getThreadsCount(project) {
-		const config = project.config.browser;
-		if (!config.headless || !config.fileParallelism || !project.browser.provider.supportsParallelism) {
-			return 1;
-		}
-		if (project.config.maxWorkers) {
-			return project.config.maxWorkers;
-		}
-		return threadsCount;
-	}
-	return {
-		name: "browser",
-		async close() {
-			await Promise.all([...providers].map((provider) => provider.close()));
-			vitest._browserSessions.sessionIds.clear();
-			providers.clear();
-			vitest.projects.forEach((project) => {
-				project.browser?.state.orchestrators.forEach((orchestrator) => {
-					orchestrator.$close();
-				});
-			});
-			debug?.("browser pool closed all providers");
-		},
-		runTests: (files) => runWorkspaceTests("run", files),
-		collectTests: (files) => runWorkspaceTests("collect", files)
-	};
-}
-function escapePathToRegexp(path) {
-	return path.replace(/[/\\.?*()^${}|[\]+]/g, "\\$&");
-}
-class BrowserPool {
-	_queue = [];
-	_promise;
-	_providedContext;
-	readySessions = new Set();
-	constructor(project, options) {
-		this.project = project;
-		this.options = options;
-	}
-	cancel() {
-		this._queue = [];
-	}
-	reject(error) {
-		this._promise?.reject(error);
-		this._promise = undefined;
-		this.cancel();
-	}
-	get orchestrators() {
-		return this.project.browser.state.orchestrators;
-	}
-	async runTests(method, files) {
-		this._promise ??= createDefer();
-		if (!files.length) {
-			debug?.("no tests found, finishing test run immediately");
-			this._promise.resolve();
-			return this._promise;
-		}
-		this._providedContext = stringify(this.project.getProvidedContext());
-		this._queue.push(...files);
-		this.readySessions.forEach((sessionId) => {
-			if (this._queue.length) {
-				this.readySessions.delete(sessionId);
-				this.runNextTest(method, sessionId);
-			}
-		});
-		if (this.orchestrators.size >= this.options.maxWorkers) {
-			debug?.("all orchestrators are ready, not creating more");
-			return this._promise;
-		}
-		// open the minimum amount of tabs
-		// if there is only 1 file running, we don't need 8 tabs running
-		const workerCount = Math.min(this.options.maxWorkers - this.orchestrators.size, files.length);
-		const promises = [];
-		for (let i = 0; i < workerCount; i++) {
-			const sessionId = crypto.randomUUID();
-			this.project.vitest._browserSessions.sessionIds.add(sessionId);
-			const project = this.project.name;
-			debug?.("[%s] creating session for %s", sessionId, project);
-			const page = this.openPage(sessionId).then(() => {
-				// start running tests on the page when it's ready
-				this.runNextTest(method, sessionId);
-			});
-			promises.push(page);
-		}
-		await Promise.all(promises);
-		debug?.("all sessions are created");
-		return this._promise;
-	}
-	async openPage(sessionId) {
-		const sessionPromise = this.project.vitest._browserSessions.createSession(sessionId, this.project, this);
-		const browser = this.project.browser;
-		const url = new URL("/__vitest_test__/", this.options.origin);
-		url.searchParams.set("sessionId", sessionId);
-		const pagePromise = browser.provider.openPage(sessionId, url.toString());
-		await Promise.all([sessionPromise, pagePromise]);
-	}
-	getOrchestrator(sessionId) {
-		const orchestrator = this.orchestrators.get(sessionId);
-		if (!orchestrator) {
-			throw new Error(`Orchestrator not found for session ${sessionId}. This is a bug in Vitest. Please, open a new issue with reproduction.`);
-		}
-		return orchestrator;
-	}
-	finishSession(sessionId) {
-		this.readySessions.add(sessionId);
-		// the last worker finished running tests
-		if (this.readySessions.size === this.orchestrators.size) {
-			this._promise?.resolve();
-			this._promise = undefined;
-			debug?.("[%s] all tests finished running", sessionId);
-		} else {
-			debug?.(`did not finish sessions for ${sessionId}: |ready - %s| |overall - %s|`, [...this.readySessions].join(", "), [...this.orchestrators.keys()].join(", "));
-		}
-	}
-	runNextTest(method, sessionId) {
-		const file = this._queue.shift();
-		if (!file) {
-			debug?.("[%s] no more tests to run", sessionId);
-			const isolate = this.project.config.browser.isolate;
-			// we don't need to cleanup testers if isolation is enabled,
-			// because cleanup is done at the end of every test
-			if (isolate) {
-				this.finishSession(sessionId);
-				return;
-			}
-			// we need to cleanup testers first because there is only
-			// one iframe and it does the cleanup only after everything is completed
-			const orchestrator = this.getOrchestrator(sessionId);
-			orchestrator.cleanupTesters().catch((error) => this.reject(error)).finally(() => this.finishSession(sessionId));
-			return;
-		}
-		if (!this._promise) {
-			throw new Error(`Unexpected empty queue`);
-		}
-		const startTime = performance.now();
-		const orchestrator = this.getOrchestrator(sessionId);
-		debug?.("[%s] run test %s", sessionId, file);
-		this.setBreakpoint(sessionId, file).then(() => {
-			// this starts running tests inside the orchestrator
-			orchestrator.createTesters({
-				method,
-				files: [file],
-				providedContext: this._providedContext || "[{}]",
-				startTime
-			}).then(() => {
-				debug?.("[%s] test %s finished running", sessionId, file);
-				this.runNextTest(method, sessionId);
-			}).catch((error) => {
-				// if user cancels the test run manually, ignore the error and exit gracefully
-				if (this.project.vitest.isCancelling && error instanceof Error && error.message.startsWith("Browser connection was closed while running tests")) {
-					this.cancel();
-					this._promise?.resolve();
-					this._promise = undefined;
-					debug?.("[%s] browser connection was closed", sessionId);
-					return;
-				}
-				debug?.("[%s] error during %s test run: %s", sessionId, file, error);
-				this.reject(error);
-			});
-		}).catch((err) => this.reject(err));
-	}
-	async setBreakpoint(sessionId, file) {
-		if (!this.project.config.inspector.waitForDebugger) {
-			return;
-		}
-		const provider = this.project.browser.provider;
-		const browser = this.project.config.browser.name;
-		if (shouldIgnoreDebugger(provider.name, browser)) {
-			debug?.("[$s] ignoring debugger in %s browser because it is not supported", sessionId, browser);
-			return;
-		}
-		if (!provider.getCDPSession) {
-			throw new Error("Unable to set breakpoint, CDP not supported");
-		}
-		debug?.("[%s] set breakpoint for %s", sessionId, file);
-		const session = await provider.getCDPSession(sessionId);
-		await session.send("Debugger.enable", {});
-		await session.send("Debugger.setBreakpointByUrl", {
-			lineNumber: 0,
-			urlRegex: escapePathToRegexp(file)
-		});
-	}
-}
-function shouldIgnoreDebugger(provider, browser) {
-	if (provider === "webdriverio") {
-		return browser !== "chrome" && browser !== "edge";
-	}
-	return browser !== "chromium";
+function defineBrowserCommand(fn) {
+	return fn;
 }
-
-async function createBrowserServer(project, configFile, prePlugins = [], postPlugins = []) {
+const createBrowserServer = async (options) => {
+	const project = options.project;
+	const configFile = project.vite.config.configFile;
 	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."));
 	}
@@ -4125,6 +3133,7 @@ async function createBrowserServer(project, configFile, prePlugins = [], postPlu
 	const logLevel = process.env.VITEST_BROWSER_DEBUG ?? "info";
 	const logger = createViteLogger(project.vitest.logger, logLevel, { allowClearScreen: false });
 	const mockerRegistry = new MockerRegistry();
+	let cacheDir;
 	const vite = await createViteServer({
 		...project.options,
 		base: "/",
@@ -4148,16 +3157,35 @@ async function createBrowserServer(project, configFile, prePlugins = [], postPlu
 		},
 		cacheDir: project.vite.config.cacheDir,
 		plugins: [
-			...prePlugins,
+			{
+				name: "vitest-internal:browser-cacheDir",
+				configResolved(config) {
+					cacheDir = config.cacheDir;
+				}
+			},
+			...options.mocksPlugins({ filter(id) {
+				if (id.includes(distRoot) || id.includes(cacheDir)) {
+					return false;
+				}
+				return true;
+			} }),
+			options.metaEnvReplacer(),
 			...project.options?.plugins || [],
 			BrowserPlugin(server),
 			interceptorPlugin({ registry: mockerRegistry }),
-			...postPlugins
+			options.coveragePlugin()
 		]
 	});
 	await vite.listen();
 	setupBrowserRpc(server, mockerRegistry);
 	return server;
+};
+function defineBrowserProvider(options) {
+	return {
+		...options,
+		options: options.options || {},
+		serverFactory: createBrowserServer
+	};
 }
 
-export { createBrowserPool, createBrowserServer, distRoot };
+export { createBrowserServer, defineBrowserCommand, defineBrowserProvider, parseKeyDef, resolveScreenshotPath };