vitest 4.0.0-beta.13 → 4.0.0-beta.15

package/browser/context.d.ts

@@ -0,0 +1,6 @@
+// @ts-ignore -- @vitest/browser-playwright might not be installed
+export * from '@vitest/browser-playwright/context'
+// @ts-ignore -- @vitest/browser-webdriverio might not be installed
+export * from '@vitest/browser-webdriverio/context'
+// @ts-ignore -- @vitest/browser-preview might not be installed
+export * from '@vitest/browser-preview/context'

package/browser/context.js

@@ -0,0 +1,20 @@
+// Vitest resolves "vitest/browser" as a virtual module instead
+
+// fake exports for static analysis
+export const page = null
+export const server = null
+export const userEvent = null
+export const cdp = null
+export const commands = null
+export const locators = null
+export const utils = null
+
+const pool = globalThis.__vitest_worker__?.ctx?.pool
+
+throw new Error(
+  // eslint-disable-next-line prefer-template
+  'vitest/browser can be imported only inside the Browser Mode. '
+  + (pool
+    ? `Your test is running in ${pool} pool. Make sure your regular tests are excluded from the "test.include" glob pattern.`
+    : 'Instead, it was imported outside of Vitest.'),
+)

package/dist/browser.d.ts

@@ -1,7 +1,7 @@
 import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.d.DGazh2r6.js';
 import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.BZtK59WP.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { V as VitestModuleRunner } from './chunks/moduleRunner.d.CeYc7nZ0.js';
+import { V as VitestModuleRunner } from './chunks/moduleRunner.d.CTZUg34g.js';
 export { collectTests, startTests } from '@vitest/runner';
 import * as _vitest_spy from '@vitest/spy';
 export { _vitest_spy as SpyModule };
@@ -15,8 +15,8 @@ import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import 'node:vm';
 import 'vite/module-runner';
-import './chunks/worker.d.buwuBpBt.js';
-import './chunks/environment.d.BsToaxti.js';
+import './chunks/worker.d.B8jq7m7O.js';
+import './chunks/environment.d.CrsxCzP1.js';
 import '@vitest/mocker';
 import './chunks/mocker.d.BE_2ls6u.js';
 

package/dist/browser.js

@@ -10,3 +10,10 @@ export { getSafeTimers, setSafeTimers } from '@vitest/utils/timers';
 import './chunks/coverage.D_JHT54q.js';
 import '@vitest/snapshot';
 import './chunks/utils.CG9h5ccR.js';
+
+/**
+* @internal
+*/
+const __INTERNAL = { _extendedMethods: /* @__PURE__ */ new Set() };
+
+export { __INTERNAL };

package/dist/chunks/{browser.d.D9YV3JvA.d.ts → browser.d.CM1rjKAX.d.ts}

@@ -1,4 +1,4 @@
-import { T as TestExecutionMethod } from './worker.d.buwuBpBt.js';
+import { T as TestExecutionMethod } from './worker.d.B8jq7m7O.js';
 
 type SerializedTestSpecification = [project: {
 	name: string | undefined;
@@ -12,7 +12,6 @@ interface BrowserTesterOptions {
 	method: TestExecutionMethod;
 	files: string[];
 	providedContext: string;
-	startTime: number;
 }
 
 export type { BrowserTesterOptions as B, SerializedTestSpecification as S };

package/dist/chunks/{cac.BBtYKH7y.js → cac.C4q82cVp.js}

@@ -3,7 +3,7 @@ import { EventEmitter } from 'events';
 import { normalize } from 'pathe';
 import c from 'tinyrainbow';
 import { a as defaultPort, d as defaultBrowserPort } from './constants.D_Q9UYh-.js';
-import { R as ReportersMap } from './index.CHrBLuEH.js';
+import { R as ReportersMap } from './index.DehVUBn4.js';
 
 function toArr(any) {
 	return any == null ? [] : Array.isArray(any) ? any : [any];
@@ -619,7 +619,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "4.0.0-beta.13";
+var version = "4.0.0-beta.15";
 
 const apiConfig = (port) => ({
 	port: {
@@ -1341,22 +1341,22 @@ function normalizeCliOptions(cliFilters, argv) {
 }
 async function start(mode, cliFilters, options) {
 	try {
-		const { startVitest } = await import('./cli-api.CeakdBUN.js').then(function (n) { return n.j; }), ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
+		const { startVitest } = await import('./cli-api.B1q8b4Kf.js').then(function (n) { return n.h; }), ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
 		if (!ctx.shouldKeepServer()) await ctx.exit();
 	} catch (e) {
-		const { errorBanner } = await import('./index.CHrBLuEH.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.DehVUBn4.js').then(function (n) { return n.u; });
 		if (console.error(`\n${errorBanner("Startup Error")}`), console.error(e), console.error("\n\n"), process.exitCode == null) process.exitCode = 1;
 		process.exit();
 	}
 }
 async function init(project) {
 	if (project !== "browser") console.error(/* @__PURE__ */ new Error("Only the \"browser\" project is supported. Use \"vitest init browser\" to create a new project.")), process.exit(1);
-	const { create } = await import('./creator.DfXDsUyL.js');
+	const { create } = await import('./creator.Daoa5_gR.js');
 	await create();
 }
 async function collect(mode, cliFilters, options) {
 	try {
-		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.CeakdBUN.js').then(function (n) { return n.j; }), ctx = await prepareVitest(mode, {
+		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.B1q8b4Kf.js').then(function (n) { return n.h; }), ctx = await prepareVitest(mode, {
 			...normalizeCliOptions(cliFilters, options),
 			watch: false,
 			run: true
@@ -1374,7 +1374,7 @@ async function collect(mode, cliFilters, options) {
 		}
 		await ctx.close();
 	} catch (e) {
-		const { errorBanner } = await import('./index.CHrBLuEH.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.DehVUBn4.js').then(function (n) { return n.u; });
 		if (console.error(`\n${errorBanner("Collect Error")}`), console.error(e), console.error("\n\n"), process.exitCode == null) process.exitCode = 1;
 		process.exit();
 	}

package/dist/chunks/{cli-api.CeakdBUN.js → cli-api.B1q8b4Kf.js}

@@ -10,9 +10,9 @@ import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultP
 import nodeos__default, { tmpdir } from 'node:os';
 import { generateHash as generateHash$1, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, hasFailed, getTasks, isTestCase } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { v as version$1 } from './cac.BBtYKH7y.js';
+import { v as version$1 } from './cac.C4q82cVp.js';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { p as parse, d as stringify, e as printError, f as formatProjectName, w as withLabel, h as errorBanner, i as divider, j as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.CHrBLuEH.js';
+import { p as parse, s as stringify, b as TraceMap, o as originalPositionFor, c as ancestor, d as createDefinesScript, e as convertTasksToEvents } from './typechecker.DsKAhua5.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -26,14 +26,13 @@ import require$$0$1 from 'buffer';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import crypto, { createHash } from 'node:crypto';
 import { distDir, rootDir } from '../path.js';
-import { h as hash, d as createFetchModuleFunction, n as normalizeResolvedIdToUrl, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, e as isBrowserEnabled, r as resolveConfig, f as groupBy, j as getCoverageProvider, k as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.DabP7UTQ.js';
-import { b as TraceMap, o as originalPositionFor, c as ancestor, d as createDefinesScript, e as convertTasksToEvents } from './typechecker.BfOQ86_a.js';
-import createDebug from 'debug';
+import { d as createDebugger, h as hash, e as createFetchModuleFunction, n as normalizeResolvedIdToUrl, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, f as isBrowserEnabled, r as resolveConfig, j as groupBy, k as getCoverageProvider, l as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.3htTSxXZ.js';
 import { VitestModuleEvaluator } from '#module-evaluator';
 import { ModuleRunner } from 'vite/module-runner';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
 import { highlight } from '@vitest/utils/highlight';
+import { p as printError, f as formatProjectName, w as withLabel, e as errorBanner, d as divider, h as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.DehVUBn4.js';
 import { createRequire, builtinModules, isBuiltin } from 'node:module';
 import url, { pathToFileURL } from 'node:url';
 import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
@@ -46,7 +45,7 @@ import { c as configDefaults } from './defaults.CXFFjsi8.js';
 import { KNOWN_ASSET_RE } from '@vitest/utils/constants';
 import { findNearestPackageData } from '@vitest/utils/resolver';
 import * as esModuleLexer from 'es-module-lexer';
-import { a as BenchmarkReportsMap } from './index.uLUz1RDt.js';
+import { a as BenchmarkReportsMap } from './index.01uBqPwR.js';
 import assert$1 from 'node:assert';
 import { serializeValue } from '@vitest/utils/serialize';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
@@ -5022,7 +5021,7 @@ var WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServerExport
 async function getModuleGraph(ctx, projectName, id, browser = false) {
 	const graph = {}, externalized = /* @__PURE__ */ new Set(), inlined = /* @__PURE__ */ new Set(), project = ctx.getProjectByName(projectName);
 	async function get(mod, seen = /* @__PURE__ */ new Map()) {
-		if (!mod || !mod.id || mod.id === "\0@vitest/browser/context") return;
+		if (!mod || !mod.id || mod.id === "\0vitest/browser") return;
 		if (seen.has(mod)) return seen.get(mod);
 		let id = clearId(mod.id);
 		seen.set(mod, id);
@@ -5230,11 +5229,6 @@ var setup$1 = /*#__PURE__*/Object.freeze({
   setup: setup
 });
 
-function createDebugger(namespace) {
-	const debug = createDebug(namespace);
-	if (debug.enabled) return debug;
-}
-
 const debug = createDebugger("vitest:ast-collect-info"), verbose = createDebugger("vitest:ast-collect-verbose");
 function astParseFile(filepath, code) {
 	const ast = parseAst(code);
@@ -5782,7 +5776,7 @@ class Logger {
 		if (!project.browser) return;
 		const resolvedUrls = project.browser.vite.resolvedUrls, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
 		if (!origin) return;
-		const output = project.isRootProject() ? "" : formatProjectName(project), provider = project.browser.provider.name, providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
+		const output = project.isRootProject() ? "" : formatProjectName(project), provider = project.browser.provider?.name, providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
 		this.log(c.dim(`${output}Browser runner started${providerString} ${c.dim("at")} ${c.blue(new URL("/__vitest_test__/", origin))}\n`));
 	}
 	printUnhandledErrors(errors) {
@@ -7359,28 +7353,22 @@ class TestProject {
 	/** @internal */
 	_parent;
 	/** @internal */
-	_initParentBrowser = deduped(async () => {
+	_initParentBrowser = deduped(async (childProject) => {
 		if (!this.isBrowserEnabled() || this._parentBrowser) return;
-		await this.vitest.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.vitest.version);
-		const { createBrowserServer, distRoot } = await import('@vitest/browser');
-		let cacheDir;
-		const browser = await createBrowserServer(this, this.vite.config.configFile, [
-			{
-				name: "vitest:browser-cacheDir",
-				configResolved(config) {
-					cacheDir = config.cacheDir;
-				}
-			},
-			...MocksPlugins({ filter(id) {
-				return !(id.includes(distRoot) || id.includes(cacheDir));
-			} }),
-			MetaEnvReplacerPlugin()
-		], [CoverageTransform(this.vitest)]);
+		const provider = this.config.browser.provider || childProject.config.browser.provider;
+		if (provider == null) throw new Error(`Proider was not specified in the "browser.provider" setting. Please, pass down playwright(), webdriverio() or preview() from "@vitest/browser-playwright", "@vitest/browser-webdriverio" or "@vitest/browser-preview" package respectively.`);
+		if (typeof provider.serverFactory !== "function") throw new TypeError(`The browser provider options do not return a "serverFactory" function. Are you using the latest "@vitest/browser-${provider.name}" package?`);
+		const browser = await provider.serverFactory({
+			project: this,
+			mocksPlugins: (options) => MocksPlugins(options),
+			metaEnvReplacer: () => MetaEnvReplacerPlugin(),
+			coveragePlugin: () => CoverageTransform(this.vitest)
+		});
 		if (this._parentBrowser = browser, this.config.browser.ui) setup(this.vitest, browser.vite);
 	});
 	/** @internal */
 	_initBrowserServer = deduped(async () => {
-		if (await this._parent?._initParentBrowser(), !this.browser && this._parent?._parentBrowser) this.browser = this._parent._parentBrowser.spawn(this), await this.vitest.report("onBrowserInit", this);
+		if (await this._parent?._initParentBrowser(this), !this.browser && this._parent?._parentBrowser) this.browser = this._parent._parentBrowser.spawn(this), await this.vitest.report("onBrowserInit", this);
 	});
 	/**
 	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
@@ -7584,19 +7572,13 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 }
 async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	const removeProjects = /* @__PURE__ */ new Set();
-	resolvedProjects.forEach((project) => {
+	return resolvedProjects.forEach((project) => {
 		if (!project.config.browser.enabled) return;
-		const instances = project.config.browser.instances || [], browser = project.config.browser.name;
-		if (instances.length === 0 && browser) instances.push({
-			browser,
-			name: project.name ? `${project.name} (${browser})` : browser
-		}), vitest.logger.warn(withLabel("yellow", "Vitest", [
-			`No browser "instances" were defined`,
-			project.name ? ` for the "${project.name}" project. ` : ". ",
-			`Running tests in "${project.config.browser.name}" browser. `,
-			"The \"browser.name\" field is deprecated since Vitest 3. ",
-			"Read more: https://vitest.dev/guide/browser/config#browser-instances"
-		].filter(Boolean).join("")));
+		const instances = project.config.browser.instances || [];
+		if (instances.length === 0) {
+			removeProjects.add(project);
+			return;
+		}
 		const originalName = project.config.name, filteredInstances = vitest.matchesProjectFilter(originalName) ? instances : instances.filter((instance) => {
 			const newName = instance.name;
 			return vitest.matchesProjectFilter(newName);
@@ -7614,6 +7596,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			}
 			const name = config.name;
 			if (name == null) throw new Error(`The browser configuration must have a "name" property. This is a bug in Vitest. Please, open a new issue with reproduction`);
+			if (config.provider?.name != null && project.config.browser.provider?.name != null && config.provider?.name !== project.config.browser.provider?.name) throw new Error(`The instance cannot have a different provider from its parent. The "${name}" instance specifies "${config.provider?.name}" provider, but its parent has a "${project.config.browser.provider?.name}" provider.`);
 			if (names.has(name)) throw new Error([
 				`Cannot define a nested project for a ${browser} browser. The project name "${name}" was already defined. `,
 				"If you have multiple instances for the same browser, make sure to define a custom \"name\". ",
@@ -7625,26 +7608,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			const clone = TestProject._cloneBrowserProject(project, clonedConfig);
 			resolvedProjects.push(clone);
 		}), removeProjects.add(project);
-	}), resolvedProjects = resolvedProjects.filter((project) => !removeProjects.has(project));
-	const headedBrowserProjects = resolvedProjects.filter((project) => {
-		return project.config.browser.enabled && !project.config.browser.headless;
-	});
-	if (headedBrowserProjects.length > 1) {
-		const message = [`Found multiple projects that run browser tests in headed mode: "${headedBrowserProjects.map((p) => p.name).join("\", \"")}".`, ` Vitest cannot run multiple headed browsers at the same time.`].join("");
-		if (!isTTY) throw new Error(`${message} Please, filter projects with --browser=name or --project=name flag or run tests with "headless: true" option.`);
-		const { projectName } = await (await import('./index.Dc3xnDvT.js').then(function (n) { return n.i; })).default({
-			type: "select",
-			name: "projectName",
-			choices: headedBrowserProjects.map((project) => ({
-				title: project.name,
-				value: project.name
-			})),
-			message: `${message} Select a single project to run or cancel and run tests with "headless: true" option. Note that you can also start tests with --browser=name or --project=name flag.`
-		});
-		if (!projectName) throw new Error("The test run was aborted.");
-		return resolvedProjects.filter((project) => project.name === projectName);
-	}
-	return resolvedProjects;
+	}), resolvedProjects.filter((project) => !removeProjects.has(project));
 }
 function cloneConfig(project, { browser,...config }) {
 	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name, provider,...overrideConfig } = config, currentConfig = project.config.browser, clonedConfig = deepClone(project.config);
@@ -9170,7 +9134,12 @@ class Vitest {
 		}
 		if (!this.projects.length) {
 			const filter = toArray(resolved.project).join("\", \"");
-			throw filter ? new Error(`No projects matched the filter "${filter}".`) : new Error(`Vitest wasn't able to resolve any project.`);
+			if (filter) throw new Error(`No projects matched the filter "${filter}".`);
+			{
+				let error = `Vitest wasn't able to resolve any project.`;
+				if (this.config.browser.enabled && !this.config.browser.instances?.length) error += ` Please, check that you specified the "browser.instances" option.`;
+				throw new Error(error);
+			}
 		}
 		if (!this.coreWorkspaceProject) this.coreWorkspaceProject = TestProject._createBasicProject(this);
 		if (this.config.testNamePattern) this.configOverride.testNamePattern = this.config.testNamePattern;
@@ -10277,4 +10246,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { FilesNotFoundError as F, GitNotFoundError as G, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, experimental_getRunnerTask as d, escapeTestName as e, registerConsoleShortcuts as f, createViteLogger as g, createDebugger as h, isValidApiRequest as i, cliApi as j, resolveFsAllow as r, startVitest as s };
+export { FilesNotFoundError as F, GitNotFoundError as G, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, experimental_getRunnerTask as d, escapeTestName as e, registerConsoleShortcuts as f, createViteLogger as g, cliApi as h, isValidApiRequest as i, resolveFsAllow as r, startVitest as s };

package/dist/chunks/{coverage.DabP7UTQ.js → coverage.3htTSxXZ.js}

@@ -1,6 +1,6 @@
 import fs, { statSync, realpathSync, promises as promises$1, mkdirSync, existsSync, readdirSync, writeFileSync } from 'node:fs';
 import path, { win32, dirname, join, resolve } from 'node:path';
-import { isExternalUrl, unwrapId, nanoid, withTrailingSlash as withTrailingSlash$1, cleanUrl, wrapId, createDefer, slash, shuffle, toArray } from '@vitest/utils/helpers';
+import { createDefer, isExternalUrl, unwrapId, nanoid, withTrailingSlash as withTrailingSlash$1, cleanUrl, wrapId, slash, shuffle, toArray } from '@vitest/utils/helpers';
 import { isAbsolute, join as join$1, dirname as dirname$1, resolve as resolve$1, relative, normalize } from 'pathe';
 import pm from 'picomatch';
 import { glob } from 'tinyglobby';
@@ -21,10 +21,11 @@ import * as nodeos from 'node:os';
 import nodeos__default, { tmpdir } from 'node:os';
 import { isatty } from 'node:tty';
 import { rootDir } from '../path.js';
+import { s as stringify, w as wrapSerializableConfig, a as Typechecker } from './typechecker.DsKAhua5.js';
+import createDebug from 'debug';
 import EventEmitter from 'node:events';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.BfOQ86_a.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { isCI, provider } from 'std-env';
@@ -53,6 +54,11 @@ function wildcardPatternToRegExp(pattern) {
 	return new RegExp(`^${regexp}`, "i");
 }
 
+function createDebugger(namespace) {
+	const debug = createDebug(namespace);
+	if (debug.enabled) return debug;
+}
+
 const hash = crypto.hash ?? ((algorithm, data, outputEncoding) => crypto.createHash(algorithm).update(data).digest(outputEncoding));
 
 const JOIN_LEADING_SLASH_RE = /^\.?\//;
@@ -2386,6 +2392,182 @@ function getWorkersCountByPercentage(percent) {
 	return Math.max(1, Math.min(maxWorkersCount, workersCountByPercentage));
 }
 
+const debug = createDebugger("vitest:browser:pool");
+function createBrowserPool(vitest) {
+	const providers = /* @__PURE__ */ new Set(), numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), projectPools = /* @__PURE__ */ new WeakMap(), ensurePool = (project) => {
+		if (projectPools.has(project)) return projectPools.get(project);
+		debug?.("creating pool for project %s", project.name);
+		const resolvedUrls = project.browser.vite.resolvedUrls, 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
+		});
+		return projectPools.set(project, pool), vitest.onCancel(() => {
+			pool.cancel();
+		}), pool;
+	}, 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;
+		});
+		const initialisedPools = await Promise.all([...groupedFiles.entries()].map(async ([project, files]) => {
+			if (await project._initBrowserProvider(), !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);
+			return vitest.state.clearFiles(project, files), providers.add(project.browser.provider), {
+				pool,
+				provider: project.browser.provider,
+				runTests: () => pool.runTests(method, files)
+			};
+		}));
+		if (isCancelled) return;
+		const parallelPools = [], 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;
+		return !config.headless || !config.fileParallelism || !project.browser.provider.supportsParallelism ? 1 : project.config.maxWorkers ? project.config.maxWorkers : 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 = /* @__PURE__ */ new Set();
+	constructor(project, options) {
+		this.project = project, this.options = options;
+	}
+	cancel() {
+		this._queue = [];
+	}
+	reject(error) {
+		this._promise?.reject(error), this._promise = void 0, this.cancel();
+	}
+	get orchestrators() {
+		return this.project.browser.state.orchestrators;
+	}
+	async runTests(method, files) {
+		if (this._promise ??= createDefer(), !files.length) return debug?.("no tests found, finishing test run immediately"), this._promise.resolve(), this._promise;
+		if (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);
+		}), this.orchestrators.size >= this.options.maxWorkers) return debug?.("all orchestrators are ready, not creating more"), 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), 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);
+		}
+		return await Promise.all(promises), debug?.("all sessions are created"), this._promise;
+	}
+	async openPage(sessionId) {
+		const sessionPromise = this.project.vitest._browserSessions.createSession(sessionId, this.project, this), browser = this.project.browser, 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) {
+		// the last worker finished running tests
+		if (this.readySessions.add(sessionId), this.readySessions.size === this.orchestrators.size) this._promise?.resolve(), this._promise = void 0, 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) {
+			// we don't need to cleanup testers if isolation is enabled,
+			// because cleanup is done at the end of every test
+			if (debug?.("[%s] no more tests to run", sessionId), this.project.config.browser.isolate) {
+				this.finishSession(sessionId);
+				return;
+			}
+			this.getOrchestrator(sessionId).cleanupTesters().catch((error) => this.reject(error)).finally(() => this.finishSession(sessionId));
+			return;
+		}
+		if (!this._promise) throw new Error(`Unexpected empty queue`);
+		const orchestrator = this.getOrchestrator(sessionId);
+		debug?.("[%s] run test %s", sessionId, file), this.setBreakpoint(sessionId, file).then(() => {
+			// this starts running tests inside the orchestrator
+			orchestrator.createTesters({
+				method,
+				files: [file],
+				providedContext: this._providedContext || "[{}]"
+			}).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 = void 0, 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, 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) {
+	return provider === "webdriverio" ? browser !== "chrome" && browser !== "edge" : browser !== "chromium";
+}
+
 const envsOrder = [
 	"node",
 	"jsdom",
@@ -3271,18 +3453,13 @@ function createPool(ctx) {
 		function getCustomPool(pool) {
 			return getConcurrentPool(pool, () => resolveCustomPool(pool));
 		}
-		function getBrowserPool() {
-			return getConcurrentPool("browser", async () => {
-				const { createBrowserPool } = await import('@vitest/browser');
-				return createBrowserPool(ctx);
-			});
-		}
 		const groupedSpecifications = {}, groups = /* @__PURE__ */ new Set(), factories = {
 			vmThreads: (specs) => createVmThreadsPool(ctx, options, specs),
 			vmForks: (specs) => createVmForksPool(ctx, options, specs),
 			threads: (specs) => createThreadsPool(ctx, options, specs),
 			forks: (specs) => createForksPool(ctx, options, specs),
-			typescript: () => createTypecheckPool(ctx)
+			typescript: () => createTypecheckPool(ctx),
+			browser: () => createBrowserPool(ctx)
 		};
 		for (const spec of files) {
 			const group = spec.project.config.sequence.groupOrder ?? 0;
@@ -3318,7 +3495,6 @@ function createPool(ctx) {
 					const factory = factories[pool];
 					return pools[pool] ??= factory(specs), pools[pool][method](specs, invalidate);
 				}
-				if (pool === "browser") return pools.browser ??= await getBrowserPool(), pools.browser[method](specs, invalidate);
 				const poolHandler = await getCustomPool(pool);
 				return pools[poolHandler.name] ??= poolHandler, poolHandler[method](specs, invalidate);
 			}));
@@ -3463,12 +3639,17 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.browser ??= {};
 	const browser = resolved.browser;
 	if (browser.enabled) {
-		if (!browser.name && !browser.instances) throw new Error(`Vitest Browser Mode requires "browser.name" (deprecated) or "browser.instances" options, none were set.`);
 		const instances = browser.instances;
-		if (browser.name && browser.instances)
- // --browser=chromium filters configs to a single one
-		browser.instances = browser.instances.filter((instance) => instance.browser === browser.name);
-		if (browser.instances && !browser.instances.length) throw new Error([`"browser.instances" was set in the config, but the array is empty. Define at least one browser config.`, browser.name && instances?.length ? ` The "browser.name" was set to "${browser.name}" which filtered all configs (${instances.map((c) => c.browser).join(", ")}). Did you mean to use another name?` : ""].join(""));
+		if (!browser.instances) browser.instances = [];
+		// use `chromium` by default when the preview provider is specified
+		// for a smoother experience. if chromium is not available, it will
+		// open the default browser anyway
+		if (!browser.instances.length && browser.provider?.name === "preview") browser.instances = [{ browser: "chromium" }];
+		if (browser.name && instances?.length) {
+			// if `instances` were defined, but now they are empty,
+			// let's throw an error because the filter is invalid
+			if (browser.instances = browser.instances.filter((instance) => instance.browser === browser.name), !browser.instances.length) throw new Error([`"browser.instances" was set in the config, but the array is empty. Define at least one browser config.`, ` The "browser.name" was set to "${browser.name}" which filtered all configs (${instances.map((c) => c.browser).join(", ")}). Did you mean to use another name?`].join(""));
+		}
 	}
 	const containsChromium = hasBrowserChromium(vitest, resolved), hasOnlyChromium = hasOnlyBrowserChromium(vitest, resolved);
 	// Browser-mode "Chromium" only features:
@@ -3644,13 +3825,13 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		...configDefaults.typecheck,
 		...resolved.typecheck
 	}, resolved.typecheck ??= {}, resolved.typecheck.enabled ??= false, resolved.typecheck.enabled) logger.console.warn(c.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."));
-	if (resolved.browser.enabled ??= false, resolved.browser.headless ??= isCI, resolved.browser.isolate ??= true, resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark", resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI, resolved.browser.screenshotDirectory) resolved.browser.screenshotDirectory = resolve$1(resolved.root, resolved.browser.screenshotDirectory);
-	if (resolved.browser.viewport ??= {}, resolved.browser.viewport.width ??= 414, resolved.browser.viewport.height ??= 896, resolved.browser.locators ??= {}, resolved.browser.locators.testIdAttribute ??= "data-testid", resolved.browser.enabled && provider === "stackblitz") resolved.browser.provider = void 0;
-	if (typeof resolved.browser.provider === "string") {
-		const source = `@vitest/browser/providers/${resolved.browser.provider}`;
+	if (resolved.browser.enabled ??= false, resolved.browser.headless ??= isCI, resolved.browser.isolate ??= true, resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark", resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI, resolved.browser.commands ??= {}, resolved.browser.screenshotDirectory) resolved.browser.screenshotDirectory = resolve$1(resolved.root, resolved.browser.screenshotDirectory);
+	if (resolved.browser.viewport ??= {}, resolved.browser.viewport.width ??= 414, resolved.browser.viewport.height ??= 896, resolved.browser.locators ??= {}, resolved.browser.locators.testIdAttribute ??= "data-testid", typeof resolved.browser.provider === "string") {
+		const source = `@vitest/browser-${resolved.browser.provider}`;
 		throw new TypeError(`The \`browser.provider\` configuration was changed to accept a factory instead of a string. Add an import of "${resolved.browser.provider}" from "${source}" instead. See: https://vitest.dev/guide/browser/config#provider`);
 	}
 	const isPreview = resolved.browser.provider?.name === "preview";
+	if (!isPreview && resolved.browser.enabled && provider === "stackblitz") throw new Error(`stackblitz environment does not support the ${resolved.browser.provider?.name} provider. Please, use "@vitest/browser-preview" instead.`);
 	if (isPreview && resolved.browser.screenshotFailures === true) console.warn(c.yellow([
 		`Browser provider "preview" doesn't support screenshots, `,
 		`so "browser.screenshotFailures" option is forcefully disabled. `,
@@ -4097,4 +4278,4 @@ function resolveMergeConfig(mod) {
 	}
 }
 
-export { BaseCoverageProvider as B, RandomSequencer as R, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, createFetchModuleFunction as d, isBrowserEnabled as e, groupBy as f, getFilePoolName as g, hash as h, isPackageExists as i, getCoverageProvider as j, createPool as k, normalizeResolvedIdToUrl as n, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };
+export { BaseCoverageProvider as B, RandomSequencer as R, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, createDebugger as d, createFetchModuleFunction as e, isBrowserEnabled as f, getFilePoolName as g, hash as h, isPackageExists as i, groupBy as j, getCoverageProvider as k, createPool as l, normalizeResolvedIdToUrl as n, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };