vitest 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/chunks/{cli-api.CZz3evYC.js → cli-api.C-JHgQgp.js}

@@ -2,16 +2,17 @@ import fs, { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from
 import { relative, resolve, dirname, extname, normalize, join, basename, isAbsolute } from 'pathe';
 import { C as CoverageProviderMap } from './coverage.D_JHT54q.js';
 import path, { resolve as resolve$1 } from 'node:path';
-import { noop, isPrimitive, createDefer, slash, highlight, toArray, cleanUrl, deepMerge, KNOWN_ASSET_RE, nanoid, deepClone, notNullish } from '@vitest/utils';
+import { noop, createDefer, slash, highlight, toArray, cleanUrl, deepMerge, KNOWN_ASSET_RE, nanoid, deepClone, isPrimitive, notNullish } from '@vitest/utils';
 import { f as findUp, p as prompt } from './index.X0nbfr6-.js';
 import * as vite from 'vite';
-import { searchForWorkspaceRoot, version, mergeConfig, createServer } from 'vite';
+import { parseAst, searchForWorkspaceRoot, version, mergeConfig, createServer } from 'vite';
 import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.D_Q9UYh-.js';
-import { generateFileHash, limitConcurrency, createFileTask, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
+import nodeos__default, { tmpdir } from 'node:os';
+import { generateHash as generateHash$1, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { v as version$1 } from './cac.WE-urWw5.js';
+import { v as version$1 } from './cac.By1HvRIk.js';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.VNI-1z5c.js';
+import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.AzwzFtyi.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -23,11 +24,12 @@ import require$$7 from 'url';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
-import { parseErrorStacktrace } from '@vitest/utils/source-map';
 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.BPRS6xgn.js';
-import { c as convertTasksToEvents } from './typechecker.Cd1wvxUM.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.DarITf6U.js';
+import { b as ancestor, c as convertTasksToEvents } from './typechecker.DSo_maXz.js';
+import { TraceMap, originalPositionFor, parseErrorStacktrace } from '@vitest/utils/source-map';
+import createDebug from 'debug';
 import { VitestModuleEvaluator } from '#module-evaluator';
 import { ModuleRunner } from 'vite/module-runner';
 import { Console } from 'node:console';
@@ -36,7 +38,6 @@ import { createRequire, builtinModules, isBuiltin } from 'node:module';
 import url, { pathToFileURL } from 'node:url';
 import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
 import { rm, mkdir, copyFile } from 'node:fs/promises';
-import nodeos__default, { tmpdir } from 'node:os';
 import pm from 'picomatch';
 import { glob, isDynamicPattern } from 'tinyglobby';
 import MagicString from 'magic-string';
@@ -44,9 +45,9 @@ import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
 import { c as configDefaults } from './defaults.CXFFjsi8.js';
 import { f as findNearestPackageData } from './resolver.Bx6lE0iq.js';
 import * as esModuleLexer from 'es-module-lexer';
-import { a as BenchmarkReportsMap } from './index.7w0eqmYM.js';
+import { a as BenchmarkReportsMap } from './index.BuwjkI-q.js';
 import assert$1 from 'node:assert';
-import { serializeError } from '@vitest/utils/error';
+import { serializeError as serializeError$1 } from '@vitest/utils/error';
 import readline from 'node:readline';
 import { stripVTControlCharacters } from 'node:util';
 
@@ -5080,7 +5081,7 @@ catch {}
 }
 
 function setup(ctx, _server) {
-	const wss = new WebSocketServer({ noServer: true }), clients = /* @__PURE__ */ new Map(), server = _server || ctx.server;
+	const wss = new WebSocketServer({ noServer: true }), clients = /* @__PURE__ */ new Map(), server = _server || ctx.vite;
 	server.httpServer?.on("upgrade", (request, socket, head) => {
 		if (!request.url) return;
 		const { pathname } = new URL(request.url, "http://localhost");
@@ -5199,17 +5200,9 @@ class WebSocketReporter {
 		});
 	}
 	async onTaskUpdate(packs, events) {
-		this.clients.size !== 0 && (packs.forEach(([taskId, result]) => {
-			const task = this.ctx.state.idMap.get(taskId), isBrowser = task && task.file.pool === "browser";
-			result?.errors?.forEach((error) => {
-				if (!isPrimitive(error)) if (isBrowser) {
-					const project = this.ctx.getProjectByName(task.file.projectName || "");
-					error.stacks = project.browser?.parseErrorStacktrace(error);
-				} else error.stacks = parseErrorStacktrace(error);
-			});
-		}), this.clients.forEach((client) => {
+		this.clients.size !== 0 && this.clients.forEach((client) => {
 			client.onTaskUpdate?.(packs, events)?.catch?.(noop);
-		}));
+		});
 	}
 	onTestRunEnd(testModules, unhandledErrors) {
 		if (!this.clients.size) return;
@@ -5236,6 +5229,265 @@ 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);
+	if (verbose) verbose("Collecting", filepath, code);
+	else debug?.("Collecting", filepath);
+	const definitions = [], getName = (callee) => {
+		if (!callee) return null;
+		if (callee.type === "Identifier") return callee.name;
+		if (callee.type === "CallExpression") return getName(callee.callee);
+		if (callee.type === "TaggedTemplateExpression") return getName(callee.tag);
+		if (callee.type === "MemberExpression")
+ // call as `__vite_ssr__.test.skip()`
+		return callee.object?.type === "Identifier" && [
+			"it",
+			"test",
+			"describe",
+			"suite"
+		].includes(callee.object.name) ? callee.object?.name : callee.object?.name?.startsWith("__vite_ssr_") || callee.object?.object?.name?.startsWith("__vite_ssr_") && callee.object?.property?.name === "Vitest" ? getName(callee.property) : getName(callee.object?.property);
+		// unwrap (0, ...)
+		if (callee.type === "SequenceExpression" && callee.expressions.length === 2) {
+			const [e0, e1] = callee.expressions;
+			if (e0.type === "Literal" && e0.value === 0) return getName(e1);
+		}
+		return null;
+	};
+	return ancestor(ast, { CallExpression(node) {
+		const { callee } = node, name = getName(callee);
+		if (!name) return;
+		if (![
+			"it",
+			"test",
+			"describe",
+			"suite"
+		].includes(name)) {
+			verbose?.(`Skipping ${name} (unknown call)`);
+			return;
+		}
+		const property = callee?.property?.name;
+		let mode = !property || property === name ? "run" : property;
+		// they will be picked up in the next iteration
+		if ([
+			"each",
+			"for",
+			"skipIf",
+			"runIf"
+		].includes(mode)) return;
+		let start;
+		const end = node.end;
+		// .each or (0, __vite_ssr_exports_0__.test)()
+		if (callee.type === "CallExpression" || callee.type === "SequenceExpression" || callee.type === "TaggedTemplateExpression") start = callee.end;
+		else start = node.start;
+		const messageNode = node.arguments?.[0];
+		if (messageNode == null) {
+			verbose?.(`Skipping node at ${node.start} because it doesn't have a name`);
+			return;
+		}
+		let message;
+		if (messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral") message = code.slice(messageNode.start + 1, messageNode.end - 1);
+		else message = code.slice(messageNode.start, messageNode.end);
+		if (message.startsWith("0,")) message = message.slice(2);
+		// cannot statically analyze, so we always skip it
+		if (message = message.replace(/__vite_ssr_import_\d+__\./g, "").replace(/__vi_import_\d+__\./g, ""), mode === "skipIf" || mode === "runIf") mode = "skip";
+		const parentCalleeName = typeof callee?.callee === "object" && callee?.callee.type === "MemberExpression" && callee?.callee.property?.name;
+		let isDynamicEach = parentCalleeName === "each" || parentCalleeName === "for";
+		if (!isDynamicEach && callee.type === "TaggedTemplateExpression") {
+			const property = callee.tag?.property?.name;
+			isDynamicEach = property === "each" || property === "for";
+		}
+		debug?.("Found", name, message, `(${mode})`), definitions.push({
+			start,
+			end,
+			name: message,
+			type: name === "it" || name === "test" ? "test" : "suite",
+			mode,
+			task: null,
+			dynamic: isDynamicEach
+		});
+	} }), {
+		ast,
+		definitions
+	};
+}
+function createFailedFileTask(project, filepath, error) {
+	const testFilepath = relative(project.config.root, filepath), file = {
+		filepath,
+		type: "suite",
+		id: /* @__PURE__ */ generateHash$1(`${testFilepath}${project.config.name || ""}`),
+		name: testFilepath,
+		mode: "run",
+		tasks: [],
+		start: 0,
+		end: 0,
+		projectName: project.name,
+		meta: {},
+		pool: project.browser ? "browser" : project.config.pool,
+		file: null,
+		result: {
+			state: "fail",
+			errors: serializeError(project, error)
+		}
+	};
+	return file.file = file, file;
+}
+function serializeError(ctx, error) {
+	if ("errors" in error && "pluginCode" in error) {
+		const errors = error.errors.map((e) => {
+			return {
+				name: error.name,
+				message: e.text,
+				stack: e.location ? `${error.name}: ${e.text}\n  at ${relative(ctx.config.root, e.location.file)}:${e.location.line}:${e.location.column}` : ""
+			};
+		});
+		return errors;
+	}
+	return [{
+		name: error.name,
+		stack: error.stack,
+		message: error.message
+	}];
+}
+function createFileTask(testFilepath, code, requestMap, options) {
+	const { definitions, ast } = astParseFile(testFilepath, code), file = {
+		filepath: options.filepath,
+		type: "suite",
+		id: /* @__PURE__ */ generateHash$1(`${testFilepath}${options.name || ""}`),
+		name: testFilepath,
+		mode: "run",
+		tasks: [],
+		start: ast.start,
+		end: ast.end,
+		projectName: options.name,
+		meta: {},
+		pool: "browser",
+		file: null
+	};
+	file.file = file;
+	const indexMap = createIndexMap(code), map = requestMap && new TraceMap(requestMap);
+	let lastSuite = file;
+	const updateLatestSuite = (index) => {
+		while (lastSuite.suite && lastSuite.end < index) lastSuite = lastSuite.suite;
+		return lastSuite;
+	};
+	definitions.sort((a, b) => a.start - b.start).forEach((definition) => {
+		const latestSuite = updateLatestSuite(definition.start);
+		let mode = definition.mode;
+		if (latestSuite.mode !== "run")
+ // inherit suite mode, if it's set
+		mode = latestSuite.mode;
+		const processedLocation = indexMap.get(definition.start);
+		let location;
+		if (map && processedLocation) {
+			const originalLocation = originalPositionFor(map, {
+				line: processedLocation.line,
+				column: processedLocation.column
+			});
+			if (originalLocation.column != null) verbose?.(`Found location for`, definition.type, definition.name, `${processedLocation.line}:${processedLocation.column}`, "->", `${originalLocation.line}:${originalLocation.column}`), location = originalLocation;
+			else debug?.("Cannot find original location for", definition.type, definition.name, `${processedLocation.column}:${processedLocation.line}`);
+		} else debug?.("Cannot find original location for", definition.type, definition.name, `${definition.start}`);
+		if (definition.type === "suite") {
+			const task = {
+				type: definition.type,
+				id: "",
+				suite: latestSuite,
+				file,
+				tasks: [],
+				mode,
+				name: definition.name,
+				end: definition.end,
+				start: definition.start,
+				location,
+				dynamic: definition.dynamic,
+				meta: {}
+			};
+			definition.task = task, latestSuite.tasks.push(task), lastSuite = task;
+			return;
+		}
+		const task = {
+			type: definition.type,
+			id: "",
+			suite: latestSuite,
+			file,
+			mode,
+			context: {},
+			name: definition.name,
+			end: definition.end,
+			start: definition.start,
+			location,
+			dynamic: definition.dynamic,
+			meta: {},
+			timeout: 0,
+			annotations: []
+		};
+		definition.task = task, latestSuite.tasks.push(task);
+	}), calculateSuiteHash(file);
+	const hasOnly = someTasksAreOnly(file);
+	if (interpretTaskModes(file, options.testNamePattern, void 0, hasOnly, false, options.allowOnly), markDynamicTests(file.tasks), !file.tasks.length) file.result = {
+		state: "fail",
+		errors: [{
+			name: "Error",
+			message: `No test suite found in file ${options.filepath}`
+		}]
+	};
+	return file;
+}
+async function astCollectTests(project, filepath) {
+	const request = await transformSSR(project, filepath), testFilepath = relative(project.config.root, filepath);
+	return request ? createFileTask(testFilepath, request.code, request.map, {
+		name: project.config.name,
+		filepath,
+		allowOnly: project.config.allowOnly,
+		testNamePattern: project.config.testNamePattern,
+		pool: project.browser ? "browser" : project.config.pool
+	}) : (debug?.("Cannot parse", testFilepath, "(vite didn't return anything)"), createFailedFileTask(project, filepath, /* @__PURE__ */ new Error(`Failed to parse ${testFilepath}. Vite didn't return anything.`)));
+}
+async function transformSSR(project, filepath) {
+	const request = await project.vite.transformRequest(filepath, { ssr: false });
+	return request ? await project.vite.ssrTransform(request.code, request.map, filepath) : null;
+}
+function createIndexMap(source) {
+	const map = /* @__PURE__ */ new Map();
+	let index = 0, line = 1, column = 1;
+	for (const char of source) if (map.set(index++, {
+		line,
+		column
+	}), char === "\n" || char === "\r\n") line++, column = 0;
+	else column++;
+	return map;
+}
+function markDynamicTests(tasks) {
+	for (const task of tasks) {
+		if (task.dynamic) task.id += "-dynamic";
+		if ("tasks" in task) markDynamicTests(task.tasks);
+	}
+}
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const kReplacers = new Map([
+	["%i", "\\d+?"],
+	["%#", "\\d+?"],
+	["%d", "[\\d.eE+-]+?"],
+	["%f", "[\\d.eE+-]+?"],
+	["%s", ".+?"],
+	["%j", ".+?"],
+	["%o", ".+?"],
+	["%%", "%"]
+]);
+function escapeTestName(label, dynamic) {
+	if (!dynamic) return escapeRegex(label);
+	// Replace object access patterns ($value, $obj.a) with %s first
+	let pattern = label.replace(/\$[a-z_.]+/gi, "%s");
+	return pattern = escapeRegex(pattern), pattern = pattern.replace(/%[i#dfsjo%]/g, (m) => kReplacers.get(m) || m), pattern;
+}
+
 class BrowserSessions {
 	sessions = /* @__PURE__ */ new Map();
 	sessionIds = /* @__PURE__ */ new Set();
@@ -5269,7 +5521,7 @@ class FilesStatsCache {
 	}
 	async populateStats(root, specs) {
 		const promises = specs.map((spec) => {
-			const key = `${spec[0].name}:${relative(root, spec.moduleId)}`;
+			const key = `${spec.project.name}:${relative(root, spec.moduleId)}`;
 			return this.updateStats(spec.moduleId, key);
 		});
 		await Promise.all(promises);
@@ -5521,10 +5773,10 @@ class Logger {
 		const color = this.ctx.config.watch ? "blue" : "cyan", mode = this.ctx.config.watch ? "DEV" : "RUN";
 		if (this.log(withLabel(color, mode, `v${this.ctx.version} `) + c.gray(this.ctx.config.root)), this.ctx.config.sequence.sequencer === RandomSequencer) this.log(PAD + c.gray(`Running tests with seed "${this.ctx.config.sequence.seed}"`));
 		if (this.ctx.config.ui) {
-			const host = this.ctx.config.api?.host || "localhost", port = this.ctx.server.config.server.port, base = this.ctx.config.uiBase;
+			const host = this.ctx.config.api?.host || "localhost", port = this.ctx.vite.config.server.port, base = this.ctx.config.uiBase;
 			this.log(PAD + c.dim(c.green(`UI started at http://${host}:${c.bold(port)}${base}`)));
 		} else if (this.ctx.config.api?.port) {
-			const resolvedUrls = this.ctx.server.resolvedUrls, fallbackUrl = `http://${this.ctx.config.api.host || "localhost"}:${this.ctx.config.api.port}`, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0] ?? fallbackUrl;
+			const resolvedUrls = this.ctx.vite.resolvedUrls, fallbackUrl = `http://${this.ctx.config.api.host || "localhost"}:${this.ctx.config.api.port}`, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0] ?? fallbackUrl;
 			this.log(PAD + c.dim(c.green(`API started at ${new URL("/", origin)}`)));
 		}
 		if (this.ctx.coverageProvider) this.log(PAD + c.dim("Coverage enabled with ") + c.yellow(this.ctx.coverageProvider.name));
@@ -5711,7 +5963,8 @@ function serializeConfig(config, coreConfig, viteConfig) {
 				viewport: browser.viewport,
 				screenshotFailures: browser.screenshotFailures,
 				locators: { testIdAttribute: browser.locators.testIdAttribute },
-				providerOptions: browser.provider === "playwright" ? { actionTimeout: browser.providerOptions?.context?.actionTimeout } : {}
+				providerOptions: browser.provider === "playwright" ? { actionTimeout: browser.providerOptions?.context?.actionTimeout } : {},
+				trackUnhandledErrors: browser.trackUnhandledErrors ?? true
 			};
 		})(config.browser),
 		standalone: config.standalone,
@@ -6587,7 +6840,7 @@ function VitestProjectResolver(ctx) {
 			if (id === "vitest" || id.startsWith("@vitest/") || id.startsWith("vitest/")) {
 				// always redirect the request to the root vitest plugin since
 				// it will be the one used to run Vitest
-				const resolved = await ctx.server.pluginContainer.resolveId(id, void 0, {
+				const resolved = await ctx.vite.pluginContainer.resolveId(id, void 0, {
 					skip: new Set([plugin]),
 					ssr
 				});
@@ -6822,18 +7075,6 @@ function matchExternalizePattern(id, moduleDirectories, patterns) {
 }
 
 class TestSpecification {
-	/**
-	* @deprecated use `project` instead
-	*/
-	0;
-	/**
-	* @deprecated use `moduleId` instead
-	*/
-	1;
-	/**
-	* @deprecated use `pool` instead
-	*/
-	2;
 	/**
 	* The task ID associated with the test module.
 	*/
@@ -6856,7 +7097,6 @@ class TestSpecification {
 	*/
 	testLines;
 	constructor(project, moduleId, pool, testLines) {
-		this[0] = project, this[1] = moduleId, this[2] = { pool };
 		const name = project.config.name, hashName = pool !== "typescript" ? name : name ? `${name}:__typecheck__` : "__typecheck__";
 		this.taskId = generateFileHash(relative(project.config.root, moduleId), hashName), this.project = project, this.moduleId = moduleId, this.pool = pool, this.testLines = testLines;
 	}
@@ -6880,13 +7120,6 @@ class TestSpecification {
 			}
 		];
 	}
-	/**
-	* for backwards compatibility
-	* @deprecated
-	*/
-	*[Symbol.iterator]() {
-		yield this.project, yield this.moduleId, yield this.pool;
-	}
 }
 
 async function createViteServer(inlineConfig) {
@@ -6914,8 +7147,6 @@ class TestProject {
 	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
 	*/
 	browser;
-	/** @deprecated use `vitest` instead */
-	ctx;
 	/**
 	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
 	*/
@@ -6925,14 +7156,14 @@ class TestProject {
 	/** @internal */ _vite;
 	/** @internal */ _hash;
 	/** @internal */ _resolver;
+	/** @inetrnal */ testFilesList = null;
 	runner;
 	closingPromise;
-	testFilesList = null;
 	typecheckFilesList = null;
 	_globalSetups;
 	_provided = {};
-	constructor(path, vitest, options) {
-		this.path = path, this.options = options, this.vitest = vitest, this.ctx = vitest, this.globalConfig = vitest.config;
+	constructor(vitest, options) {
+		this.options = options, this.vitest = vitest, this.globalConfig = vitest.config;
 	}
 	/**
 	* The unique hash of this project. This value is consistent between the reruns.
@@ -7024,28 +7255,12 @@ class TestProject {
 	get serializedConfig() {
 		return this._serializeOverriddenConfig();
 	}
-	/** @deprecated use `vite` instead */
-	get server() {
-		return this._vite;
-	}
 	/**
 	* Check if this is the root project. The root project is the one that has the root config.
 	*/
 	isRootProject() {
 		return this.vitest.getRootProject() === this;
 	}
-	/** @deprecated use `isRootProject` instead */
-	isCore() {
-		return this.isRootProject();
-	}
-	/** @deprecated use `createSpecification` instead */
-	createSpec(moduleId, pool) {
-		return new TestSpecification(this, moduleId, pool);
-	}
-	/** @deprecated */
-	initializeGlobalSetup() {
-		return this._initializeGlobalSetup();
-	}
 	/** @internal */
 	async _initializeGlobalSetup() {
 		if (!this._globalSetups) {
@@ -7061,37 +7276,10 @@ class TestProject {
 	onTestsRerun(cb) {
 		this.vitest.onTestsRerun(cb);
 	}
-	/** @deprecated */
-	teardownGlobalSetup() {
-		return this._teardownGlobalSetup();
-	}
 	/** @internal */
 	async _teardownGlobalSetup() {
 		if (this._globalSetups) for (const globalSetupFile of [...this._globalSetups].reverse()) await globalSetupFile.teardown?.();
 	}
-	/** @deprecated use `vitest.logger` instead */
-	get logger() {
-		return this.vitest.logger;
-	}
-	// it's possible that file path was imported with different queries (?raw, ?url, etc)
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getModulesByFilepath(file) {
-		const set = this.server.moduleGraph.getModulesByFile(file) || this.browser?.vite.moduleGraph.getModulesByFile(file);
-		return set || /* @__PURE__ */ new Set();
-	}
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getModuleById(id) {
-		return this.server.moduleGraph.getModuleById(id) || this.browser?.vite.moduleGraph.getModuleById(id);
-	}
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getSourceMapModuleById(id) {
-		const mod = this.server.moduleGraph.getModuleById(id);
-		return mod?.ssrTransformResult?.map || mod?.transformResult?.map;
-	}
-	/** @deprecated use `vitest.reporters` instead */
-	get reporters() {
-		return this.ctx.reporters;
-	}
 	/**
 	* Get all files in the project that match the globs in the config and the filters.
 	* @param filters String filters to match the test files.
@@ -7143,10 +7331,6 @@ class TestProject {
 	_isCachedTypecheckFile(testPath) {
 		return !!this.typecheckFilesList && this.typecheckFilesList.includes(testPath);
 	}
-	/** @deprecated use `serializedConfig` instead */
-	getSerializableConfig() {
-		return this._serializeOverriddenConfig();
-	}
 	/** @internal */
 	async globFiles(include, exclude, cwd) {
 		const globOptions = {
@@ -7174,10 +7358,6 @@ class TestProject {
 		}
 		return false;
 	}
-	/** @deprecated use `matchesTestGlob` instead */
-	async isTargetFile(id, source) {
-		return this.matchesTestGlob(id, source ? () => source : void 0);
-	}
 	isInSourceTestCode(code) {
 		return code.includes("import.meta.vitest");
 	}
@@ -7242,14 +7422,6 @@ class TestProject {
 	import(moduleId) {
 		return this.runner.import(moduleId);
 	}
-	/** @deprecated use `name` instead */
-	getName() {
-		return this.config.name || "";
-	}
-	/** @deprecated internal */
-	setServer(options, server) {
-		return this._configureServer(options, server);
-	}
 	_setHash() {
 		this._hash = generateHash(this._config.root + this._config.name);
 	}
@@ -7277,10 +7449,6 @@ class TestProject {
 			await rm(this.tmpDir, { recursive: true });
 		} catch {}
 	}
-	/** @deprecated */
-	initBrowserProvider() {
-		return this._initBrowserProvider();
-	}
 	/** @internal */
 	_initBrowserProvider = deduped(async () => {
 		if (!(!this.isBrowserEnabled() || this.browser?.provider)) {
@@ -7298,12 +7466,12 @@ class TestProject {
 	}
 	/** @internal */
 	static _createBasicProject(vitest) {
-		const project = new TestProject(vitest.config.name || vitest.config.root, vitest);
-		return project.runner = vitest.runner, project._vite = vitest.server, project._config = vitest.config, project._resolver = vitest._resolver, project._setHash(), project._provideObject(vitest.config.provide), project;
+		const project = new TestProject(vitest);
+		return project.runner = vitest.runner, project._vite = vitest.vite, project._config = vitest.config, project._resolver = vitest._resolver, project._setHash(), project._provideObject(vitest.config.provide), project;
 	}
 	/** @internal */
 	static _cloneBrowserProject(parent, config) {
-		const clone = new TestProject(parent.path, parent.vitest);
+		const clone = new TestProject(parent.vitest);
 		return clone.runner = parent.runner, clone._vite = parent._vite, clone._resolver = parent._resolver, clone._config = config, clone._setHash(), clone._parent = parent, clone._provideObject(config.provide), clone;
 	}
 }
@@ -7317,7 +7485,7 @@ function deduped(cb) {
 	});
 }
 async function initializeProject(workspacePath, ctx, options) {
-	const project = new TestProject(workspacePath, ctx, options), { configFile,...restOptions } = options, config = {
+	const project = new TestProject(ctx, options), { configFile,...restOptions } = options, config = {
 		...restOptions,
 		configFile,
 		configLoader: ctx.vite.config.inlineConfig.configLoader,
@@ -8073,6 +8241,9 @@ function getSuiteState(task) {
 	if (state === "pass") return "passed";
 	throw new Error(`Unknown suite state: ${state}`);
 }
+function experimental_getRunnerTask(entity) {
+	return entity.task;
+}
 
 function isAggregateError(err) {
 	return typeof AggregateError !== "undefined" && err instanceof AggregateError ? true : err instanceof Error && "errors" in err;
@@ -8159,7 +8330,7 @@ class StateManager {
 	}
 	clearFiles(project, paths = []) {
 		paths.forEach((path) => {
-			const files = this.filesMap.get(path), fileTask = createFileTask(path, project.config.root, project.config.name);
+			const files = this.filesMap.get(path), fileTask = createFileTask$1(path, project.config.root, project.config.name);
 			if (fileTask.local = true, TestModule.register(fileTask, project), this.idMap.set(fileTask.id, fileTask), !files) {
 				this.filesMap.set(path, [fileTask]);
 				return;
@@ -8203,7 +8374,7 @@ class StateManager {
 		return Array.from(this.idMap.values()).filter((t) => t.result?.state === "fail").length;
 	}
 	cancelFiles(files, project) {
-		this.collectFiles(project, files.map((filepath) => createFileTask(filepath, project.config.root, project.config.name)));
+		this.collectFiles(project, files.map((filepath) => createFileTask$1(filepath, project.config.root, project.config.name)));
 	}
 }
 
@@ -8686,9 +8857,9 @@ class TestRun {
 		return assert$1(task && entity, `Entity must be found for task ${task?.name || testId}`), assert$1(entity.type === "test", `Annotation can only be added to a test, instead got ${entity.type}`), await this.resolveTestAttachment(entity, annotation), entity.task.annotations.push(annotation), await this.vitest.report("onTestCaseAnnotate", entity, annotation), annotation;
 	}
 	async updated(update, events) {
-		this.vitest.state.updateTasks(update);
+		this.syncUpdateStacks(update), this.vitest.state.updateTasks(update);
 		for (const [id, event, data] of events) await this.reportEvent(id, event, data).catch((error) => {
-			this.vitest.state.catchError(serializeError(error), "Unhandled Reporter Error");
+			this.vitest.state.catchError(serializeError$1(error), "Unhandled Reporter Error");
 		});
 		// TODO: what is the order or reports here?
 		// "onTaskUpdate" in parallel with others or before all or after all?
@@ -8705,6 +8876,17 @@ class TestRun {
 	hasFailed(modules) {
 		return modules.length ? modules.some((m) => !m.ok()) : !this.vitest.config.passWithNoTests;
 	}
+	syncUpdateStacks(update) {
+		update.forEach(([taskId, result]) => {
+			const task = this.vitest.state.idMap.get(taskId), isBrowser = task && task.file.pool === "browser";
+			result?.errors?.forEach((error) => {
+				if (isPrimitive(error)) return;
+				const project = this.vitest.getProjectByName(task.file.projectName || "");
+				if (isBrowser) error.stacks = project.browser?.parseErrorStacktrace(error, { frameFilter: project.config.onStackTrace }) || [];
+				else error.stacks = parseErrorStacktrace(error, { frameFilter: project.config.onStackTrace });
+			});
+		});
+	}
 	async reportEvent(id, event, data) {
 		const task = this.vitest.state.idMap.get(id), entity = task && this.vitest.state.getReportedEntity(task);
 		if (assert$1(task && entity, `Entity must be found for task ${task?.name || id}`), event === "suite-prepare" && entity.type === "suite") return await this.vitest.report("onTestSuiteReady", entity);
@@ -8786,8 +8968,8 @@ class VitestWatcher {
 	registerWatcher() {
 		const watcher = this.vitest.vite.watcher;
 		if (this.vitest.config.forceRerunTriggers.length) watcher.add(this.vitest.config.forceRerunTriggers);
-		return watcher.on("change", this.onChange), watcher.on("unlink", this.onUnlink), watcher.on("add", this.onAdd), this.unregisterWatcher = () => {
-			watcher.off("change", this.onChange), watcher.off("unlink", this.onUnlink), watcher.off("add", this.onAdd), this.unregisterWatcher = noop;
+		return watcher.on("change", this.onFileChange), watcher.on("unlink", this.onFileDelete), watcher.on("add", this.onFileCreate), this.unregisterWatcher = () => {
+			watcher.off("change", this.onFileChange), watcher.off("unlink", this.onFileDelete), watcher.off("add", this.onFileCreate), this.unregisterWatcher = noop;
 		}, this;
 	}
 	scheduleRerun(file) {
@@ -8805,7 +8987,7 @@ class VitestWatcher {
 			}
 		}), triggered;
 	}
-	onChange = (id) => {
+	onFileChange = (id) => {
 		id = slash(id), this.vitest.logger.clearHighlightCache(id), this.vitest.invalidateFile(id);
 		const testFiles = this.getTestFilesFromWatcherTrigger(id);
 		if (testFiles) this.scheduleRerun(id);
@@ -8814,10 +8996,10 @@ class VitestWatcher {
 			if (needsRerun) this.scheduleRerun(id);
 		}
 	};
-	onUnlink = (id) => {
+	onFileDelete = (id) => {
 		if (id = slash(id), this.vitest.logger.clearHighlightCache(id), this.invalidates.add(id), this.vitest.state.filesMap.has(id)) this.vitest.projects.forEach((project) => project._removeCachedTestFile(id)), this.vitest.state.filesMap.delete(id), this.vitest.cache.results.removeFromCache(id), this.vitest.cache.stats.removeStats(id), this.changedTests.delete(id), this.vitest.report("onTestRemoved", id);
 	};
-	onAdd = (id) => {
+	onFileCreate = (id) => {
 		id = slash(id), this.vitest.invalidateFile(id);
 		const testFiles = this.getTestFilesFromWatcherTrigger(id);
 		if (testFiles) {
@@ -8910,8 +9092,15 @@ class Vitest {
 	* If projects were filtered with `--project` flag, they won't appear here.
 	*/
 	projects = [];
+	/**
+	* A watcher handler. This is not the file system watcher. The handler only
+	* exposes methods to handle changed files.
+	*
+	* If you have your own watcher, you can use these methods to replicate
+	* Vitest behaviour.
+	*/
+	watcher;
 	/** @internal */ configOverride = {};
-	/** @internal */ coverageProvider;
 	/** @internal */ filenamePattern;
 	/** @internal */ runningPromise;
 	/** @internal */ closingPromise;
@@ -8926,15 +9115,15 @@ class Vitest {
 	isFirstRun = true;
 	restartsCount = 0;
 	specifications;
-	watcher;
 	pool;
 	_config;
 	_vite;
 	_state;
 	_cache;
 	_snapshot;
+	_coverageProvider;
 	constructor(mode, cliOptions, options = {}) {
-		this.mode = mode, this._cliOptions = cliOptions, this.logger = new Logger(this, options.stdout, options.stderr), this.packageInstaller = options.packageInstaller || new VitestPackageInstaller(), this.specifications = new VitestSpecifications(this), this.watcher = new VitestWatcher(this).onWatcherRerun((file) => this.scheduleRerun([file]));
+		this.mode = mode, this._cliOptions = cliOptions, this.logger = new Logger(this, options.stdout, options.stderr), this.packageInstaller = options.packageInstaller || new VitestPackageInstaller(), this.specifications = new VitestSpecifications(this), this.watcher = new VitestWatcher(this).onWatcherRerun((file) => this.scheduleRerun(file));
 	}
 	_onRestartListeners = [];
 	_onClose = [];
@@ -8942,24 +9131,12 @@ class Vitest {
 	_onCancelListeners = [];
 	_onUserTestsRerun = [];
 	_onFilterWatchedSpecification = [];
-	/** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
-	get invalidates() {
-		return this.watcher.invalidates;
-	}
-	/** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
-	get changedTests() {
-		return this.watcher.changedTests;
-	}
 	/**
 	* The global config.
 	*/
 	get config() {
 		return assert(this._config, "config"), this._config;
 	}
-	/** @deprecated use `vitest.vite` instead */
-	get server() {
-		return this._vite;
-	}
 	/**
 	* Global Vite's dev server instance.
 	*/
@@ -8985,13 +9162,9 @@ class Vitest {
 	get cache() {
 		return assert(this._cache, "cache"), this._cache;
 	}
-	/** @deprecated internal */
-	setServer(options, server) {
-		return this._setServer(options, server);
-	}
 	/** @internal */
 	async _setServer(options, server) {
-		this.watcher.unregisterWatcher(), clearTimeout(this._rerunTimer), this.restartsCount += 1, this.pool?.close?.(), this.pool = void 0, this.closingPromise = void 0, this.projects = [], this.coverageProvider = void 0, this.runningPromise = void 0, this.coreWorkspaceProject = void 0, this.specifications.clearCache(), this._onUserTestsRerun = [], this._vite = server;
+		this.watcher.unregisterWatcher(), clearTimeout(this._rerunTimer), this.restartsCount += 1, this.pool?.close?.(), this.pool = void 0, this.closingPromise = void 0, this.projects = [], this.runningPromise = void 0, this.coreWorkspaceProject = void 0, this.specifications.clearCache(), this._coverageProvider = void 0, this._onUserTestsRerun = [], this._vite = server;
 		const resolved = resolveConfig(this, options, server.config);
 		if (this._config = resolved, this._state = new StateManager({ onUnhandledError: resolved.onUnhandledError }), this._cache = new VitestCache(this.version), this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions }), this._testRun = new TestRun(this), this.config.watch) this.watcher.registerWatcher();
 		this._resolver = new VitestResolver(server.config.cacheDir, resolved);
@@ -9032,6 +9205,26 @@ class Vitest {
 		if (this.config.testNamePattern) this.configOverride.testNamePattern = this.config.testNamePattern;
 		this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this), await Promise.all(this._onSetServer.map((fn) => fn()));
 	}
+	/** @internal */
+	get coverageProvider() {
+		return this.configOverride.coverage?.enabled === false ? null : this._coverageProvider;
+	}
+	async enableCoverage() {
+		this.configOverride.coverage = {}, this.configOverride.coverage.enabled = true, await this.createCoverageProvider(), await this.coverageProvider?.onEnabled?.();
+	}
+	disableCoverage() {
+		this.configOverride.coverage ??= {}, this.configOverride.coverage.enabled = false;
+	}
+	_coverageOverrideCache = /* @__PURE__ */ new WeakMap();
+	/** @internal */
+	get _coverageOptions() {
+		if (!this.configOverride.coverage) return this.config.coverage;
+		if (!this._coverageOverrideCache.has(this.configOverride.coverage)) {
+			const coverage = deepClone(this.config.coverage), options = deepMerge(coverage, this.configOverride.coverage);
+			this._coverageOverrideCache.set(this.configOverride.coverage, options);
+		}
+		return this._coverageOverrideCache.get(this.configOverride.coverage);
+	}
 	/**
 	* Inject new test projects into the workspace.
 	* @param config Glob, config path or a custom config options.
@@ -9057,10 +9250,6 @@ class Vitest {
 	_ensureRootProject() {
 		return this.coreWorkspaceProject ||= TestProject._createBasicProject(this), this.coreWorkspaceProject;
 	}
-	/** @deprecated use `getRootProject` instead */
-	getCoreWorkspaceProject() {
-		return this.getRootProject();
-	}
 	/**
 	* Return project that has the root (or "global") config.
 	*/
@@ -9068,13 +9257,6 @@ class Vitest {
 		if (!this.coreWorkspaceProject) throw new Error(`Root project is not initialized. This means that the Vite server was not established yet and the the workspace config is not resolved.`);
 		return this.coreWorkspaceProject;
 	}
-	/**
-	* @deprecated use Reported Task API instead
-	*/
-	getProjectByTaskId(taskId) {
-		const task = this.state.idMap.get(taskId), projectName = task.projectName || task?.file?.projectName || "";
-		return this.getProjectByName(projectName);
-	}
 	getProjectByName(name) {
 		const project = this.projects.find((p) => p.name === name) || this.coreWorkspaceProject || this.projects[0];
 		if (!project) throw new Error(`Project "${name}" was not found.`);
@@ -9087,6 +9269,15 @@ class Vitest {
 	import(moduleId) {
 		return this.runner.import(moduleId);
 	}
+	/**
+	* Creates a coverage provider if `coverage` is enabled in the config.
+	*/
+	async createCoverageProvider() {
+		if (this._coverageProvider) return this._coverageProvider;
+		const coverageProvider = await this.initCoverageProvider();
+		if (coverageProvider) await coverageProvider.clean(this._coverageOptions.clean);
+		return coverageProvider || null;
+	}
 	async resolveProjects(cliOptions) {
 		const names = /* @__PURE__ */ new Set();
 		if (this.config.projects) return resolveProjects(this, cliOptions, void 0, this.config.projects, names);
@@ -9104,10 +9295,10 @@ class Vitest {
 		return this.specifications.globTestSpecifications(filters);
 	}
 	async initCoverageProvider() {
-		if (this.coverageProvider === void 0) {
-			if (this.coverageProvider = await getCoverageProvider(this.config.coverage, this.runner), this.coverageProvider) await this.coverageProvider.initialize(this), this.config.coverage = this.coverageProvider.resolveOptions();
-			return this.coverageProvider;
-		}
+		if (this._coverageProvider != null) return;
+		const coverageConfig = this.configOverride.coverage ? this.getRootProject().serializedConfig.coverage : this.config.coverage;
+		if (this._coverageProvider = await getCoverageProvider(coverageConfig, this.runner), this._coverageProvider) await this._coverageProvider.initialize(this), this.config.coverage = this._coverageProvider.resolveOptions();
+		return this._coverageProvider;
 	}
 	/**
 	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
@@ -9151,10 +9342,6 @@ class Vitest {
 			unhandledErrors: []
 		};
 	}
-	/** @deprecated use `getRelevantTestSpecifications` instead */
-	listFiles(filters) {
-		return this.getRelevantTestSpecifications(filters);
-	}
 	/**
 	* Returns the list of test files that match the config and filters.
 	* @param filters String filters to match the test files
@@ -9172,7 +9359,7 @@ class Vitest {
 	*/
 	async start(filters) {
 		try {
-			await this.initCoverageProvider(), await this.coverageProvider?.clean(this.config.coverage.clean);
+			await this.initCoverageProvider(), await this.coverageProvider?.clean(this._coverageOptions.clean);
 		} finally {
 			await this.report("onInit", this);
 		}
@@ -9198,21 +9385,18 @@ class Vitest {
 	*/
 	async init() {
 		try {
-			await this.initCoverageProvider(), await this.coverageProvider?.clean(this.config.coverage.clean);
+			await this.initCoverageProvider(), await this.coverageProvider?.clean(this._coverageOptions.clean);
 		} finally {
 			await this.report("onInit", this);
 		}
 		if (await this.globTestSpecifications(), this.config.watch) await this.report("onWatcherStart");
 	}
 	/**
-	* @deprecated remove when vscode extension supports "getModuleSpecifications"
+	* If there is a test run happening, returns a promise that will
+	* resolve when the test run is finished.
 	*/
-	getProjectsByTestFile(file) {
-		return this.getModuleSpecifications(file);
-	}
-	/** @deprecated */
-	getFileWorkspaceSpecs(file) {
-		return this.getModuleSpecifications(file);
+	async waitForTestRunEnd() {
+		this.runningPromise && await this.runningPromise;
 	}
 	/**
 	* Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
@@ -9227,7 +9411,9 @@ class Vitest {
 	* Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache altogether.
 	*/
 	clearSpecificationsCache(moduleId) {
-		this.specifications.clearCache(moduleId);
+		if (this.specifications.clearCache(moduleId), !moduleId) this.projects.forEach((project) => {
+			project.testFilesList = null;
+		});
 	}
 	/**
 	* Run tests for the given test specifications. This does not trigger `onWatcher*` events.
@@ -9243,7 +9429,6 @@ class Vitest {
 	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
 	*/
 	async rerunTestSpecifications(specifications, allTestsRun = false) {
-		this.configOverride.testNamePattern = void 0;
 		const files = specifications.map((spec) => spec.moduleId);
 		await Promise.all([this.report("onWatcherRerun", files, "rerun test"), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
 		const result = await this.runTestSpecifications(specifications, allTestsRun);
@@ -9254,7 +9439,7 @@ class Vitest {
 			try {
 				if (!this.pool) this.pool = createPool(this);
 				const invalidates = Array.from(this.watcher.invalidates);
-				if (this.watcher.invalidates.clear(), this.snapshot.clear(), this.state.clearErrors(), !this.isFirstRun && this.config.coverage.cleanOnRerun) await this.coverageProvider?.clean();
+				if (this.watcher.invalidates.clear(), this.snapshot.clear(), this.state.clearErrors(), !this.isFirstRun && this._coverageOptions.cleanOnRerun) await this.coverageProvider?.clean();
 				await this.initializeGlobalSetup(specs);
 				try {
 					await this.pool.runTests(specs, invalidates);
@@ -9278,6 +9463,18 @@ class Vitest {
 			this.runningPromise = void 0, this.isFirstRun = false, this.config.changed = false, this.config.related = void 0;
 		}), await this.runningPromise;
 	}
+	async experimental_parseSpecifications(specifications, options) {
+		if (this.mode !== "test") throw new Error(`The \`experimental_parseSpecifications\` does not support "${this.mode}" mode.`);
+		const concurrency = options?.concurrency ?? (typeof nodeos__default.availableParallelism === "function" ? nodeos__default.availableParallelism() : nodeos__default.cpus().length), limit = limitConcurrency(concurrency), promises = specifications.map((specification) => limit(() => this.experimental_parseSpecification(specification)));
+		return Promise.all(promises);
+	}
+	async experimental_parseSpecification(specification) {
+		if (this.mode !== "test") throw new Error(`The \`experimental_parseSpecification\` does not support "${this.mode}" mode.`);
+		const file = await astCollectTests(specification.project, specification.moduleId).catch((error) => {
+			return createFailedFileTask(specification.project, specification.moduleId, error);
+		});
+		return this.state.collectFiles(specification.project, [file]), this.state.getReportedEntity(file);
+	}
 	/**
 	* Collect tests in specified modules. Vitest will run the files to collect tests.
 	* @param specifications A list of specifications to run.
@@ -9416,7 +9613,6 @@ class Vitest {
 		this.configOverride.testNamePattern = void 0;
 	}
 	_rerunTimer;
-	// we can't use a single `triggerId` yet because vscode extension relies on this
 	async scheduleRerun(triggerId) {
 		const currentCount = this.restartsCount;
 		clearTimeout(this._rerunTimer), await this.runningPromise, clearTimeout(this._rerunTimer), this.restartsCount === currentCount && (this._rerunTimer = setTimeout(async () => {
@@ -9434,7 +9630,7 @@ class Vitest {
 				if (files = files.filter((file) => filteredFiles.some((f) => f.moduleId === file)), files.length === 0) return;
 			}
 			this.watcher.changedTests.clear();
-			const triggerIds = new Set(triggerId.map((id) => relative(this.config.root, id))), triggerLabel = Array.from(triggerIds).join(", "), specifications = files.flatMap((file) => this.getModuleSpecifications(file)).filter((specification) => {
+			const triggerLabel = relative(this.config.root, triggerId), specifications = files.flatMap((file) => this.getModuleSpecifications(file)).filter((specification) => {
 				return this._onFilterWatchedSpecification.length === 0 ? true : this._onFilterWatchedSpecification.every((fn) => fn(specification));
 			});
 			await Promise.all([this.report("onWatcherRerun", files, triggerLabel), ...this._onUserTestsRerun.map((fn) => fn(specifications))]), await this.runFiles(specifications, false), await this.report("onWatcherStart", this.state.getFiles(files));
@@ -9452,17 +9648,13 @@ class Vitest {
 			});
 		});
 	}
-	/** @deprecated use `invalidateFile` */
-	updateLastChanged(filepath) {
-		this.invalidateFile(filepath);
-	}
 	/** @internal */
 	_checkUnhandledErrors(errors) {
 		if (errors.length && !this.config.dangerouslyIgnoreUnhandledErrors) process.exitCode = 1;
 	}
 	async reportCoverage(coverage, allTestsRun) {
 		if (this.state.getCountOfFailedTests() > 0) {
-			if (await this.coverageProvider?.onTestFailure?.(), !this.config.coverage.reportOnFailure) return;
+			if (await this.coverageProvider?.onTestFailure?.(), !this._coverageOptions.reportOnFailure) return;
 		}
 		if (this.coverageProvider) {
 			await this.coverageProvider.reportCoverage(coverage, { allTestsRun });
@@ -9526,25 +9718,6 @@ class Vitest {
 		return Array.from(new Set(specifications.map((spec) => spec.moduleId)));
 	}
 	/**
-	* @deprecated use `globTestSpecifications` instead
-	*/
-	async globTestSpecs(filters = []) {
-		return this.globTestSpecifications(filters);
-	}
-	/**
-	* @deprecated use `globTestSpecifications` instead
-	*/
-	async globTestFiles(filters = []) {
-		return this.globTestSpecifications(filters);
-	}
-	/** @deprecated filter by `this.projects` yourself */
-	getModuleProjects(filepath) {
-		return this.projects.filter((project) => {
-			return project.getModulesByFilepath(filepath).size;
-			// TODO: reevaluate || project.browser?.moduleGraph.getModulesByFile(id)?.size
-		});
-	}
-	/**
 	* Should the server be kept running after the tests are done.
 	*/
 	shouldKeepServer() {
@@ -9961,8 +10134,8 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 	async function inputFilePattern() {
 		off();
 		const watchFilter = new WatchFilter("Input filename pattern", stdin, stdout), filter = await watchFilter.filter(async (str) => {
-			const files = await ctx.globTestFiles([str]);
-			return files.map((file) => relative(ctx.config.root, file[1])).filter((file, index, all) => all.indexOf(file) === index);
+			const specifications = await ctx.globTestSpecifications([str]);
+			return specifications.map((specification) => relative(ctx.config.root, specification.moduleId)).filter((file, index, all) => all.indexOf(file) === index);
 		});
 		if (on(), typeof filter === "undefined") return;
 		latestFilename = filter?.trim() || "";
@@ -9992,8 +10165,8 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 */
 async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, vitestOptions) {
 	const root = resolve(options.root || process.cwd()), ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions, cliFilters);
-	if (mode === "test" && ctx.config.coverage.enabled) {
-		const provider = ctx.config.coverage.provider || "v8", requiredPackages = CoverageProviderMap[provider];
+	if (mode === "test" && ctx._coverageOptions.enabled) {
+		const provider = ctx._coverageOptions.provider || "v8", requiredPackages = CoverageProviderMap[provider];
 		if (requiredPackages) {
 			if (!await ctx.packageInstaller.ensureInstalled(requiredPackages, root, ctx.version)) return process.exitCode = 1, ctx;
 		}
@@ -10114,4 +10287,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, registerConsoleShortcuts as d, createViteLogger as e, cliApi as f, isValidApiRequest as i, 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, createDebugger as h, isValidApiRequest as i, cliApi as j, resolveFsAllow as r, startVitest as s };