vitest 4.0.0-beta.6 → 4.0.0-beta.7

package/dist/browser.d.ts

@@ -1,7 +1,7 @@
-import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.d.CKNVOKm0.js';
+import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.d._GBBbReY.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.8kKUsuDg.js';
+import { V as VitestModuleRunner } from './chunks/moduleRunner.d.CX4DuqOx.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
 import * as spy from '@vitest/spy';
 export { spy as SpyModule };
@@ -11,7 +11,7 @@ import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import 'node:vm';
 import 'vite/module-runner';
-import './chunks/worker.d.D9QWnzAe.js';
+import './chunks/worker.d.DYlqbejz.js';
 import './chunks/environment.d.2fYMoz3o.js';
 import '@vitest/mocker';
 import './chunks/mocker.d.BE_2ls6u.js';

package/dist/chunks/{browser.d.Cawq_X_N.d.ts → browser.d.DOMmqJQx.d.ts}

@@ -1,4 +1,4 @@
-import { T as TestExecutionMethod } from './worker.d.D9QWnzAe.js';
+import { T as TestExecutionMethod } from './worker.d.DYlqbejz.js';
 
 type SerializedTestSpecification = [project: {
 	name: string | undefined;

package/dist/chunks/{cac.WE-urWw5.js → cac.Dsn7ixFt.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.VNI-1z5c.js';
+import { R as ReportersMap } from './index.C3EbxYwt.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.6";
+var version = "4.0.0-beta.7";
 
 const apiConfig = (port) => ({
 	port: {
@@ -870,6 +870,7 @@ const cliOptionsConfig = {
 				description: "If connection to the browser takes longer, the test suite will fail (default: `60_000`)",
 				argument: "<timeout>"
 			},
+			trackUnhandledErrors: { description: "Control if Vitest catches uncaught exceptions so they can be reported (default: `true`)" },
 			orchestratorScripts: null,
 			testerScripts: null,
 			commands: null,
@@ -1335,10 +1336,10 @@ async function start(mode, cliFilters, options) {
 		process.title = "node (vitest)";
 	} catch {}
 	try {
-		const { startVitest } = await import('./cli-api.CZz3evYC.js').then(function (n) { return n.f; }), ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
+		const { startVitest } = await import('./cli-api.DfGJyldU.js').then(function (n) { return n.j; }), ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
 		if (!ctx.shouldKeepServer()) await ctx.exit();
 	} catch (e) {
-		const { errorBanner } = await import('./index.VNI-1z5c.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.C3EbxYwt.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();
 	}
@@ -1353,7 +1354,7 @@ async function collect(mode, cliFilters, options) {
 		process.title = "node (vitest)";
 	} catch {}
 	try {
-		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.CZz3evYC.js').then(function (n) { return n.f; }), ctx = await prepareVitest(mode, {
+		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.DfGJyldU.js').then(function (n) { return n.j; }), ctx = await prepareVitest(mode, {
 			...normalizeCliOptions(cliFilters, options),
 			watch: false,
 			run: true
@@ -1371,7 +1372,7 @@ async function collect(mode, cliFilters, options) {
 		}
 		await ctx.close();
 	} catch (e) {
-		const { errorBanner } = await import('./index.VNI-1z5c.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.C3EbxYwt.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.CZz3evYC.js → cli-api.DfGJyldU.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.Dsn7ixFt.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.C3EbxYwt.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.Dvxug1RM.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.D2B6d2vv.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';
 
@@ -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.getName(),
+		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();
@@ -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,
@@ -6925,9 +7178,9 @@ class TestProject {
 	/** @internal */ _vite;
 	/** @internal */ _hash;
 	/** @internal */ _resolver;
+	/** @inetrnal */ testFilesList = null;
 	runner;
 	closingPromise;
-	testFilesList = null;
 	typecheckFilesList = null;
 	_globalSetups;
 	_provided = {};
@@ -8073,6 +8326,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 +8415,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 +8459,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 +8942,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 +8961,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 +9053,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 +9072,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 +9081,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,6 +9177,14 @@ 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;
@@ -8926,7 +9201,6 @@ class Vitest {
 	isFirstRun = true;
 	restartsCount = 0;
 	specifications;
-	watcher;
 	pool;
 	_config;
 	_vite;
@@ -8934,7 +9208,7 @@ class Vitest {
 	_cache;
 	_snapshot;
 	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 = [];
@@ -9087,6 +9361,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.config.coverage.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);
@@ -9215,6 +9498,13 @@ class Vitest {
 		return this.getModuleSpecifications(file);
 	}
 	/**
+	* If there is a test run happening, returns a promise that will
+	* resolve when the test run is finished.
+	*/
+	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.
 	*
 	* **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
@@ -9227,7 +9517,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.
@@ -9278,6 +9570,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 +9720,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 +9737,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));
@@ -10114,4 +10417,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 };

package/dist/chunks/{config.d.CKNVOKm0.d.ts → config.d._GBBbReY.d.ts}

@@ -187,6 +187,7 @@ interface SerializedConfig {
 			// for playwright
 			actionTimeout?: number;
 		};
+		trackUnhandledErrors: boolean;
 	};
 	standalone: boolean;
 	logHeapUsage: boolean | undefined;

package/dist/chunks/{coverage.BPRS6xgn.js → coverage.Dvxug1RM.js}

@@ -23,7 +23,7 @@ import { isatty } from 'node:tty';
 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.Cd1wvxUM.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.DSo_maXz.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';