vitest 4.0.17 → 4.1.0-beta.2

package/dist/chunks/{cli-api.Cx2DW4Bc.js → cli-api.ChbI1JU9.js}

@@ -2,20 +2,20 @@ import fs, { promises, existsSync, mkdirSync, readFileSync, statSync, readdirSyn
 import { relative, resolve, dirname, join, extname, normalize, basename, isAbsolute } from 'pathe';
 import { C as CoverageProviderMap } from './coverage.D_JHT54q.js';
 import path, { resolve as resolve$1 } from 'node:path';
-import { noop, createDefer, slash, withTrailingSlash, cleanUrl, wrapId, isExternalUrl, unwrapId, toArray, deepMerge, nanoid, deepClone, isPrimitive, notNullish } from '@vitest/utils/helpers';
+import { cleanUrl, noop, unique, createDefer, slash, withTrailingSlash, wrapId, isExternalUrl, unwrapId, toArray, deepMerge, nanoid, deepClone, isPrimitive, notNullish } from '@vitest/utils/helpers';
 import { a as any, p as prompt } from './index.D4KonVSU.js';
-import { h as hash, R as RandomSequencer, i as isPackageExists, c as isBrowserEnabled, r as resolveConfig, g as getCoverageProvider, a as resolveApiServerConfig, d as resolveModule } from './coverage.AVPTjMgw.js';
+import { i as isPackageExists, r as resolveModule } from './index.BCY_7LL2.js';
 import * as vite from 'vite';
-import { isFileServingAllowed as isFileServingAllowed$1, parseAst, searchForWorkspaceRoot, fetchModule, version, mergeConfig, createServer, isFileLoadingAllowed, normalizePath } from 'vite';
-import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.D_Q9UYh-.js';
+import { createServer, isFileLoadingAllowed, normalizePath, parseAst, searchForWorkspaceRoot, fetchModule, version, mergeConfig } from 'vite';
+import { A as API_PATH, c as configFiles, d as defaultBrowserPort, b as defaultPort } from './constants.B63TT-Bl.js';
 import * as nodeos from 'node:os';
 import nodeos__default, { tmpdir } from 'node:os';
-import { generateHash as generateHash$1, createTaskName, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, hasFailed, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, getTasks, isTestCase } from '@vitest/runner/utils';
+import { generateHash as generateHash$1, createTaskName, validateTags, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, hasFailed, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, getTasks, isTestCase } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { v as version$1 } from './cac.jRCLJDDc.js';
+import { v as version$1 } from './cac.C4jjt2RX.js';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { c as createBirpc } from './index.Chj8NDwU.js';
-import { p as parse, d as stringify, e as createIndexLocationsMap, h as TraceMap, o as originalPositionFor, i as ancestor, j as printError, f as formatProjectName, w as withLabel, k as errorBanner, l as divider, m as Typechecker, n as generateCodeFrame, q as escapeRegExp, r as createDefinesScript, R as ReportersMap, u as groupBy, B as BlobReporter, v as readBlobs, x as convertTasksToEvents, H as HangingProcessReporter, y as wildcardPatternToRegExp, z as stdout } from './index.M8mOzt4Y.js';
+import { p as parse, d as stringify, e as createIndexLocationsMap, h as TraceMap, o as originalPositionFor, i as ancestor, j as printError, f as formatProjectName, w as withLabel, k as errorBanner, l as divider, m as Typechecker, n as generateCodeFrame, q as escapeRegExp, r as createDefinesScript, R as ReportersMap, u as groupBy, B as BlobReporter, v as readBlobs, x as convertTasksToEvents, H as HangingProcessReporter, y as wildcardPatternToRegExp, z as stdout } from './index.B-iBE_Gx.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -29,8 +29,10 @@ import require$$0$1 from 'buffer';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.D26ty3Ew.js';
 import crypto, { createHash } from 'node:crypto';
 import { rootDir, distDir } from '../path.js';
+import { N as NativeModuleRunner } from './nativeModuleRunner.BIakptoF.js';
 import { T as Traces } from './traces.CCmnQaNT.js';
 import { createDebug } from 'obug';
+import { h as hash, R as RandomSequencer, i as isBrowserEnabled, r as resolveConfig, g as getCoverageProvider, a as resolveApiServerConfig } from './coverage.tyqbzn4W.js';
 import { rm, readFile, writeFile, rename, stat, unlink, mkdir, copyFile } from 'node:fs/promises';
 import c from 'tinyrainbow';
 import { VitestModuleEvaluator } from '#module-evaluator';
@@ -53,7 +55,7 @@ import { c as configDefaults } from './defaults.BOqNVLsY.js';
 import { KNOWN_ASSET_RE } from '@vitest/utils/constants';
 import { findNearestPackageData } from '@vitest/utils/resolver';
 import * as esModuleLexer from 'es-module-lexer';
-import { a as BenchmarkReportsMap } from './index.C5r1PdPD.js';
+import { a as BenchmarkReportsMap } from './index.CFulQRmC.js';
 import assert$1 from 'node:assert';
 import { serializeValue } from '@vitest/utils/serialize';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
@@ -76,6 +78,7 @@ function requireConstants () {
 
 	constants = {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT: 30000,
 	  EMPTY_BUFFER: Buffer.alloc(0),
 	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
 	  hasBlob,
@@ -2846,6 +2849,7 @@ function requireWebsocket () {
 
 	const {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT,
 	  EMPTY_BUFFER,
 	  GUID,
 	  kForOnEventAttribute,
@@ -2860,7 +2864,6 @@ function requireWebsocket () {
 	const { format, parse } = requireExtension();
 	const { toBuffer } = requireBufferUtil();
 
-	const closeTimeout = 30 * 1000;
 	const kAborted = Symbol('kAborted');
 	const protocolVersions = [8, 13];
 	const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
@@ -2916,6 +2919,7 @@ function requireWebsocket () {
 	      initAsClient(this, address, protocols, options);
 	    } else {
 	      this._autoPong = options.autoPong;
+	      this._closeTimeout = options.closeTimeout;
 	      this._isServer = true;
 	    }
 	  }
@@ -3457,6 +3461,8 @@ function requireWebsocket () {
 	 *     times in the same tick
 	 * @param {Boolean} [options.autoPong=true] Specifies whether or not to
 	 *     automatically send a pong in response to a ping
+	 * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to wait
+	 *     for the closing handshake to finish after `websocket.close()` is called
 	 * @param {Function} [options.finishRequest] A function which can be used to
 	 *     customize the headers of each http request before it is sent
 	 * @param {Boolean} [options.followRedirects=false] Whether or not to follow
@@ -3483,6 +3489,7 @@ function requireWebsocket () {
 	  const opts = {
 	    allowSynchronousEvents: true,
 	    autoPong: true,
+	    closeTimeout: CLOSE_TIMEOUT,
 	    protocolVersion: protocolVersions[1],
 	    maxPayload: 100 * 1024 * 1024,
 	    skipUTF8Validation: false,
@@ -3501,6 +3508,7 @@ function requireWebsocket () {
 	  };
 
 	  websocket._autoPong = opts.autoPong;
+	  websocket._closeTimeout = opts.closeTimeout;
 
 	  if (!protocolVersions.includes(opts.protocolVersion)) {
 	    throw new RangeError(
@@ -4118,7 +4126,7 @@ function requireWebsocket () {
 	function setCloseTimer(websocket) {
 	  websocket._closeTimer = setTimeout(
 	    websocket._socket.destroy.bind(websocket._socket),
-	    closeTimeout
+	    websocket._closeTimeout
 	  );
 	}
 
@@ -4136,23 +4144,23 @@ function requireWebsocket () {
 
 	  websocket._readyState = WebSocket.CLOSING;
 
-	  let chunk;
-
 	  //
 	  // The close frame might not have been received or the `'end'` event emitted,
 	  // for example, if the socket was destroyed due to an error. Ensure that the
 	  // `receiver` stream is closed after writing any remaining buffered data to
 	  // it. If the readable side of the socket is in flowing mode then there is no
-	  // buffered data as everything has been already written and `readable.read()`
-	  // will return `null`. If instead, the socket is paused, any possible buffered
-	  // data will be read as a single chunk.
+	  // buffered data as everything has been already written. If instead, the
+	  // socket is paused, any possible buffered data will be read as a single
+	  // chunk.
 	  //
 	  if (
 	    !this._readableState.endEmitted &&
 	    !websocket._closeFrameReceived &&
 	    !websocket._receiver._writableState.errorEmitted &&
-	    (chunk = websocket._socket.read()) !== null
+	    this._readableState.length !== 0
 	  ) {
+	    const chunk = this.read(this._readableState.length);
+
 	    websocket._receiver.write(chunk);
 	  }
 
@@ -4483,7 +4491,7 @@ function requireWebsocketServer () {
 	const PerMessageDeflate = requirePermessageDeflate();
 	const subprotocol = requireSubprotocol();
 	const WebSocket = requireWebsocket();
-	const { GUID, kWebSocket } = requireConstants();
+	const { CLOSE_TIMEOUT, GUID, kWebSocket } = requireConstants();
 
 	const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
 
@@ -4510,6 +4518,9 @@ function requireWebsocketServer () {
 	   *     pending connections
 	   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
 	   *     track clients
+	   * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
+	   *     wait for the closing handshake to finish after `websocket.close()` is
+	   *     called
 	   * @param {Function} [options.handleProtocols] A hook to handle protocols
 	   * @param {String} [options.host] The hostname where to bind the server
 	   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
@@ -4539,6 +4550,7 @@ function requireWebsocketServer () {
 	      perMessageDeflate: false,
 	      handleProtocols: null,
 	      clientTracking: true,
+	      closeTimeout: CLOSE_TIMEOUT,
 	      verifyClient: null,
 	      noServer: false,
 	      backlog: null, // use default (511 as implemented in net.js)
@@ -5026,17 +5038,40 @@ function requireWebsocketServer () {
 var websocketServerExports = requireWebsocketServer();
 var WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServerExports);
 
+async function createViteServer(inlineConfig) {
+	// Vite prints an error (https://github.com/vitejs/vite/issues/14328)
+	// But Vitest works correctly either way
+	const error = console.error;
+	console.error = (...args) => {
+		if (typeof args[0] === "string" && args[0].includes("WebSocket server error:")) return;
+		error(...args);
+	};
+	const server = await createServer(inlineConfig);
+	console.error = error;
+	return server;
+}
+function isFileServingAllowed(configOrUrl, urlOrServer) {
+	const config = typeof urlOrServer === "string" ? configOrUrl : urlOrServer.config;
+	const url = typeof urlOrServer === "string" ? urlOrServer : configOrUrl;
+	if (!config.server.fs.strict) return true;
+	return isFileLoadingAllowed(config, fsPathFromUrl(url));
+}
+const FS_PREFIX = "/@fs/";
+const VOLUME_RE = /^[A-Z]:/i;
+function fsPathFromId(id) {
+	const fsPath = normalizePath(id.startsWith(FS_PREFIX) ? id.slice(5) : id);
+	return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
+}
+function fsPathFromUrl(url) {
+	return fsPathFromId(cleanUrl(url));
+}
+
 function getTestFileEnvironment(project, testFile, browser = false) {
-	let environment;
-	if (browser) environment = project.browser?.vite.environments.client;
+	if (browser) return project.browser?.vite.environments.client;
 	else for (const name in project.vite.environments) {
 		const env = project.vite.environments[name];
-		if (env.moduleGraph.getModuleById(testFile)) {
-			environment = env;
-			break;
-		}
+		if (env.moduleGraph.getModuleById(testFile)) return env;
 	}
-	return environment;
 }
 
 async function getModuleGraph(ctx, projectName, testFilePath, browser = false) {
@@ -5044,7 +5079,7 @@ async function getModuleGraph(ctx, projectName, testFilePath, browser = false) {
 	const externalized = /* @__PURE__ */ new Set();
 	const inlined = /* @__PURE__ */ new Set();
 	const project = ctx.getProjectByName(projectName);
-	const environment = getTestFileEnvironment(project, testFilePath, browser);
+	const environment = project.config.experimental.viteModuleRunner === false ? project.vite.environments.__vitest__ : getTestFileEnvironment(project, testFilePath, browser);
 	if (!environment) throw new Error(`Cannot find environment for ${testFilePath}`);
 	const seen = /* @__PURE__ */ new Map();
 	function get(mod) {
@@ -5175,7 +5210,7 @@ function setup(ctx, _server) {
 			async getExternalResult(moduleId, testFileTaskId) {
 				const testModule = ctx.state.getReportedEntityById(testFileTaskId);
 				if (!testModule) return;
-				if (!isFileServingAllowed$1(testModule.project.vite.config, moduleId)) return;
+				if (!isFileServingAllowed(testModule.project.vite.config, moduleId)) return;
 				const result = {};
 				try {
 					result.source = await promises.readFile(moduleId, "utf-8");
@@ -5185,7 +5220,7 @@ function setup(ctx, _server) {
 			async getTransformResult(projectName, moduleId, testFileTaskId, browser = false) {
 				const project = ctx.getProjectByName(projectName);
 				const testModule = ctx.state.getReportedEntityById(testFileTaskId);
-				if (!testModule || !isFileServingAllowed$1(project.vite.config, moduleId)) return;
+				if (!testModule || !isFileServingAllowed(project.vite.config, moduleId)) return;
 				const environment = getTestFileEnvironment(project, testModule.moduleId, browser);
 				const moduleNode = environment?.moduleGraph.getModuleById(moduleId);
 				if (!environment || !moduleNode?.transformResult) return;
@@ -5325,8 +5360,62 @@ function createDebugger(namespace) {
 	if (debug.enabled) return debug;
 }
 
+async function getSpecificationsOptions(specifications) {
+	const environments = /* @__PURE__ */ new WeakMap();
+	const cache = /* @__PURE__ */ new Map();
+	const tags = /* @__PURE__ */ new WeakMap();
+	await Promise.all(specifications.map(async (spec) => {
+		const { moduleId: filepath, project, pool } = spec;
+		// browser pool handles its own environment
+		if (pool === "browser") return;
+		// reuse if projects have the same test files
+		let code = cache.get(filepath);
+		if (!code) {
+			code = await promises.readFile(filepath, "utf-8").catch(() => "");
+			cache.set(filepath, code);
+		}
+		const { env = project.config.environment || "node", envOptions, tags: specTags = [] } = detectCodeBlock(code);
+		tags.set(spec, specTags);
+		const environment = {
+			name: env,
+			options: envOptions ? { [env === "happy-dom" ? "happyDOM" : env]: envOptions } : null
+		};
+		environments.set(spec, environment);
+	}));
+	return {
+		environments,
+		tags
+	};
+}
+function detectCodeBlock(content) {
+	const env = content.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
+	let envOptionsJson = content.match(/@(?:vitest|jest)-environment-options\s+(.+)/)?.[1];
+	if (envOptionsJson?.endsWith("*/"))
+ // Trim closing Docblock characters the above regex might have captured
+	envOptionsJson = envOptionsJson.slice(0, -2);
+	const envOptions = JSON.parse(envOptionsJson || "null");
+	const tags = [];
+	let tagMatch;
+	// eslint-disable-next-line no-cond-assign
+	while (tagMatch = content.match(/(\/\/|\*)\s*@module-tag\s+([\w\-/]+)\b/)) {
+		tags.push(tagMatch[2]);
+		content = content.slice(tagMatch.index + tagMatch[0].length);
+	}
+	return {
+		env,
+		envOptions,
+		tags
+	};
+}
+
 const debug$1 = createDebugger("vitest:ast-collect-info");
 const verbose = createDebugger("vitest:ast-collect-verbose");
+function isTestFunctionName(name) {
+	return name === "it" || name === "test" || name.startsWith("test") || name.endsWith("Test");
+}
+function isVitestFunctionName(name) {
+	return name === "describe" || name === "suite" || isTestFunctionName(name);
+}
 function astParseFile(filepath, code) {
 	const ast = parseAst(code);
 	if (verbose) verbose("Collecting", filepath, code);
@@ -5338,12 +5427,7 @@ function astParseFile(filepath, code) {
 		if (callee.type === "CallExpression") return getName(callee.callee);
 		if (callee.type === "TaggedTemplateExpression") return getName(callee.tag);
 		if (callee.type === "MemberExpression") {
-			if (callee.object?.type === "Identifier" && [
-				"it",
-				"test",
-				"describe",
-				"suite"
-			].includes(callee.object.name)) return callee.object?.name;
+			if (callee.object?.type === "Identifier" && isVitestFunctionName(callee.object.name)) return callee.object?.name;
 			if (callee.object?.name?.startsWith("__vite_ssr_") || callee.object?.object?.name?.startsWith("__vite_ssr_") && callee.object?.property?.name === "Vitest") return getName(callee.property);
 			// call as `__vite_ssr__.test.skip()`
 			return getName(callee.object?.property);
@@ -5359,12 +5443,7 @@ function astParseFile(filepath, code) {
 		const { callee } = node;
 		const name = getName(callee);
 		if (!name) return;
-		if (![
-			"it",
-			"test",
-			"describe",
-			"suite"
-		].includes(name)) {
+		if (!isVitestFunctionName(name)) {
 			verbose?.(`Skipping ${name} (unknown call)`);
 			return;
 		}
@@ -5375,7 +5454,9 @@ function astParseFile(filepath, code) {
 			"each",
 			"for",
 			"skipIf",
-			"runIf"
+			"runIf",
+			"extend",
+			"scoped"
 		].includes(mode)) return;
 		let start;
 		const end = node.end;
@@ -5400,15 +5481,32 @@ function astParseFile(filepath, code) {
 			const property = callee.tag?.property?.name;
 			isDynamicEach = property === "each" || property === "for";
 		}
-		debug$1?.("Found", name, message, `(${mode})`);
+		// Extract tags from the second argument if it's an options object
+		const tags = [];
+		const secondArg = node.arguments?.[1];
+		if (secondArg?.type === "ObjectExpression") {
+			const tagsProperty = secondArg.properties?.find((p) => p.type === "Property" && p.key?.type === "Identifier" && p.key.name === "tags");
+			if (tagsProperty) {
+				const tagsValue = tagsProperty.value;
+				if (tagsValue?.type === "Literal" && typeof tagsValue.value === "string")
+ // tags: 'single-tag'
+				tags.push(tagsValue.value);
+				else if (tagsValue?.type === "ArrayExpression") {
+					// tags: ['tag1', 'tag2']
+					for (const element of tagsValue.elements || []) if (element?.type === "Literal" && typeof element.value === "string") tags.push(element.value);
+				}
+			}
+		}
+		debug$1?.("Found", name, message, `(${mode})`, tags.length ? `[${tags.join(", ")}]` : "");
 		definitions.push({
 			start,
 			end,
 			name: message,
-			type: name === "it" || name === "test" ? "test" : "suite",
+			type: isTestFunctionName(name) ? "test" : "suite",
 			mode,
 			task: null,
-			dynamic: isDynamicEach
+			dynamic: isDynamicEach,
+			tags
 		});
 	} });
 	return {
@@ -5454,22 +5552,23 @@ function serializeError(ctx, error) {
 		message: error.message
 	}];
 }
-function createFileTask(testFilepath, code, requestMap, options) {
+function createFileTask(testFilepath, code, requestMap, config, filepath, fileTags) {
 	const { definitions, ast } = astParseFile(testFilepath, code);
 	const file = {
-		filepath: options.filepath,
+		filepath,
 		type: "suite",
-		id: /* @__PURE__ */ generateHash$1(`${testFilepath}${options.name || ""}`),
+		id: /* @__PURE__ */ generateHash$1(`${testFilepath}${config.name || ""}`),
 		name: testFilepath,
 		fullName: testFilepath,
 		mode: "run",
 		tasks: [],
 		start: ast.start,
 		end: ast.end,
-		projectName: options.name,
+		projectName: config.name,
 		meta: {},
 		pool: "browser",
-		file: null
+		file: null,
+		tags: fileTags || []
 	};
 	file.file = file;
 	const indexMap = createIndexLocationsMap(code);
@@ -5494,9 +5593,13 @@ function createFileTask(testFilepath, code, requestMap, options) {
 			});
 			if (originalLocation.column != null) {
 				verbose?.(`Found location for`, definition.type, definition.name, `${processedLocation.line}:${processedLocation.column}`, "->", `${originalLocation.line}:${originalLocation.column}`);
-				location = originalLocation;
+				location = {
+					line: originalLocation.line,
+					column: originalLocation.column
+				};
 			} else debug$1?.("Cannot find original location for", definition.type, definition.name, `${processedLocation.column}:${processedLocation.line}`);
 		} else debug$1?.("Cannot find original location for", definition.type, definition.name, `${definition.start}`);
+		const taskTags = unique([...latestSuite.tags || [], ...definition.tags]);
 		if (definition.type === "suite") {
 			const task = {
 				type: definition.type,
@@ -5505,6 +5608,7 @@ function createFileTask(testFilepath, code, requestMap, options) {
 				file,
 				tasks: [],
 				mode,
+				each: definition.dynamic,
 				name: definition.name,
 				fullName: createTaskName([latestSuite.fullName, definition.name]),
 				fullTestName: createTaskName([latestSuite.fullTestName, definition.name]),
@@ -5512,18 +5616,21 @@ function createFileTask(testFilepath, code, requestMap, options) {
 				start: definition.start,
 				location,
 				dynamic: definition.dynamic,
-				meta: {}
+				meta: {},
+				tags: taskTags
 			};
 			definition.task = task;
 			latestSuite.tasks.push(task);
 			lastSuite = task;
 			return;
 		}
+		validateTags(config, taskTags);
 		const task = {
 			type: definition.type,
 			id: "",
 			suite: latestSuite,
 			file,
+			each: definition.dynamic,
 			mode,
 			context: {},
 			name: definition.name,
@@ -5536,20 +5643,21 @@ function createFileTask(testFilepath, code, requestMap, options) {
 			meta: {},
 			timeout: 0,
 			annotations: [],
-			artifacts: []
+			artifacts: [],
+			tags: taskTags
 		};
 		definition.task = task;
 		latestSuite.tasks.push(task);
 	});
 	calculateSuiteHash(file);
 	const hasOnly = someTasksAreOnly(file);
-	interpretTaskModes(file, options.testNamePattern, void 0, hasOnly, false, options.allowOnly);
+	interpretTaskModes(file, config.testNamePattern, void 0, void 0, void 0, hasOnly, false, config.allowOnly);
 	markDynamicTests(file.tasks);
 	if (!file.tasks.length) file.result = {
 		state: "fail",
 		errors: [{
 			name: "Error",
-			message: `No test suite found in file ${options.filepath}`
+			message: `No test suite found in file ${filepath}`
 		}]
 	};
 	return file;
@@ -5561,18 +5669,17 @@ async function astCollectTests(project, filepath) {
 		debug$1?.("Cannot parse", testFilepath, "(vite didn't return anything)");
 		return createFailedFileTask(project, filepath, /* @__PURE__ */ new Error(`Failed to parse ${testFilepath}. Vite didn't return anything.`));
 	}
-	return createFileTask(testFilepath, request.code, request.map, {
-		name: project.config.name,
-		filepath,
-		allowOnly: project.config.allowOnly,
-		testNamePattern: project.config.testNamePattern,
-		pool: project.browser ? "browser" : project.config.pool
-	});
+	return createFileTask(testFilepath, request.code, request.map, project.serializedConfig, filepath, request.fileTags);
 }
 async function transformSSR(project, filepath) {
-	const request = await project.vite.transformRequest(filepath, { ssr: false });
-	if (!request) return null;
-	return await project.vite.ssrTransform(request.code, request.map, filepath);
+	const { env: pragmaEnv, tags: fileTags } = detectCodeBlock(await promises.readFile(filepath, "utf-8").catch(() => ""));
+	// Use environment from pragma if defined, otherwise fall back to config
+	const environment = pragmaEnv || project.config.environment;
+	const transformResult = await (environment === "jsdom" || environment === "happy-dom" ? project.vite.environments.client : project.vite.environments.ssr).transformRequest(filepath);
+	return transformResult ? {
+		...transformResult,
+		fileTags
+	} : null;
 }
 function markDynamicTests(tasks) {
 	for (const task of tasks) {
@@ -6560,6 +6667,25 @@ class Logger {
 		this._highlights.set(filename, code);
 		return code;
 	}
+	printNoTestTagsFound() {
+		this.error(c.bgRed(" ERROR "), c.red("No test tags found in any project. Exiting with code 1."));
+	}
+	printTags() {
+		const vitest = this.ctx;
+		const rootProject = vitest.getRootProject();
+		const projects = [rootProject, ...vitest.projects.filter((p) => p !== rootProject)];
+		if (!projects.some((p) => p.config.tags && p.config.tags.length > 0)) {
+			process.exitCode = 1;
+			return this.printNoTestTagsFound();
+		}
+		for (const project of projects) {
+			if (project.name) this.log(formatProjectName(project, ""));
+			project.config.tags.forEach((tag) => {
+				const tagLog = `${tag.name}${tag.description ? `: ${tag.description}` : ""}`;
+				this.log(`  ${tagLog}`);
+			});
+		}
+	}
 	printNoTestFound(filters) {
 		const config = this.ctx.config;
 		if (config.watch && (config.changed || config.related?.length)) this.log(`No affected ${config.mode} files found\n`);
@@ -6992,35 +7118,6 @@ function stringToBytes(input, percentageReference) {
 	return null;
 }
 
-async function getSpecificationsEnvironments(specifications) {
-	const environments = /* @__PURE__ */ new WeakMap();
-	const cache = /* @__PURE__ */ new Map();
-	await Promise.all(specifications.map(async (spec) => {
-		const { moduleId: filepath, project } = spec;
-		// reuse if projects have the same test files
-		let code = cache.get(filepath);
-		if (!code) {
-			code = await promises.readFile(filepath, "utf-8");
-			cache.set(filepath, code);
-		}
-		// 1. Check for control comments in the file
-		let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
-		// 2. Fallback to global env
-		env ||= project.config.environment || "node";
-		let envOptionsJson = code.match(/@(?:vitest|jest)-environment-options\s+(.+)/)?.[1];
-		if (envOptionsJson?.endsWith("*/"))
- // Trim closing Docblock characters the above regex might have captured
-		envOptionsJson = envOptionsJson.slice(0, -2);
-		const envOptions = JSON.parse(envOptionsJson || "null");
-		const environment = {
-			name: env,
-			options: envOptions ? { [env === "happy-dom" ? "happyDOM" : env]: envOptions } : null
-		};
-		environments.set(spec, environment);
-	}));
-	return environments;
-}
-
 const debug = createDebugger("vitest:browser:pool");
 function createBrowserPool(vitest) {
 	const providers = /* @__PURE__ */ new Set();
@@ -7048,11 +7145,29 @@ function createBrowserPool(vitest) {
 	};
 	const runWorkspaceTests = async (method, specs) => {
 		const groupedFiles = /* @__PURE__ */ new Map();
-		for (const { project, moduleId, testLines } of specs) {
+		const testFilesCode = /* @__PURE__ */ new Map();
+		const testFileTags = /* @__PURE__ */ new WeakMap();
+		await Promise.all(specs.map(async (spec) => {
+			let code = testFilesCode.get(spec.moduleId);
+			// TODO: this really should be done only once when collecting specifications
+			if (code == null) {
+				code = await readFile(spec.moduleId, "utf-8").catch(() => "");
+				testFilesCode.set(spec.moduleId, code);
+			}
+			const { tags } = detectCodeBlock(code);
+			testFileTags.set(spec, tags);
+		}));
+		// to keep the sorting, we need to iterate over specs separately
+		for (const spec of specs) {
+			const { project, moduleId, testLines, testIds, testNamePattern, testTagsFilter } = spec;
 			const files = groupedFiles.get(project) || [];
 			files.push({
 				filepath: moduleId,
-				testLocations: testLines
+				testLocations: testLines,
+				testIds,
+				testNamePattern,
+				testTagsFilter,
+				fileTags: testFileTags.get(spec)
 			});
 			groupedFiles.set(project, files);
 		}
@@ -7176,7 +7291,7 @@ class BrowserPool {
 			let page = this._traces.$(`vitest.browser.open`, {
 				context: this._otel.context,
 				attributes: { "vitest.browser.session_id": sessionId }
-			}, () => this.openPage(sessionId));
+			}, () => this.openPage(sessionId, { parallel: workerCount > 1 }));
 			page = page.then(() => {
 				// start running tests on the page when it's ready
 				this.runNextTest(method, sessionId);
@@ -7187,14 +7302,14 @@ class BrowserPool {
 		debug?.("all sessions are created");
 		return this._promise;
 	}
-	async openPage(sessionId) {
+	async openPage(sessionId, options) {
 		const sessionPromise = this.project.vitest._browserSessions.createSession(sessionId, this.project, this);
 		const browser = this.project.browser;
 		const url = new URL("/__vitest_test__/", this.options.origin);
 		url.searchParams.set("sessionId", sessionId);
 		const otelCarrier = this._traces.getContextCarrier();
 		if (otelCarrier) url.searchParams.set("otelCarrier", JSON.stringify(otelCarrier));
-		const pagePromise = browser.provider.openPage(sessionId, url.toString());
+		const pagePromise = browser.provider.openPage(sessionId, url.toString(), options);
 		await Promise.all([sessionPromise, pagePromise]);
 	}
 	getOrchestrator(sessionId) {
@@ -7364,6 +7479,34 @@ function createMethodsRPC(project, methodsOptions = {}) {
 		},
 		getCountOfFailedTests() {
 			return vitest.state.getCountOfFailedTests();
+		},
+		ensureModuleGraphEntry(id, importer) {
+			const filepath = id.startsWith("file:") ? fileURLToPath(id) : id;
+			const importerPath = importer.startsWith("file:") ? fileURLToPath(importer) : importer;
+			// environment itself doesn't matter
+			const moduleGraph = project.vite.environments.__vitest__?.moduleGraph;
+			if (!moduleGraph) {
+				// TODO: is it possible?
+				console.error("no module graph for", id);
+				return;
+			}
+			const importerNode = moduleGraph.getModuleById(importerPath) || moduleGraph.createFileOnlyEntry(importerPath);
+			const moduleNode = moduleGraph.getModuleById(filepath) || moduleGraph.createFileOnlyEntry(filepath);
+			if (!moduleGraph.idToModuleMap.has(importerPath)) {
+				importerNode.id = importerPath;
+				moduleGraph.idToModuleMap.set(importerPath, importerNode);
+			}
+			if (!moduleGraph.idToModuleMap.has(filepath)) {
+				moduleNode.id = filepath;
+				moduleGraph.idToModuleMap.set(filepath, moduleNode);
+			}
+			// this is checked by the "printError" function - TODO: is there a better way?
+			moduleNode.transformResult = {
+				code: " ",
+				map: null
+			};
+			importerNode.importedModules.add(moduleNode);
+			moduleNode.importers.add(importerNode);
 		}
 	};
 }
@@ -8205,7 +8348,7 @@ function createPool(ctx) {
 		const taskGroups = [];
 		let workerId = 0;
 		const sorted = await sequencer.sort(specs);
-		const environments = await getSpecificationsEnvironments(specs);
+		const { environments, tags } = await getSpecificationsOptions(specs);
 		const groups = groupSpecs(sorted, environments);
 		const projectEnvs = /* @__PURE__ */ new WeakMap();
 		const projectExecArgvs = /* @__PURE__ */ new WeakMap();
@@ -8247,7 +8390,11 @@ function createPool(ctx) {
 					context: {
 						files: specs.map((spec) => ({
 							filepath: spec.moduleId,
-							testLocations: spec.testLines
+							fileTags: tags.get(spec),
+							testLocations: spec.testLines,
+							testNamePattern: spec.testNamePattern,
+							testIds: spec.testIds,
+							testTagsFilter: spec.testTagsFilter
 						})),
 						invalidates,
 						providedContext: project.getProvidedContext(),
@@ -8521,8 +8668,13 @@ function serializeConfig(project) {
 		experimental: {
 			fsModuleCache: config.experimental.fsModuleCache ?? false,
 			printImportBreakdown: config.experimental.printImportBreakdown,
+			viteModuleRunner: config.experimental.viteModuleRunner ?? true,
+			nodeLoader: config.experimental.nodeLoader ?? true,
 			openTelemetry: config.experimental.openTelemetry
-		}
+		},
+		tags: config.tags || [],
+		tagsFilter: config.tagsFilter,
+		strictTags: config.strictTags ?? true
 	};
 }
 
@@ -9580,15 +9732,12 @@ function WorkspaceVitestPlugin(project, options) {
 					label: name,
 					color
 				} };
+				vitestConfig.experimental ??= {};
 				// always inherit the global `fsModuleCache` value even without `extends: true`
-				if (testConfig.experimental?.fsModuleCache == null && project.vitest.config.experimental?.fsModuleCache !== null) {
-					vitestConfig.experimental ??= {};
-					vitestConfig.experimental.fsModuleCache = project.vitest.config.experimental.fsModuleCache;
-				}
-				if (testConfig.experimental?.fsModuleCachePath == null && project.vitest.config.experimental?.fsModuleCachePath !== null) {
-					vitestConfig.experimental ??= {};
-					vitestConfig.experimental.fsModuleCachePath = project.vitest.config.experimental.fsModuleCachePath;
-				}
+				if (testConfig.experimental?.fsModuleCache == null && project.vitest.config.experimental?.fsModuleCache != null) vitestConfig.experimental.fsModuleCache = project.vitest.config.experimental.fsModuleCache;
+				if (testConfig.experimental?.fsModuleCachePath == null && project.vitest.config.experimental?.fsModuleCachePath != null) vitestConfig.experimental.fsModuleCachePath = project.vitest.config.experimental.fsModuleCachePath;
+				if (testConfig.experimental?.viteModuleRunner == null && project.vitest.config.experimental?.viteModuleRunner != null) vitestConfig.experimental.viteModuleRunner = project.vitest.config.experimental.viteModuleRunner;
+				if (testConfig.experimental?.nodeLoader == null && project.vitest.config.experimental?.nodeLoader != null) vitestConfig.experimental.nodeLoader = project.vitest.config.experimental.nodeLoader;
 				return {
 					base: "/",
 					environments: { __vitest__: { dev: {} } },
@@ -9807,7 +9956,7 @@ function matchPattern(id, moduleDirectories, patterns) {
 
 class TestSpecification {
 	/**
-	* The task ID associated with the test module.
+	* The task id associated with the test module.
 	*/
 	taskId;
 	/**
@@ -9815,29 +9964,51 @@ class TestSpecification {
 	*/
 	project;
 	/**
-	* The ID of the module in the Vite module graph. It is usually an absolute file path.
+	* The id of the module in the Vite module graph. It is usually an absolute file path.
 	*/
 	moduleId;
 	/**
-	* The current test pool. It's possible to have multiple pools in a single test project with `poolMatchGlob` and `typecheck.enabled`.
-	* @experimental In Vitest 4, the project will only support a single pool and this property will be removed.
+	* The current test pool. It's possible to have multiple pools in a single test project with `typecheck.enabled`.
+	* @experimental In later versions, the project will only support a single pool.
 	*/
 	pool;
 	/**
 	* Line numbers of the test locations to run.
 	*/
 	testLines;
-	constructor(project, moduleId, pool, testLines) {
-		const name = project.config.name;
-		const hashName = pool !== "typescript" ? name : name ? `${name}:__typecheck__` : "__typecheck__";
+	/**
+	* Regular expression pattern to filter test names.
+	*/
+	testNamePattern;
+	/**
+	* The ids of tasks inside of this specification to run.
+	*/
+	testIds;
+	/**
+	* The tags of tests to run.
+	*/
+	testTagsFilter;
+	/**
+	* This class represents a test suite for a test module within a single project.
+	* @internal
+	*/
+	constructor(project, moduleId, pool, testLinesOrOptions) {
+		const projectName = project.config.name;
+		const hashName = pool !== "typescript" ? projectName : projectName ? `${projectName}:__typecheck__` : "__typecheck__";
 		this.taskId = generateFileHash(relative(project.config.root, moduleId), hashName);
 		this.project = project;
 		this.moduleId = moduleId;
 		this.pool = pool;
-		this.testLines = testLines;
+		if (Array.isArray(testLinesOrOptions)) this.testLines = testLinesOrOptions;
+		else if (testLinesOrOptions && typeof testLinesOrOptions === "object") {
+			this.testLines = testLinesOrOptions.testLines;
+			this.testNamePattern = testLinesOrOptions.testNamePattern;
+			this.testIds = testLinesOrOptions.testIds;
+			this.testTagsFilter = testLinesOrOptions.testTagsFilter;
+		}
 	}
 	/**
-	* Test module associated with the specification.
+	* Test module associated with the specification. This will be `undefined` if tests have not been run yet.
 	*/
 	get testModule() {
 		const task = this.project.vitest.state.idMap.get(this.taskId);
@@ -9853,40 +10024,15 @@ class TestSpecification {
 			this.moduleId,
 			{
 				pool: this.pool,
-				testLines: this.testLines
+				testLines: this.testLines,
+				testIds: this.testIds,
+				testNamePattern: this.testNamePattern,
+				testTagsFilter: this.testTagsFilter
 			}
 		];
 	}
 }
 
-async function createViteServer(inlineConfig) {
-	// Vite prints an error (https://github.com/vitejs/vite/issues/14328)
-	// But Vitest works correctly either way
-	const error = console.error;
-	console.error = (...args) => {
-		if (typeof args[0] === "string" && args[0].includes("WebSocket server error:")) return;
-		error(...args);
-	};
-	const server = await createServer(inlineConfig);
-	console.error = error;
-	return server;
-}
-function isFileServingAllowed(configOrUrl, urlOrServer) {
-	const config = typeof urlOrServer === "string" ? configOrUrl : urlOrServer.config;
-	const url = typeof urlOrServer === "string" ? urlOrServer : configOrUrl;
-	if (!config.server.fs.strict) return true;
-	return isFileLoadingAllowed(config, fsPathFromUrl(url));
-}
-const FS_PREFIX = "/@fs/";
-const VOLUME_RE = /^[A-Z]:/i;
-function fsPathFromId(id) {
-	const fsPath = normalizePath(id.startsWith(FS_PREFIX) ? id.slice(5) : id);
-	return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
-}
-function fsPathFromUrl(url) {
-	return fsPathFromId(cleanUrl(url));
-}
-
 class TestProject {
 	/**
 	* The global Vitest instance.
@@ -9962,8 +10108,8 @@ class TestProject {
 	* Creates a new test specification. Specifications describe how to run tests.
 	* @param moduleId The file path
 	*/
-	createSpecification(moduleId, locations, pool) {
-		return new TestSpecification(this, moduleId, pool || getFilePoolName(this), locations);
+	createSpecification(moduleId, locationsOrOptions, pool) {
+		return new TestSpecification(this, moduleId, pool || getFilePoolName(this), locationsOrOptions);
 	}
 	toJSON() {
 		return {
@@ -10188,7 +10334,7 @@ class TestProject {
 		if (!this.closingPromise) this.closingPromise = Promise.all([
 			this.vite?.close(),
 			this.typechecker?.stop(),
-			this.browser?.close(),
+			(this.browser || this._parent?._parentBrowser?.vite)?.close(),
 			this.clearTmpDir()
 		].filter(Boolean)).then(() => {
 			if (!this.runner.isClosed()) return this.runner.close();
@@ -10227,7 +10373,11 @@ class TestProject {
 		this._serializedDefines = createDefinesScript(server.config.define);
 		this._fetcher = createFetchModuleFunction(this._resolver, this._config, this.vitest._fsCache, this.vitest._traces, this.tmpDir);
 		const environment = server.environments.__vitest__;
-		this.runner = new ServerModuleRunner(environment, this._fetcher, this._config);
+		this.runner = this._config.experimental.viteModuleRunner === false ? new NativeModuleRunner(this._config.root) : new ServerModuleRunner(environment, this._fetcher, this._config);
+	}
+	/** @internal */
+	_getViteEnvironments() {
+		return [...Object.values(this.browser?.vite.environments || {}), ...Object.values(this.vite.environments || {})];
 	}
 	_serializeOverriddenConfig() {
 		// TODO: serialize the config _once_ or when needed
@@ -10342,7 +10492,8 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		"printConsoleTrace",
 		"inspect",
 		"inspectBrk",
-		"fileParallelism"
+		"fileParallelism",
+		"tagsFilter"
 	].reduce((acc, name) => {
 		if (name in cliOptions) acc[name] = cliOptions[name];
 		return acc;
@@ -10361,6 +10512,14 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 			...options,
 			root,
 			configFile,
+			plugins: [{
+				name: "vitest:tags",
+				configResolved(config) {
+					config.test ??= {};
+					config.test.tags = options.test?.tags;
+				},
+				api: { vitest: { experimental: { ignoreFsModuleCache: true } } }
+			}, ...options.plugins || []],
 			test: {
 				...options.test,
 				...cliOverrides
@@ -10827,6 +10986,10 @@ class TestCase extends ReportedTaskImplementation {
 	* Parent suite. If the test was called directly inside the module, the parent will be the module itself.
 	*/
 	parent;
+	/**
+	* Tags associated with the test.
+	*/
+	tags;
 	/** @internal */
 	constructor(task, project) {
 		super(task, project);
@@ -10836,6 +10999,7 @@ class TestCase extends ReportedTaskImplementation {
 		if (suite) this.parent = getReportedTask(project, suite);
 		else this.parent = this.module;
 		this.options = buildOptions(task);
+		this.tags = this.options.tags || [];
 	}
 	/**
 	* Full name of the test including all parent suites separated with `>`.
@@ -10912,6 +11076,13 @@ class TestCase extends ReportedTaskImplementation {
 			flaky: !!result.retryCount && result.state === "pass" && result.retryCount > 0
 		};
 	}
+	/**
+	* Returns a new test specification that can be used to filter or run this specific test case.
+	*/
+	toTestSpecification() {
+		const isTypecheck = this.task.meta.typecheck === true;
+		return this.project.createSpecification(this.module.moduleId, { testIds: [this.id] }, isTypecheck ? "typecheck" : void 0);
+	}
 }
 class TestCollection {
 	#task;
@@ -11031,6 +11202,14 @@ class TestSuite extends SuiteImplementation {
 		return getSuiteState(this.task);
 	}
 	/**
+	* Returns a new test specification that can be used to filter or run this specific test suite.
+	*/
+	toTestSpecification() {
+		const isTypecheck = this.task.meta.typecheck === true;
+		const testIds = [...this.children.allTests()].map((test) => test.id);
+		return this.project.createSpecification(this.module.moduleId, { testIds }, isTypecheck ? "typecheck" : void 0);
+	}
+	/**
 	* Full name of the suite including all parent suites separated with `>`.
 	*/
 	get fullName() {
@@ -11066,6 +11245,13 @@ class TestModule extends SuiteImplementation {
 		else if (typeof task.viteEnvironment === "string") this.viteEnvironment = project.vite.environments[task.viteEnvironment];
 	}
 	/**
+	* Returns a new test specification that can be used to filter or run this specific test module.
+	*/
+	toTestSpecification() {
+		const isTypecheck = this.task.meta.typecheck === true;
+		return this.project.createSpecification(this.moduleId, void 0, isTypecheck ? "typecheck" : void 0);
+	}
+	/**
 	* Checks the running state of the test file.
 	*/
 	state() {
@@ -11099,6 +11285,8 @@ function buildOptions(task) {
 		shuffle: task.shuffle,
 		retry: task.retry,
 		repeats: task.repeats,
+		tags: task.tags,
+		timeout: task.type === "test" ? task.timeout : void 0,
 		mode: task.mode
 	};
 }
@@ -11279,6 +11467,19 @@ class StateManager {
 	}
 }
 
+function populateProjectsTags(rootProject, projects) {
+	// Include root project if not already in the list
+	const allProjects = projects.includes(rootProject) ? projects : [rootProject, ...projects];
+	// Collect all tags from all projects (first definition wins)
+	const globalTags = /* @__PURE__ */ new Map();
+	for (const project of allProjects) for (const tag of project.config.tags || []) if (!globalTags.has(tag.name)) globalTags.set(tag.name, tag);
+	// Add missing tags to each project (without overriding local definitions)
+	for (const project of allProjects) {
+		const projectTagNames = new Set(project.config.tags.map((t) => t.name));
+		for (const [tagName, tagDef] of globalTags) if (!projectTagNames.has(tagName)) project.config.tags.push(tagDef);
+	}
+}
+
 const types = {
     'application/andrew-inset': ['ez'],
     'application/appinstaller': ['appinstaller'],
@@ -11918,6 +12119,9 @@ class VitestWatcher {
 		this._onRerun.push(cb);
 		return this;
 	}
+	close() {
+		this.vitest.vite.watcher.close();
+	}
 	unregisterWatcher = noop;
 	registerWatcher() {
 		const watcher = this.vitest.vite.watcher;
@@ -12017,7 +12221,9 @@ class VitestWatcher {
 		}
 		if (this.handleSetupFile(filepath)) return true;
 		const projects = this.vitest.projects.filter((project) => {
-			return (project.browser?.vite.moduleGraph || project.vite.moduleGraph).getModulesByFile(filepath)?.size;
+			return project._getViteEnvironments().some(({ moduleGraph }) => {
+				return moduleGraph.getModulesByFile(filepath)?.size;
+			});
 		});
 		if (!projects.length) {
 			// if there are no modules it's possible that server was restarted
@@ -12030,8 +12236,8 @@ class VitestWatcher {
 		}
 		const files = [];
 		for (const project of projects) {
-			const mods = project.browser?.vite.moduleGraph.getModulesByFile(filepath) || project.vite.moduleGraph.getModulesByFile(filepath);
-			if (!mods || !mods.size) continue;
+			const environmentMods = project._getViteEnvironments().map(({ moduleGraph }) => moduleGraph.getModulesByFile(filepath));
+			if (!environmentMods.length) continue;
 			this.invalidates.add(filepath);
 			// one of test files that we already run, or one of test files that we can run
 			if (this.vitest.state.filesMap.has(filepath) || project._isCachedTestFile(filepath)) {
@@ -12040,7 +12246,7 @@ class VitestWatcher {
 				continue;
 			}
 			let rerun = false;
-			for (const mod of mods) mod.importers.forEach((i) => {
+			for (const mods of environmentMods) for (const mod of mods || []) mod.importers.forEach((i) => {
 				if (!i.file) return;
 				if (this.handleFileChanged(i.file)) rerun = true;
 			});
@@ -12102,6 +12308,7 @@ class Vitest {
 	/** @internal */ reporters = [];
 	/** @internal */ runner;
 	/** @internal */ _testRun = void 0;
+	/** @internal */ _config;
 	/** @internal */ _resolver;
 	/** @internal */ _fetcher;
 	/** @internal */ _fsCache;
@@ -12111,7 +12318,6 @@ class Vitest {
 	restartsCount = 0;
 	specifications;
 	pool;
-	_config;
 	_vite;
 	_state;
 	_cache;
@@ -12199,7 +12405,7 @@ class Vitest {
 		this._fsCache = new FileSystemModuleCache(this);
 		this._fetcher = createFetchModuleFunction(this._resolver, this._config, this._fsCache, this._traces, this._tmpDir);
 		const environment = server.environments.__vitest__;
-		this.runner = new ServerModuleRunner(environment, this._fetcher, resolved);
+		this.runner = resolved.experimental.viteModuleRunner === false ? new NativeModuleRunner(resolved.root) : new ServerModuleRunner(environment, this._fetcher, resolved);
 		if (this.config.watch) {
 			// hijack server restart
 			const serverRestart = server.restart;
@@ -12248,6 +12454,9 @@ class Vitest {
 		}
 		if (!this.coreWorkspaceProject) this.coreWorkspaceProject = TestProject._createBasicProject(this);
 		if (this.config.testNamePattern) this.configOverride.testNamePattern = this.config.testNamePattern;
+		// populate will merge all configs into every project,
+		// we don't want that when just listing tags
+		if (!this.config.listTags) populateProjectsTags(this.coreWorkspaceProject, this.projects);
 		this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this);
 		await this._fsCache.ensureCacheIntegrity();
 		await Promise.all([...this._onSetServer.map((fn) => fn()), this._traces.waitInit()]);
@@ -12257,6 +12466,24 @@ class Vitest {
 		if (this.configOverride.coverage?.enabled === false) return null;
 		return this._coverageProvider;
 	}
+	async listTags() {
+		const listTags = this.config.listTags;
+		if (typeof listTags === "boolean") this.logger.printTags();
+		else if (listTags === "json") if (![this.getRootProject(), ...this.projects].some((p) => p.config.tags && p.config.tags.length > 0)) {
+			process.exitCode = 1;
+			this.logger.printNoTestTagsFound();
+		} else {
+			const manifest = {
+				tags: this.config.tags,
+				projects: this.projects.filter((p) => p !== this.coreWorkspaceProject).map((p) => ({
+					name: p.name,
+					tags: p.config.tags
+				}))
+			};
+			this.logger.log(JSON.stringify(manifest, null, 2));
+		}
+		else throw new Error(`Unknown value for "test.listTags": ${listTags}`);
+	}
 	async enableCoverage() {
 		this.configOverride.coverage = {};
 		this.configOverride.coverage.enabled = true;
@@ -12476,7 +12703,7 @@ class Vitest {
 			}
 			this.filenamePattern = filters && filters?.length > 0 ? filters : void 0;
 			startSpan.setAttribute("vitest.start.filters", this.filenamePattern || []);
-			const files = await this._traces.$("vitest.config.resolve_include_glob", async () => {
+			const specifications = await this._traces.$("vitest.config.resolve_include_glob", async () => {
 				const specifications = await this.specifications.getRelevantTestSpecifications(filters);
 				startSpan.setAttribute("vitest.start.specifications", specifications.map((s) => {
 					const relativeModuleId = relative(s.project.config.root, s.moduleId);
@@ -12486,7 +12713,7 @@ class Vitest {
 				return specifications;
 			});
 			// if run with --changed, don't exit if no tests are found
-			if (!files.length) {
+			if (!specifications.length) {
 				await this._traces.$("vitest.test_run", async () => {
 					await this._testRun.start([]);
 					const coverage = await this.coverageProvider?.generateCoverage?.({ allTestsRun: true });
@@ -12500,10 +12727,10 @@ class Vitest {
 				testModules: [],
 				unhandledErrors: []
 			};
-			if (files.length) {
+			if (specifications.length) {
 				// populate once, update cache on watch
-				await this.cache.stats.populateStats(this.config.root, files);
-				testModules = await this.runFiles(files, true);
+				await this.cache.stats.populateStats(this.config.root, specifications);
+				testModules = await this.runFiles(specifications, true);
 			}
 			if (this.config.watch) await this.report("onWatcherStart");
 			return testModules;
@@ -12562,6 +12789,19 @@ class Vitest {
 		return this.runFiles(specifications, allTestsRun);
 	}
 	/**
+	* Runs tests for the given file paths. This does not trigger `onWatcher*` events.
+	* @param filepaths A list of file paths to run tests for.
+	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+	*/
+	async runTestFiles(filepaths, allTestsRun = false) {
+		const specifications = await this.specifications.getRelevantTestSpecifications(filepaths);
+		if (!specifications.length) return {
+			testModules: [],
+			unhandledErrors: []
+		};
+		return this.runFiles(specifications, allTestsRun);
+	}
+	/**
 	* Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
 	* @param specifications A list of specifications to run.
 	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
@@ -12746,8 +12986,12 @@ class Vitest {
 	async rerunTask(id) {
 		const task = this.state.idMap.get(id);
 		if (!task) throw new Error(`Task ${id} was not found`);
-		const taskNamePattern = task.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-		await this.changeNamePattern(taskNamePattern, [task.file.filepath], "tasks" in task ? "rerun suite" : "rerun test");
+		const reportedTask = this.state.getReportedEntityById(id);
+		if (!reportedTask) throw new Error(`Test specification for task ${id} was not found`);
+		const specifications = [reportedTask.toTestSpecification()];
+		await Promise.all([this.report("onWatcherRerun", [task.file.filepath], "tasks" in task ? "rerun suite" : "rerun test"), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
+		await this.runFiles(specifications, false);
+		await this.report("onWatcherStart", ["module" in reportedTask ? reportedTask.module.task : reportedTask.task]);
 	}
 	/** @internal */
 	async changeProjectName(pattern) {
@@ -13055,7 +13299,8 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				// store defines for globalThis to make them
 				// reassignable when running in worker in src/runtime/setup.ts
 				const originalDefine = { ...viteConfig.define };
-				options.defines = deleteDefineConfig(viteConfig);
+				const defines = deleteDefineConfig(viteConfig);
+				options.defines = defines;
 				options.viteDefine = originalDefine;
 				let open = false;
 				if (testConfig.ui && testConfig.open) open = testConfig.uiBase ?? "/__vitest__/";
@@ -13510,7 +13755,8 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
 		else ctx.start(cliFilters);
 	});
 	try {
-		if (ctx.config.clearCache) await ctx.experimental_clearCache();
+		if (ctx.config.listTags) await ctx.listTags();
+		else if (ctx.config.clearCache) await ctx.experimental_clearCache();
 		else if (ctx.config.mergeReports) await ctx.mergeReports();
 		else if (ctx.config.standalone) await ctx.init();
 		else await ctx.start(cliFilters);