@vitest/runner 4.0.17 → 4.1.0-beta.2

package/dist/chunk-tasks.js

@@ -34,7 +34,7 @@ function createChainable(keys, fn) {
 /**
 * If any tasks been marked as `only`, mark all other tasks as `skip`.
 */
-function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIsOnly, allowOnly) {
+function interpretTaskModes(file, namePattern, testLocations, testIds, testTagsFilter, onlyMode, parentIsOnly, allowOnly) {
 	const matchedLocations = [];
 	const traverseSuite = (suite, parentIsOnly, parentMatchedWithLocation) => {
 		const suiteIsOnly = parentIsOnly || suite.mode === "only";
@@ -60,7 +60,7 @@ function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIs
 			}
 			let hasLocationMatch = parentMatchedWithLocation;
 			// Match test location against provided locations, only run if present
-			// in `testLocations`. Note: if `includeTaskLocations` is not enabled,
+			// in `testLocations`. Note: if `includeTaskLocation` is not enabled,
 			// all test will be skipped.
 			if (testLocations !== undefined && testLocations.length !== 0) {
 				if (t.location && (testLocations === null || testLocations === void 0 ? void 0 : testLocations.includes(t.location.line))) {
@@ -77,6 +77,12 @@ function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIs
 				if (namePattern && !getTaskFullName(t).match(namePattern)) {
 					t.mode = "skip";
 				}
+				if (testIds && !testIds.includes(t.id)) {
+					t.mode = "skip";
+				}
+				if (testTagsFilter && !testTagsFilter(t.tags || [])) {
+					t.mode = "skip";
+				}
 			} else if (t.type === "suite") {
 				if (t.mode === "skip") {
 					skipAllTasks(t);
@@ -274,6 +280,241 @@ function partitionSuiteChildren(suite) {
 	return tasksGroups;
 }
 
+function validateTags(config, tags) {
+	if (!config.strictTags) {
+		return;
+	}
+	const availableTags = new Set(config.tags.map((tag) => tag.name));
+	for (const tag of tags) {
+		if (!availableTags.has(tag)) {
+			throw createNoTagsError(config.tags, tag);
+		}
+	}
+}
+function createNoTagsError(availableTags, tag, prefix = "tag") {
+	if (!availableTags.length) {
+		throw new Error(`The Vitest config does't define any "tags", cannot apply "${tag}" ${prefix} for this test. See: https://vitest.dev/guide/test-tags`);
+	}
+	throw new Error(`The ${prefix} "${tag}" is not defined in the configuration. Available tags are:\n${availableTags.map((t) => `- ${t.name}${t.description ? `: ${t.description}` : ""}`).join("\n")}`);
+}
+function createTagsFilter(tagsExpr, availableTags) {
+	const matchers = tagsExpr.map((expr) => parseTagsExpression(expr, availableTags));
+	return (testTags) => {
+		return matchers.every((matcher) => matcher(testTags));
+	};
+}
+function parseTagsExpression(expr, availableTags) {
+	const tokens = tokenize(expr);
+	const stream = new TokenStream(tokens, expr);
+	const ast = parseOrExpression(stream, availableTags);
+	if (stream.peek().type !== "EOF") {
+		throw new Error(`Invalid tags expression: unexpected "${formatToken(stream.peek())}" in "${expr}"`);
+	}
+	return (tags) => evaluateNode(ast, tags);
+}
+function formatToken(token) {
+	switch (token.type) {
+		case "TAG": return token.value;
+		default: return formatTokenType(token.type);
+	}
+}
+function tokenize(expr) {
+	const tokens = [];
+	let i = 0;
+	while (i < expr.length) {
+		if (expr[i] === " " || expr[i] === "	") {
+			i++;
+			continue;
+		}
+		if (expr[i] === "(") {
+			tokens.push({ type: "LPAREN" });
+			i++;
+			continue;
+		}
+		if (expr[i] === ")") {
+			tokens.push({ type: "RPAREN" });
+			i++;
+			continue;
+		}
+		if (expr[i] === "!") {
+			tokens.push({ type: "NOT" });
+			i++;
+			continue;
+		}
+		if (expr.slice(i, i + 2) === "&&") {
+			tokens.push({ type: "AND" });
+			i += 2;
+			continue;
+		}
+		if (expr.slice(i, i + 2) === "||") {
+			tokens.push({ type: "OR" });
+			i += 2;
+			continue;
+		}
+		if (/^and(?:\s|\)|$)/i.test(expr.slice(i))) {
+			tokens.push({ type: "AND" });
+			i += 3;
+			continue;
+		}
+		if (/^or(?:\s|\)|$)/i.test(expr.slice(i))) {
+			tokens.push({ type: "OR" });
+			i += 2;
+			continue;
+		}
+		if (/^not\s/i.test(expr.slice(i))) {
+			tokens.push({ type: "NOT" });
+			i += 3;
+			continue;
+		}
+		let tag = "";
+		while (i < expr.length && expr[i] !== " " && expr[i] !== "	" && expr[i] !== "(" && expr[i] !== ")" && expr[i] !== "!" && expr[i] !== "&" && expr[i] !== "|") {
+			const remaining = expr.slice(i);
+			// Only treat and/or/not as operators if we're at the start of a tag (after whitespace)
+			// This allows tags like "demand", "editor", "cannot" to work correctly
+			if (tag === "" && (/^and(?:\s|\)|$)/i.test(remaining) || /^or(?:\s|\)|$)/i.test(remaining) || /^not\s/i.test(remaining))) {
+				break;
+			}
+			tag += expr[i];
+			i++;
+		}
+		if (tag) {
+			tokens.push({
+				type: "TAG",
+				value: tag
+			});
+		}
+	}
+	tokens.push({ type: "EOF" });
+	return tokens;
+}
+class TokenStream {
+	pos = 0;
+	constructor(tokens, expr) {
+		this.tokens = tokens;
+		this.expr = expr;
+	}
+	peek() {
+		return this.tokens[this.pos];
+	}
+	next() {
+		return this.tokens[this.pos++];
+	}
+	expect(type) {
+		const token = this.next();
+		if (token.type !== type) {
+			if (type === "RPAREN" && token.type === "EOF") {
+				throw new Error(`Invalid tags expression: missing closing ")" in "${this.expr}"`);
+			}
+			throw new Error(`Invalid tags expression: expected "${formatTokenType(type)}" but got "${formatToken(token)}" in "${this.expr}"`);
+		}
+		return token;
+	}
+	unexpectedToken() {
+		const token = this.peek();
+		if (token.type === "EOF") {
+			throw new Error(`Invalid tags expression: unexpected end of expression in "${this.expr}"`);
+		}
+		throw new Error(`Invalid tags expression: unexpected "${formatToken(token)}" in "${this.expr}"`);
+	}
+}
+function formatTokenType(type) {
+	switch (type) {
+		case "TAG": return "tag";
+		case "AND": return "and";
+		case "OR": return "or";
+		case "NOT": return "not";
+		case "LPAREN": return "(";
+		case "RPAREN": return ")";
+		case "EOF": return "end of expression";
+	}
+}
+function parseOrExpression(stream, availableTags) {
+	let left = parseAndExpression(stream, availableTags);
+	while (stream.peek().type === "OR") {
+		stream.next();
+		const right = parseAndExpression(stream, availableTags);
+		left = {
+			type: "or",
+			left,
+			right
+		};
+	}
+	return left;
+}
+function parseAndExpression(stream, availableTags) {
+	let left = parseUnaryExpression(stream, availableTags);
+	while (stream.peek().type === "AND") {
+		stream.next();
+		const right = parseUnaryExpression(stream, availableTags);
+		left = {
+			type: "and",
+			left,
+			right
+		};
+	}
+	return left;
+}
+function parseUnaryExpression(stream, availableTags) {
+	if (stream.peek().type === "NOT") {
+		stream.next();
+		const operand = parseUnaryExpression(stream, availableTags);
+		return {
+			type: "not",
+			operand
+		};
+	}
+	return parsePrimaryExpression(stream, availableTags);
+}
+function parsePrimaryExpression(stream, availableTags) {
+	const token = stream.peek();
+	if (token.type === "LPAREN") {
+		stream.next();
+		const expr = parseOrExpression(stream, availableTags);
+		stream.expect("RPAREN");
+		return expr;
+	}
+	if (token.type === "TAG") {
+		stream.next();
+		const tagValue = token.value;
+		const pattern = resolveTagPattern(tagValue, availableTags);
+		return {
+			type: "tag",
+			value: tagValue,
+			pattern
+		};
+	}
+	stream.unexpectedToken();
+}
+function createWildcardRegex(pattern) {
+	return new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+}
+function resolveTagPattern(tagPattern, availableTags) {
+	if (tagPattern.includes("*")) {
+		const regex = createWildcardRegex(tagPattern);
+		const hasMatch = availableTags.some((tag) => regex.test(tag.name));
+		if (!hasMatch) {
+			throw createNoTagsError(availableTags, tagPattern, "tag pattern");
+		}
+		return regex;
+	}
+	if (!availableTags.length || !availableTags.some((tag) => tag.name === tagPattern)) {
+		throw createNoTagsError(availableTags, tagPattern, "tag pattern");
+	}
+	return null;
+}
+function evaluateNode(node, tags) {
+	switch (node.type) {
+		case "tag":
+			if (node.pattern) {
+				return tags.some((tag) => node.pattern.test(tag));
+			}
+			return tags.includes(node.value);
+		case "not": return !evaluateNode(node.operand, tags);
+		case "and": return evaluateNode(node.left, tags) && evaluateNode(node.right, tags);
+		case "or": return evaluateNode(node.left, tags) || evaluateNode(node.right, tags);
+	}
+}
+
 function isTestCase(s) {
 	return s.type === "test";
 }
@@ -337,4 +578,4 @@ function createTaskName(names, separator = " > ") {
 	return names.filter((name) => name !== undefined).join(separator);
 }
 
-export { calculateSuiteHash as a, createFileTask as b, createChainable as c, generateHash as d, createTaskName as e, findTestFileStackTrace as f, generateFileHash as g, getFullName as h, interpretTaskModes as i, getNames as j, getSuites as k, limitConcurrency as l, getTasks as m, getTestName as n, getTests as o, partitionSuiteChildren as p, hasFailed as q, hasTests as r, someTasksAreOnly as s, isTestCase as t };
+export { calculateSuiteHash as a, createFileTask as b, createChainable as c, generateHash as d, createTagsFilter as e, findTestFileStackTrace as f, generateFileHash as g, createTaskName as h, interpretTaskModes as i, getFullName as j, getNames as k, limitConcurrency as l, getSuites as m, getTasks as n, getTestName as o, partitionSuiteChildren as p, getTests as q, hasFailed as r, someTasksAreOnly as s, hasTests as t, isTestCase as u, validateTags as v, createNoTagsError as w };

package/dist/index.d.ts

@@ -1,8 +1,6 @@
-import { b as TestArtifact, a as Test, S as Suite, d as SuiteHooks, F as File, e as TaskUpdateEvent, T as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-C7UxawJ9.js';
-export { A as AfterAllListener, n as AfterEachListener, B as BeforeAllListener, p as BeforeEachListener, q as Fixture, r as FixtureFn, s as FixtureOptions, t as Fixtures, I as ImportDuration, u as InferFixturesTypes, O as OnTestFailedHandler, v as OnTestFinishedHandler, R as RunMode, w as RuntimeContext, x as SequenceHooks, y as SequenceSetupFiles, z as SuiteFactory, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, V as TestArtifactBase, W as TestArtifactLocation, X as TestArtifactRegistry, Y as TestAttachment, Z as TestContext, _ as TestFunction, $ as TestOptions, a0 as Use, a1 as VisualRegressionArtifact, i as afterAll, j as afterEach, k as beforeAll, l as beforeEach, o as onTestFailed, m as onTestFinished } from './tasks.d-C7UxawJ9.js';
+import { T as TestArtifact, a as Test, S as Suite, b as SuiteHooks, F as FileSpecification, V as VitestRunner, c as File, d as TaskUpdateEvent, e as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-CLPU8HE4.js';
+export { A as AfterAllListener, s as AfterEachListener, B as BeforeAllListener, t as BeforeEachListener, C as CancelReason, u as Fixture, v as FixtureFn, w as FixtureOptions, x as Fixtures, I as ImportDuration, y as InferFixturesTypes, O as OnTestFailedHandler, z as OnTestFinishedHandler, R as Retry, D as RunMode, E as RuntimeContext, G as SequenceHooks, H as SequenceSetupFiles, J as SerializableRetry, K as SuiteFactory, L as TaskBase, M as TaskCustomOptions, N as TaskEventPack, P as TaskHook, Q as TaskMeta, U as TaskPopulated, W as TaskResult, X as TaskResultPack, Y as TaskState, Z as TestAnnotation, _ as TestAnnotationArtifact, $ as TestAnnotationLocation, a0 as TestArtifactBase, a1 as TestArtifactLocation, a2 as TestArtifactRegistry, a3 as TestAttachment, a4 as TestContext, a5 as TestFunction, a6 as TestOptions, n as TestTagDefinition, a7 as TestTags, a8 as Use, a9 as VisualRegressionArtifact, p as VitestRunnerConfig, q as VitestRunnerConstructor, r as VitestRunnerImportSource, i as afterAll, j as afterEach, k as beforeAll, l as beforeEach, o as onTestFailed, m as onTestFinished } from './tasks.d-CLPU8HE4.js';
 import { Awaitable } from '@vitest/utils';
-import { FileSpecification, VitestRunner } from './types.js';
-export { CancelReason, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource } from './types.js';
 import '@vitest/utils/diff';
 
 /**

package/dist/index.js

@@ -1,8 +1,8 @@
 import { processError } from '@vitest/utils/error';
-import { isObject, createDefer, assertTypes, toArray, isNegativeNaN, objectAttr, shuffle } from '@vitest/utils/helpers';
+import { isObject, filterOutComments, createDefer, assertTypes, toArray, isNegativeNaN, unique, objectAttr, shuffle } from '@vitest/utils/helpers';
 import { getSafeTimers } from '@vitest/utils/timers';
 import { format, formatRegExp, objDisplay } from '@vitest/utils/display';
-import { c as createChainable, e as createTaskName, f as findTestFileStackTrace, b as createFileTask, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, l as limitConcurrency, p as partitionSuiteChildren, r as hasTests, q as hasFailed } from './chunk-tasks.js';
+import { c as createChainable, v as validateTags, h as createTaskName, w as createNoTagsError, f as findTestFileStackTrace, e as createTagsFilter, b as createFileTask, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, l as limitConcurrency, p as partitionSuiteChildren, t as hasTests, r as hasFailed } from './chunk-tasks.js';
 import '@vitest/utils/source-map';
 import 'pathe';
 
@@ -311,31 +311,6 @@ function getUsedProps(fn) {
 	}
 	return props;
 }
-function filterOutComments(s) {
-	const result = [];
-	let commentState = "none";
-	for (let i = 0; i < s.length; ++i) {
-		if (commentState === "singleline") {
-			if (s[i] === "\n") {
-				commentState = "none";
-			}
-		} else if (commentState === "multiline") {
-			if (s[i - 1] === "*" && s[i] === "/") {
-				commentState = "none";
-			}
-		} else if (commentState === "none") {
-			if (s[i] === "/" && s[i + 1] === "/") {
-				commentState = "singleline";
-			} else if (s[i] === "/" && s[i + 1] === "*") {
-				commentState = "multiline";
-				i += 2;
-			} else {
-				result.push(s[i]);
-			}
-		}
-	}
-	return result.join("");
-}
 function splitByComma(s) {
 	const result = [];
 	const stack = [];
@@ -693,18 +668,22 @@ function getRunner() {
 }
 function createDefaultSuite(runner) {
 	const config = runner.config.sequence;
-	const collector = suite("", { concurrent: config.concurrent }, () => {});
+	const options = {};
+	if (config.concurrent != null) {
+		options.concurrent = config.concurrent;
+	}
+	const collector = suite("", options, () => {});
 	// no parent suite for top-level tests
 	delete collector.suite;
 	return collector;
 }
 function clearCollectorContext(file, currentRunner) {
+	currentTestFilepath = file.filepath;
+	runner = currentRunner;
 	if (!defaultSuite) {
 		defaultSuite = createDefaultSuite(currentRunner);
 	}
 	defaultSuite.file = file;
-	runner = currentRunner;
-	currentTestFilepath = file.filepath;
 	collectorContext.tasks.length = 0;
 	defaultSuite.clear();
 	collectorContext.currentSuite = defaultSuite;
@@ -722,6 +701,7 @@ function createSuiteHooks() {
 		afterEach: []
 	};
 }
+const POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
 function parseArguments(optionsOrFn, timeoutOrTest) {
 	if (timeoutOrTest != null && typeof timeoutOrTest === "object") {
 		throw new TypeError(`Signature "test(name, fn, { ... })" was deprecated in Vitest 3 and removed in Vitest 4. Please, provide options as a second argument instead.`);
@@ -753,27 +733,47 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 	let suite;
 	initSuite(true);
 	const task = function(name = "", options = {}) {
-		var _collectorContext$cur, _collectorContext$cur2, _collectorContext$cur3;
-		const timeout = (options === null || options === void 0 ? void 0 : options.timeout) ?? runner.config.testTimeout;
+		var _collectorContext$cur, _collectorContext$cur2, _collectorContext$cur3, _collectorContext$cur4;
 		const currentSuite = (_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.suite;
+		const parentTask = currentSuite ?? ((_collectorContext$cur2 = collectorContext.currentSuite) === null || _collectorContext$cur2 === void 0 ? void 0 : _collectorContext$cur2.file);
+		const parentTags = (parentTask === null || parentTask === void 0 ? void 0 : parentTask.tags) || [];
+		const testTags = unique([...parentTags, ...toArray(options.tags)]);
+		const tagsOptions = testTags.map((tag) => {
+			var _runner$config$tags;
+			const tagDefinition = (_runner$config$tags = runner.config.tags) === null || _runner$config$tags === void 0 ? void 0 : _runner$config$tags.find((t) => t.name === tag);
+			if (!tagDefinition && runner.config.strictTags) {
+				throw createNoTagsError(runner.config.tags, tag);
+			}
+			return tagDefinition;
+		}).filter((r) => r != null).sort((tag1, tag2) => (tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag) => {
+			const { name, description, priority, ...options } = tag;
+			Object.assign(acc, options);
+			return acc;
+		}, {});
+		options = {
+			...tagsOptions,
+			...options
+		};
+		const timeout = options.timeout ?? runner.config.testTimeout;
 		const task = {
 			id: "",
 			name,
-			fullName: createTaskName([(currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur2 = collectorContext.currentSuite) === null || _collectorContext$cur2 === void 0 || (_collectorContext$cur2 = _collectorContext$cur2.file) === null || _collectorContext$cur2 === void 0 ? void 0 : _collectorContext$cur2.fullName), name]),
+			fullName: createTaskName([(currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur3 = collectorContext.currentSuite) === null || _collectorContext$cur3 === void 0 || (_collectorContext$cur3 = _collectorContext$cur3.file) === null || _collectorContext$cur3 === void 0 ? void 0 : _collectorContext$cur3.fullName), name]),
 			fullTestName: createTaskName([currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName, name]),
 			suite: currentSuite,
 			each: options.each,
 			fails: options.fails,
 			context: undefined,
 			type: "test",
-			file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur3 = collectorContext.currentSuite) === null || _collectorContext$cur3 === void 0 ? void 0 : _collectorContext$cur3.file),
+			file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur4 = collectorContext.currentSuite) === null || _collectorContext$cur4 === void 0 ? void 0 : _collectorContext$cur4.file),
 			timeout,
 			retry: options.retry ?? runner.config.retry,
 			repeats: options.repeats,
 			mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
 			meta: options.meta ?? Object.create(null),
 			annotations: [],
-			artifacts: []
+			artifacts: [],
+			tags: testTags
 		};
 		const handler = options.handler;
 		if (task.mode === "run" && !handler) {
@@ -818,8 +818,14 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 			options = Object.assign({}, suiteOptions, options);
 		}
 		// inherit concurrent / sequential from suite
-		options.concurrent = this.concurrent || !this.sequential && (options === null || options === void 0 ? void 0 : options.concurrent);
-		options.sequential = this.sequential || !this.concurrent && (options === null || options === void 0 ? void 0 : options.sequential);
+		const concurrent = this.concurrent ?? (!this.sequential && (options === null || options === void 0 ? void 0 : options.concurrent));
+		if (options.concurrent != null && concurrent != null) {
+			options.concurrent = concurrent;
+		}
+		const sequential = this.sequential ?? (!this.concurrent && (options === null || options === void 0 ? void 0 : options.sequential));
+		if (options.sequential != null && sequential != null) {
+			options.sequential = sequential;
+		}
 		const test = task(formatName(name), {
 			...this,
 			...options,
@@ -854,25 +860,29 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		getHooks(suite)[name].push(...fn);
 	}
 	function initSuite(includeLocation) {
-		var _collectorContext$cur4, _collectorContext$cur5, _collectorContext$cur6;
+		var _collectorContext$cur5, _collectorContext$cur6, _collectorContext$cur7, _collectorContext$cur8;
 		if (typeof suiteOptions === "number") {
 			suiteOptions = { timeout: suiteOptions };
 		}
-		const currentSuite = (_collectorContext$cur4 = collectorContext.currentSuite) === null || _collectorContext$cur4 === void 0 ? void 0 : _collectorContext$cur4.suite;
+		const currentSuite = (_collectorContext$cur5 = collectorContext.currentSuite) === null || _collectorContext$cur5 === void 0 ? void 0 : _collectorContext$cur5.suite;
+		const parentTask = currentSuite ?? ((_collectorContext$cur6 = collectorContext.currentSuite) === null || _collectorContext$cur6 === void 0 ? void 0 : _collectorContext$cur6.file);
+		const suiteTags = toArray(suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.tags);
+		validateTags(runner.config, suiteTags);
 		suite = {
 			id: "",
 			type: "suite",
 			name,
-			fullName: createTaskName([(currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur5 = collectorContext.currentSuite) === null || _collectorContext$cur5 === void 0 || (_collectorContext$cur5 = _collectorContext$cur5.file) === null || _collectorContext$cur5 === void 0 ? void 0 : _collectorContext$cur5.fullName), name]),
+			fullName: createTaskName([(currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur7 = collectorContext.currentSuite) === null || _collectorContext$cur7 === void 0 || (_collectorContext$cur7 = _collectorContext$cur7.file) === null || _collectorContext$cur7 === void 0 ? void 0 : _collectorContext$cur7.fullName), name]),
 			fullTestName: createTaskName([currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName, name]),
 			suite: currentSuite,
 			mode,
 			each,
-			file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur6 = collectorContext.currentSuite) === null || _collectorContext$cur6 === void 0 ? void 0 : _collectorContext$cur6.file),
+			file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur8 = collectorContext.currentSuite) === null || _collectorContext$cur8 === void 0 ? void 0 : _collectorContext$cur8.file),
 			shuffle: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle,
 			tasks: [],
 			meta: Object.create(null),
-			concurrent: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.concurrent
+			concurrent: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.concurrent,
+			tags: unique([...(parentTask === null || parentTask === void 0 ? void 0 : parentTask.tags) || [], ...suiteTags])
 		};
 		if (runner && includeLocation && runner.config.includeTaskLocation) {
 			const limit = Error.stackTraceLimit;
@@ -930,25 +940,33 @@ function createSuite() {
 		if (getCurrentTest()) {
 			throw new Error("Calling the suite function inside test function is not allowed. It can be only called at the top level or inside another suite function.");
 		}
-		let mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
 		const currentSuite = collectorContext.currentSuite || defaultSuite;
 		let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
-		if (mode === "run" && !factory) {
-			mode = "todo";
-		}
 		const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
 		const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
 		// inherit options from current suite
 		options = {
 			...currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.options,
-			...options,
-			shuffle: this.shuffle ?? options.shuffle ?? (currentSuite === null || currentSuite === void 0 || (_currentSuite$options = currentSuite.options) === null || _currentSuite$options === void 0 ? void 0 : _currentSuite$options.shuffle) ?? (runner === null || runner === void 0 ? void 0 : runner.config.sequence.shuffle)
+			...options
 		};
+		const shuffle = this.shuffle ?? options.shuffle ?? (currentSuite === null || currentSuite === void 0 || (_currentSuite$options = currentSuite.options) === null || _currentSuite$options === void 0 ? void 0 : _currentSuite$options.shuffle) ?? (runner === null || runner === void 0 ? void 0 : runner.config.sequence.shuffle);
+		if (shuffle != null) {
+			options.shuffle = shuffle;
+		}
+		let mode = this.only ?? options.only ? "only" : this.skip ?? options.skip ? "skip" : this.todo ?? options.todo ? "todo" : "run";
+		// passed as test(name), assume it's a "todo"
+		if (mode === "run" && !factory) {
+			mode = "todo";
+		}
 		// inherit concurrent / sequential from suite
 		const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
 		const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
-		options.concurrent = isConcurrent && !isSequential;
-		options.sequential = isSequential && !isConcurrent;
+		if (isConcurrent != null) {
+			options.concurrent = isConcurrent && !isSequential;
+		}
+		if (isSequential != null) {
+			options.sequential = isSequential && !isConcurrent;
+		}
 		return createSuiteCollector(formatName(name), factory, mode, this.each, options, currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fixtures());
 	}
 	suiteFn.each = function(cases, ...args) {
@@ -1360,18 +1378,24 @@ async function collectTests(specs, runner) {
 	const files = [];
 	const config = runner.config;
 	const $ = runner.trace;
+	let defaultTagsFilter;
 	for (const spec of specs) {
 		const filepath = typeof spec === "string" ? spec : spec.filepath;
 		await $("collect_spec", { "code.file.path": filepath }, async () => {
-			var _runner$onCollectStar;
 			const testLocations = typeof spec === "string" ? undefined : spec.testLocations;
+			const testNamePattern = typeof spec === "string" ? undefined : spec.testNamePattern;
+			const testIds = typeof spec === "string" ? undefined : spec.testIds;
+			const testTagsFilter = typeof spec === "object" && spec.testTagsFilter ? createTagsFilter(spec.testTagsFilter, config.tags) : undefined;
+			const fileTags = typeof spec === "string" ? [] : spec.fileTags || [];
 			const file = createFileTask(filepath, config.root, config.name, runner.pool, runner.viteEnvironment);
 			setFileContext(file, Object.create(null));
+			file.tags = fileTags;
 			file.shuffle = config.sequence.shuffle;
-			(_runner$onCollectStar = runner.onCollectStart) === null || _runner$onCollectStar === void 0 ? void 0 : _runner$onCollectStar.call(runner, file);
-			clearCollectorContext(file, runner);
 			try {
-				var _runner$getImportDura;
+				var _runner$onCollectStar, _runner$getImportDura;
+				validateTags(runner.config, fileTags);
+				(_runner$onCollectStar = runner.onCollectStart) === null || _runner$onCollectStar === void 0 ? void 0 : _runner$onCollectStar.call(runner, file);
+				clearCollectorContext(file, runner);
 				const setupFiles = toArray(config.setupFiles);
 				if (setupFiles.length) {
 					const setupStart = now$1();
@@ -1420,7 +1444,10 @@ async function collectTests(specs, runner) {
 			}
 			calculateSuiteHash(file);
 			const hasOnlyTasks = someTasksAreOnly(file);
-			interpretTaskModes(file, config.testNamePattern, testLocations, hasOnlyTasks, false, config.allowOnly);
+			if (!testTagsFilter && !defaultTagsFilter && config.tagsFilter) {
+				defaultTagsFilter = createTagsFilter(config.tagsFilter, config.tags);
+			}
+			interpretTaskModes(file, testNamePattern ?? config.testNamePattern, testLocations, testIds, testTagsFilter ?? defaultTagsFilter, hasOnlyTasks, false, config.allowOnly);
 			if (file.mode === "queued") {
 				file.mode = "run";
 			}
@@ -1440,6 +1467,37 @@ function mergeHooks(baseHooks, hooks) {
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const unixNow = Date.now;
 const { clearTimeout, setTimeout } = getSafeTimers();
+/**
+* Normalizes retry configuration to extract individual values.
+* Handles both number and object forms.
+*/
+function getRetryCount(retry) {
+	if (retry === undefined) {
+		return 0;
+	}
+	if (typeof retry === "number") {
+		return retry;
+	}
+	return retry.count ?? 0;
+}
+function getRetryDelay(retry) {
+	if (retry === undefined) {
+		return 0;
+	}
+	if (typeof retry === "number") {
+		return 0;
+	}
+	return retry.delay ?? 0;
+}
+function getRetryCondition(retry) {
+	if (retry === undefined) {
+		return undefined;
+	}
+	if (typeof retry === "number") {
+		return undefined;
+	}
+	return retry.condition;
+}
 function updateSuiteHookState(task, name, state, runner) {
 	if (!task.result) {
 		task.result = { state: "run" };
@@ -1603,6 +1661,25 @@ async function callCleanupHooks(runner, cleanups) {
 		}
 	}
 }
+/**
+* Determines if a test should be retried based on its retryCondition configuration
+*/
+function passesRetryCondition(test, errors) {
+	const condition = getRetryCondition(test.retry);
+	if (!errors || errors.length === 0) {
+		return false;
+	}
+	if (!condition) {
+		return true;
+	}
+	const error = errors[errors.length - 1];
+	if (condition instanceof RegExp) {
+		return condition.test(error.message || "");
+	} else if (typeof condition === "function") {
+		return condition(error);
+	}
+	return false;
+}
 async function runTest(test, runner) {
 	var _runner$onBeforeRunTa, _test$result, _runner$onAfterRunTas;
 	await ((_runner$onBeforeRunTa = runner.onBeforeRunTask) === null || _runner$onBeforeRunTa === void 0 ? void 0 : _runner$onBeforeRunTa.call(runner, test));
@@ -1631,7 +1708,7 @@ async function runTest(test, runner) {
 	const $ = runner.trace;
 	const repeats = test.repeats ?? 0;
 	for (let repeatCount = 0; repeatCount <= repeats; repeatCount++) {
-		const retry = test.retry ?? 0;
+		const retry = getRetryCount(test.retry);
 		for (let retryCount = 0; retryCount <= retry; retryCount++) {
 			var _test$onFinished, _test$onFailed, _runner$onAfterRetryT, _test$result2, _test$result3;
 			let beforeEachCleanups = [];
@@ -1712,9 +1789,16 @@ async function runTest(test, runner) {
 				break;
 			}
 			if (retryCount < retry) {
-				// reset state when retry test
+				const shouldRetry = passesRetryCondition(test, test.result.errors);
+				if (!shouldRetry) {
+					break;
+				}
 				test.result.state = "run";
 				test.result.retryCount = (test.result.retryCount ?? 0) + 1;
+				const delay = getRetryDelay(test.retry);
+				if (delay > 0) {
+					await new Promise((resolve) => setTimeout(resolve, delay));
+				}
 			}
 			// update retry info
 			updateTask("test-retried", test, runner);

package/dist/{tasks.d-C7UxawJ9.d.ts → tasks.d-CLPU8HE4.d.ts}

@@ -1,5 +1,205 @@
+import { DiffOptions } from '@vitest/utils/diff';
 import { TestError, Awaitable } from '@vitest/utils';
 
+/**
+* This is a subset of Vitest config that's required for the runner to work.
+*/
+interface VitestRunnerConfig {
+	root: string;
+	setupFiles: string[];
+	name?: string;
+	passWithNoTests: boolean;
+	testNamePattern?: RegExp;
+	allowOnly?: boolean;
+	sequence: {
+		shuffle?: boolean;
+		concurrent?: boolean;
+		seed: number;
+		hooks: SequenceHooks;
+		setupFiles: SequenceSetupFiles;
+	};
+	chaiConfig?: {
+		truncateThreshold?: number;
+	};
+	maxConcurrency: number;
+	testTimeout: number;
+	hookTimeout: number;
+	retry: SerializableRetry;
+	includeTaskLocation?: boolean;
+	diffOptions?: DiffOptions;
+	tags: TestTagDefinition[];
+	tagsFilter?: string[];
+	strictTags: boolean;
+}
+/**
+* Possible options to run a single file in a test.
+*/
+interface FileSpecification {
+	filepath: string;
+	fileTags?: string[];
+	testLocations: number[] | undefined;
+	testNamePattern: RegExp | undefined;
+	testTagsFilter: string[] | undefined;
+	testIds: string[] | undefined;
+}
+interface TestTagDefinition extends Omit<TestOptions, "tags" | "shuffle"> {
+	/**
+	* The name of the tag. This is what you use in the `tags` array in tests.
+	*/
+	name: keyof TestTags extends never ? string : TestTags[keyof TestTags];
+	/**
+	* A description for the tag. This will be shown in the CLI help and UI.
+	*/
+	description?: string;
+	/**
+	* Priority for merging options when multiple tags with the same options are applied to a test.
+	*
+	* Lower number means higher priority. E.g., priority 1 takes precedence over priority 3.
+	*/
+	priority?: number;
+}
+type VitestRunnerImportSource = "collect" | "setup";
+interface VitestRunnerConstructor {
+	new (config: VitestRunnerConfig): VitestRunner;
+}
+type CancelReason = "keyboard-input" | "test-failure" | (string & Record<string, never>);
+interface VitestRunner {
+	/**
+	* First thing that's getting called before actually collecting and running tests.
+	*/
+	onBeforeCollect?: (paths: string[]) => unknown;
+	/**
+	* Called after the file task was created but not collected yet.
+	*/
+	onCollectStart?: (file: File) => unknown;
+	/**
+	* Called after collecting tests and before "onBeforeRun".
+	*/
+	onCollected?: (files: File[]) => unknown;
+	/**
+	* Called when test runner should cancel next test runs.
+	* Runner should listen for this method and mark tests and suites as skipped in
+	* "onBeforeRunSuite" and "onBeforeRunTask" when called.
+	*/
+	cancel?: (reason: CancelReason) => unknown;
+	/**
+	* Called before running a single test. Doesn't have "result" yet.
+	*/
+	onBeforeRunTask?: (test: Test) => unknown;
+	/**
+	* Called before actually running the test function. Already has "result" with "state" and "startTime".
+	*/
+	onBeforeTryTask?: (test: Test, options: {
+		retry: number;
+		repeats: number;
+	}) => unknown;
+	/**
+	* When the task has finished running, but before cleanup hooks are called
+	*/
+	onTaskFinished?: (test: Test) => unknown;
+	/**
+	* Called after result and state are set.
+	*/
+	onAfterRunTask?: (test: Test) => unknown;
+	/**
+	* Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
+	*/
+	onAfterTryTask?: (test: Test, options: {
+		retry: number;
+		repeats: number;
+	}) => unknown;
+	/**
+	* Called after the retry resolution happend. Unlike `onAfterTryTask`, the test now has a new state.
+	* All `after` hooks were also called by this point.
+	*/
+	onAfterRetryTask?: (test: Test, options: {
+		retry: number;
+		repeats: number;
+	}) => unknown;
+	/**
+	* Called before running a single suite. Doesn't have "result" yet.
+	*/
+	onBeforeRunSuite?: (suite: Suite) => unknown;
+	/**
+	* Called after running a single suite. Has state and result.
+	*/
+	onAfterRunSuite?: (suite: Suite) => unknown;
+	/**
+	* If defined, will be called instead of usual Vitest suite partition and handling.
+	* "before" and "after" hooks will not be ignored.
+	*/
+	runSuite?: (suite: Suite) => Promise<void>;
+	/**
+	* If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
+	* "before" and "after" hooks will not be ignored.
+	*/
+	runTask?: (test: Test) => Promise<void>;
+	/**
+	* Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
+	*/
+	onTaskUpdate?: (task: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	/**
+	* Called when annotation is added via the `context.annotate` method.
+	*/
+	onTestAnnotate?: (test: Test, annotation: TestAnnotation) => Promise<TestAnnotation>;
+	/**
+	* @experimental
+	*
+	* Called when artifacts are recorded on tests via the `recordArtifact` utility.
+	*/
+	onTestArtifactRecord?: <Artifact extends TestArtifact>(test: Test, artifact: Artifact) => Promise<Artifact>;
+	/**
+	* Called before running all tests in collected paths.
+	*/
+	onBeforeRunFiles?: (files: File[]) => unknown;
+	/**
+	* Called right after running all tests in collected paths.
+	*/
+	onAfterRunFiles?: (files: File[]) => unknown;
+	/**
+	* Called when new context for a test is defined. Useful if you want to add custom properties to the context.
+	* If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
+	*
+	* @see https://vitest.dev/advanced/runner#your-task-function
+	*/
+	extendTaskContext?: (context: TestContext) => TestContext;
+	/**
+	* Called when test and setup files are imported. Can be called in two situations: when collecting tests and when importing setup files.
+	*/
+	importFile: (filepath: string, source: VitestRunnerImportSource) => unknown;
+	/**
+	* Function that is called when the runner attempts to get the value when `test.extend` is used with `{ injected: true }`
+	*/
+	injectValue?: (key: string) => unknown;
+	/**
+	* Gets the time spent importing each individual non-externalized file that Vitest collected.
+	*/
+	getImportDurations?: () => Record<string, ImportDuration>;
+	/**
+	* Publicly available configuration.
+	*/
+	config: VitestRunnerConfig;
+	/**
+	* The name of the current pool. Can affect how stack trace is inferred on the server side.
+	*/
+	pool?: string;
+	/**
+	* The current Vite environment that processes the files on the server.
+	*/
+	viteEnvironment?: string;
+	/**
+	* Return the worker context for fixtures specified with `scope: 'worker'`
+	*/
+	getWorkerContext?: () => Record<string, unknown>;
+	onCleanupWorkerContext?: (cleanup: () => unknown) => void;
+	trace?<T>(name: string, cb: () => T): T;
+	trace?<T>(name: string, attributes: Record<string, any>, cb: () => T): T;
+	/** @private */
+	_currentTaskStartTime?: number;
+	/** @private */
+	_currentTaskTimeout?: number;
+}
+
 interface FixtureItem extends FixtureOptions {
 	prop: string;
 	value: any;
@@ -226,10 +426,12 @@ interface TaskBase {
 	*/
 	result?: TaskResult;
 	/**
-	* The amount of times the task should be retried if it fails.
+	* Retry configuration for the task.
+	* - If a number, specifies how many times to retry
+	* - If an object, allows fine-grained retry control
 	* @default 0
 	*/
-	retry?: number;
+	retry?: Retry;
 	/**
 	* The amount of times the task should be repeated after the successful run.
 	* If the task fails, it will not be retried unless `retry` is specified.
@@ -251,6 +453,10 @@ interface TaskBase {
 	* @experimental
 	*/
 	dynamic?: boolean;
+	/**
+	* Custom tags of the task. Useful for filtering tasks.
+	*/
+	tags?: string[];
 }
 interface TaskPopulated extends TaskBase {
 	/**
@@ -448,18 +654,68 @@ type ChainableTestAPI<ExtraContext = object> = ChainableFunction<"concurrent" |
 	for: TestForFunction<ExtraContext>;
 }>;
 type TestCollectorOptions = Omit<TestOptions, "shuffle">;
+/**
+* Retry configuration for tests.
+* Can be a number for simple retry count, or an object for advanced retry control.
+*/
+type Retry = number | {
+	/**
+	* The number of times to retry the test if it fails.
+	* @default 0
+	*/
+	count?: number;
+	/**
+	* Delay in milliseconds between retry attempts.
+	* @default 0
+	*/
+	delay?: number;
+	/**
+	* Condition to determine if a test should be retried based on the error.
+	* - If a RegExp, it is tested against the error message
+	* - If a function, called with the TestError object; return true to retry
+	*
+	* NOTE: Functions can only be used in test files, not in vitest.config.ts,
+	* because the configuration is serialized when passed to worker threads.
+	*
+	* @default undefined (retry on all errors)
+	*/
+	condition?: RegExp | ((error: TestError) => boolean);
+};
+/**
+* Serializable retry configuration (used in config files).
+* Functions cannot be serialized, so only string conditions are allowed.
+*/
+type SerializableRetry = number | {
+	/**
+	* The number of times to retry the test if it fails.
+	* @default 0
+	*/
+	count?: number;
+	/**
+	* Delay in milliseconds between retry attempts.
+	* @default 0
+	*/
+	delay?: number;
+	/**
+	* Condition to determine if a test should be retried based on the error.
+	* Must be a RegExp tested against the error message.
+	*
+	* @default undefined (retry on all errors)
+	*/
+	condition?: RegExp;
+};
 interface TestOptions {
 	/**
 	* Test timeout.
 	*/
 	timeout?: number;
 	/**
-	* Times to retry the test if fails. Useful for making flaky tests more stable.
-	* When retries is up, the last test error will be thrown.
-	*
+	* Retry configuration for the test.
+	* - If a number, specifies how many times to retry
+	* - If an object, allows fine-grained retry control
 	* @default 0
 	*/
-	retry?: number;
+	retry?: Retry;
 	/**
 	* How many times the test will run again.
 	* Only inner tests will repeat if set on `describe()`, nested `describe()` will inherit parent's repeat by default.
@@ -478,10 +734,6 @@ interface TestOptions {
 	*/
 	sequential?: boolean;
 	/**
-	* Whether the tasks of the suite run in a random order.
-	*/
-	shuffle?: boolean;
-	/**
 	* Whether the test should be skipped.
 	*/
 	skip?: boolean;
@@ -497,6 +749,17 @@ interface TestOptions {
 	* Whether the test is expected to fail. If it does, the test will pass, otherwise it will fail.
 	*/
 	fails?: boolean;
+	/**
+	* Custom tags of the test. Useful for filtering tests.
+	*/
+	tags?: keyof TestTags extends never ? string[] | string : TestTags[keyof TestTags] | TestTags[keyof TestTags][];
+}
+interface TestTags {}
+interface SuiteOptions extends TestOptions {
+	/**
+	* Whether the tasks of the suite run in a random order.
+	*/
+	shuffle?: boolean;
 }
 interface ExtendedAPI<ExtraContext> {
 	skipIf: (condition: any) => ChainableTestAPI<ExtraContext>;
@@ -551,7 +814,7 @@ type Fixtures<
 type InferFixturesTypes<T> = T extends TestAPI<infer C> ? C : T;
 interface SuiteCollectorCallable<ExtraContext = object> {
 	<OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, fn?: SuiteFactory<OverrideExtraContext>, options?: number): SuiteCollector<OverrideExtraContext>;
-	<OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, options: TestOptions, fn?: SuiteFactory<OverrideExtraContext>): SuiteCollector<OverrideExtraContext>;
+	<OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, options: SuiteOptions, fn?: SuiteFactory<OverrideExtraContext>): SuiteCollector<OverrideExtraContext>;
 }
 type ChainableSuiteAPI<ExtraContext = object> = ChainableFunction<"concurrent" | "sequential" | "only" | "skip" | "todo" | "shuffle", SuiteCollectorCallable<ExtraContext>, {
 	each: TestEachFunction;
@@ -602,7 +865,7 @@ interface TaskCustomOptions extends TestOptions {
 interface SuiteCollector<ExtraContext = object> {
 	readonly name: string;
 	readonly mode: RunMode;
-	options?: TestOptions;
+	options?: SuiteOptions;
 	type: "collector";
 	test: TestAPI<ExtraContext>;
 	tasks: (Suite | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
@@ -830,5 +1093,5 @@ interface TestArtifactRegistry {}
 */
 type TestArtifact = TestAnnotationArtifact | VisualRegressionArtifact | TestArtifactRegistry[keyof TestArtifactRegistry];
 
-export { createChainable as c, afterAll as i, afterEach as j, beforeAll as k, beforeEach as l, onTestFinished as m, onTestFailed as o };
-export type { TestOptions as $, AfterAllListener as A, BeforeAllListener as B, ChainableFunction as C, TaskBase as D, TaskCustomOptions as E, File as F, TaskEventPack as G, TaskHook as H, ImportDuration as I, TaskMeta as J, TaskPopulated as K, TaskResult as L, TaskResultPack as M, TaskState as N, OnTestFailedHandler as O, TestAnnotation as P, TestAnnotationArtifact as Q, RunMode as R, Suite as S, Task as T, TestAnnotationLocation as U, TestArtifactBase as V, TestArtifactLocation as W, TestArtifactRegistry as X, TestAttachment as Y, TestContext as Z, TestFunction as _, Test as a, Use as a0, VisualRegressionArtifact as a1, TestArtifact as b, SuiteHooks as d, TaskUpdateEvent as e, TestAPI as f, SuiteAPI as g, SuiteCollector as h, AfterEachListener as n, BeforeEachListener as p, Fixture as q, FixtureFn as r, FixtureOptions as s, Fixtures as t, InferFixturesTypes as u, OnTestFinishedHandler as v, RuntimeContext as w, SequenceHooks as x, SequenceSetupFiles as y, SuiteFactory as z };
+export { createChainable as ab, afterAll as i, afterEach as j, beforeAll as k, beforeEach as l, onTestFinished as m, onTestFailed as o };
+export type { TestAnnotationLocation as $, AfterAllListener as A, BeforeAllListener as B, CancelReason as C, RunMode as D, RuntimeContext as E, FileSpecification as F, SequenceHooks as G, SequenceSetupFiles as H, ImportDuration as I, SerializableRetry as J, SuiteFactory as K, TaskBase as L, TaskCustomOptions as M, TaskEventPack as N, OnTestFailedHandler as O, TaskHook as P, TaskMeta as Q, Retry as R, Suite as S, TestArtifact as T, TaskPopulated as U, VitestRunner as V, TaskResult as W, TaskResultPack as X, TaskState as Y, TestAnnotation as Z, TestAnnotationArtifact as _, Test as a, TestArtifactBase as a0, TestArtifactLocation as a1, TestArtifactRegistry as a2, TestAttachment as a3, TestContext as a4, TestFunction as a5, TestOptions as a6, TestTags as a7, Use as a8, VisualRegressionArtifact as a9, ChainableFunction as aa, SuiteHooks as b, File as c, TaskUpdateEvent as d, Task as e, TestAPI as f, SuiteAPI as g, SuiteCollector as h, TestTagDefinition as n, VitestRunnerConfig as p, VitestRunnerConstructor as q, VitestRunnerImportSource as r, AfterEachListener as s, BeforeEachListener as t, Fixture as u, FixtureFn as v, FixtureOptions as w, Fixtures as x, InferFixturesTypes as y, OnTestFinishedHandler as z };

package/dist/types.d.ts

@@ -1,183 +1,3 @@
-import { DiffOptions } from '@vitest/utils/diff';
-import { F as File, a as Test, S as Suite, M as TaskResultPack, G as TaskEventPack, P as TestAnnotation, b as TestArtifact, Z as TestContext, I as ImportDuration, x as SequenceHooks, y as SequenceSetupFiles } from './tasks.d-C7UxawJ9.js';
-export { A as AfterAllListener, n as AfterEachListener, B as BeforeAllListener, p as BeforeEachListener, q as Fixture, r as FixtureFn, s as FixtureOptions, t as Fixtures, u as InferFixturesTypes, O as OnTestFailedHandler, v as OnTestFinishedHandler, R as RunMode, w as RuntimeContext, g as SuiteAPI, h as SuiteCollector, z as SuiteFactory, d as SuiteHooks, T as Task, D as TaskBase, E as TaskCustomOptions, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, N as TaskState, e as TaskUpdateEvent, f as TestAPI, Q as TestAnnotationArtifact, U as TestAnnotationLocation, V as TestArtifactBase, W as TestArtifactLocation, X as TestArtifactRegistry, Y as TestAttachment, _ as TestFunction, $ as TestOptions, a0 as Use, a1 as VisualRegressionArtifact } from './tasks.d-C7UxawJ9.js';
+export { A as AfterAllListener, s as AfterEachListener, B as BeforeAllListener, t as BeforeEachListener, C as CancelReason, c as File, F as FileSpecification, u as Fixture, v as FixtureFn, w as FixtureOptions, x as Fixtures, I as ImportDuration, y as InferFixturesTypes, O as OnTestFailedHandler, z as OnTestFinishedHandler, R as Retry, D as RunMode, E as RuntimeContext, G as SequenceHooks, H as SequenceSetupFiles, J as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, K as SuiteFactory, b as SuiteHooks, e as Task, L as TaskBase, M as TaskCustomOptions, N as TaskEventPack, P as TaskHook, Q as TaskMeta, U as TaskPopulated, W as TaskResult, X as TaskResultPack, Y as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, Z as TestAnnotation, _ as TestAnnotationArtifact, $ as TestAnnotationLocation, T as TestArtifact, a0 as TestArtifactBase, a1 as TestArtifactLocation, a2 as TestArtifactRegistry, a3 as TestAttachment, a4 as TestContext, a5 as TestFunction, a6 as TestOptions, n as TestTagDefinition, a7 as TestTags, a8 as Use, a9 as VisualRegressionArtifact, V as VitestRunner, p as VitestRunnerConfig, q as VitestRunnerConstructor, r as VitestRunnerImportSource } from './tasks.d-CLPU8HE4.js';
+import '@vitest/utils/diff';
 import '@vitest/utils';
-
-/**
-* This is a subset of Vitest config that's required for the runner to work.
-*/
-interface VitestRunnerConfig {
-	root: string;
-	setupFiles: string[];
-	name?: string;
-	passWithNoTests: boolean;
-	testNamePattern?: RegExp;
-	allowOnly?: boolean;
-	sequence: {
-		shuffle?: boolean;
-		concurrent?: boolean;
-		seed: number;
-		hooks: SequenceHooks;
-		setupFiles: SequenceSetupFiles;
-	};
-	chaiConfig?: {
-		truncateThreshold?: number;
-	};
-	maxConcurrency: number;
-	testTimeout: number;
-	hookTimeout: number;
-	retry: number;
-	includeTaskLocation?: boolean;
-	diffOptions?: DiffOptions;
-}
-/**
-* Possible options to run a single file in a test.
-*/
-interface FileSpecification {
-	filepath: string;
-	testLocations: number[] | undefined;
-}
-type VitestRunnerImportSource = "collect" | "setup";
-interface VitestRunnerConstructor {
-	new (config: VitestRunnerConfig): VitestRunner;
-}
-type CancelReason = "keyboard-input" | "test-failure" | (string & Record<string, never>);
-interface VitestRunner {
-	/**
-	* First thing that's getting called before actually collecting and running tests.
-	*/
-	onBeforeCollect?: (paths: string[]) => unknown;
-	/**
-	* Called after the file task was created but not collected yet.
-	*/
-	onCollectStart?: (file: File) => unknown;
-	/**
-	* Called after collecting tests and before "onBeforeRun".
-	*/
-	onCollected?: (files: File[]) => unknown;
-	/**
-	* Called when test runner should cancel next test runs.
-	* Runner should listen for this method and mark tests and suites as skipped in
-	* "onBeforeRunSuite" and "onBeforeRunTask" when called.
-	*/
-	cancel?: (reason: CancelReason) => unknown;
-	/**
-	* Called before running a single test. Doesn't have "result" yet.
-	*/
-	onBeforeRunTask?: (test: Test) => unknown;
-	/**
-	* Called before actually running the test function. Already has "result" with "state" and "startTime".
-	*/
-	onBeforeTryTask?: (test: Test, options: {
-		retry: number;
-		repeats: number;
-	}) => unknown;
-	/**
-	* When the task has finished running, but before cleanup hooks are called
-	*/
-	onTaskFinished?: (test: Test) => unknown;
-	/**
-	* Called after result and state are set.
-	*/
-	onAfterRunTask?: (test: Test) => unknown;
-	/**
-	* Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
-	*/
-	onAfterTryTask?: (test: Test, options: {
-		retry: number;
-		repeats: number;
-	}) => unknown;
-	/**
-	* Called after the retry resolution happend. Unlike `onAfterTryTask`, the test now has a new state.
-	* All `after` hooks were also called by this point.
-	*/
-	onAfterRetryTask?: (test: Test, options: {
-		retry: number;
-		repeats: number;
-	}) => unknown;
-	/**
-	* Called before running a single suite. Doesn't have "result" yet.
-	*/
-	onBeforeRunSuite?: (suite: Suite) => unknown;
-	/**
-	* Called after running a single suite. Has state and result.
-	*/
-	onAfterRunSuite?: (suite: Suite) => unknown;
-	/**
-	* If defined, will be called instead of usual Vitest suite partition and handling.
-	* "before" and "after" hooks will not be ignored.
-	*/
-	runSuite?: (suite: Suite) => Promise<void>;
-	/**
-	* If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
-	* "before" and "after" hooks will not be ignored.
-	*/
-	runTask?: (test: Test) => Promise<void>;
-	/**
-	* Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
-	*/
-	onTaskUpdate?: (task: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
-	/**
-	* Called when annotation is added via the `context.annotate` method.
-	*/
-	onTestAnnotate?: (test: Test, annotation: TestAnnotation) => Promise<TestAnnotation>;
-	/**
-	* @experimental
-	*
-	* Called when artifacts are recorded on tests via the `recordArtifact` utility.
-	*/
-	onTestArtifactRecord?: <Artifact extends TestArtifact>(test: Test, artifact: Artifact) => Promise<Artifact>;
-	/**
-	* Called before running all tests in collected paths.
-	*/
-	onBeforeRunFiles?: (files: File[]) => unknown;
-	/**
-	* Called right after running all tests in collected paths.
-	*/
-	onAfterRunFiles?: (files: File[]) => unknown;
-	/**
-	* Called when new context for a test is defined. Useful if you want to add custom properties to the context.
-	* If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
-	*
-	* @see https://vitest.dev/advanced/runner#your-task-function
-	*/
-	extendTaskContext?: (context: TestContext) => TestContext;
-	/**
-	* Called when test and setup files are imported. Can be called in two situations: when collecting tests and when importing setup files.
-	*/
-	importFile: (filepath: string, source: VitestRunnerImportSource) => unknown;
-	/**
-	* Function that is called when the runner attempts to get the value when `test.extend` is used with `{ injected: true }`
-	*/
-	injectValue?: (key: string) => unknown;
-	/**
-	* Gets the time spent importing each individual non-externalized file that Vitest collected.
-	*/
-	getImportDurations?: () => Record<string, ImportDuration>;
-	/**
-	* Publicly available configuration.
-	*/
-	config: VitestRunnerConfig;
-	/**
-	* The name of the current pool. Can affect how stack trace is inferred on the server side.
-	*/
-	pool?: string;
-	/**
-	* The current Vite environment that processes the files on the server.
-	*/
-	viteEnvironment?: string;
-	/**
-	* Return the worker context for fixtures specified with `scope: 'worker'`
-	*/
-	getWorkerContext?: () => Record<string, unknown>;
-	onCleanupWorkerContext?: (cleanup: () => unknown) => void;
-	trace?<T>(name: string, cb: () => T): T;
-	trace?<T>(name: string, attributes: Record<string, any>, cb: () => T): T;
-	/** @private */
-	_currentTaskStartTime?: number;
-	/** @private */
-	_currentTaskTimeout?: number;
-}
-
-export { File, ImportDuration, SequenceHooks, SequenceSetupFiles, Suite, TaskEventPack, TaskResultPack, Test, TestAnnotation, TestArtifact, TestContext };
-export type { CancelReason, FileSpecification, VitestRunner, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,11 +1,12 @@
-import { S as Suite, F as File, T as Task, a as Test } from './tasks.d-C7UxawJ9.js';
-export { C as ChainableFunction, c as createChainable } from './tasks.d-C7UxawJ9.js';
+import { S as Suite, c as File, e as Task, n as TestTagDefinition, p as VitestRunnerConfig, a as Test } from './tasks.d-CLPU8HE4.js';
+export { aa as ChainableFunction, ab as createChainable } from './tasks.d-CLPU8HE4.js';
 import { ParsedStack, Arrayable } from '@vitest/utils';
+import '@vitest/utils/diff';
 
 /**
 * If any tasks been marked as `only`, mark all other tasks as `skip`.
 */
-declare function interpretTaskModes(file: Suite, namePattern?: string | RegExp, testLocations?: number[] | undefined, onlyMode?: boolean, parentIsOnly?: boolean, allowOnly?: boolean): void;
+declare function interpretTaskModes(file: Suite, namePattern?: string | RegExp, testLocations?: number[] | undefined, testIds?: string[] | undefined, testTagsFilter?: ((testTags: string[]) => boolean) | undefined, onlyMode?: boolean, parentIsOnly?: boolean, allowOnly?: boolean): void;
 declare function someTasksAreOnly(suite: Suite): boolean;
 declare function generateHash(str: string): string;
 declare function calculateSuiteHash(parent: Suite): void;
@@ -31,6 +32,9 @@ declare function limitConcurrency(concurrency?: number): <
 */
 declare function partitionSuiteChildren(suite: Suite): Task[][];
 
+declare function validateTags(config: VitestRunnerConfig, tags: string[]): void;
+declare function createTagsFilter(tagsExpr: string[], availableTags: TestTagDefinition[]): (testTags: string[]) => boolean;
+
 declare function isTestCase(s: Task): s is Test;
 declare function getTests(suite: Arrayable<Task>): Test[];
 declare function getTasks(tasks?: Arrayable<Task>): Task[];
@@ -42,4 +46,4 @@ declare function getFullName(task: Task, separator?: string): string;
 declare function getTestName(task: Task, separator?: string): string;
 declare function createTaskName(names: readonly (string | undefined)[], separator?: string): string;
 
-export { calculateSuiteHash, createFileTask, createTaskName, findTestFileStackTrace, generateFileHash, generateHash, getFullName, getNames, getSuites, getTasks, getTestName, getTests, hasFailed, hasTests, interpretTaskModes, isTestCase, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };
+export { calculateSuiteHash, createFileTask, createTagsFilter, createTaskName, findTestFileStackTrace, generateFileHash, generateHash, getFullName, getNames, getSuites, getTasks, getTestName, getTests, hasFailed, hasTests, interpretTaskModes, isTestCase, limitConcurrency, partitionSuiteChildren, someTasksAreOnly, validateTags };

package/dist/utils.js

@@ -1,4 +1,4 @@
-export { a as calculateSuiteHash, c as createChainable, b as createFileTask, e as createTaskName, f as findTestFileStackTrace, g as generateFileHash, d as generateHash, h as getFullName, j as getNames, k as getSuites, m as getTasks, n as getTestName, o as getTests, q as hasFailed, r as hasTests, i as interpretTaskModes, t as isTestCase, l as limitConcurrency, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
+export { a as calculateSuiteHash, c as createChainable, b as createFileTask, e as createTagsFilter, h as createTaskName, f as findTestFileStackTrace, g as generateFileHash, d as generateHash, j as getFullName, k as getNames, m as getSuites, n as getTasks, o as getTestName, q as getTests, r as hasFailed, t as hasTests, i as interpretTaskModes, u as isTestCase, l as limitConcurrency, p as partitionSuiteChildren, s as someTasksAreOnly, v as validateTags } from './chunk-tasks.js';
 import '@vitest/utils/error';
 import '@vitest/utils/source-map';
 import 'pathe';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "4.0.17",
+  "version": "4.1.0-beta.2",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "pathe": "^2.0.3",
-    "@vitest/utils": "4.0.17"
+    "@vitest/utils": "4.1.0-beta.2"
   },
   "scripts": {
     "build": "premove dist && rollup -c",