vitest 4.0.16 → 4.1.0-beta.1

package/dist/chunks/{cli-api.BKg19Fvw.js → cli-api.B4CqEpI6.js}

@@ -4,7 +4,7 @@ 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 { 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.BuJUwVtg.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 * 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';
@@ -12,10 +12,10 @@ 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 { SnapshotManager } from '@vitest/snapshot/manager';
-import { v as version$1 } from './cac.BGonGPac.js';
+import { v as version$1 } from './cac.B1v3xxoC.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.456_DGfR.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 require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -29,7 +29,7 @@ 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 { T as Traces } from './traces.U4xDYhzZ.js';
+import { T as Traces } from './traces.CCmnQaNT.js';
 import { createDebug } from 'obug';
 import { rm, readFile, writeFile, rename, stat, unlink, mkdir, copyFile } from 'node:fs/promises';
 import c from 'tinyrainbow';
@@ -53,7 +53,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.Drsj_6e7.js';
+import { a as BenchmarkReportsMap } from './index.DyBZXrH3.js';
 import assert$1 from 'node:assert';
 import { serializeValue } from '@vitest/utils/serialize';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
@@ -76,6 +76,7 @@ function requireConstants () {
 
 	constants = {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT: 30000,
 	  EMPTY_BUFFER: Buffer.alloc(0),
 	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
 	  hasBlob,
@@ -2846,6 +2847,7 @@ function requireWebsocket () {
 
 	const {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT,
 	  EMPTY_BUFFER,
 	  GUID,
 	  kForOnEventAttribute,
@@ -2860,7 +2862,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 +2917,7 @@ function requireWebsocket () {
 	      initAsClient(this, address, protocols, options);
 	    } else {
 	      this._autoPong = options.autoPong;
+	      this._closeTimeout = options.closeTimeout;
 	      this._isServer = true;
 	    }
 	  }
@@ -3457,6 +3459,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 +3487,7 @@ function requireWebsocket () {
 	  const opts = {
 	    allowSynchronousEvents: true,
 	    autoPong: true,
+	    closeTimeout: CLOSE_TIMEOUT,
 	    protocolVersion: protocolVersions[1],
 	    maxPayload: 100 * 1024 * 1024,
 	    skipUTF8Validation: false,
@@ -3501,6 +3506,7 @@ function requireWebsocket () {
 	  };
 
 	  websocket._autoPong = opts.autoPong;
+	  websocket._closeTimeout = opts.closeTimeout;
 
 	  if (!protocolVersions.includes(opts.protocolVersion)) {
 	    throw new RangeError(
@@ -4118,7 +4124,7 @@ function requireWebsocket () {
 	function setCloseTimer(websocket) {
 	  websocket._closeTimer = setTimeout(
 	    websocket._socket.destroy.bind(websocket._socket),
-	    closeTimeout
+	    websocket._closeTimeout
 	  );
 	}
 
@@ -4136,23 +4142,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 +4489,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 +4516,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 +4548,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)
@@ -5327,6 +5337,12 @@ function createDebugger(namespace) {
 
 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 +5354,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 +5370,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 +5381,9 @@ function astParseFile(filepath, code) {
 			"each",
 			"for",
 			"skipIf",
-			"runIf"
+			"runIf",
+			"extend",
+			"scoped"
 		].includes(mode)) return;
 		let start;
 		const end = node.end;
@@ -5405,7 +5413,7 @@ function astParseFile(filepath, code) {
 			start,
 			end,
 			name: message,
-			type: name === "it" || name === "test" ? "test" : "suite",
+			type: isTestFunctionName(name) ? "test" : "suite",
 			mode,
 			task: null,
 			dynamic: isDynamicEach
@@ -5494,7 +5502,10 @@ 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}`);
 		if (definition.type === "suite") {
@@ -5543,7 +5554,7 @@ function createFileTask(testFilepath, code, requestMap, options) {
 	});
 	calculateSuiteHash(file);
 	const hasOnly = someTasksAreOnly(file);
-	interpretTaskModes(file, options.testNamePattern, void 0, hasOnly, false, options.allowOnly);
+	interpretTaskModes(file, options.testNamePattern, void 0, void 0, hasOnly, false, options.allowOnly);
 	markDynamicTests(file.tasks);
 	if (!file.tasks.length) file.result = {
 		state: "fail",
@@ -5570,9 +5581,9 @@ async function astCollectTests(project, filepath) {
 	});
 }
 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 environment = project.config.environment;
+	if (environment === "jsdom" || environment === "happy-dom") return project.vite.environments.client.transformRequest(filepath);
+	return project.vite.environments.ssr.transformRequest(filepath);
 }
 function markDynamicTests(tasks) {
 	for (const task of tasks) {
@@ -5771,7 +5782,7 @@ class FileSystemModuleCache {
 	*/
 	rootCache;
 	metadataFilePath;
-	version = "1.0.0-beta.3";
+	version = "1.0.0-beta.4";
 	fsCacheRoots = /* @__PURE__ */ new WeakMap();
 	fsEnvironmentHashMap = /* @__PURE__ */ new WeakMap();
 	fsCacheKeyGenerators = /* @__PURE__ */ new Set();
@@ -5828,18 +5839,16 @@ class FileSystemModuleCache {
 			url: meta.url,
 			file: meta.file,
 			code,
-			importers: meta.importers,
 			importedUrls: meta.importedUrls,
 			mappings: meta.mappings
 		};
 	}
-	async saveCachedModule(cachedFilePath, fetchResult, importers = [], importedUrls = [], mappings = false) {
+	async saveCachedModule(cachedFilePath, fetchResult, importedUrls = [], mappings = false) {
 		if ("code" in fetchResult) {
 			const result = {
 				file: fetchResult.file,
 				id: fetchResult.id,
 				url: fetchResult.url,
-				importers,
 				importedUrls,
 				mappings
 			};
@@ -6178,17 +6187,16 @@ class ModuleFetcher {
 			this.recordResult(trace, result);
 			return result;
 		});
-		const cachedModule = await this.getCachedModule(cachePath, environment, moduleGraphModule);
+		const cachedModule = await this.getCachedModule(cachePath, environment, moduleGraphModule, importer);
 		if (cachedModule) {
 			this.recordResult(trace, cachedModule);
 			return cachedModule;
 		}
 		const result = await this.fetchAndProcess(environment, url, importer, moduleGraphModule, options);
-		const importers = this.getSerializedDependencies(moduleGraphModule);
 		const importedUrls = this.getSerializedImports(moduleGraphModule);
 		const map = moduleGraphModule.transformResult?.map;
 		const mappings = map && !("version" in map) && map.mappings === "";
-		return this.cacheResult(result, cachePath, importers, importedUrls, !!mappings);
+		return this.cacheResult(result, cachePath, importedUrls, !!mappings);
 	}
 	// we need this for UI to be able to show a module graph
 	getSerializedImports(node) {
@@ -6198,14 +6206,6 @@ class ModuleFetcher {
 		});
 		return imports;
 	}
-	// we need this for the watcher to be able to find the related test file
-	getSerializedDependencies(node) {
-		const dependencies = [];
-		node.importers.forEach((importer) => {
-			if (importer.id) dependencies.push(importer.id);
-		});
-		return dependencies;
-	}
 	recordResult(trace, result) {
 		if ("externalize" in result) trace.setAttributes({
 			"vitest.fetched_module.external": result.externalize,
@@ -6242,7 +6242,7 @@ class ModuleFetcher {
 		if (loadResult != null) return loadResult.code;
 		return "";
 	}
-	async getCachedModule(cachePath, environment, moduleGraphModule) {
+	async getCachedModule(cachePath, environment, moduleGraphModule, importer) {
 		if (moduleGraphModule.transformResult?.__vitestTmp) return {
 			cached: true,
 			file: moduleGraphModule.file,
@@ -6265,13 +6265,16 @@ class ModuleFetcher {
 			__vitestTmp: cachePath
 		};
 		// we populate the module graph to make the watch mode work because it relies on importers
-		cachedModule.importers.forEach((importer) => {
+		if (importer) {
 			const environmentNode = environment.moduleGraph.getModuleById(importer);
 			if (environmentNode) moduleGraphModule.importers.add(environmentNode);
-		});
+		}
 		await Promise.all(cachedModule.importedUrls.map(async (url) => {
 			const moduleNode = await environment.moduleGraph.ensureEntryFromUrl(url).catch(() => null);
-			if (moduleNode) moduleGraphModule.importedModules.add(moduleNode);
+			if (moduleNode) {
+				moduleNode.importers.add(moduleGraphModule);
+				moduleGraphModule.importedModules.add(moduleNode);
+			}
 		}));
 		return {
 			cached: true,
@@ -6288,13 +6291,13 @@ class ModuleFetcher {
 			inlineSourceMap: false
 		}).catch(handleRollupError));
 	}
-	async cacheResult(result, cachePath, importers = [], importedUrls = [], mappings = false) {
+	async cacheResult(result, cachePath, importedUrls = [], mappings = false) {
 		const returnResult = "code" in result ? getCachedResult(result, cachePath) : result;
 		if (saveCachePromises.has(cachePath)) {
 			await saveCachePromises.get(cachePath);
 			return returnResult;
 		}
-		const savePromise = this.fsCache.saveCachedModule(cachePath, result, importers, importedUrls, mappings).then(() => result).finally(() => {
+		const savePromise = this.fsCache.saveCachedModule(cachePath, result, importedUrls, mappings).then(() => result).finally(() => {
 			saveCachePromises.delete(cachePath);
 		});
 		saveCachePromises.set(cachePath, savePromise);
@@ -7056,11 +7059,13 @@ function createBrowserPool(vitest) {
 	};
 	const runWorkspaceTests = async (method, specs) => {
 		const groupedFiles = /* @__PURE__ */ new Map();
-		for (const { project, moduleId, testLines } of specs) {
+		for (const { project, moduleId, testLines, testIds, testNamePattern } of specs) {
 			const files = groupedFiles.get(project) || [];
 			files.push({
 				filepath: moduleId,
-				testLocations: testLines
+				testLocations: testLines,
+				testIds,
+				testNamePattern
 			});
 			groupedFiles.set(project, files);
 		}
@@ -7129,12 +7134,21 @@ class BrowserPool {
 	_promise;
 	_providedContext;
 	readySessions = /* @__PURE__ */ new Set();
+	_traces;
+	_otel;
 	constructor(project, options) {
 		this.project = project;
 		this.options = options;
+		this._traces = project.vitest._traces;
+		this._otel = this._traces.startContextSpan("vitest.browser");
+		this._otel.span.setAttributes({
+			"vitest.project": project.name,
+			"vitest.browser.provider": this.project.browser.provider.name
+		});
 	}
 	cancel() {
 		this._queue = [];
+		this._otel.span.end();
 	}
 	reject(error) {
 		this._promise?.reject(error);
@@ -7172,7 +7186,11 @@ class BrowserPool {
 			this.project.vitest._browserSessions.sessionIds.add(sessionId);
 			const project = this.project.name;
 			debug?.("[%s] creating session for %s", sessionId, project);
-			const page = this.openPage(sessionId).then(() => {
+			let page = this._traces.$(`vitest.browser.open`, {
+				context: this._otel.context,
+				attributes: { "vitest.browser.session_id": sessionId }
+			}, () => this.openPage(sessionId));
+			page = page.then(() => {
 				// start running tests on the page when it's ready
 				this.runNextTest(method, sessionId);
 			});
@@ -7187,6 +7205,8 @@ class BrowserPool {
 		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());
 		await Promise.all([sessionPromise, pagePromise]);
 	}
@@ -7199,6 +7219,7 @@ class BrowserPool {
 		this.readySessions.add(sessionId);
 		// the last worker finished running tests
 		if (this.readySessions.size === this.orchestrators.size) {
+			this._otel.span.end();
 			this._promise?.resolve();
 			this._promise = void 0;
 			debug?.("[%s] all tests finished running", sessionId);
@@ -7221,11 +7242,16 @@ class BrowserPool {
 		const orchestrator = this.getOrchestrator(sessionId);
 		debug?.("[%s] run test %s", sessionId, file);
 		this.setBreakpoint(sessionId, file.filepath).then(() => {
-			// this starts running tests inside the orchestrator
-			orchestrator.createTesters({
-				method,
-				files: [file],
-				providedContext: this._providedContext || "[{}]"
+			this._traces.$(`vitest.browser.run`, {
+				context: this._otel.context,
+				attributes: { "code.file.path": file.filepath }
+			}, async () => {
+				return orchestrator.createTesters({
+					method,
+					files: [file],
+					providedContext: this._providedContext || "[{}]",
+					otelCarrier: this._traces.getContextCarrier()
+				});
 			}).then(() => {
 				debug?.("[%s] test %s finished running", sessionId, file);
 				this.runNextTest(method, sessionId);
@@ -7359,6 +7385,7 @@ var RunnerState = /* @__PURE__ */ function(RunnerState) {
 	RunnerState["IDLE"] = "idle";
 	RunnerState["STARTING"] = "starting";
 	RunnerState["STARTED"] = "started";
+	RunnerState["START_FAILURE"] = "start_failure";
 	RunnerState["STOPPING"] = "stopping";
 	RunnerState["STOPPED"] = "stopped";
 	return RunnerState;
@@ -7420,6 +7447,14 @@ class PoolRunner {
 		});
 		this._offCancel = vitest.onCancel((reason) => this._rpc.onCancel(reason));
 	}
+	/**
+	* "reconfigure" can only be called if `environment` is different, since different project always
+	* requires a new PoolRunner instance.
+	*/
+	reconfigure(task) {
+		this.environment = task.context.environment;
+		this._otel?.span.setAttribute("vitest.environment", this.environment.name);
+	}
 	postMessage(message) {
 		// Only send messages when runner is active (not fully stopped)
 		// Allow sending during STOPPING state for the 'stop' message itself
@@ -7495,7 +7530,7 @@ class PoolRunner {
 			await startPromise;
 			this._state = RunnerState.STARTED;
 		} catch (error) {
-			this._state = RunnerState.IDLE;
+			this._state = RunnerState.START_FAILURE;
 			startSpan?.recordException(error);
 			throw error;
 		} finally {
@@ -7932,6 +7967,9 @@ class VmForksPoolWorker extends ForksPoolWorker {
 		/** Loads {@link file://./../../../runtime/workers/vmForks.ts} */
 		this.entrypoint = resolve$1(options.distPath, "workers/vmForks.js");
 	}
+	canReuse() {
+		return true;
+	}
 }
 
 /** @experimental */
@@ -7947,6 +7985,9 @@ class VmThreadsPoolWorker extends ThreadsPoolWorker {
 		/** Loads {@link file://./../../../runtime/workers/vmThreads.ts} */
 		this.entrypoint = resolve$1(options.distPath, "workers/vmThreads.js");
 	}
+	canReuse() {
+		return true;
+	}
 }
 
 const WORKER_START_TIMEOUT = 9e4;
@@ -8015,17 +8056,15 @@ class Pool {
 					resolver.reject(new Error(`[vitest-pool]: Worker ${task.worker} emitted error.`, { cause: error }));
 				});
 				const id = setTimeout(() => resolver.reject(/* @__PURE__ */ new Error(`[vitest-pool]: Timeout starting ${task.worker} runner.`)), WORKER_START_TIMEOUT);
-				await runner.start({ workerId: task.context.workerId }).finally(() => clearTimeout(id));
+				await runner.start({ workerId: task.context.workerId }).catch((error) => resolver.reject(new Error(`[vitest-pool]: Failed to start ${task.worker} worker for test files ${formatFiles(task)}.`, { cause: error }))).finally(() => clearTimeout(id));
 			}
-			const span = runner.startTracesSpan(`vitest.worker.${method}`);
-			// Start running the test in the worker
-			runner.request(method, task.context);
-			await resolver.promise.catch((error) => {
-				span.recordException(error);
-				throw error;
-			}).finally(() => {
-				span.end();
-			});
+			let span;
+			if (!resolver.isRejected) {
+				span = runner.startTracesSpan(`vitest.worker.${method}`);
+				// Start running the test in the worker
+				runner.request(method, task.context);
+			}
+			await resolver.promise.catch((error) => span?.recordException(error)).finally(() => span?.end());
 			const index = this.activeTasks.indexOf(activeTask);
 			if (index !== -1) this.activeTasks.splice(index, 1);
 			if (!task.isolate && !isMemoryLimitReached && this.queue[0]?.task.isolate === false && isEqualRunner(runner, this.queue[0].task)) {
@@ -8036,7 +8075,7 @@ class Pool {
 			// Runner termination can also already start from task cancellation.
 			if (!runner.isTerminated) {
 				const id = setTimeout(() => this.logger.error(`[vitest-pool]: Timeout terminating ${task.worker} worker for test files ${formatFiles(task)}.`), this.options.teardownTimeout);
-				this.exitPromises.push(runner.stop().then(() => clearTimeout(id)).catch((error) => this.logger.error(`[vitest-pool]: Failed to terminate ${task.worker} worker for test files ${formatFiles(task)}.`, error)));
+				this.exitPromises.push(runner.stop({ force: resolver.isRejected }).then(() => clearTimeout(id)).catch((error) => this.logger.error(`[vitest-pool]: Failed to terminate ${task.worker} worker for test files ${formatFiles(task)}.`, error)));
 			}
 			this.freeWorkerId(poolId);
 		} 
@@ -8073,13 +8112,17 @@ catch (error) {
 	getPoolRunner(task, method) {
 		if (task.isolate === false) {
 			const index = this.sharedRunners.findIndex((runner) => isEqualRunner(runner, task));
-			if (index !== -1) return this.sharedRunners.splice(index, 1)[0];
+			if (index !== -1) {
+				const runner = this.sharedRunners.splice(index, 1)[0];
+				runner.reconfigure(task);
+				return runner;
+			}
 		}
 		const options = {
 			distPath: this.options.distPath,
 			project: task.project,
 			method,
-			environment: task.environment,
+			environment: task.context.environment,
 			env: task.env,
 			execArgv: task.execArgv
 		};
@@ -8111,22 +8154,44 @@ catch (error) {
 function withResolvers() {
 	let resolve = () => {};
 	let reject = (_error) => {};
-	const promise = new Promise((res, rej) => {
-		resolve = res;
-		reject = rej;
-	});
-	return {
+	const resolver = {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
 		resolve,
-		reject,
-		promise
+		reject: (reason) => {
+			resolver.isRejected = true;
+			reject(reason);
+		},
+		isRejected: false
 	};
+	return resolver;
 }
 function formatFiles(task) {
 	return task.context.files.map((file) => file.filepath).join(", ");
 }
 function isEqualRunner(runner, task) {
 	if (task.isolate) throw new Error("Isolated tasks should not share runners");
-	return runner.worker.name === task.worker && runner.project === task.project && runner.environment.name === task.environment.name && (!runner.worker.canReuse || runner.worker.canReuse(task));
+	if (runner.worker.name !== task.worker || runner.project !== task.project) return false;
+	// by default, check that the environments are the same
+	// some workers (like vmThreads/vmForks) do not need this check
+	if (!runner.worker.canReuse) return isEnvironmentEqual(task.context.environment, runner.environment);
+	return runner.worker.canReuse(task);
+}
+function isEnvironmentEqual(env1, env2) {
+	if (env1.name !== env2.name) return false;
+	return deepEqual(env1.options, env2.options);
+}
+function deepEqual(obj1, obj2) {
+	if (obj1 === obj2) return true;
+	if (obj1 == null || obj2 == null) return obj1 === obj2;
+	if (typeof obj1 !== "object" || typeof obj2 !== "object") return false;
+	const keys1 = Object.keys(obj1);
+	const keys2 = Object.keys(obj2);
+	if (keys1.length !== keys2.length) return false;
+	for (const key of keys1) if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) return false;
+	return true;
 }
 
 const suppressWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
@@ -8195,13 +8260,15 @@ function createPool(ctx) {
 					context: {
 						files: specs.map((spec) => ({
 							filepath: spec.moduleId,
-							testLocations: spec.testLines
+							testLocations: spec.testLines,
+							testNamePattern: spec.testNamePattern,
+							testIds: spec.testIds
 						})),
 						invalidates,
 						providedContext: project.getProvidedContext(),
-						workerId: workerId++
+						workerId: workerId++,
+						environment
 					},
-					environment,
 					project,
 					env,
 					execArgv,
@@ -8468,7 +8535,8 @@ function serializeConfig(project) {
 		serializedDefines: config.browser.enabled ? "" : project._serializedDefines || "",
 		experimental: {
 			fsModuleCache: config.experimental.fsModuleCache ?? false,
-			printImportBreakdown: config.experimental.printImportBreakdown
+			printImportBreakdown: config.experimental.printImportBreakdown,
+			openTelemetry: config.experimental.openTelemetry
 		}
 	};
 }
@@ -9550,6 +9618,7 @@ function WorkspaceVitestPlugin(project, options) {
 				this.meta.watchMode = false;
 			},
 			config(viteConfig) {
+				const originalDefine = { ...viteConfig.define };
 				const defines = deleteDefineConfig(viteConfig);
 				const testConfig = viteConfig.test || {};
 				const root = testConfig.root || viteConfig.root || options.root;
@@ -9586,6 +9655,7 @@ function WorkspaceVitestPlugin(project, options) {
 					}
 				};
 				config.test.defines = defines;
+				config.test.viteDefine = originalDefine;
 				const classNameStrategy = typeof testConfig.css !== "boolean" && testConfig.css?.modules?.classNameStrategy || "stable";
 				if (classNameStrategy !== "scoped") {
 					config.css ??= {};
@@ -9752,7 +9822,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;
 	/**
@@ -9760,29 +9830,46 @@ 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;
+	/**
+	* 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;
+		}
 	}
 	/**
-	* 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);
@@ -9798,7 +9885,9 @@ class TestSpecification {
 			this.moduleId,
 			{
 				pool: this.pool,
-				testLines: this.testLines
+				testLines: this.testLines,
+				testIds: this.testIds,
+				testNamePattern: this.testNamePattern
 			}
 		];
 	}
@@ -9907,8 +9996,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 {
@@ -10106,7 +10195,7 @@ class TestProject {
 	_initParentBrowser = deduped(async (childProject) => {
 		if (!this.isBrowserEnabled() || this._parentBrowser) return;
 		const provider = this.config.browser.provider || childProject.config.browser.provider;
-		if (provider == null) throw new Error(`Proider was not specified in the "browser.provider" setting. Please, pass down playwright(), webdriverio() or preview() from "@vitest/browser-playwright", "@vitest/browser-webdriverio" or "@vitest/browser-preview" package respectively.`);
+		if (provider == null) throw new Error(`Provider was not specified in the "browser.provider" setting. Please, pass down playwright(), webdriverio() or preview() from "@vitest/browser-playwright", "@vitest/browser-webdriverio" or "@vitest/browser-preview" package respectively.`);
 		if (typeof provider.serverFactory !== "function") throw new TypeError(`The browser provider options do not return a "serverFactory" function. Are you using the latest "@vitest/browser-${provider.name}" package?`);
 		const browser = await provider.serverFactory({
 			project: this,
@@ -10133,7 +10222,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();
@@ -10159,6 +10248,7 @@ class TestProject {
 			...options,
 			coverage: this.vitest.config.coverage
 		}, server.config);
+		this._config.api.token = this.vitest.config.api.token;
 		this._setHash();
 		for (const _providedKey in this.config.provide) {
 			const providedKey = _providedKey;
@@ -10411,7 +10501,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	return resolvedProjects.filter((project) => !removeProjects.has(project));
 }
 function cloneConfig(project, { browser, ...config }) {
-	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name, provider, ...overrideConfig } = config;
+	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, fileParallelism, browser: _browser, name, provider, ...overrideConfig } = config;
 	const currentConfig = project.config.browser;
 	const clonedConfig = deepClone(project.config);
 	return mergeConfig({
@@ -10425,6 +10515,7 @@ function cloneConfig(project, { browser, ...config }) {
 			screenshotFailures: screenshotFailures ?? currentConfig.screenshotFailures,
 			headless: headless ?? currentConfig.headless,
 			provider: provider ?? currentConfig.provider,
+			fileParallelism: fileParallelism ?? currentConfig.fileParallelism,
 			name: browser,
 			instances: []
 		},
@@ -11767,6 +11858,12 @@ class TestRun {
 		const task = this.vitest.state.idMap.get(id);
 		const entity = task && this.vitest.state.getReportedEntity(task);
 		assert$1(task && entity, `Entity must be found for task ${task?.name || id}`);
+		if (event === "suite-failed-early" && entity.type === "module") {
+			// the file failed during import
+			await this.vitest.report("onTestModuleStart", entity);
+			await this.vitest.report("onTestModuleEnd", entity);
+			return;
+		}
 		if (event === "suite-prepare" && entity.type === "suite") return await this.vitest.report("onTestSuiteReady", entity);
 		if (event === "suite-prepare" && entity.type === "module") return await this.vitest.report("onTestModuleStart", entity);
 		if (event === "suite-finished") {
@@ -12401,7 +12498,7 @@ class Vitest {
 	* @param filters String filters to match the test files
 	*/
 	async start(filters) {
-		return this._traces.$("vitest.start", async (startSpan) => {
+		return this._traces.$("vitest.start", { context: this._traces.getContextFromEnv(process.env) }, async (startSpan) => {
 			startSpan.setAttributes({ config: this.vite.config.configFile });
 			try {
 				await this._traces.$("vitest.coverage.init", async () => {
@@ -12413,7 +12510,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);
@@ -12423,7 +12520,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 });
@@ -12437,10 +12534,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;
@@ -12499,6 +12596,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.
@@ -12989,7 +13099,12 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				// this is repeated in configResolved where the config is final
 				const testConfig = deepMerge({}, configDefaults, removeUndefinedValues(viteConfig.test ?? {}), options);
 				testConfig.api = resolveApiServerConfig(testConfig, defaultPort);
-				options.defines = deleteDefineConfig(viteConfig);
+				// store defines for globalThis to make them
+				// reassignable when running in worker in src/runtime/setup.ts
+				const originalDefine = { ...viteConfig.define };
+				const defines = deleteDefineConfig(viteConfig);
+				options.defines = defines;
+				options.viteDefine = originalDefine;
 				let open = false;
 				if (testConfig.ui && testConfig.open) open = testConfig.uiBase ?? "/__vitest__/";
 				const resolveOptions = getDefaultResolveOptions();