vitest 4.1.0-beta.1 → 4.1.0-beta.2

package/dist/chunks/{cli-api.B4CqEpI6.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.BMlOMIWl.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.B1v3xxoC.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.Dm4xqZ0s.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.DyBZXrH3.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';
@@ -5036,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) {
@@ -5054,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) {
@@ -5185,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");
@@ -5195,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;
@@ -5335,6 +5360,54 @@ 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) {
@@ -5408,7 +5481,23 @@ 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,
@@ -5416,7 +5505,8 @@ function astParseFile(filepath, code) {
 			type: isTestFunctionName(name) ? "test" : "suite",
 			mode,
 			task: null,
-			dynamic: isDynamicEach
+			dynamic: isDynamicEach,
+			tags
 		});
 	} });
 	return {
@@ -5462,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);
@@ -5508,6 +5599,7 @@ function createFileTask(testFilepath, code, requestMap, options) {
 				};
 			} 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,
@@ -5516,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]),
@@ -5523,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,
@@ -5547,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, 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;
@@ -5572,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 environment = project.config.environment;
-	if (environment === "jsdom" || environment === "happy-dom") return project.vite.environments.client.transformRequest(filepath);
-	return project.vite.environments.ssr.transformRequest(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) {
@@ -6571,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`);
@@ -7003,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();
@@ -7059,13 +7145,29 @@ function createBrowserPool(vitest) {
 	};
 	const runWorkspaceTests = async (method, specs) => {
 		const groupedFiles = /* @__PURE__ */ new Map();
-		for (const { project, moduleId, testLines, testIds, testNamePattern } 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,
 				testIds,
-				testNamePattern
+				testNamePattern,
+				testTagsFilter,
+				fileTags: testFileTags.get(spec)
 			});
 			groupedFiles.set(project, files);
 		}
@@ -7189,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);
@@ -7200,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) {
@@ -7377,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);
 		}
 	};
 }
@@ -8218,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();
@@ -8260,9 +8390,11 @@ function createPool(ctx) {
 					context: {
 						files: specs.map((spec) => ({
 							filepath: spec.moduleId,
+							fileTags: tags.get(spec),
 							testLocations: spec.testLines,
 							testNamePattern: spec.testNamePattern,
-							testIds: spec.testIds
+							testIds: spec.testIds,
+							testTagsFilter: spec.testTagsFilter
 						})),
 						invalidates,
 						providedContext: project.getProvidedContext(),
@@ -8536,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
 	};
 }
 
@@ -9595,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: {} } },
@@ -9851,6 +9985,10 @@ class TestSpecification {
 	*/
 	testIds;
 	/**
+	* The tags of tests to run.
+	*/
+	testTagsFilter;
+	/**
 	* This class represents a test suite for a test module within a single project.
 	* @internal
 	*/
@@ -9866,6 +10004,7 @@ class TestSpecification {
 			this.testLines = testLinesOrOptions.testLines;
 			this.testNamePattern = testLinesOrOptions.testNamePattern;
 			this.testIds = testLinesOrOptions.testIds;
+			this.testTagsFilter = testLinesOrOptions.testTagsFilter;
 		}
 	}
 	/**
@@ -9887,40 +10026,13 @@ class TestSpecification {
 				pool: this.pool,
 				testLines: this.testLines,
 				testIds: this.testIds,
-				testNamePattern: this.testNamePattern
+				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.
@@ -10261,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
@@ -10376,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;
@@ -10395,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
@@ -10861,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);
@@ -10870,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 `>`.
@@ -10946,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;
@@ -11065,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() {
@@ -11100,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() {
@@ -11133,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
 	};
 }
@@ -11313,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'],
@@ -11952,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;
@@ -12051,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
@@ -12064,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)) {
@@ -12074,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;
 			});
@@ -12136,6 +12308,7 @@ class Vitest {
 	/** @internal */ reporters = [];
 	/** @internal */ runner;
 	/** @internal */ _testRun = void 0;
+	/** @internal */ _config;
 	/** @internal */ _resolver;
 	/** @internal */ _fetcher;
 	/** @internal */ _fsCache;
@@ -12145,7 +12318,6 @@ class Vitest {
 	restartsCount = 0;
 	specifications;
 	pool;
-	_config;
 	_vite;
 	_state;
 	_cache;
@@ -12233,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;
@@ -12282,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()]);
@@ -12291,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;
@@ -12793,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) {
@@ -13558,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);