@vitest/runner 4.1.0-beta.1 → 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, testIds, 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";
@@ -80,6 +80,9 @@ function interpretTaskModes(file, namePattern, testLocations, testIds, onlyMode,
 				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);
@@ -277,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";
 }
@@ -340,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-hZ73xajr.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 Retry, w as RunMode, x as RuntimeContext, y as SequenceHooks, z as SequenceSetupFiles, D as SerializableRetry, E as SuiteFactory, G as TaskBase, H as TaskCustomOptions, J as TaskEventPack, K as TaskHook, L as TaskMeta, M as TaskPopulated, N as TaskResult, P as TaskResultPack, Q as TaskState, U as TestAnnotation, V as TestAnnotationArtifact, W as TestAnnotationLocation, X as TestArtifactBase, Y as TestArtifactLocation, Z as TestArtifactRegistry, _ as TestAttachment, $ as TestContext, a0 as TestFunction, a1 as TestOptions, a2 as Use, a3 as VisualRegressionArtifact, i as afterAll, j as afterEach, k as beforeAll, l as beforeEach, o as onTestFailed, m as onTestFinished } from './tasks.d-hZ73xajr.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,20 +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();
@@ -1422,7 +1444,10 @@ async function collectTests(specs, runner) {
 			}
 			calculateSuiteHash(file);
 			const hasOnlyTasks = someTasksAreOnly(file);
-			interpretTaskModes(file, testNamePattern ?? config.testNamePattern, testLocations, testIds, 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";
 			}

package/dist/{tasks.d-hZ73xajr.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;
@@ -253,6 +453,10 @@ interface TaskBase {
 	* @experimental
 	*/
 	dynamic?: boolean;
+	/**
+	* Custom tags of the task. Useful for filtering tasks.
+	*/
+	tags?: string[];
 }
 interface TaskPopulated extends TaskBase {
 	/**
@@ -530,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;
@@ -549,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>;
@@ -603,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;
@@ -654,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>)[];
@@ -882,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 { TestContext as $, AfterAllListener as A, BeforeAllListener as B, ChainableFunction as C, SerializableRetry as D, SuiteFactory as E, File as F, TaskBase as G, TaskCustomOptions as H, ImportDuration as I, TaskEventPack as J, TaskHook as K, TaskMeta as L, TaskPopulated as M, TaskResult as N, OnTestFailedHandler as O, TaskResultPack as P, TaskState as Q, Retry as R, Suite as S, Task as T, TestAnnotation as U, TestAnnotationArtifact as V, TestAnnotationLocation as W, TestArtifactBase as X, TestArtifactLocation as Y, TestArtifactRegistry as Z, TestAttachment as _, Test as a, TestFunction as a0, TestOptions as a1, Use as a2, VisualRegressionArtifact as a3, 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, RunMode as w, RuntimeContext as x, SequenceHooks as y, SequenceSetupFiles 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,185 +1,3 @@
-import { DiffOptions } from '@vitest/utils/diff';
-import { F as File, a as Test, S as Suite, P as TaskResultPack, J as TaskEventPack, U as TestAnnotation, b as TestArtifact, $ as TestContext, I as ImportDuration, y as SequenceHooks, z as SequenceSetupFiles, D as SerializableRetry } from './tasks.d-hZ73xajr.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 Retry, w as RunMode, x as RuntimeContext, g as SuiteAPI, h as SuiteCollector, E as SuiteFactory, d as SuiteHooks, T as Task, G as TaskBase, H as TaskCustomOptions, K as TaskHook, L as TaskMeta, M as TaskPopulated, N as TaskResult, Q as TaskState, e as TaskUpdateEvent, f as TestAPI, V as TestAnnotationArtifact, W as TestAnnotationLocation, X as TestArtifactBase, Y as TestArtifactLocation, Z as TestArtifactRegistry, _ as TestAttachment, a0 as TestFunction, a1 as TestOptions, a2 as Use, a3 as VisualRegressionArtifact } from './tasks.d-hZ73xajr.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: SerializableRetry;
-	includeTaskLocation?: boolean;
-	diffOptions?: DiffOptions;
-}
-/**
-* Possible options to run a single file in a test.
-*/
-interface FileSpecification {
-	filepath: string;
-	testLocations: number[] | undefined;
-	testNamePattern: RegExp | undefined;
-	testIds: string[] | 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, SerializableRetry, 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-hZ73xajr.js';
-export { C as ChainableFunction, c as createChainable } from './tasks.d-hZ73xajr.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, testIds?: string[] | 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.1.0-beta.1",
+  "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.1.0-beta.1"
+    "@vitest/utils": "4.1.0-beta.2"
   },
   "scripts": {
     "build": "premove dist && rollup -c",