vitest 4.0.0-beta.4 → 4.0.0-beta.6

package/dist/chunks/{cli-api.B8xRY9Zt.js → cli-api.CZz3evYC.js}

@@ -1,19 +1,17 @@
 import fs, { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { relative, resolve, dirname, extname, normalize, join, basename, isAbsolute } from 'pathe';
-import { C as CoverageProviderMap } from './coverage.DVF1vEu8.js';
+import { C as CoverageProviderMap } from './coverage.D_JHT54q.js';
 import path, { resolve as resolve$1 } from 'node:path';
-import { noop, isPrimitive, createDefer, slash, highlight, toArray, deepMerge, nanoid, deepClone, notNullish } from '@vitest/utils';
+import { noop, isPrimitive, createDefer, slash, highlight, toArray, cleanUrl, deepMerge, KNOWN_ASSET_RE, nanoid, deepClone, notNullish } from '@vitest/utils';
 import { f as findUp, p as prompt } from './index.X0nbfr6-.js';
 import * as vite from 'vite';
-import { searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
-import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.CXzqaLmq.js';
+import { searchForWorkspaceRoot, version, mergeConfig, createServer } from 'vite';
+import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.D_Q9UYh-.js';
 import { generateFileHash, limitConcurrency, createFileTask, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { ViteNodeRunner } from 'vite-node/client';
-import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.CY0IAxC4.js';
+import { v as version$1 } from './cac.WE-urWw5.js';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.Bz6b0Ib7.js';
+import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.VNI-1z5c.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -28,22 +26,25 @@ import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import crypto, { createHash } from 'node:crypto';
 import { distDir, rootDir } from '../path.js';
-import { h as hash, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, d as isBrowserEnabled, r as resolveConfig, e as groupBy, f as getCoverageProvider, j as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.C84l9G-M.js';
-import { c as convertTasksToEvents } from './typechecker.CMNPqJOo.js';
+import { h as hash, d as createFetchModuleFunction, n as normalizeResolvedIdToUrl, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, e as isBrowserEnabled, r as resolveConfig, f as groupBy, j as getCoverageProvider, k as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.BPRS6xgn.js';
+import { c as convertTasksToEvents } from './typechecker.Cd1wvxUM.js';
+import { VitestModuleEvaluator } from '#module-evaluator';
+import { ModuleRunner } from 'vite/module-runner';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
-import { createRequire } from 'node:module';
-import url from 'node:url';
+import { createRequire, builtinModules, isBuiltin } from 'node:module';
+import url, { pathToFileURL } from 'node:url';
 import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
 import { rm, mkdir, copyFile } from 'node:fs/promises';
 import nodeos__default, { tmpdir } from 'node:os';
 import pm from 'picomatch';
 import { glob, isDynamicPattern } from 'tinyglobby';
-import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
+import MagicString from 'magic-string';
 import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
 import { c as configDefaults } from './defaults.CXFFjsi8.js';
-import MagicString from 'magic-string';
-import { a as BenchmarkReportsMap } from './index.D3SKT3tv.js';
+import { f as findNearestPackageData } from './resolver.Bx6lE0iq.js';
+import * as esModuleLexer from 'es-module-lexer';
+import { a as BenchmarkReportsMap } from './index.7w0eqmYM.js';
 import assert$1 from 'node:assert';
 import { serializeError } from '@vitest/utils/error';
 import readline from 'node:readline';
@@ -5016,25 +5017,18 @@ var websocketServerExports = requireWebsocketServer();
 var WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServerExports);
 
 async function getModuleGraph(ctx, projectName, id, browser = false) {
-	const graph = {};
-	const externalized = /* @__PURE__ */ new Set();
-	const inlined = /* @__PURE__ */ new Set();
-	const project = ctx.getProjectByName(projectName);
+	const graph = {}, externalized = /* @__PURE__ */ new Set(), inlined = /* @__PURE__ */ new Set(), project = ctx.getProjectByName(projectName);
 	async function get(mod, seen = /* @__PURE__ */ new Map()) {
-		if (!mod || !mod.id) return;
-		if (mod.id === "\0@vitest/browser/context") return;
+		if (!mod || !mod.id || mod.id === "\0@vitest/browser/context") return;
 		if (seen.has(mod)) return seen.get(mod);
 		let id = clearId(mod.id);
 		seen.set(mod, id);
-		const rewrote = browser ? mod.file?.includes(project.browser.vite.config.cacheDir) ? mod.id : false : await project.vitenode.shouldExternalize(id);
-		if (rewrote) {
-			id = rewrote;
-			externalized.add(id);
-			seen.set(mod, id);
-		} else inlined.add(id);
+		// TODO: how to know if it was rewritten(?) - what is rewritten?
+		const rewrote = browser ? mod.file?.includes(project.browser.vite.config.cacheDir) ? mod.id : false : false;
+		if (rewrote) id = rewrote, externalized.add(id), seen.set(mod, id);
+		else inlined.add(id);
 		const mods = Array.from(mod.importedModules).filter((i) => i.id && !i.id.includes("/vitest/dist/"));
-		graph[id] = (await Promise.all(mods.map((m) => get(m, seen)))).filter(Boolean);
-		return id;
+		return graph[id] = (await Promise.all(mods.map((m) => get(m, seen)))).filter(Boolean), id;
 	}
 	if (browser && project.browser) await get(project.browser.vite.moduleGraph.getModuleById(id));
 	else await get(project.vite.moduleGraph.getModuleById(id));
@@ -5086,21 +5080,19 @@ catch {}
 }
 
 function setup(ctx, _server) {
-	const wss = new WebSocketServer({ noServer: true });
-	const clients = /* @__PURE__ */ new Map();
-	const server = _server || ctx.server;
+	const wss = new WebSocketServer({ noServer: true }), clients = /* @__PURE__ */ new Map(), server = _server || ctx.server;
 	server.httpServer?.on("upgrade", (request, socket, head) => {
 		if (!request.url) return;
 		const { pathname } = new URL(request.url, "http://localhost");
-		if (pathname !== API_PATH) return;
-		if (!isValidApiRequest(ctx.config, request)) {
-			socket.destroy();
-			return;
+		if (pathname === API_PATH) {
+			if (!isValidApiRequest(ctx.config, request)) {
+				socket.destroy();
+				return;
+			}
+			wss.handleUpgrade(request, socket, head, (ws) => {
+				wss.emit("connection", ws, request), setupClient(ws);
+			});
 		}
-		wss.handleUpgrade(request, socket, head, (ws) => {
-			wss.emit("connection", ws, request);
-			setupClient(ws);
-		});
 	});
 	function setupClient(ws) {
 		const rpc = createBirpc({
@@ -5114,8 +5106,7 @@ function setup(ctx, _server) {
 				return ctx.state.getPaths();
 			},
 			async readTestFile(id) {
-				if (!ctx.state.filesMap.has(id) || !existsSync(id)) return null;
-				return promises.readFile(id, "utf-8");
+				return !ctx.state.filesMap.has(id) || !existsSync(id) ? null : promises.readFile(id, "utf-8");
 			},
 			async saveTestFile(id, content) {
 				if (!ctx.state.filesMap.has(id) || !existsSync(id)) throw new Error(`Test file "${id}" was not registered, so it cannot be updated using the API.`);
@@ -5137,8 +5128,7 @@ function setup(ctx, _server) {
 				}));
 			},
 			async getTransformResult(projectName, id, browser = false) {
-				const project = ctx.getProjectByName(projectName);
-				const result = browser ? await project.browser.vite.transformRequest(id) : await project.vitenode.transformRequest(id);
+				const project = ctx.getProjectByName(projectName), result = browser ? await project.browser.vite.transformRequest(id) : await project.vite.transformRequest(id);
 				if (result) {
 					try {
 						result.source = result.source || await promises.readFile(id, "utf-8");
@@ -5181,56 +5171,49 @@ function setup(ctx, _server) {
 			deserialize: parse,
 			timeout: -1
 		});
-		clients.set(ws, rpc);
-		ws.on("close", () => {
-			clients.delete(ws);
-			rpc.$close(/* @__PURE__ */ new Error("[vitest-api]: Pending methods while closing rpc"));
+		clients.set(ws, rpc), ws.on("close", () => {
+			clients.delete(ws), rpc.$close(/* @__PURE__ */ new Error("[vitest-api]: Pending methods while closing rpc"));
 		});
 	}
 	ctx.reporters.push(new WebSocketReporter(ctx, wss, clients));
 }
 class WebSocketReporter {
 	constructor(ctx, wss, clients) {
-		this.ctx = ctx;
-		this.wss = wss;
-		this.clients = clients;
+		this.ctx = ctx, this.wss = wss, this.clients = clients;
 	}
-	onCollected(files) {
-		if (this.clients.size === 0) return;
-		this.clients.forEach((client) => {
-			client.onCollected?.(files)?.catch?.(noop);
+	onTestModuleCollected(testModule) {
+		this.clients.size !== 0 && this.clients.forEach((client) => {
+			client.onCollected?.([testModule.task])?.catch?.(noop);
 		});
 	}
-	onSpecsCollected(specs) {
+	onTestRunStart(specifications) {
 		if (this.clients.size === 0) return;
+		const serializedSpecs = specifications.map((spec) => spec.toJSON());
 		this.clients.forEach((client) => {
-			client.onSpecsCollected?.(specs)?.catch?.(noop);
+			client.onSpecsCollected?.(serializedSpecs)?.catch?.(noop);
 		});
 	}
 	async onTestCaseAnnotate(testCase, annotation) {
-		if (this.clients.size === 0) return;
-		this.clients.forEach((client) => {
+		this.clients.size !== 0 && this.clients.forEach((client) => {
 			client.onTestAnnotate?.(testCase.id, annotation)?.catch?.(noop);
 		});
 	}
 	async onTaskUpdate(packs, events) {
-		if (this.clients.size === 0) return;
-		packs.forEach(([taskId, result]) => {
-			const task = this.ctx.state.idMap.get(taskId);
-			const isBrowser = task && task.file.pool === "browser";
+		this.clients.size !== 0 && (packs.forEach(([taskId, result]) => {
+			const task = this.ctx.state.idMap.get(taskId), isBrowser = task && task.file.pool === "browser";
 			result?.errors?.forEach((error) => {
-				if (isPrimitive(error)) return;
-				if (isBrowser) {
+				if (!isPrimitive(error)) if (isBrowser) {
 					const project = this.ctx.getProjectByName(task.file.projectName || "");
 					error.stacks = project.browser?.parseErrorStacktrace(error);
 				} else error.stacks = parseErrorStacktrace(error);
 			});
-		});
-		this.clients.forEach((client) => {
+		}), this.clients.forEach((client) => {
 			client.onTaskUpdate?.(packs, events)?.catch?.(noop);
-		});
+		}));
 	}
-	onFinished(files, errors) {
+	onTestRunEnd(testModules, unhandledErrors) {
+		if (!this.clients.size) return;
+		const files = testModules.map((testModule) => testModule.task), errors = [...unhandledErrors];
 		this.clients.forEach((client) => {
 			client.onFinished?.(files, errors)?.catch?.(noop);
 		});
@@ -5264,23 +5247,18 @@ class BrowserSessions {
 	}
 	createSession(sessionId, project, pool) {
 		// this promise only waits for the WS connection with the orhcestrator to be established
-		const defer = createDefer();
-		const timeout = setTimeout(() => {
+		const defer = createDefer(), timeout = setTimeout(() => {
 			defer.reject(/* @__PURE__ */ new Error(`Failed to connect to the browser session "${sessionId}" [${project.name}] within the timeout.`));
 		}, project.vitest.config.browser.connectTimeout ?? 6e4).unref();
-		this.sessions.set(sessionId, {
+		return this.sessions.set(sessionId, {
 			project,
 			connected: () => {
-				defer.resolve();
-				clearTimeout(timeout);
+				defer.resolve(), clearTimeout(timeout);
 			},
 			fail: (error) => {
-				defer.resolve();
-				clearTimeout(timeout);
-				pool.reject(error);
+				defer.resolve(), clearTimeout(timeout), pool.reject(error);
 			}
-		});
-		return defer;
+		}), defer;
 	}
 }
 
@@ -5321,37 +5299,25 @@ class ResultsCache {
 		return this.cachePath;
 	}
 	setConfig(root, config) {
-		this.root = root;
-		if (config) this.cachePath = resolve(config.dir, "results.json");
+		if (this.root = root, config) this.cachePath = resolve(config.dir, "results.json");
 	}
 	getResults(key) {
 		return this.cache.get(key);
 	}
 	async readFromCache() {
-		if (!this.cachePath) return;
-		if (!fs.existsSync(this.cachePath)) return;
-		const resultsCache = await fs.promises.readFile(this.cachePath, "utf8");
-		const { results, version } = JSON.parse(resultsCache || "[]");
-		const [major, minor] = version.split(".");
+		if (!this.cachePath || !fs.existsSync(this.cachePath)) return;
+		const resultsCache = await fs.promises.readFile(this.cachePath, "utf8"), { results, version } = JSON.parse(resultsCache || "[]"), [major, minor] = version.split(".");
 		// handling changed in 0.30.0
-		if (major > 0 || Number(minor) >= 30) {
-			this.cache = new Map(results);
-			this.version = version;
-			results.forEach(([spec]) => {
-				const [projectName, relativePath] = spec.split(":");
-				const keyMap = this.workspacesKeyMap.get(relativePath) || [];
-				keyMap.push(projectName);
-				this.workspacesKeyMap.set(relativePath, keyMap);
-			});
-		}
+		if (major > 0 || Number(minor) >= 30) this.cache = new Map(results), this.version = version, results.forEach(([spec]) => {
+			const [projectName, relativePath] = spec.split(":"), keyMap = this.workspacesKeyMap.get(relativePath) || [];
+			keyMap.push(projectName), this.workspacesKeyMap.set(relativePath, keyMap);
+		});
 	}
 	updateResults(files) {
 		files.forEach((file) => {
 			const result = file.result;
 			if (!result) return;
-			const duration = result.duration || 0;
-			// store as relative, so cache would be the same in CI and locally
-			const relativePath = relative(this.root, file.filepath);
+			const duration = result.duration || 0, relativePath = relative(this.root, file.filepath);
 			this.cache.set(`${file.projectName || ""}:${relativePath}`, {
 				duration: duration >= 0 ? duration : 0,
 				failed: result.state === "fail"
@@ -5365,8 +5331,7 @@ class ResultsCache {
 	}
 	async writeToCache() {
 		if (!this.cachePath) return;
-		const results = Array.from(this.cache.entries());
-		const cacheDirname = dirname(this.cachePath);
+		const results = Array.from(this.cache.entries()), cacheDirname = dirname(this.cachePath);
 		if (!fs.existsSync(cacheDirname)) await fs.promises.mkdir(cacheDirname, { recursive: true });
 		const cache = JSON.stringify({
 			version: this.version,
@@ -5394,6 +5359,34 @@ class VitestCache {
 	}
 }
 
+class ServerModuleRunner extends ModuleRunner {
+	constructor(environment, resolver, config) {
+		const fetchModule = createFetchModuleFunction(resolver, false);
+		super({
+			hmr: false,
+			sourcemapInterceptor: "node",
+			transport: { async invoke(event) {
+				if (event.type !== "custom") throw new Error(`Vitest Module Runner doesn't support Vite HMR events.`);
+				const { data } = event.data;
+				try {
+					const result = await fetchModule(data[0], data[1], environment, data[2]);
+					return { result };
+				} catch (error) {
+					return { error };
+				}
+			} }
+		}, new VitestModuleEvaluator()), this.environment = environment, this.config = config;
+	}
+	async import(rawId) {
+		const resolved = await this.environment.pluginContainer.resolveId(rawId, this.config.root);
+		if (!resolved) return super.import(rawId);
+		// Vite will make "@vitest/coverage-v8" into "@vitest/coverage-v8.js" url
+		// instead of using an actual file path-like URL, so we resolve it here first
+		const url = normalizeResolvedIdToUrl(this.environment, resolved.id);
+		return super.import(url);
+	}
+}
+
 class FilesNotFoundError extends Error {
 	code = "VITEST_FILES_NOT_FOUND";
 	constructor(mode) {
@@ -5449,43 +5442,26 @@ function highlightCode(id, source, colors) {
 	});
 }
 
-const PAD = "      ";
-const ESC$1 = "\x1B[";
-const ERASE_DOWN = `${ESC$1}J`;
-const ERASE_SCROLLBACK = `${ESC$1}3J`;
-const CURSOR_TO_START = `${ESC$1}1;1H`;
-const HIDE_CURSOR = `${ESC$1}?25l`;
-const SHOW_CURSOR = `${ESC$1}?25h`;
-const CLEAR_SCREEN = "\x1Bc";
+const PAD = "      ", ESC$1 = "\x1B[", ERASE_DOWN = `${ESC$1}J`, ERASE_SCROLLBACK = `${ESC$1}3J`, CURSOR_TO_START = `${ESC$1}1;1H`, HIDE_CURSOR = `${ESC$1}?25l`, SHOW_CURSOR = `${ESC$1}?25h`, CLEAR_SCREEN = "\x1Bc";
 class Logger {
 	_clearScreenPending;
 	_highlights = /* @__PURE__ */ new Map();
 	cleanupListeners = [];
 	console;
 	constructor(ctx, outputStream = process.stdout, errorStream = process.stderr) {
-		this.ctx = ctx;
-		this.outputStream = outputStream;
-		this.errorStream = errorStream;
-		this.console = new Console({
+		if (this.ctx = ctx, this.outputStream = outputStream, this.errorStream = errorStream, this.console = new Console({
 			stdout: outputStream,
 			stderr: errorStream
-		});
-		this._highlights.clear();
-		this.addCleanupListeners();
-		this.registerUnhandledRejection();
-		if (this.outputStream.isTTY) this.outputStream.write(HIDE_CURSOR);
+		}), this._highlights.clear(), this.addCleanupListeners(), this.registerUnhandledRejection(), this.outputStream.isTTY) this.outputStream.write(HIDE_CURSOR);
 	}
 	log(...args) {
-		this._clearScreen();
-		this.console.log(...args);
+		this._clearScreen(), this.console.log(...args);
 	}
 	error(...args) {
-		this._clearScreen();
-		this.console.error(...args);
+		this._clearScreen(), this.console.error(...args);
 	}
 	warn(...args) {
-		this._clearScreen();
-		this.console.warn(...args);
+		this._clearScreen(), this.console.warn(...args);
 	}
 	clearFullScreen(message = "") {
 		if (!this.ctx.config.clearScreen) {
@@ -5500,14 +5476,12 @@ class Logger {
 			this.console.log(message);
 			return;
 		}
-		this._clearScreenPending = message;
-		if (force) this._clearScreen();
+		if (this._clearScreenPending = message, force) this._clearScreen();
 	}
 	_clearScreen() {
 		if (this._clearScreenPending == null) return;
 		const log = this._clearScreenPending;
-		this._clearScreenPending = void 0;
-		this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`);
+		this._clearScreenPending = void 0, this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`);
 	}
 	printError(err, options = {}) {
 		printError(err, this.ctx, this, options);
@@ -5522,8 +5496,7 @@ class Logger {
 	highlight(filename, source) {
 		if (this._highlights.has(filename)) return this._highlights.get(filename);
 		const code = highlightCode(filename, source);
-		this._highlights.set(filename, code);
-		return code;
+		return this._highlights.set(filename, code), code;
 	}
 	printNoTestFound(filters) {
 		const config = this.ctx.config;
@@ -5536,34 +5509,22 @@ class Logger {
 		const projectsFilter = toArray(config.project);
 		if (projectsFilter.length) this.console.error(c.dim("projects: ") + c.yellow(projectsFilter.join(comma)));
 		this.ctx.projects.forEach((project) => {
-			const config = project.config;
-			const printConfig = !project.isRootProject() && project.name;
+			const config = project.config, printConfig = !project.isRootProject() && project.name;
 			if (printConfig) this.console.error(`\n${formatProjectName(project)}\n`);
 			if (config.include) this.console.error(c.dim("include: ") + c.yellow(config.include.join(comma)));
 			if (config.exclude) this.console.error(c.dim("exclude:  ") + c.yellow(config.exclude.join(comma)));
-			if (config.typecheck.enabled) {
-				this.console.error(c.dim("typecheck include: ") + c.yellow(config.typecheck.include.join(comma)));
-				this.console.error(c.dim("typecheck exclude: ") + c.yellow(config.typecheck.exclude.join(comma)));
-			}
-		});
-		this.console.error();
+			if (config.typecheck.enabled) this.console.error(c.dim("typecheck include: ") + c.yellow(config.typecheck.include.join(comma))), this.console.error(c.dim("typecheck exclude: ") + c.yellow(config.typecheck.exclude.join(comma)));
+		}), this.console.error();
 	}
 	printBanner() {
 		this.log();
-		const color = this.ctx.config.watch ? "blue" : "cyan";
-		const mode = this.ctx.config.watch ? "DEV" : "RUN";
-		this.log(withLabel(color, mode, `v${this.ctx.version} `) + c.gray(this.ctx.config.root));
-		if (this.ctx.config.sequence.sequencer === RandomSequencer) this.log(PAD + c.gray(`Running tests with seed "${this.ctx.config.sequence.seed}"`));
+		const color = this.ctx.config.watch ? "blue" : "cyan", mode = this.ctx.config.watch ? "DEV" : "RUN";
+		if (this.log(withLabel(color, mode, `v${this.ctx.version} `) + c.gray(this.ctx.config.root)), this.ctx.config.sequence.sequencer === RandomSequencer) this.log(PAD + c.gray(`Running tests with seed "${this.ctx.config.sequence.seed}"`));
 		if (this.ctx.config.ui) {
-			const host = this.ctx.config.api?.host || "localhost";
-			const port = this.ctx.server.config.server.port;
-			const base = this.ctx.config.uiBase;
+			const host = this.ctx.config.api?.host || "localhost", port = this.ctx.server.config.server.port, base = this.ctx.config.uiBase;
 			this.log(PAD + c.dim(c.green(`UI started at http://${host}:${c.bold(port)}${base}`)));
 		} else if (this.ctx.config.api?.port) {
-			const resolvedUrls = this.ctx.server.resolvedUrls;
-			// workaround for https://github.com/vitejs/vite/issues/15438, it was fixed in vite 5.1
-			const fallbackUrl = `http://${this.ctx.config.api.host || "localhost"}:${this.ctx.config.api.port}`;
-			const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0] ?? fallbackUrl;
+			const resolvedUrls = this.ctx.server.resolvedUrls, fallbackUrl = `http://${this.ctx.config.api.host || "localhost"}:${this.ctx.config.api.port}`, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0] ?? fallbackUrl;
 			this.log(PAD + c.dim(c.green(`API started at ${new URL("/", origin)}`)));
 		}
 		if (this.ctx.coverageProvider) this.log(PAD + c.dim("Coverage enabled with ") + c.yellow(this.ctx.coverageProvider.name));
@@ -5572,35 +5533,26 @@ class Logger {
 	}
 	printBrowserBanner(project) {
 		if (!project.browser) return;
-		const resolvedUrls = project.browser.vite.resolvedUrls;
-		const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
+		const resolvedUrls = project.browser.vite.resolvedUrls, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
 		if (!origin) return;
-		const output = project.isRootProject() ? "" : formatProjectName(project);
-		const provider = project.browser.provider.name;
-		const providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
+		const output = project.isRootProject() ? "" : formatProjectName(project), provider = project.browser.provider.name, providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
 		this.log(c.dim(`${output}Browser runner started${providerString} ${c.dim("at")} ${c.blue(new URL("/__vitest_test__/", origin))}\n`));
 	}
 	printUnhandledErrors(errors) {
 		const errorMessage = c.red(c.bold(`\nVitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} during the test run.
 This might cause false positive tests. Resolve unhandled errors to make sure your tests are not affected.`));
-		this.error(errorBanner("Unhandled Errors"));
-		this.error(errorMessage);
-		errors.forEach((err) => {
+		this.error(errorBanner("Unhandled Errors")), this.error(errorMessage), errors.forEach((err) => {
 			this.printError(err, {
 				fullStack: true,
 				type: err.type || "Unhandled Error"
 			});
-		});
-		this.error(c.red(divider()));
+		}), this.error(c.red(divider()));
 	}
 	printSourceTypeErrors(errors) {
 		const errorMessage = c.red(c.bold(`\nVitest found ${errors.length} error${errors.length > 1 ? "s" : ""} not related to your test files.`));
-		this.log(errorBanner("Source Errors"));
-		this.log(errorMessage);
-		errors.forEach((err) => {
+		this.log(errorBanner("Source Errors")), this.log(errorMessage), errors.forEach((err) => {
 			this.printError(err, { fullStack: true });
-		});
-		this.log(c.red(divider()));
+		}), this.log(c.red(divider()));
 	}
 	getColumns() {
 		return "columns" in this.outputStream ? this.outputStream.columns : 80;
@@ -5610,38 +5562,25 @@ This might cause false positive tests. Resolve unhandled errors to make sure you
 	}
 	addCleanupListeners() {
 		const cleanup = () => {
-			this.cleanupListeners.forEach((fn) => fn());
-			if (this.outputStream.isTTY) this.outputStream.write(SHOW_CURSOR);
-		};
-		const onExit = (signal, exitCode) => {
-			cleanup();
+			if (this.cleanupListeners.forEach((fn) => fn()), this.outputStream.isTTY) this.outputStream.write(SHOW_CURSOR);
+		}, onExit = (signal, exitCode) => {
 			// Interrupted signals don't set exit code automatically.
 			// Use same exit code as node: https://nodejs.org/api/process.html#signal-events
-			if (process.exitCode === void 0) process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
+			if (cleanup(), process.exitCode === void 0) process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
 			process.exit();
 		};
-		process.once("SIGINT", onExit);
-		process.once("SIGTERM", onExit);
-		process.once("exit", onExit);
-		this.ctx.onClose(() => {
-			process.off("SIGINT", onExit);
-			process.off("SIGTERM", onExit);
-			process.off("exit", onExit);
-			cleanup();
+		process.once("SIGINT", onExit), process.once("SIGTERM", onExit), process.once("exit", onExit), this.ctx.onClose(() => {
+			process.off("SIGINT", onExit), process.off("SIGTERM", onExit), process.off("exit", onExit), cleanup();
 		});
 	}
 	registerUnhandledRejection() {
 		const onUnhandledRejection = (err) => {
-			process.exitCode = 1;
-			this.printError(err, {
+			process.exitCode = 1, this.printError(err, {
 				fullStack: true,
 				type: "Unhandled Rejection"
-			});
-			this.error("\n\n");
-			process.exit();
+			}), this.error("\n\n"), process.exit();
 		};
-		process.on("unhandledRejection", onUnhandledRejection);
-		this.ctx.onClose(() => {
+		process.on("unhandledRejection", onUnhandledRejection), this.ctx.onClose(() => {
 			process.off("unhandledRejection", onUnhandledRejection);
 		});
 	}
@@ -5657,36 +5596,26 @@ class VitestPackageInstaller {
 		if (process.versions.pnp) {
 			const targetRequire = createRequire(__dirname);
 			try {
-				targetRequire.resolve(dependency, { paths: [root, __dirname] });
-				return true;
+				return targetRequire.resolve(dependency, { paths: [root, __dirname] }), true;
 			} catch {}
 		}
 		if (/* @__PURE__ */ isPackageExists(dependency, { paths: [root, __dirname] })) return true;
-		process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEPENDENCY "))} Cannot find dependency '${dependency}'\n\n`));
-		if (!isTTY) return false;
-		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; });
-		const { install } = await prompts.default({
+		if (process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEPENDENCY "))} Cannot find dependency '${dependency}'\n\n`)), !isTTY) return false;
+		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; }), { install } = await prompts.default({
 			type: "confirm",
 			name: "install",
 			message: c.reset(`Do you want to install ${c.green(dependency)}?`)
 		});
 		if (install) {
 			const packageName = version ? `${dependency}@${version}` : dependency;
-			await (await import('./index.D3XRDfWc.js')).installPackage(packageName, { dev: true });
-			// TODO: somehow it fails to load the package after installation, remove this when it's fixed
-			process.stderr.write(c.yellow(`\nPackage ${packageName} installed, re-run the command to start.\n`));
-			process.exit();
-			return true;
+			return await (await import('./index.D3XRDfWc.js')).installPackage(packageName, { dev: true }), process.stderr.write(c.yellow(`\nPackage ${packageName} installed, re-run the command to start.\n`)), process.exit(), true;
 		}
 		return false;
 	}
 }
 
 function serializeConfig(config, coreConfig, viteConfig) {
-	const optimizer = config.deps?.optimizer;
-	const poolOptions = config.poolOptions;
-	// Resolve from server.config to avoid comparing against default value
-	const isolate = viteConfig?.test?.isolate;
+	const optimizer = config.deps?.optimizer || {}, poolOptions = config.poolOptions, isolate = viteConfig?.test?.isolate;
 	return {
 		environmentOptions: config.environmentOptions,
 		mode: config.mode,
@@ -5720,8 +5649,7 @@ function serializeConfig(config, coreConfig, viteConfig) {
 		snapshotEnvironment: config.snapshotEnvironment,
 		passWithNoTests: config.passWithNoTests,
 		coverage: ((coverage) => {
-			const htmlReporter = coverage.reporter.find(([reporterName]) => reporterName === "html");
-			const subdir = htmlReporter && htmlReporter[1]?.subdir;
+			const htmlReporter = coverage.reporter.find(([reporterName]) => reporterName === "html"), subdir = htmlReporter && htmlReporter[1]?.subdir;
 			return {
 				reportsDirectory: coverage.reportsDirectory,
 				provider: coverage.provider,
@@ -5745,10 +5673,9 @@ function serializeConfig(config, coreConfig, viteConfig) {
 		},
 		deps: {
 			web: config.deps.web || {},
-			optimizer: {
-				web: { enabled: optimizer?.web?.enabled ?? true },
-				ssr: { enabled: optimizer?.ssr?.enabled ?? true }
-			},
+			optimizer: Object.entries(optimizer).reduce((acc, [name, option]) => {
+				return acc[name] = { enabled: option?.enabled ?? false }, acc;
+			}, {}),
 			interopDefault: config.deps.interopDefault,
 			moduleDirectories: config.deps.moduleDirectories
 		},
@@ -5798,7 +5725,7 @@ async function loadGlobalSetupFiles(runner, globalSetup) {
 	return Promise.all(globalSetupFiles.map((file) => loadGlobalSetupFile(file, runner)));
 }
 async function loadGlobalSetupFile(file, runner) {
-	const m = await runner.executeFile(file);
+	const m = await runner.import(file);
 	for (const exp of [
 		"default",
 		"setup",
@@ -5808,211 +5735,23 @@ async function loadGlobalSetupFile(file, runner) {
 		file,
 		setup: m.default
 	};
-	else if (m.setup || m.teardown) return {
+	if (m.setup || m.teardown) return {
 		file,
 		setup: m.setup,
 		teardown: m.teardown
 	};
-	else throw new Error(`invalid globalSetup file ${file}. Must export setup, teardown or have a default export`);
+	throw new Error(`invalid globalSetup file ${file}. Must export setup, teardown or have a default export`);
 }
 
 function CoverageTransform(ctx) {
 	return {
 		name: "vitest:coverage-transform",
 		transform(srcCode, id) {
-			return ctx.coverageProvider?.onFileTransform?.(srcCode, normalizeRequestId(id), this);
-		}
-	};
-}
-
-function MocksPlugins(options = {}) {
-	const normalizedDistDir = normalize(distDir);
-	return [hoistMocksPlugin({
-		filter(id) {
-			if (id.includes(normalizedDistDir)) return false;
-			if (options.filter) return options.filter(id);
-			return true;
-		},
-		codeFrameGenerator(node, id, code) {
-			return generateCodeFrame(code, 4, node.start + 1);
-		}
-	}), automockPlugin()];
-}
-
-function generateCssFilenameHash(filepath) {
-	return hash("sha1", filepath, "hex").slice(0, 6);
-}
-function generateScopedClassName(strategy, name, filename) {
-	// should be configured by Vite defaults
-	if (strategy === "scoped") return null;
-	if (strategy === "non-scoped") return name;
-	const hash = generateCssFilenameHash(filename);
-	return `_${name}_${hash}`;
-}
-
-const LogLevels = {
-	silent: 0,
-	error: 1,
-	warn: 2,
-	info: 3
-};
-function clearScreen(logger) {
-	const repeatCount = process.stdout.rows - 2;
-	const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
-	logger.clearScreen(blank);
-}
-let lastType;
-let lastMsg;
-let sameCount = 0;
-// Only initialize the timeFormatter when the timestamp option is used, and
-// reuse it across all loggers
-let timeFormatter;
-function getTimeFormatter() {
-	timeFormatter ??= new Intl.DateTimeFormat(void 0, {
-		hour: "numeric",
-		minute: "numeric",
-		second: "numeric"
-	});
-	return timeFormatter;
-}
-// This is copy-pasted and needs to be synced from time to time. Ideally, Vite's `createLogger` should accept a custom `console`
-// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/logger.ts?rgh-link-date=2024-10-16T23%3A29%3A19Z
-// When Vitest supports only Vite 6 and above, we can use Vite's `createLogger({ console })`
-// https://github.com/vitejs/vite/pull/18379
-function createViteLogger(console, level = "info", options = {}) {
-	const loggedErrors = /* @__PURE__ */ new WeakSet();
-	const { prefix = "[vite]", allowClearScreen = true } = options;
-	const thresh = LogLevels[level];
-	const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
-	const clear = canClearScreen ? clearScreen : () => {};
-	function format(type, msg, options = {}) {
-		if (options.timestamp) {
-			let tag = "";
-			if (type === "info") tag = c.cyan(c.bold(prefix));
-			else if (type === "warn") tag = c.yellow(c.bold(prefix));
-			else tag = c.red(c.bold(prefix));
-			const environment = options.environment ? `${options.environment} ` : "";
-			return `${c.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
-		} else return msg;
-	}
-	function output(type, msg, options = {}) {
-		if (thresh >= LogLevels[type]) {
-			const method = type === "info" ? "log" : type;
-			if (options.error) loggedErrors.add(options.error);
-			if (canClearScreen) if (type === lastType && msg === lastMsg) {
-				sameCount++;
-				clear(console);
-				console[method](format(type, msg, options), c.yellow(`(x${sameCount + 1})`));
-			} else {
-				sameCount = 0;
-				lastMsg = msg;
-				lastType = type;
-				if (options.clear) clear(console);
-				console[method](format(type, msg, options));
-			}
-			else console[method](format(type, msg, options));
-		}
-	}
-	const warnedMessages = /* @__PURE__ */ new Set();
-	const logger = {
-		hasWarned: false,
-		info(msg, opts) {
-			output("info", msg, opts);
-		},
-		warn(msg, opts) {
-			logger.hasWarned = true;
-			output("warn", msg, opts);
-		},
-		warnOnce(msg, opts) {
-			if (warnedMessages.has(msg)) return;
-			logger.hasWarned = true;
-			output("warn", msg, opts);
-			warnedMessages.add(msg);
-		},
-		error(msg, opts) {
-			logger.hasWarned = true;
-			output("error", msg, opts);
-		},
-		clearScreen(type) {
-			if (thresh >= LogLevels[type]) clear(console);
-		},
-		hasErrorLogged(error) {
-			return loggedErrors.has(error);
-		}
-	};
-	return logger;
-}
-// silence warning by Vite for statically not analyzable dynamic import
-function silenceImportViteIgnoreWarning(logger) {
-	return {
-		...logger,
-		warn(msg, options) {
-			if (msg.includes("The above dynamic import cannot be analyzed by Vite")) return;
-			logger.warn(msg, options);
+			return ctx.coverageProvider?.onFileTransform?.(srcCode, id, this);
 		}
 	};
 }
 
-const cssLangs = "\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)";
-const cssLangRE = new RegExp(cssLangs);
-const cssModuleRE = /* @__PURE__ */ new RegExp(`\\.module${cssLangs}`);
-const cssInlineRE = /[?&]inline(?:&|$)/;
-function isCSS(id) {
-	return cssLangRE.test(id);
-}
-function isCSSModule(id) {
-	return cssModuleRE.test(id);
-}
-// inline css requests are expected to just return the
-// string content directly and not the proxy module
-function isInline(id) {
-	return cssInlineRE.test(id);
-}
-function getCSSModuleProxyReturn(strategy, filename) {
-	if (strategy === "non-scoped") return "style";
-	const hash = generateCssFilenameHash(filename);
-	return `\`_\${style}_${hash}\``;
-}
-function CSSEnablerPlugin(ctx) {
-	const shouldProcessCSS = (id) => {
-		const { css } = ctx.config;
-		if (typeof css === "boolean") return css;
-		if (toArray(css.exclude).some((re) => re.test(id))) return false;
-		if (toArray(css.include).some((re) => re.test(id))) return true;
-		return false;
-	};
-	return [{
-		name: "vitest:css-disable",
-		enforce: "pre",
-		transform(code, id) {
-			if (!isCSS(id)) return;
-			// css plugin inside Vite won't do anything if the code is empty
-			// but it will put __vite__updateStyle anyway
-			if (!shouldProcessCSS(id)) return { code: "" };
-		}
-	}, {
-		name: "vitest:css-empty-post",
-		enforce: "post",
-		transform(_, id) {
-			if (!isCSS(id) || shouldProcessCSS(id)) return;
-			if (isCSSModule(id) && !isInline(id)) {
-				// return proxy for css modules, so that imported module has names:
-				// styles.foo returns a "foo" instead of "undefined"
-				// we don't use code content to generate hash for "scoped", because it's empty
-				const scopeStrategy = typeof ctx.config.css !== "boolean" && ctx.config.css.modules?.classNameStrategy || "stable";
-				const proxyReturn = getCSSModuleProxyReturn(scopeStrategy, relative(ctx.config.root, id));
-				const code = `export default new Proxy(Object.create(null), {
-            get(_, style) {
-              return ${proxyReturn};
-            },
-          })`;
-				return { code };
-			}
-			return { code: "export default \"\"" };
-		}
-	}];
-}
-
 var jsTokens_1;
 var hasRequiredJsTokens;
 
@@ -6497,136 +6236,208 @@ function stripLiteralDetailed(code, options) {
   return stripLiteralJsTokens(code);
 }
 
-const metaUrlLength = 15;
-const locationString = "self.location".padEnd(metaUrlLength, " ");
-// Vite transforms new URL('./path', import.meta.url) to new URL('/path.js', import.meta.url)
-// This makes "href" equal to "http://localhost:3000/path.js" in the browser, but if we keep it like this,
-// then in tests the URL will become "file:///path.js".
-// To battle this, we replace "import.meta.url" with "self.location" in the code to keep the browser behavior.
-function NormalizeURLPlugin() {
+// so people can reassign envs at runtime
+// import.meta.env.VITE_NAME = 'app' -> process.env.VITE_NAME = 'app'
+function MetaEnvReplacerPlugin() {
 	return {
-		name: "vitest:normalize-url",
-		enforce: "post",
-		transform(code, id, options) {
-			const ssr = options?.ssr === true;
-			if (ssr || !code.includes("new URL") || !code.includes("import.meta.url")) return;
-			const cleanString = stripLiteral(code);
-			const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*(?:'[^']+'|"[^"]+"|`[^`]+`)\s*,\s*(?:'' \+ )?import\.meta\.url\s*(?:,\s*)?\)/g;
-			let updatedCode = code;
-			let match;
-			// eslint-disable-next-line no-cond-assign
-			while (match = assetImportMetaUrlRE.exec(cleanString)) {
-				const { 0: exp, index } = match;
-				const metaUrlIndex = index + exp.indexOf("import.meta.url");
-				updatedCode = updatedCode.slice(0, metaUrlIndex) + locationString + updatedCode.slice(metaUrlIndex + metaUrlLength);
+		name: "vitest:meta-env-replacer",
+		enforce: "pre",
+		transform(code, id) {
+			if (!/\bimport\.meta\.env\b/.test(code)) return null;
+			let s = null;
+			const cleanCode = stripLiteral(code), envs = cleanCode.matchAll(/\bimport\.meta\.env\b/g);
+			for (const env of envs) {
+				s ||= new MagicString(code);
+				const startIndex = env.index, endIndex = startIndex + env[0].length;
+				s.overwrite(startIndex, endIndex, `Object.assign(/* istanbul ignore next */ globalThis.__vitest_worker__?.metaEnv ?? import.meta.env)`);
 			}
-			return {
-				code: updatedCode,
-				map: null
+			if (s) return {
+				code: s.toString(),
+				map: s.generateMap({
+					hires: "boundary",
+					source: cleanUrl(id)
+				})
 			};
 		}
 	};
 }
 
-function resolveOptimizerConfig(_testOptions, viteOptions) {
-	const testOptions = _testOptions || {};
-	const newConfig = {};
-	const [major, minor, fix] = version.split(".").map(Number);
-	const allowed = major >= 5 || major === 4 && minor >= 4 || major === 4 && minor === 3 && fix >= 2;
-	if (!allowed && testOptions?.enabled === true) console.warn(`Vitest: "deps.optimizer" is only available in Vite >= 4.3.2, current Vite version: ${version}`);
-	else testOptions.enabled ??= false;
-	if (!allowed || testOptions?.enabled !== true) {
-		newConfig.cacheDir = void 0;
-		newConfig.optimizeDeps = {
-			disabled: true,
-			entries: []
-		};
-	} else {
-		const currentInclude = testOptions.include || viteOptions?.include || [];
-		const exclude = [
-			"vitest",
-			"react",
-			"vue",
-			...testOptions.exclude || viteOptions?.exclude || []
-		];
-		const runtime = currentInclude.filter((n) => n.endsWith("jsx-dev-runtime") || n.endsWith("jsx-runtime"));
-		exclude.push(...runtime);
-		const include = (testOptions.include || viteOptions?.include || []).filter((n) => !exclude.includes(n));
-		newConfig.optimizeDeps = {
-			...viteOptions,
-			...testOptions,
-			noDiscovery: true,
-			disabled: false,
-			entries: [],
-			exclude,
-			include
-		};
-	}
-	// `optimizeDeps.disabled` is deprecated since v5.1.0-beta.1
-	// https://github.com/vitejs/vite/pull/15184
-	if (major >= 5 && minor >= 1 || major >= 6) {
-		if (newConfig.optimizeDeps.disabled) {
-			newConfig.optimizeDeps.noDiscovery = true;
-			newConfig.optimizeDeps.include = [];
-		}
-		delete newConfig.optimizeDeps.disabled;
-	}
-	return newConfig;
-}
-function deleteDefineConfig(viteConfig) {
-	const defines = {};
-	if (viteConfig.define) {
-		delete viteConfig.define["import.meta.vitest"];
-		delete viteConfig.define["process.env"];
-		delete viteConfig.define.process;
-		delete viteConfig.define.global;
-	}
-	for (const key in viteConfig.define) {
-		const val = viteConfig.define[key];
-		let replacement;
-		try {
-			replacement = typeof val === "string" ? JSON.parse(val) : val;
-		} catch {
-			// probably means it contains reference to some variable,
-			// like this: "__VAR__": "process.env.VAR"
-			continue;
-		}
-		if (key.startsWith("import.meta.env.")) {
-			const envKey = key.slice(16);
-			process.env[envKey] = replacement;
-			delete viteConfig.define[key];
-		} else if (key.startsWith("process.env.")) {
-			const envKey = key.slice(12);
-			process.env[envKey] = replacement;
-			delete viteConfig.define[key];
-		} else if (!key.includes(".")) {
-			defines[key] = replacement;
-			delete viteConfig.define[key];
+function MocksPlugins(options = {}) {
+	const normalizedDistDir = normalize(distDir);
+	return [hoistMocksPlugin({
+		filter(id) {
+			return id.includes(normalizedDistDir) ? false : options.filter ? options.filter(id) : true;
+		},
+		codeFrameGenerator(node, id, code) {
+			return generateCodeFrame(code, 4, node.start + 1);
 		}
-	}
-	return defines;
+	}), automockPlugin()];
 }
-function resolveFsAllow(projectRoot, rootConfigFile) {
-	if (!rootConfigFile) return [searchForWorkspaceRoot(projectRoot), rootDir];
-	return [
-		dirname(rootConfigFile),
-		searchForWorkspaceRoot(projectRoot),
-		rootDir
-	];
+
+function generateCssFilenameHash(filepath) {
+	return hash("sha1", filepath, "hex").slice(0, 6);
 }
-function getDefaultResolveOptions() {
-	return {
-		mainFields: [],
-		conditions: getDefaultServerConditions()
-	};
+function generateScopedClassName(strategy, name, filename) {
+	// should be configured by Vite defaults
+	if (strategy === "scoped") return null;
+	if (strategy === "non-scoped") return name;
+	const hash = generateCssFilenameHash(filename);
+	return `_${name}_${hash}`;
 }
-function getDefaultServerConditions() {
-	const viteMajor = Number(version.split(".")[0]);
-	if (viteMajor >= 6) {
-		const conditions = vite.defaultServerConditions;
-		return conditions.filter((c) => c !== "module");
+
+const LogLevels = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3
+};
+function clearScreen(logger) {
+	const repeatCount = process.stdout.rows - 2, blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+	logger.clearScreen(blank);
+}
+let lastType, lastMsg, sameCount = 0, timeFormatter;
+function getTimeFormatter() {
+	return timeFormatter ??= new Intl.DateTimeFormat(void 0, {
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	}), timeFormatter;
+}
+// This is copy-pasted and needs to be synced from time to time. Ideally, Vite's `createLogger` should accept a custom `console`
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/logger.ts?rgh-link-date=2024-10-16T23%3A29%3A19Z
+// When Vitest supports only Vite 6 and above, we can use Vite's `createLogger({ console })`
+// https://github.com/vitejs/vite/pull/18379
+function createViteLogger(console, level = "info", options = {}) {
+	const loggedErrors = /* @__PURE__ */ new WeakSet(), { prefix = "[vite]", allowClearScreen = true } = options, thresh = LogLevels[level], canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI, clear = canClearScreen ? clearScreen : () => {};
+	function format(type, msg, options = {}) {
+		if (options.timestamp) {
+			let tag = "";
+			if (type === "info") tag = c.cyan(c.bold(prefix));
+			else if (type === "warn") tag = c.yellow(c.bold(prefix));
+			else tag = c.red(c.bold(prefix));
+			const environment = options.environment ? `${options.environment} ` : "";
+			return `${c.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
+		} else return msg;
 	}
-	return ["node"];
+	function output(type, msg, options = {}) {
+		if (thresh >= LogLevels[type]) {
+			const method = type === "info" ? "log" : type;
+			if (options.error) loggedErrors.add(options.error);
+			if (canClearScreen) if (type === lastType && msg === lastMsg) sameCount++, clear(console), console[method](format(type, msg, options), c.yellow(`(x${sameCount + 1})`));
+			else {
+				if (sameCount = 0, lastMsg = msg, lastType = type, options.clear) clear(console);
+				console[method](format(type, msg, options));
+			}
+			else console[method](format(type, msg, options));
+		}
+	}
+	const warnedMessages = /* @__PURE__ */ new Set(), logger = {
+		hasWarned: false,
+		info(msg, opts) {
+			output("info", msg, opts);
+		},
+		warn(msg, opts) {
+			logger.hasWarned = true, output("warn", msg, opts);
+		},
+		warnOnce(msg, opts) {
+			warnedMessages.has(msg) || (logger.hasWarned = true, output("warn", msg, opts), warnedMessages.add(msg));
+		},
+		error(msg, opts) {
+			logger.hasWarned = true, output("error", msg, opts);
+		},
+		clearScreen(type) {
+			if (thresh >= LogLevels[type]) clear(console);
+		},
+		hasErrorLogged(error) {
+			return loggedErrors.has(error);
+		}
+	};
+	return logger;
+}
+// silence warning by Vite for statically not analyzable dynamic import
+function silenceImportViteIgnoreWarning(logger) {
+	return {
+		...logger,
+		warn(msg, options) {
+			msg.includes("The above dynamic import cannot be analyzed by Vite") || logger.warn(msg, options);
+		}
+	};
+}
+
+const cssLangs = "\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)", cssLangRE = new RegExp(cssLangs), cssModuleRE = /* @__PURE__ */ new RegExp(`\\.module${cssLangs}`), cssInlineRE = /[?&]inline(?:&|$)/;
+function isCSS(id) {
+	return cssLangRE.test(id);
+}
+function isCSSModule(id) {
+	return cssModuleRE.test(id);
+}
+// inline css requests are expected to just return the
+// string content directly and not the proxy module
+function isInline(id) {
+	return cssInlineRE.test(id);
+}
+function getCSSModuleProxyReturn(strategy, filename) {
+	if (strategy === "non-scoped") return "style";
+	const hash = generateCssFilenameHash(filename);
+	return `\`_\${style}_${hash}\``;
+}
+function CSSEnablerPlugin(ctx) {
+	const shouldProcessCSS = (id) => {
+		const { css } = ctx.config;
+		return typeof css === "boolean" ? css : toArray(css.exclude).some((re) => re.test(id)) ? false : !!toArray(css.include).some((re) => re.test(id));
+	};
+	return [{
+		name: "vitest:css-disable",
+		enforce: "pre",
+		transform(code, id) {
+			if (isCSS(id) && !shouldProcessCSS(id)) return { code: "" };
+		}
+	}, {
+		name: "vitest:css-empty-post",
+		enforce: "post",
+		transform(_, id) {
+			if (!(!isCSS(id) || shouldProcessCSS(id))) {
+				if (isCSSModule(id) && !isInline(id)) {
+					// return proxy for css modules, so that imported module has names:
+					// styles.foo returns a "foo" instead of "undefined"
+					// we don't use code content to generate hash for "scoped", because it's empty
+					const scopeStrategy = typeof ctx.config.css !== "boolean" && ctx.config.css.modules?.classNameStrategy || "stable", proxyReturn = getCSSModuleProxyReturn(scopeStrategy, relative(ctx.config.root, id)), code = `export default new Proxy(Object.create(null), {
+            get(_, style) {
+              return ${proxyReturn};
+            },
+          })`;
+					return { code };
+				}
+				return { code: "export default \"\"" };
+			}
+		}
+	}];
+}
+
+const metaUrlLength = 15, locationString = "self.location".padEnd(metaUrlLength, " ");
+// Vite transforms new URL('./path', import.meta.url) to new URL('/path.js', import.meta.url)
+// This makes "href" equal to "http://localhost:3000/path.js" in the browser, but if we keep it like this,
+// then in tests the URL will become "file:///path.js".
+// To battle this, we replace "import.meta.url" with "self.location" in the code to keep the browser behavior.
+function NormalizeURLPlugin() {
+	return {
+		name: "vitest:normalize-url",
+		enforce: "post",
+		transform(code) {
+			if (this.environment.name !== "client" || !code.includes("new URL") || !code.includes("import.meta.url")) return;
+			const cleanString = stripLiteral(code), assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*(?:'[^']+'|"[^"]+"|`[^`]+`)\s*,\s*(?:'' \+ )?import\.meta\.url\s*(?:,\s*)?\)/g;
+			let updatedCode = code, match;
+			// eslint-disable-next-line no-cond-assign
+			while (match = assetImportMetaUrlRE.exec(cleanString)) {
+				const { 0: exp, index } = match, metaUrlIndex = index + exp.indexOf("import.meta.url");
+				updatedCode = updatedCode.slice(0, metaUrlIndex) + locationString + updatedCode.slice(metaUrlIndex + metaUrlLength);
+			}
+			return {
+				code: updatedCode,
+				map: null
+			};
+		}
+	};
 }
 
 function VitestOptimizer() {
@@ -6635,48 +6446,138 @@ function VitestOptimizer() {
 		config: {
 			order: "post",
 			handler(viteConfig) {
-				const testConfig = viteConfig.test || {};
-				const webOptimizer = resolveOptimizerConfig(testConfig.deps?.optimizer?.web, viteConfig.optimizeDeps);
-				const ssrOptimizer = resolveOptimizerConfig(testConfig.deps?.optimizer?.ssr, viteConfig.ssr?.optimizeDeps);
-				const root = resolve(viteConfig.root || process.cwd());
-				const name = viteConfig.test?.name;
-				const label = typeof name === "string" ? name : name?.label || "";
+				const testConfig = viteConfig.test || {}, root = resolve(viteConfig.root || process.cwd()), name = viteConfig.test?.name, label = typeof name === "string" ? name : name?.label || "";
 				viteConfig.cacheDir = VitestCache.resolveCacheDir(resolve(root || process.cwd()), testConfig.cache != null && testConfig.cache !== false ? testConfig.cache.dir : viteConfig.cacheDir, label);
-				viteConfig.optimizeDeps = webOptimizer.optimizeDeps;
-				viteConfig.ssr ??= {};
-				viteConfig.ssr.optimizeDeps = ssrOptimizer.optimizeDeps;
 			}
 		}
 	};
 }
 
-// so people can reassign envs at runtime
-// import.meta.env.VITE_NAME = 'app' -> process.env.VITE_NAME = 'app'
-function SsrReplacerPlugin() {
+function resolveOptimizerConfig(_testOptions, viteOptions) {
+	const testOptions = _testOptions || {};
+	let optimizeDeps;
+	if (testOptions.enabled !== true) testOptions.enabled ??= false, optimizeDeps = {
+		disabled: true,
+		entries: []
+	};
+	else {
+		const currentInclude = testOptions.include || viteOptions?.include || [], exclude = [
+			"vitest",
+			"react",
+			"vue",
+			...testOptions.exclude || viteOptions?.exclude || []
+		], runtime = currentInclude.filter((n) => n.endsWith("jsx-dev-runtime") || n.endsWith("jsx-runtime"));
+		exclude.push(...runtime);
+		const include = (testOptions.include || viteOptions?.include || []).filter((n) => !exclude.includes(n));
+		optimizeDeps = {
+			...viteOptions,
+			...testOptions,
+			noDiscovery: true,
+			disabled: false,
+			entries: [],
+			exclude,
+			include
+		};
+	}
+	// `optimizeDeps.disabled` is deprecated since v5.1.0-beta.1
+	// https://github.com/vitejs/vite/pull/15184
+	if (optimizeDeps.disabled) optimizeDeps.noDiscovery = true, optimizeDeps.include = [];
+	return delete optimizeDeps.disabled, optimizeDeps;
+}
+function deleteDefineConfig(viteConfig) {
+	const defines = {};
+	if (viteConfig.define) delete viteConfig.define["import.meta.vitest"], delete viteConfig.define["process.env"], delete viteConfig.define.process, delete viteConfig.define.global;
+	for (const key in viteConfig.define) {
+		const val = viteConfig.define[key];
+		let replacement;
+		try {
+			replacement = typeof val === "string" ? JSON.parse(val) : val;
+		} catch {
+			// probably means it contains reference to some variable,
+			// like this: "__VAR__": "process.env.VAR"
+			continue;
+		}
+		if (key.startsWith("import.meta.env.")) {
+			const envKey = key.slice(16);
+			process.env[envKey] = replacement, delete viteConfig.define[key];
+		} else if (key.startsWith("process.env.")) {
+			const envKey = key.slice(12);
+			process.env[envKey] = replacement, delete viteConfig.define[key];
+		} else if (!key.includes(".")) defines[key] = replacement, delete viteConfig.define[key];
+	}
+	return defines;
+}
+function resolveFsAllow(projectRoot, rootConfigFile) {
+	return rootConfigFile ? [
+		dirname(rootConfigFile),
+		searchForWorkspaceRoot(projectRoot),
+		rootDir
+	] : [searchForWorkspaceRoot(projectRoot), rootDir];
+}
+function getDefaultResolveOptions() {
 	return {
-		name: "vitest:ssr-replacer",
-		enforce: "pre",
-		transform(code, id) {
-			if (!/\bimport\.meta\.env\b/.test(code)) return null;
-			let s = null;
-			const cleanCode = stripLiteral(code);
-			const envs = cleanCode.matchAll(/\bimport\.meta\.env\b/g);
-			for (const env of envs) {
-				s ||= new MagicString(code);
-				const startIndex = env.index;
-				const endIndex = startIndex + env[0].length;
-				s.overwrite(startIndex, endIndex, "__vite_ssr_import_meta__.env");
+		mainFields: [],
+		conditions: getDefaultServerConditions()
+	};
+}
+function getDefaultServerConditions() {
+	const viteMajor = Number(version.split(".")[0]);
+	if (viteMajor >= 6) {
+		const conditions = vite.defaultServerConditions;
+		return conditions.filter((c) => c !== "module");
+	}
+	return ["node"];
+}
+
+function ModuleRunnerTransform() {
+	// make sure Vite always applies the module runner transform
+	return {
+		name: "vitest:environments-module-runner",
+		config: {
+			order: "post",
+			handler(config) {
+				const testConfig = config.test || {};
+				config.environments ??= {};
+				const names = new Set(Object.keys(config.environments));
+				names.add("client"), names.add("ssr");
+				const pool = config.test?.pool;
+				if (pool === "vmForks" || pool === "vmThreads") names.add("__vitest_vm__");
+				const external = [], noExternal = [];
+				let noExternalAll;
+				for (const name of names) {
+					config.environments[name] ??= {};
+					const environment = config.environments[name];
+					// vm tests run using the native import mechanism
+					if (environment.dev ??= {}, name === "__vitest_vm__") environment.dev.moduleRunnerTransform = false, environment.consumer = "client";
+					else environment.dev.moduleRunnerTransform = true;
+					environment.dev.preTransformRequests = false, environment.keepProcessEnv = true;
+					const resolveExternal = name === "client" ? config.resolve?.external : [], resolveNoExternal = name === "client" ? config.resolve?.noExternal : [], topLevelResolveOptions = {};
+					if (resolveExternal != null) topLevelResolveOptions.external = resolveExternal;
+					if (resolveNoExternal != null) topLevelResolveOptions.noExternal = resolveNoExternal;
+					const currentResolveOptions = mergeConfig(topLevelResolveOptions, environment.resolve || {}), envNoExternal = resolveViteResolveOptions("noExternal", currentResolveOptions);
+					if (envNoExternal === true) noExternalAll = true;
+					else noExternal.push(...envNoExternal);
+					const envExternal = resolveViteResolveOptions("external", currentResolveOptions);
+					if (envExternal !== true) external.push(...envExternal);
+					if (environment.resolve ??= {}, environment.resolve.external = [...builtinModules, ...builtinModules.map((m) => `node:${m}`)], environment.resolve.noExternal = true, name === "__vitest_vm__" || name === "__vitest__") continue;
+					const currentOptimizeDeps = environment.optimizeDeps || (name === "client" ? config.optimizeDeps : name === "ssr" ? config.ssr?.optimizeDeps : void 0), optimizeDeps = resolveOptimizerConfig(testConfig.deps?.optimizer?.[name], currentOptimizeDeps);
+					// Vite respects the root level optimize deps, so we override it instead
+					if (name === "client") config.optimizeDeps = optimizeDeps, environment.optimizeDeps = void 0;
+					else if (name === "ssr") config.ssr ??= {}, config.ssr.optimizeDeps = optimizeDeps, environment.optimizeDeps = void 0;
+					else environment.optimizeDeps = optimizeDeps;
+				}
+				if (testConfig.server ??= {}, testConfig.server.deps ??= {}, testConfig.server.deps.inline !== true) {
+					if (noExternalAll) testConfig.server.deps.inline = true;
+					else if (noExternal.length) testConfig.server.deps.inline ??= [], testConfig.server.deps.inline.push(...noExternal);
+				}
+				if (external.length) testConfig.server.deps.external ??= [], testConfig.server.deps.external.push(...external);
 			}
-			if (s) return {
-				code: s.toString(),
-				map: s.generateMap({
-					hires: "boundary",
-					source: cleanUrl(id)
-				})
-			};
 		}
 	};
 }
+function resolveViteResolveOptions(key, options) {
+	return Array.isArray(options[key]) ? options[key] : typeof options[key] === "string" || options[key] instanceof RegExp ? [options[key]] : typeof options[key] === "boolean" ? true : [];
+}
 
 function VitestProjectResolver(ctx) {
 	const plugin = {
@@ -6722,23 +6623,16 @@ function WorkspaceVitestPlugin(project, options) {
 				};
 				if (!name) if (typeof options.workspacePath === "string") {
 					// if there is a package.json, read the name from it
-					const dir = options.workspacePath.endsWith("/") ? options.workspacePath.slice(0, -1) : dirname(options.workspacePath);
-					const pkgJsonPath = resolve(dir, "package.json");
+					const dir = options.workspacePath.endsWith("/") ? options.workspacePath.slice(0, -1) : dirname(options.workspacePath), pkgJsonPath = resolve(dir, "package.json");
 					if (existsSync(pkgJsonPath)) name = JSON.parse(readFileSync(pkgJsonPath, "utf-8")).name;
 					if (typeof name !== "string" || !name) name = basename(dir);
 				} else name = options.workspacePath.toString();
-				const isUserBrowserEnabled = viteConfig.test?.browser?.enabled;
-				const isBrowserEnabled = isUserBrowserEnabled ?? (viteConfig.test?.browser && project.vitest._cliOptions.browser?.enabled);
-				// keep project names to potentially filter it out
-				const workspaceNames = [name];
-				const browser = viteConfig.test.browser || {};
+				const isUserBrowserEnabled = viteConfig.test?.browser?.enabled, isBrowserEnabled = isUserBrowserEnabled ?? (viteConfig.test?.browser && project.vitest._cliOptions.browser?.enabled), workspaceNames = [name], browser = viteConfig.test.browser || {};
 				if (isBrowserEnabled && browser.name && !browser.instances?.length)
  // vitest injects `instances` in this case later on
 				workspaceNames.push(name ? `${name} (${browser.name})` : browser.name);
 				viteConfig.test?.browser?.instances?.forEach((instance) => {
-					// every instance is a potential project
-					instance.name ??= name ? `${name} (${instance.browser})` : instance.browser;
-					if (isBrowserEnabled) workspaceNames.push(instance.name);
+					if (instance.name ??= name ? `${name} (${instance.browser})` : instance.browser, isBrowserEnabled) workspaceNames.push(instance.name);
 				});
 				const filters = project.vitest.config.project;
 				// if there is `--project=...` filter, check if any of the potential projects match
@@ -6750,10 +6644,13 @@ function WorkspaceVitestPlugin(project, options) {
 					});
 					if (!hasProject) throw new VitestFilteredOutProjectError();
 				}
-				return { test: { name: {
-					label: name,
-					color
-				} } };
+				return {
+					environments: { __vitest__: { dev: {} } },
+					test: { name: {
+						label: name,
+						color
+					} }
+				};
 			}
 		},
 		{
@@ -6763,22 +6660,14 @@ function WorkspaceVitestPlugin(project, options) {
 				this.meta.watchMode = false;
 			},
 			config(viteConfig) {
-				const defines = deleteDefineConfig(viteConfig);
-				const testConfig = viteConfig.test || {};
-				const root = testConfig.root || viteConfig.root || options.root;
-				const resolveOptions = getDefaultResolveOptions();
-				const config = {
+				const defines = deleteDefineConfig(viteConfig), testConfig = viteConfig.test || {}, root = testConfig.root || viteConfig.root || options.root, resolveOptions = getDefaultResolveOptions();
+				let config = {
 					root,
 					define: { "process.env.NODE_ENV": "process.env.NODE_ENV" },
 					resolve: {
 						...resolveOptions,
 						alias: testConfig.alias
 					},
-					esbuild: viteConfig.esbuild === false ? false : {
-						target: viteConfig.esbuild?.target || "node18",
-						sourcemap: "external",
-						legalComments: "inline"
-					},
 					server: {
 						watch: null,
 						open: false,
@@ -6791,19 +6680,27 @@ function WorkspaceVitestPlugin(project, options) {
 					environments: { ssr: { resolve: resolveOptions } },
 					test: {}
 				};
+				if ("rolldownVersion" in vite) config = {
+					...config,
+					oxc: viteConfig.oxc === false ? false : { target: viteConfig.oxc?.target || "node18" }
+				};
+				else config = {
+					...config,
+					esbuild: viteConfig.esbuild === false ? false : {
+						target: viteConfig.esbuild?.target || "node18",
+						sourcemap: "external",
+						legalComments: "inline"
+					}
+				};
 				config.test.defines = defines;
 				const classNameStrategy = typeof testConfig.css !== "boolean" && testConfig.css?.modules?.classNameStrategy || "stable";
 				if (classNameStrategy !== "scoped") {
-					config.css ??= {};
-					config.css.modules ??= {};
-					if (config.css.modules) config.css.modules.generateScopedName = (name, filename) => {
+					if (config.css ??= {}, config.css.modules ??= {}, config.css.modules) config.css.modules.generateScopedName = (name, filename) => {
 						const root = project.config.root;
 						return generateScopedClassName(classNameStrategy, name, relative(root, filename));
 					};
 				}
-				config.customLogger = createViteLogger(project.vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false });
-				config.customLogger = silenceImportViteIgnoreWarning(config.customLogger);
-				return config;
+				return config.customLogger = createViteLogger(project.vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false }), config.customLogger = silenceImportViteIgnoreWarning(config.customLogger), config;
 			}
 		},
 		{
@@ -6811,20 +6708,119 @@ function WorkspaceVitestPlugin(project, options) {
 			enforce: "post",
 			async configureServer(server) {
 				const options = deepMerge({}, configDefaults, server.config.test || {});
-				await project._configureServer(options, server);
-				await server.watcher.close();
+				await project._configureServer(options, server), await server.watcher.close();
 			}
 		},
-		SsrReplacerPlugin(),
+		MetaEnvReplacerPlugin(),
 		...CSSEnablerPlugin(project),
 		CoverageTransform(project.vitest),
 		...MocksPlugins(),
 		VitestProjectResolver(project.vitest),
 		VitestOptimizer(),
-		NormalizeURLPlugin()
+		NormalizeURLPlugin(),
+		ModuleRunnerTransform()
 	];
 }
 
+class VitestResolver {
+	options;
+	externalizeCache = /* @__PURE__ */ new Map();
+	constructor(cacheDir, config) {
+		this.options = {
+			moduleDirectories: config.deps.moduleDirectories,
+			inlineFiles: config.setupFiles.flatMap((file) => {
+				if (file.startsWith("file://")) return file;
+				const resolvedId = resolve(file);
+				return [resolvedId, pathToFileURL(resolvedId).href];
+			}),
+			cacheDir,
+			inline: config.server.deps?.inline,
+			external: config.server.deps?.external
+		};
+	}
+	shouldExternalize(file) {
+		return shouldExternalize(normalizeId(file), this.options, this.externalizeCache);
+	}
+}
+function normalizeId(id) {
+	if (id.startsWith("/@fs/")) id = id.slice(isWindows ? 5 : 4);
+	return id;
+}
+const BUILTIN_EXTENSIONS = new Set([
+	".mjs",
+	".cjs",
+	".node",
+	".wasm"
+]), ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/, ESM_FOLDER_RE = /\/(es|esm)\/(.*\.js)$/, defaultInline = [
+	/virtual:/,
+	/\.[mc]?ts$/,
+	/[?&](init|raw|url|inline)\b/,
+	KNOWN_ASSET_RE,
+	/^(?!.*node_modules).*\.mjs$/,
+	/^(?!.*node_modules).*\.cjs\.js$/,
+	/vite\w*\/dist\/client\/env.mjs/
+], depsExternal = [/\/node_modules\/.*\.cjs\.js$/, /\/node_modules\/.*\.mjs$/];
+function guessCJSversion(id) {
+	if (id.match(ESM_EXT_RE)) {
+		for (const i of [
+			id.replace(ESM_EXT_RE, ".mjs"),
+			id.replace(ESM_EXT_RE, ".umd.js"),
+			id.replace(ESM_EXT_RE, ".cjs.js"),
+			id.replace(ESM_EXT_RE, ".js")
+		]) if (existsSync(i)) return i;
+	}
+	if (id.match(ESM_FOLDER_RE)) {
+		for (const i of [
+			id.replace(ESM_FOLDER_RE, "/umd/$1"),
+			id.replace(ESM_FOLDER_RE, "/cjs/$1"),
+			id.replace(ESM_FOLDER_RE, "/lib/$1"),
+			id.replace(ESM_FOLDER_RE, "/$1")
+		]) if (existsSync(i)) return i;
+	}
+}
+// The code from https://github.com/unjs/mlly/blob/c5bcca0cda175921344fd6de1bc0c499e73e5dac/src/syntax.ts#L51-L98
+async function isValidNodeImport(id) {
+	const extension = extname(id);
+	if (BUILTIN_EXTENSIONS.has(extension)) return true;
+	if (extension !== ".js") return false;
+	id = id.replace("file:///", "");
+	const package_ = findNearestPackageData(dirname(id));
+	if (package_.type === "module") return true;
+	if (/\.(?:\w+-)?esm?(?:-\w+)?\.js$|\/esm?\//.test(id)) return false;
+	try {
+		await esModuleLexer.init;
+		const code = await promises.readFile(id, "utf8"), [, , , hasModuleSyntax] = esModuleLexer.parse(code);
+		return !hasModuleSyntax;
+	} catch {
+		return false;
+	}
+}
+async function shouldExternalize(id, options, cache) {
+	if (!cache.has(id)) cache.set(id, _shouldExternalize(id, options));
+	return cache.get(id);
+}
+async function _shouldExternalize(id, options) {
+	// data: should be processed by native import,
+	// since it is a feature of ESM.
+	// also externalize network imports since nodejs allows it when --experimental-network-imports
+	if (isBuiltin(id) || id.startsWith("data:") || /^(?:https?:)?\/\//.test(id)) return id;
+	const moduleDirectories = options?.moduleDirectories || ["/node_modules/"];
+	if (matchExternalizePattern(id, moduleDirectories, options?.inline) || options?.inlineFiles && options?.inlineFiles.includes(id)) return false;
+	// Unless the user explicitly opted to inline them, externalize Vite deps.
+	// They are too big to inline by default.
+	if (matchExternalizePattern(id, moduleDirectories, options?.external) || options?.cacheDir && id.includes(options.cacheDir)) return id;
+	const isLibraryModule = moduleDirectories.some((dir) => id.includes(dir)), guessCJS = isLibraryModule && options?.fallbackCJS;
+	return id = guessCJS ? guessCJSversion(id) || id : id, matchExternalizePattern(id, moduleDirectories, defaultInline) ? false : matchExternalizePattern(id, moduleDirectories, depsExternal) || isLibraryModule && await isValidNodeImport(id) ? id : false;
+}
+function matchExternalizePattern(id, moduleDirectories, patterns) {
+	if (patterns == null) return false;
+	if (patterns === true) return true;
+	for (const ex of patterns) if (typeof ex === "string") {
+		if (moduleDirectories.some((dir) => id.includes(join(dir, ex)))) return true;
+	} else if (ex.test(id)) return true;
+	return false;
+}
+
 class TestSpecification {
 	/**
 	* @deprecated use `project` instead
@@ -6860,24 +6856,16 @@ class TestSpecification {
 	*/
 	testLines;
 	constructor(project, moduleId, pool, testLines) {
-		this[0] = project;
-		this[1] = moduleId;
-		this[2] = { pool };
-		const name = project.config.name;
-		const hashName = pool !== "typescript" ? name : name ? `${name}:__typecheck__` : "__typecheck__";
-		this.taskId = generateFileHash(relative(project.config.root, moduleId), hashName);
-		this.project = project;
-		this.moduleId = moduleId;
-		this.pool = pool;
-		this.testLines = testLines;
+		this[0] = project, this[1] = moduleId, this[2] = { pool };
+		const name = project.config.name, hashName = pool !== "typescript" ? name : name ? `${name}:__typecheck__` : "__typecheck__";
+		this.taskId = generateFileHash(relative(project.config.root, moduleId), hashName), this.project = project, this.moduleId = moduleId, this.pool = pool, this.testLines = testLines;
 	}
 	/**
 	* Test module associated with the specification.
 	*/
 	get testModule() {
 		const task = this.project.vitest.state.idMap.get(this.taskId);
-		if (!task) return void 0;
-		return this.project.vitest.state.getReportedEntity(task);
+		return task ? this.project.vitest.state.getReportedEntity(task) : void 0;
 	}
 	toJSON() {
 		return [
@@ -6897,9 +6885,7 @@ class TestSpecification {
 	* @deprecated
 	*/
 	*[Symbol.iterator]() {
-		yield this.project;
-		yield this.moduleId;
-		yield this.pool;
+		yield this.project, yield this.moduleId, yield this.pool;
 	}
 }
 
@@ -6908,12 +6894,10 @@ async function createViteServer(inlineConfig) {
 	// 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);
+		typeof args[0] === "string" && args[0].includes("WebSocket server error:") || error(...args);
 	};
 	const server = await createServer(inlineConfig);
-	console.error = error;
-	return server;
+	return console.error = error, server;
 }
 
 class TestProject {
@@ -6936,11 +6920,11 @@ class TestProject {
 	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
 	*/
 	tmpDir = join(tmpdir(), nanoid());
-	/** @internal */ vitenode;
 	/** @internal */ typechecker;
 	/** @internal */ _config;
 	/** @internal */ _vite;
 	/** @internal */ _hash;
+	/** @internal */ _resolver;
 	runner;
 	closingPromise;
 	testFilesList = null;
@@ -6948,11 +6932,7 @@ class TestProject {
 	_globalSetups;
 	_provided = {};
 	constructor(path, vitest, options) {
-		this.path = path;
-		this.options = options;
-		this.vitest = vitest;
-		this.ctx = vitest;
-		this.globalConfig = vitest.config;
+		this.path = path, this.options = options, this.vitest = vitest, this.ctx = vitest, this.globalConfig = vitest.config;
 	}
 	/**
 	* The unique hash of this project. This value is consistent between the reruns.
@@ -6981,10 +6961,9 @@ class TestProject {
 	* Get the provided context. The project context is merged with the global context.
 	*/
 	getProvidedContext() {
-		if (this.isRootProject()) return this._provided;
 		// globalSetup can run even if core workspace is not part of the test run
 		// so we need to inherit its provided context
-		return {
+		return this.isRootProject() ? this._provided : {
 			...this.vitest.getRootProject().getProvidedContext(),
 			...this._provided
 		};
@@ -7008,13 +6987,11 @@ class TestProject {
 	*/
 	get vite() {
 		if (!this._vite) throw new Error("The server was not set. It means that `project.vite` was called before the Vite server was established.");
-		// checking it once should be enough
-		Object.defineProperty(this, "vite", {
+		return Object.defineProperty(this, "vite", {
 			configurable: true,
 			writable: true,
 			value: this._vite
-		});
-		return this._vite;
+		}), this._vite;
 	}
 	/**
 	* Resolved project configuration.
@@ -7071,13 +7048,14 @@ class TestProject {
 	}
 	/** @internal */
 	async _initializeGlobalSetup() {
-		if (this._globalSetups) return;
-		this._globalSetups = await loadGlobalSetupFiles(this.runner, this.config.globalSetup);
-		for (const globalSetupFile of this._globalSetups) {
-			const teardown = await globalSetupFile.setup?.(this);
-			if (teardown == null || !!globalSetupFile.teardown) continue;
-			if (typeof teardown !== "function") throw new TypeError(`invalid return value in globalSetup file ${globalSetupFile.file}. Must return a function`);
-			globalSetupFile.teardown = teardown;
+		if (!this._globalSetups) {
+			this._globalSetups = await loadGlobalSetupFiles(this.runner, this.config.globalSetup);
+			for (const globalSetupFile of this._globalSetups) {
+				const teardown = await globalSetupFile.setup?.(this);
+				if (teardown == null || !!globalSetupFile.teardown) continue;
+				if (typeof teardown !== "function") throw new TypeError(`invalid return value in globalSetup file ${globalSetupFile.file}. Must return a function`);
+				globalSetupFile.teardown = teardown;
+			}
 		}
 	}
 	onTestsRerun(cb) {
@@ -7089,8 +7067,7 @@ class TestProject {
 	}
 	/** @internal */
 	async _teardownGlobalSetup() {
-		if (!this._globalSetups) return;
-		for (const globalSetupFile of [...this._globalSetups].reverse()) await globalSetupFile.teardown?.();
+		if (this._globalSetups) for (const globalSetupFile of [...this._globalSetups].reverse()) await globalSetupFile.teardown?.();
 	}
 	/** @deprecated use `vitest.logger` instead */
 	get logger() {
@@ -7120,12 +7097,8 @@ class TestProject {
 	* @param filters String filters to match the test files.
 	*/
 	async globTestFiles(filters = []) {
-		const dir = this.config.dir || this.config.root;
-		const { include, exclude, includeSource } = this.config;
-		const typecheck = this.config.typecheck;
-		const [testFiles, typecheckTestFiles] = await Promise.all([typecheck.enabled && typecheck.only ? [] : this.globAllTestFiles(include, exclude, includeSource, dir), typecheck.enabled ? this.typecheckFilesList || this.globFiles(typecheck.include, typecheck.exclude, dir) : []]);
-		this.typecheckFilesList = typecheckTestFiles;
-		return {
+		const dir = this.config.dir || this.config.root, { include, exclude, includeSource } = this.config, typecheck = this.config.typecheck, [testFiles, typecheckTestFiles] = await Promise.all([typecheck.enabled && typecheck.only ? [] : this.globAllTestFiles(include, exclude, includeSource, dir), typecheck.enabled ? this.typecheckFilesList || this.globFiles(typecheck.include, typecheck.exclude, dir) : []]);
+		return this.typecheckFilesList = typecheckTestFiles, {
 			testFiles: this.filterFiles(testFiles, filters, dir),
 			typecheckTestFiles: this.filterFiles(typecheckTestFiles, filters, dir)
 		};
@@ -7144,8 +7117,7 @@ class TestProject {
 				}
 			}));
 		}
-		this.testFilesList = testFiles;
-		return testFiles;
+		return this.testFilesList = testFiles, testFiles;
 	}
 	isBrowserEnabled() {
 		return isBrowserEnabled(this.config);
@@ -7182,8 +7154,7 @@ class TestProject {
 			cwd,
 			ignore: exclude,
 			expandDirectories: false
-		};
-		const files = await glob(include, globOptions);
+		}, files = await glob(include, globOptions);
 		// keep the slashes consistent with Vite
 		// we are not using the pathe here because it normalizes the drive letter on Windows
 		// and we want to keep it the same as working dir
@@ -7196,16 +7167,10 @@ class TestProject {
 		if (this._isCachedTestFile(moduleId)) return true;
 		const relativeId = relative(this.config.dir || this.config.root, moduleId);
 		if (pm.isMatch(relativeId, this.config.exclude)) return false;
-		if (pm.isMatch(relativeId, this.config.include)) {
-			this.markTestFile(moduleId);
-			return true;
-		}
+		if (pm.isMatch(relativeId, this.config.include)) return this.markTestFile(moduleId), true;
 		if (this.config.includeSource?.length && pm.isMatch(relativeId, this.config.includeSource)) {
 			const code = source?.() || readFileSync(moduleId, "utf-8");
-			if (this.isInSourceTestCode(code)) {
-				this.markTestFile(moduleId);
-				return true;
-			}
+			if (this.isInSourceTestCode(code)) return this.markTestFile(moduleId), true;
 		}
 		return false;
 	}
@@ -7218,7 +7183,7 @@ class TestProject {
 	}
 	filterFiles(testFiles, filters, dir) {
 		if (filters.length && process.platform === "win32") filters = filters.map((f) => slash(f));
-		if (filters.length) return testFiles.filter((t) => {
+		return filters.length ? testFiles.filter((t) => {
 			const testFile = relative(dir, t).toLocaleLowerCase();
 			return filters.some((f) => {
 				// if filter is a full file path, we should include it if it's in the same folder
@@ -7226,8 +7191,7 @@ class TestProject {
 				const relativePath = f.endsWith("/") ? join(relative(dir, f), "/") : relative(dir, f);
 				return testFile.includes(f.toLocaleLowerCase()) || testFile.includes(relativePath.toLocaleLowerCase());
 			});
-		});
-		return testFiles;
+		}) : testFiles;
 	}
 	_parentBrowser;
 	/** @internal */
@@ -7238,25 +7202,23 @@ class TestProject {
 		await this.vitest.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.vitest.version);
 		const { createBrowserServer, distRoot } = await import('@vitest/browser');
 		let cacheDir;
-		const browser = await createBrowserServer(this, this.vite.config.configFile, [{
-			name: "vitest:browser-cacheDir",
-			configResolved(config) {
-				cacheDir = config.cacheDir;
-			}
-		}, ...MocksPlugins({ filter(id) {
-			if (id.includes(distRoot) || id.includes(cacheDir)) return false;
-			return true;
-		} })], [CoverageTransform(this.vitest)]);
-		this._parentBrowser = browser;
-		if (this.config.browser.ui) setup(this.vitest, browser.vite);
+		const browser = await createBrowserServer(this, this.vite.config.configFile, [
+			{
+				name: "vitest:browser-cacheDir",
+				configResolved(config) {
+					cacheDir = config.cacheDir;
+				}
+			},
+			...MocksPlugins({ filter(id) {
+				return !(id.includes(distRoot) || id.includes(cacheDir));
+			} }),
+			MetaEnvReplacerPlugin()
+		], [CoverageTransform(this.vitest)]);
+		if (this._parentBrowser = browser, this.config.browser.ui) setup(this.vitest, browser.vite);
 	});
 	/** @internal */
 	_initBrowserServer = deduped(async () => {
-		await this._parent?._initParentBrowser();
-		if (!this.browser && this._parent?._parentBrowser) {
-			this.browser = this._parent._parentBrowser.spawn(this);
-			await this.vitest.report("onBrowserInit", this);
-		}
+		if (await this._parent?._initParentBrowser(), !this.browser && this._parent?._parentBrowser) this.browser = this._parent._parentBrowser.spawn(this), await this.vitest.report("onBrowserInit", this);
 	});
 	/**
 	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
@@ -7269,8 +7231,7 @@ class TestProject {
 			this.browser?.close(),
 			this.clearTmpDir()
 		].filter(Boolean)).then(() => {
-			this._provided = {};
-			this._vite = void 0;
+			this._provided = {}, this._vite = void 0;
 		});
 		return this.closingPromise;
 	}
@@ -7279,7 +7240,7 @@ class TestProject {
 	* @param moduleId The ID of the module in Vite module graph
 	*/
 	import(moduleId) {
-		return this.runner.executeId(moduleId);
+		return this.runner.import(moduleId);
 	}
 	/** @deprecated use `name` instead */
 	getName() {
@@ -7294,36 +7255,22 @@ class TestProject {
 	}
 	/** @internal */
 	async _configureServer(options, server) {
-		this._config = resolveConfig(this.vitest, {
+		for (const _providedKey in this._config = resolveConfig(this.vitest, {
 			...options,
 			coverage: this.vitest.config.coverage
-		}, server.config);
-		this._setHash();
-		for (const _providedKey in this.config.provide) {
+		}, server.config), this._setHash(), this.config.provide) {
 			const providedKey = _providedKey;
 			// type is very strict here, so we cast it to any
 			this.provide(providedKey, this.config.provide[providedKey]);
 		}
-		this.closingPromise = void 0;
-		this._vite = server;
-		this.vitenode = new ViteNodeServer(server, this.config.server);
-		const node = this.vitenode;
-		this.runner = new ViteNodeRunner({
-			root: server.config.root,
-			base: server.config.base,
-			fetchModule(id) {
-				return node.fetchModule(id);
-			},
-			resolveId(id, importer) {
-				return node.resolveId(id, importer);
-			}
-		});
+		this.closingPromise = void 0, this._resolver = new VitestResolver(server.config.cacheDir, this._config), this._vite = server;
+		const environment = server.environments.__vitest__;
+		this.runner = new ServerModuleRunner(environment, this._resolver, this._config);
 	}
 	_serializeOverriddenConfig() {
 		// TODO: serialize the config _once_ or when needed
 		const config = serializeConfig(this.config, this.vitest.config, this.vite.config);
-		if (!this.vitest.configOverride) return config;
-		return deepMerge(config, this.vitest.configOverride);
+		return this.vitest.configOverride ? deepMerge(config, this.vitest.configOverride) : config;
 	}
 	async clearTmpDir() {
 		try {
@@ -7336,9 +7283,10 @@ class TestProject {
 	}
 	/** @internal */
 	_initBrowserProvider = deduped(async () => {
-		if (!this.isBrowserEnabled() || this.browser?.provider) return;
-		if (!this.browser) await this._initBrowserServer();
-		await this.browser?.initBrowserProvider(this);
+		if (!(!this.isBrowserEnabled() || this.browser?.provider)) {
+			if (!this.browser) await this._initBrowserServer();
+			await this.browser?.initBrowserProvider(this);
+		}
 	});
 	/** @internal */
 	_provideObject(context) {
@@ -7351,40 +7299,25 @@ class TestProject {
 	/** @internal */
 	static _createBasicProject(vitest) {
 		const project = new TestProject(vitest.config.name || vitest.config.root, vitest);
-		project.vitenode = vitest.vitenode;
-		project.runner = vitest.runner;
-		project._vite = vitest.server;
-		project._config = vitest.config;
-		project._setHash();
-		project._provideObject(vitest.config.provide);
-		return project;
+		return project.runner = vitest.runner, project._vite = vitest.server, project._config = vitest.config, project._resolver = vitest._resolver, project._setHash(), project._provideObject(vitest.config.provide), project;
 	}
 	/** @internal */
 	static _cloneBrowserProject(parent, config) {
 		const clone = new TestProject(parent.path, parent.vitest);
-		clone.vitenode = parent.vitenode;
-		clone.runner = parent.runner;
-		clone._vite = parent._vite;
-		clone._config = config;
-		clone._setHash();
-		clone._parent = parent;
-		clone._provideObject(config.provide);
-		return clone;
+		return clone.runner = parent.runner, clone._vite = parent._vite, clone._resolver = parent._resolver, clone._config = config, clone._setHash(), clone._parent = parent, clone._provideObject(config.provide), clone;
 	}
 }
 function deduped(cb) {
 	let _promise;
-	return (...args) => {
+	return ((...args) => {
 		if (!_promise) _promise = cb(...args).finally(() => {
 			_promise = void 0;
 		});
 		return _promise;
-	};
+	});
 }
 async function initializeProject(workspacePath, ctx, options) {
-	const project = new TestProject(workspacePath, ctx, options);
-	const { configFile,...restOptions } = options;
-	const config = {
+	const project = new TestProject(workspacePath, ctx, options), { configFile,...restOptions } = options, config = {
 		...restOptions,
 		configFile,
 		configLoader: ctx.vite.config.inlineConfig.configLoader,
@@ -7394,25 +7327,20 @@ async function initializeProject(workspacePath, ctx, options) {
 			workspacePath
 		})]
 	};
-	await createViteServer(config);
-	return project;
+	return await createViteServer(config), project;
 }
 function generateHash(str) {
 	let hash = 0;
 	if (str.length === 0) return `${hash}`;
 	for (let i = 0; i < str.length; i++) {
 		const char = str.charCodeAt(i);
-		hash = (hash << 5) - hash + char;
-		hash = hash & hash;
+		hash = (hash << 5) - hash + char, hash = hash & hash;
 	}
 	return `${hash}`;
 }
 
 async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projectsDefinition, names) {
-	const { configFiles, projectConfigs, nonConfigDirectories } = await resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDefinition);
-	// cli options that affect the project config,
-	// not all options are allowed to be overridden
-	const overridesOptions = [
+	const { configFiles, projectConfigs, nonConfigDirectories } = await resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDefinition), overridesOptions = [
 		"logHeapUsage",
 		"allowOnly",
 		"sequence",
@@ -7431,21 +7359,12 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		"inspect",
 		"inspectBrk",
 		"fileParallelism"
-	];
-	const cliOverrides = overridesOptions.reduce((acc, name) => {
+	], cliOverrides = overridesOptions.reduce((acc, name) => {
 		if (name in cliOptions) acc[name] = cliOptions[name];
 		return acc;
-	}, {});
-	const projectPromises = [];
-	const fileProjects = [...configFiles, ...nonConfigDirectories];
-	const concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
+	}, {}), projectPromises = [], fileProjects = [...configFiles, ...nonConfigDirectories], concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
 	projectConfigs.forEach((options, index) => {
-		const configRoot = vitest.config.root;
-		// if extends a config file, resolve the file path
-		const configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : options.extends === true ? vitest.vite.config.configFile || false : false;
-		// if `root` is configured, resolve it relative to the workspace file or vite root (like other options)
-		// if `root` is not specified, inline configs use the same root as the root project
-		const root = options.root ? resolve(configRoot, options.root) : vitest.config.root;
+		const configRoot = vitest.config.root, configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : options.extends === true ? vitest.vite.config.configFile || false : false, root = options.root ? resolve(configRoot, options.root) : vitest.config.root;
 		projectPromises.push(concurrent(() => initializeProject(index, vitest, {
 			...options,
 			root,
@@ -7463,8 +7382,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 			if (project) projectPromises.push(Promise.resolve(project));
 			continue;
 		}
-		const configFile = path.endsWith("/") ? false : path;
-		const root = path.endsWith("/") ? path : dirname(path);
+		const configFile = path.endsWith("/") ? false : path, root = path.endsWith("/") ? path : dirname(path);
 		projectPromises.push(concurrent(() => initializeProject(path, vitest, {
 			root,
 			configFile,
@@ -7477,9 +7395,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		vitest.config.project.length ? `The filter matched no projects: ${vitest.config.project.join(", ")}. ` : "",
 		`The projects definition: ${JSON.stringify(projectsDefinition, null, 4)}.`
 	].join(""));
-	const resolvedProjectsPromises = await Promise.allSettled(projectPromises);
-	const errors = [];
-	const resolvedProjects = [];
+	const resolvedProjectsPromises = await Promise.allSettled(projectPromises), errors = [], resolvedProjects = [];
 	for (const result of resolvedProjectsPromises) if (result.status === "rejected") {
 		if (result.reason instanceof VitestFilteredOutProjectError)
  // filter out filtered out projects
@@ -7491,8 +7407,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 	for (const project of resolvedProjects) {
 		const name = project.name;
 		if (names.has(name)) {
-			const duplicate = resolvedProjects.find((p) => p.name === name && p !== project);
-			const filesError = fileProjects.length ? [
+			const duplicate = resolvedProjects.find((p) => p.name === name && p !== project), filesError = fileProjects.length ? [
 				"\n\nYour config matched these files:\n",
 				fileProjects.map((p) => ` - ${relative(vitest.config.root, p)}`).join("\n"),
 				"\n\n"
@@ -7514,24 +7429,18 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	const removeProjects = /* @__PURE__ */ new Set();
 	resolvedProjects.forEach((project) => {
 		if (!project.config.browser.enabled) return;
-		const instances = project.config.browser.instances || [];
-		const browser = project.config.browser.name;
-		if (instances.length === 0 && browser) {
-			instances.push({
-				browser,
-				name: project.name ? `${project.name} (${browser})` : browser
-			});
-			vitest.logger.warn(withLabel("yellow", "Vitest", [
-				`No browser "instances" were defined`,
-				project.name ? ` for the "${project.name}" project. ` : ". ",
-				`Running tests in "${project.config.browser.name}" browser. `,
-				"The \"browser.name\" field is deprecated since Vitest 3. ",
-				"Read more: https://vitest.dev/guide/browser/config#browser-instances"
-			].filter(Boolean).join("")));
-		}
-		const originalName = project.config.name;
-		// if original name is in the --project=name filter, keep all instances
-		const filteredInstances = vitest.matchesProjectFilter(originalName) ? instances : instances.filter((instance) => {
+		const instances = project.config.browser.instances || [], browser = project.config.browser.name;
+		if (instances.length === 0 && browser) instances.push({
+			browser,
+			name: project.name ? `${project.name} (${browser})` : browser
+		}), vitest.logger.warn(withLabel("yellow", "Vitest", [
+			`No browser "instances" were defined`,
+			project.name ? ` for the "${project.name}" project. ` : ". ",
+			`Running tests in "${project.config.browser.name}" browser. `,
+			"The \"browser.name\" field is deprecated since Vitest 3. ",
+			"Read more: https://vitest.dev/guide/browser/config#browser-instances"
+		].filter(Boolean).join("")));
+		const originalName = project.config.name, filteredInstances = vitest.matchesProjectFilter(originalName) ? instances : instances.filter((instance) => {
 			const newName = instance.name;
 			return vitest.matchesProjectFilter(newName);
 		});
@@ -7544,8 +7453,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 		filteredInstances.forEach((config, index) => {
 			const browser = config.browser;
 			if (!browser) {
-				const nth = index + 1;
-				const ending = nth === 2 ? "nd" : nth === 3 ? "rd" : "th";
+				const nth = index + 1, ending = nth === 2 ? "nd" : nth === 3 ? "rd" : "th";
 				throw new Error(`The browser configuration must have a "browser" property. The ${nth}${ending} item in "browser.instances" doesn't have it. Make sure your${originalName ? ` "${originalName}"` : ""} configuration is correct.`);
 			}
 			const name = config.name;
@@ -7560,18 +7468,15 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			clonedConfig.name = name;
 			const clone = TestProject._cloneBrowserProject(project, clonedConfig);
 			resolvedProjects.push(clone);
-		});
-		removeProjects.add(project);
-	});
-	resolvedProjects = resolvedProjects.filter((project) => !removeProjects.has(project));
+		}), removeProjects.add(project);
+	}), resolvedProjects = resolvedProjects.filter((project) => !removeProjects.has(project));
 	const headedBrowserProjects = resolvedProjects.filter((project) => {
 		return project.config.browser.enabled && !project.config.browser.headless;
 	});
 	if (headedBrowserProjects.length > 1) {
 		const message = [`Found multiple projects that run browser tests in headed mode: "${headedBrowserProjects.map((p) => p.name).join("\", \"")}".`, ` Vitest cannot run multiple headed browsers at the same time.`].join("");
 		if (!isTTY) throw new Error(`${message} Please, filter projects with --browser=name or --project=name flag or run tests with "headless: true" option.`);
-		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; });
-		const { projectName } = await prompts.default({
+		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; }), { projectName } = await prompts.default({
 			type: "select",
 			name: "projectName",
 			choices: headedBrowserProjects.map((project) => ({
@@ -7586,10 +7491,9 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	return resolvedProjects;
 }
 function cloneConfig(project, { browser,...config }) {
-	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name,...overrideConfig } = config;
-	const currentConfig = project.config.browser;
+	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name,...overrideConfig } = config, currentConfig = project.config.browser, clonedConfig = deepClone(project.config);
 	return mergeConfig({
-		...deepClone(project.config),
+		...clonedConfig,
 		browser: {
 			...project.config.browser,
 			locators: locators ? { testIdAttribute: locators.testIdAttribute ?? currentConfig.locators.testIdAttribute } : project.config.browser.locators,
@@ -7601,18 +7505,15 @@ function cloneConfig(project, { browser,...config }) {
 			name: browser,
 			providerOptions: config,
 			instances: void 0
-		}
+		},
+		include: overrideConfig.include && overrideConfig.include.length > 0 ? [] : clonedConfig.include,
+		exclude: overrideConfig.exclude && overrideConfig.exclude.length > 0 ? [] : clonedConfig.exclude,
+		includeSource: overrideConfig.includeSource && overrideConfig.includeSource.length > 0 ? [] : clonedConfig.includeSource
 	}, overrideConfig);
 }
 async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDefinition) {
 	// project configurations that were specified directly
-	const projectsOptions = [];
-	// custom config files that were specified directly or resolved from a directory
-	const projectsConfigFiles = [];
-	// custom glob matches that should be resolved as directories or config files
-	const projectsGlobMatches = [];
-	// directories that don't have a config file inside, but should be treated as projects
-	const nonConfigProjectDirectories = [];
+	const projectsOptions = [], projectsConfigFiles = [], projectsGlobMatches = [], nonConfigProjectDirectories = [];
 	for (const definition of projectsDefinition) if (typeof definition === "string") {
 		const stringOption = definition.replace("<rootDir>", vitest.config.root);
 		// if the string doesn't contain a glob, we can resolve it directly
@@ -7656,8 +7557,7 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 				"**/*.timestamp-*",
 				"**/.DS_Store"
 			]
-		};
-		const projectsFs = await glob(projectsGlobMatches, globOptions);
+		}, projectsFs = await glob(projectsGlobMatches, globOptions);
 		await Promise.all(projectsFs.map(async (path) => {
 			// directories are allowed with a glob like `packages/*`
 			// in this case every directory is treated as a project
@@ -7676,21 +7576,15 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 	};
 }
 async function resolveDirectoryConfig(directory) {
-	const files = new Set(await promises.readdir(directory));
-	// default resolution looks for vitest.config.* or vite.config.* files
-	// this simulates how `findUp` works in packages/vitest/src/node/create.ts:29
-	const configFile = configFiles.find((file) => files.has(file));
-	if (configFile) return resolve(directory, configFile);
-	return null;
+	const files = new Set(await promises.readdir(directory)), configFile = configFiles.find((file) => files.has(file));
+	return configFile ? resolve(directory, configFile) : null;
 }
 function getDefaultTestProject(vitest) {
-	const filter = vitest.config.project;
-	const project = vitest._ensureRootProject();
+	const filter = vitest.config.project, project = vitest._ensureRootProject();
 	if (!filter.length) return project;
 	// check for the project name and browser names
 	const hasProjects = getPotentialProjectNames(project).some((p) => vitest.matchesProjectFilter(p));
-	if (hasProjects) return project;
-	return null;
+	return hasProjects ? project : null;
 }
 function getPotentialProjectNames(project) {
 	const names = [project.name];
@@ -7702,7 +7596,7 @@ function getPotentialProjectNames(project) {
 async function loadCustomReporterModule(path, runner) {
 	let customReporterModule;
 	try {
-		customReporterModule = await runner.executeId(path);
+		customReporterModule = await runner.import(path);
 	} catch (customReporterModuleError) {
 		throw new Error(`Failed to load custom Reporter from ${path}`, { cause: customReporterModuleError });
 	}
@@ -7710,12 +7604,11 @@ async function loadCustomReporterModule(path, runner) {
 	return customReporterModule.default;
 }
 function createReporters(reporterReferences, ctx) {
-	const runner = ctx.runner;
-	const promisedReporters = reporterReferences.map(async (referenceOrInstance) => {
+	const runner = ctx.runner, promisedReporters = reporterReferences.map(async (referenceOrInstance) => {
 		if (Array.isArray(referenceOrInstance)) {
 			const [reporterName, reporterOptions] = referenceOrInstance;
 			if (reporterName === "html") {
-				await ctx.packageInstaller.ensureInstalled("@vitest/ui", runner.root, ctx.version);
+				await ctx.packageInstaller.ensureInstalled("@vitest/ui", ctx.config.root, ctx.version);
 				const CustomReporter = await loadCustomReporterModule("@vitest/ui/reporter", runner);
 				return new CustomReporter(reporterOptions);
 			} else if (reporterName in ReportersMap) {
@@ -7752,14 +7645,12 @@ function parseFilter(filter) {
 		filename: parsedFilename,
 		lineNumber: Number.parseInt(lineNumber)
 	};
-	else if (lineNumber.match(/^\d+-\d+$/)) throw new RangeLocationFilterProvidedError(filter);
-	else return { filename: filter };
+	if (lineNumber.match(/^\d+-\d+$/)) throw new RangeLocationFilterProvidedError(filter);
+	return { filename: filter };
 }
 function groupFilters(filters) {
-	const groupedFilters_ = groupBy(filters, (f) => f.filename);
-	const groupedFilters = Object.fromEntries(Object.entries(groupedFilters_).map((entry) => {
-		const [filename, filters] = entry;
-		const testLocations = filters.map((f) => f.lineNumber);
+	const groupedFilters_ = groupBy(filters, (f) => f.filename), groupedFilters = Object.fromEntries(Object.entries(groupedFilters_).map((entry) => {
+		const [filename, filters] = entry, testLocations = filters.map((f) => f.lineNumber);
 		return [filename, testLocations.filter((l) => l !== void 0)];
 	}));
 	return groupedFilters;
@@ -7778,45 +7669,35 @@ class VitestSpecifications {
 			if (project._isCachedTestFile(moduleId)) specs.push(project.createSpecification(moduleId));
 			if (project._isCachedTypecheckFile(moduleId)) specs.push(project.createSpecification(moduleId, [], "typescript"));
 		}
-		specs.forEach((spec) => this.ensureSpecificationCached(spec));
-		return specs;
+		return specs.forEach((spec) => this.ensureSpecificationCached(spec)), specs;
 	}
 	async getRelevantTestSpecifications(filters = []) {
 		return this.filterTestsBySource(await this.globTestSpecifications(filters));
 	}
 	async globTestSpecifications(filters = []) {
-		const files = [];
-		const dir = process.cwd();
-		const parsedFilters = filters.map((f) => parseFilter(f));
+		const files = [], dir = process.cwd(), parsedFilters = filters.map((f) => parseFilter(f));
 		// Require includeTaskLocation when a location filter is passed
 		if (!this.vitest.config.includeTaskLocation && parsedFilters.some((f) => f.lineNumber !== void 0)) throw new IncludeTaskLocationDisabledError();
 		const testLines = groupFilters(parsedFilters.map((f) => ({
 			...f,
 			filename: resolve(dir, f.filename)
-		})));
-		// Key is file and val specifies whether we have matched this file with testLocation
-		const testLocHasMatch = {};
-		await Promise.all(this.vitest.projects.map(async (project) => {
+		}))), testLocHasMatch = {};
+		return await Promise.all(this.vitest.projects.map(async (project) => {
 			const { testFiles, typecheckTestFiles } = await project.globTestFiles(parsedFilters.map((f) => f.filename));
 			testFiles.forEach((file) => {
 				const lines = testLines[file];
 				testLocHasMatch[file] = true;
 				const spec = project.createSpecification(file, lines);
-				this.ensureSpecificationCached(spec);
-				files.push(spec);
-			});
-			typecheckTestFiles.forEach((file) => {
+				this.ensureSpecificationCached(spec), files.push(spec);
+			}), typecheckTestFiles.forEach((file) => {
 				const lines = testLines[file];
 				testLocHasMatch[file] = true;
 				const spec = project.createSpecification(file, lines, "typescript");
-				this.ensureSpecificationCached(spec);
-				files.push(spec);
+				this.ensureSpecificationCached(spec), files.push(spec);
 			});
-		}));
-		Object.entries(testLines).forEach(([filepath, loc]) => {
+		})), Object.entries(testLines).forEach(([filepath, loc]) => {
 			if (loc.length !== 0 && !testLocHasMatch[filepath]) throw new LocationFilterFileNotFoundError(relative(dir, filepath));
-		});
-		return files;
+		}), files;
 	}
 	clearCache(moduleId) {
 		if (moduleId) this._cachedSpecs.delete(moduleId);
@@ -7826,30 +7707,20 @@ class VitestSpecifications {
 		return this._cachedSpecs.get(moduleId);
 	}
 	ensureSpecificationCached(spec) {
-		const file = spec.moduleId;
-		const specs = this._cachedSpecs.get(file) || [];
-		const index = specs.findIndex((_s) => _s.project === spec.project && _s.pool === spec.pool);
-		if (index === -1) {
-			specs.push(spec);
-			this._cachedSpecs.set(file, specs);
-		} else specs.splice(index, 1, spec);
+		const file = spec.moduleId, specs = this._cachedSpecs.get(file) || [], index = specs.findIndex((_s) => _s.project === spec.project && _s.pool === spec.pool);
+		if (index === -1) specs.push(spec), this._cachedSpecs.set(file, specs);
+		else specs.splice(index, 1, spec);
 		return specs;
 	}
 	async filterTestsBySource(specs) {
 		if (this.vitest.config.changed && !this.vitest.config.related) {
-			const { VitestGit } = await import('./git.BVQ8w_Sw.js');
-			const vitestGit = new VitestGit(this.vitest.config.root);
-			const related = await vitestGit.findChangedFiles({ changedSince: this.vitest.config.changed });
-			if (!related) {
-				process.exitCode = 1;
-				throw new GitNotFoundError();
-			}
+			const { VitestGit } = await import('./git.BFNcloKD.js'), vitestGit = new VitestGit(this.vitest.config.root), related = await vitestGit.findChangedFiles({ changedSince: this.vitest.config.changed });
+			if (!related) throw process.exitCode = 1, new GitNotFoundError();
 			this.vitest.config.related = Array.from(new Set(related));
 		}
 		const related = this.vitest.config.related;
 		if (!related) return specs;
-		const forceRerunTriggers = this.vitest.config.forceRerunTriggers;
-		const matcher = forceRerunTriggers.length ? pm(forceRerunTriggers) : void 0;
+		const forceRerunTriggers = this.vitest.config.forceRerunTriggers, matcher = forceRerunTriggers.length ? pm(forceRerunTriggers) : void 0;
 		if (matcher && related.some((file) => matcher(file))) return specs;
 		// don't run anything if no related sources are found
 		// if we are in watch mode, we want to process all tests
@@ -7857,8 +7728,7 @@ class VitestSpecifications {
 		const testGraphs = await Promise.all(specs.map(async (spec) => {
 			const deps = await this.getTestDependencies(spec);
 			return [spec, deps];
-		}));
-		const runningTests = [];
+		})), runningTests = [];
 		for (const [specification, deps] of testGraphs)
  // if deps or the test itself were changed
 		if (related.some((path) => path === specification.moduleId || deps.has(path))) runningTests.push(specification);
@@ -7868,8 +7738,7 @@ class VitestSpecifications {
 		const addImports = async (project, filepath) => {
 			if (deps.has(filepath)) return;
 			deps.add(filepath);
-			const mod = project.vite.moduleGraph.getModuleById(filepath);
-			const transformed = mod?.ssrTransformResult || await project.vitenode.transformRequest(filepath);
+			const mod = project.vite.environments.ssr.moduleGraph.getModuleById(filepath), transformed = mod?.transformResult || await project.vite.environments.ssr.transformRequest(filepath);
 			if (!transformed) return;
 			const dependencies = [...transformed.deps || [], ...transformed.dynamicDeps || []];
 			await Promise.all(dependencies.map(async (dep) => {
@@ -7877,9 +7746,7 @@ class VitestSpecifications {
 				if (!fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) await addImports(project, fsPath);
 			}));
 		};
-		await addImports(spec.project, spec.moduleId);
-		deps.delete(spec.moduleId);
-		return deps;
+		return await addImports(spec.project, spec.moduleId), deps.delete(spec.moduleId), deps;
 	}
 }
 
@@ -7905,10 +7772,7 @@ class ReportedTaskImplementation {
 	location;
 	/** @internal */
 	constructor(task, project) {
-		this.task = task;
-		this.project = project;
-		this.id = task.id;
-		this.location = task.location;
+		this.task = task, this.project = project, this.id = task.id, this.location = task.location;
 	}
 	/**
 	* Checks if the test did not fail the suite.
@@ -7930,8 +7794,7 @@ class ReportedTaskImplementation {
 	*/
 	static register(task, project) {
 		const state = new this(task, project);
-		storeTask(project, task, state);
-		return state;
+		return storeTask(project, task, state), state;
 	}
 }
 class TestCase extends ReportedTaskImplementation {
@@ -7955,9 +7818,7 @@ class TestCase extends ReportedTaskImplementation {
 	parent;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.name = task.name;
-		this.module = getReportedTask(project, task.file);
+		super(task, project), this.name = task.name, this.module = getReportedTask(project, task.file);
 		const suite = this.task.suite;
 		if (suite) this.parent = getReportedTask(project, suite);
 		else this.parent = this.module;
@@ -7979,8 +7840,7 @@ class TestCase extends ReportedTaskImplementation {
 	* - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
 	*/
 	result() {
-		const result = this.task.result;
-		const mode = result?.state || this.task.mode;
+		const result = this.task.result, mode = result?.state || this.task.mode;
 		if (!result && (mode === "skip" || mode === "todo")) return {
 			state: "skipped",
 			note: void 0,
@@ -7991,16 +7851,14 @@ class TestCase extends ReportedTaskImplementation {
 			errors: void 0
 		};
 		const state = result.state === "fail" ? "failed" : result.state === "pass" ? "passed" : "skipped";
-		if (state === "skipped") return {
+		return state === "skipped" ? {
 			state,
 			note: result.note,
 			errors: void 0
-		};
-		if (state === "passed") return {
+		} : state === "passed" ? {
 			state,
 			errors: result.errors
-		};
-		return {
+		} : {
 			state,
 			errors: result.errors || []
 		};
@@ -8019,8 +7877,7 @@ class TestCase extends ReportedTaskImplementation {
 		const result = this.task.result;
 		// startTime should always be available if the test has properly finished
 		if (!result || !result.startTime) return void 0;
-		const duration = result.duration || 0;
-		const slow = duration > this.project.globalConfig.slowTestThreshold;
+		const duration = result.duration || 0, slow = duration > this.project.globalConfig.slowTestThreshold;
 		return {
 			slow,
 			heap: result.heap,
@@ -8036,8 +7893,7 @@ class TestCollection {
 	#task;
 	#project;
 	constructor(task, project) {
-		this.#task = task;
-		this.#project = project;
+		this.#task = task, this.#project = project;
 	}
 	/**
 	* Returns the test or suite at a specific index.
@@ -8090,10 +7946,7 @@ class TestCollection {
 	* Filters all suites that are part of this collection and its children.
 	*/
 	*allSuites() {
-		for (const child of this) if (child.type === "suite") {
-			yield child;
-			yield* child.children.allSuites();
-		}
+		for (const child of this) if (child.type === "suite") yield child, yield* child.children.allSuites();
 	}
 	*[Symbol.iterator]() {
 		for (const task of this.#task.tasks) yield getReportedTask(this.#project, task);
@@ -8106,8 +7959,7 @@ class SuiteImplementation extends ReportedTaskImplementation {
 	children;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.children = new TestCollection(task, project);
+		super(task, project), this.children = new TestCollection(task, project);
 	}
 	/**
 	* Errors that happened outside of the test run during collection, like syntax errors.
@@ -8137,9 +7989,7 @@ class TestSuite extends SuiteImplementation {
 	options;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.name = task.name;
-		this.module = getReportedTask(project, task.file);
+		super(task, project), this.name = task.name, this.module = getReportedTask(project, task.file);
 		const suite = this.task.suite;
 		if (suite) this.parent = getReportedTask(project, suite);
 		else this.parent = this.module;
@@ -8170,29 +8020,21 @@ class TestModule extends SuiteImplementation {
 	moduleId;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.moduleId = task.filepath;
+		super(task, project), this.moduleId = task.filepath;
 	}
 	/**
 	* Checks the running state of the test file.
 	*/
 	state() {
 		const state = this.task.result?.state;
-		if (state === "queued") return "queued";
-		return getSuiteState(this.task);
+		return state === "queued" ? "queued" : getSuiteState(this.task);
 	}
 	/**
 	* Useful information about the module like duration, memory usage, etc.
 	* If the module was not executed yet, all diagnostic values will return `0`.
 	*/
 	diagnostic() {
-		const setupDuration = this.task.setupDuration || 0;
-		const collectDuration = this.task.collectDuration || 0;
-		const prepareDuration = this.task.prepareDuration || 0;
-		const environmentSetupDuration = this.task.environmentLoad || 0;
-		const duration = this.task.result?.duration || 0;
-		const heap = this.task.result?.heap;
-		const importDurations = this.task.importDurations ?? {};
+		const setupDuration = this.task.setupDuration || 0, collectDuration = this.task.collectDuration || 0, prepareDuration = this.task.prepareDuration || 0, environmentSetupDuration = this.task.environmentLoad || 0, duration = this.task.result?.duration || 0, heap = this.task.result?.heap, importDurations = this.task.importDurations ?? {};
 		return {
 			environmentSetupDuration,
 			prepareDuration,
@@ -8224,8 +8066,7 @@ function getReportedTask(project, runnerTask) {
 	return reportedTask;
 }
 function getSuiteState(task) {
-	const mode = task.mode;
-	const state = task.result?.state;
+	const mode = task.mode, state = task.result?.state;
 	if (mode === "skip" || mode === "todo" || state === "skip" || state === "todo") return "skipped";
 	if (state == null || state === "run" || state === "only") return "pending";
 	if (state === "fail") return "failed";
@@ -8234,8 +8075,7 @@ function getSuiteState(task) {
 }
 
 function isAggregateError(err) {
-	if (typeof AggregateError !== "undefined" && err instanceof AggregateError) return true;
-	return err instanceof Error && "errors" in err;
+	return typeof AggregateError !== "undefined" && err instanceof AggregateError ? true : err instanceof Error && "errors" in err;
 }
 class StateManager {
 	filesMap = /* @__PURE__ */ new Map();
@@ -8246,6 +8086,7 @@ class StateManager {
 	processTimeoutCauses = /* @__PURE__ */ new Set();
 	reportedTasksMap = /* @__PURE__ */ new WeakMap();
 	blobs;
+	transformTime = 0;
 	onUnhandledError;
 	/** @internal */
 	_data = {
@@ -8265,12 +8106,7 @@ class StateManager {
 		const _error = error;
 		if (_error && typeof _error === "object" && _error.code === "VITEST_PENDING") {
 			const task = this.idMap.get(_error.taskId);
-			if (task) {
-				task.mode = "skip";
-				task.result ??= { state: "skip" };
-				task.result.state = "skip";
-				task.result.note = _error.note;
-			}
+			if (task) task.mode = "skip", task.result ??= { state: "skip" }, task.result.state = "skip", task.result.note = _error.note;
 			return;
 		}
 		if (!this.onUnhandledError || this.onUnhandledError(error) !== false) this.errorsSet.add(error);
@@ -8294,12 +8130,8 @@ class StateManager {
 	* Return files that were running or collected.
 	*/
 	getFiles(keys) {
-		if (keys) return keys.map((key) => this.filesMap.get(key)).flat().filter((file) => file && !file.local);
-		return Array.from(this.filesMap.values()).flat().filter((file) => !file.local).sort((f1, f2) => {
-			// print typecheck files first
-			if (f1.meta?.typecheck && f2.meta?.typecheck) return 0;
-			if (f1.meta?.typecheck) return -1;
-			return 1;
+		return keys ? keys.map((key) => this.filesMap.get(key)).flat().filter((file) => file && !file.local) : Array.from(this.filesMap.values()).flat().filter((file) => !file.local).sort((f1, f2) => {
+			return f1.meta?.typecheck && f2.meta?.typecheck ? 0 : f1.meta?.typecheck ? -1 : 1;
 		});
 	}
 	getTestModules(keys) {
@@ -8318,25 +8150,17 @@ class StateManager {
 	}
 	collectFiles(project, files = []) {
 		files.forEach((file) => {
-			const existing = this.filesMap.get(file.filepath) || [];
-			const otherFiles = existing.filter((i) => i.projectName !== file.projectName || i.meta.typecheck !== file.meta.typecheck);
-			const currentFile = existing.find((i) => i.projectName === file.projectName);
+			const existing = this.filesMap.get(file.filepath) || [], otherFiles = existing.filter((i) => i.projectName !== file.projectName || i.meta.typecheck !== file.meta.typecheck), currentFile = existing.find((i) => i.projectName === file.projectName);
 			// keep logs for the previous file because it should always be initiated before the collections phase
 			// which means that all logs are collected during the collection and not inside tests
 			if (currentFile) file.logs = currentFile.logs;
-			otherFiles.push(file);
-			this.filesMap.set(file.filepath, otherFiles);
-			this.updateId(file, project);
+			otherFiles.push(file), this.filesMap.set(file.filepath, otherFiles), this.updateId(file, project);
 		});
 	}
 	clearFiles(project, paths = []) {
 		paths.forEach((path) => {
-			const files = this.filesMap.get(path);
-			const fileTask = createFileTask(path, project.config.root, project.config.name);
-			fileTask.local = true;
-			TestModule.register(fileTask, project);
-			this.idMap.set(fileTask.id, fileTask);
-			if (!files) {
+			const files = this.filesMap.get(path), fileTask = createFileTask(path, project.config.root, project.config.name);
+			if (fileTask.local = true, TestModule.register(fileTask, project), this.idMap.set(fileTask.id, fileTask), !files) {
 				this.filesMap.set(path, [fileTask]);
 				return;
 			}
@@ -8347,14 +8171,14 @@ class StateManager {
 		});
 	}
 	updateId(task, project) {
-		if (this.idMap.get(task.id) === task) return;
-		if (task.type === "suite" && "filepath" in task) TestModule.register(task, project);
-		else if (task.type === "suite") TestSuite.register(task, project);
-		else TestCase.register(task, project);
-		this.idMap.set(task.id, task);
-		if (task.type === "suite") task.tasks.forEach((task) => {
-			this.updateId(task, project);
-		});
+		if (this.idMap.get(task.id) !== task) {
+			if (task.type === "suite" && "filepath" in task) TestModule.register(task, project);
+			else if (task.type === "suite") TestSuite.register(task, project);
+			else TestCase.register(task, project);
+			if (this.idMap.set(task.id, task), task.type === "suite") task.tasks.forEach((task) => {
+				this.updateId(task, project);
+			});
+		}
 	}
 	getReportedEntity(task) {
 		return this.reportedTasksMap.get(task);
@@ -8363,10 +8187,8 @@ class StateManager {
 		for (const [id, result, meta] of packs) {
 			const task = this.idMap.get(id);
 			if (task) {
-				task.result = result;
-				task.meta = meta;
 				// skipped with new PendingError
-				if (result?.state === "skip") task.mode = "skip";
+				if (task.result = result, task.meta = meta, result?.state === "skip") task.mode = "skip";
 			}
 		}
 	}
@@ -8843,10 +8665,7 @@ class TestRun {
 	}
 	async start(specifications) {
 		const filepaths = specifications.map((spec) => spec.moduleId);
-		this.vitest.state.collectPaths(filepaths);
-		await this.vitest.report("onPathsCollected", Array.from(new Set(filepaths)));
-		await this.vitest.report("onSpecsCollected", specifications.map((spec) => spec.toJSON()));
-		await this.vitest.report("onTestRunStart", [...specifications]);
+		this.vitest.state.collectPaths(filepaths), await this.vitest.report("onTestRunStart", [...specifications]);
 	}
 	async enqueued(project, file) {
 		this.vitest.state.collectFiles(project, [file]);
@@ -8854,25 +8673,17 @@ class TestRun {
 		await this.vitest.report("onTestModuleQueued", testModule);
 	}
 	async collected(project, files) {
-		this.vitest.state.collectFiles(project, files);
-		await Promise.all([this.vitest.report("onCollected", files), ...files.map((file) => {
+		this.vitest.state.collectFiles(project, files), await Promise.all(files.map((file) => {
 			const testModule = this.vitest.state.getReportedEntity(file);
 			return this.vitest.report("onTestModuleCollected", testModule);
-		})]);
+		}));
 	}
 	async log(log) {
-		this.vitest.state.updateUserLog(log);
-		await this.vitest.report("onUserConsoleLog", log);
+		this.vitest.state.updateUserLog(log), await this.vitest.report("onUserConsoleLog", log);
 	}
 	async annotate(testId, annotation) {
-		const task = this.vitest.state.idMap.get(testId);
-		const entity = task && this.vitest.state.getReportedEntity(task);
-		assert$1(task && entity, `Entity must be found for task ${task?.name || testId}`);
-		assert$1(entity.type === "test", `Annotation can only be added to a test, instead got ${entity.type}`);
-		await this.resolveTestAttachment(entity, annotation);
-		entity.task.annotations.push(annotation);
-		await this.vitest.report("onTestCaseAnnotate", entity, annotation);
-		return annotation;
+		const task = this.vitest.state.idMap.get(testId), entity = task && this.vitest.state.getReportedEntity(task);
+		return assert$1(task && entity, `Entity must be found for task ${task?.name || testId}`), assert$1(entity.type === "test", `Annotation can only be added to a test, instead got ${entity.type}`), await this.resolveTestAttachment(entity, annotation), entity.task.annotations.push(annotation), await this.vitest.report("onTestCaseAnnotate", entity, annotation), annotation;
 	}
 	async updated(update, events) {
 		this.vitest.state.updateTasks(update);
@@ -8885,30 +8696,21 @@ class TestRun {
 		await this.vitest.report("onTaskUpdate", update, events);
 	}
 	async end(specifications, errors, coverage) {
+		if (coverage) await this.vitest.report("onCoverage", coverage);
 		// specification won't have the File task if they were filtered by the --shard command
-		const modules = specifications.map((spec) => spec.testModule).filter((s) => s != null);
-		const files = modules.map((m) => m.task);
-		const state = this.vitest.isCancelling ? "interrupted" : this.hasFailed(modules) ? "failed" : "passed";
+		const modules = specifications.map((spec) => spec.testModule).filter((s) => s != null), state = this.vitest.isCancelling ? "interrupted" : this.hasFailed(modules) ? "failed" : "passed";
 		if (state !== "passed") process.exitCode = 1;
-		try {
-			await Promise.all([this.vitest.report("onTestRunEnd", modules, [...errors], state), this.vitest.report("onFinished", files, errors, coverage)]);
-		} finally {
-			if (coverage) await this.vitest.report("onCoverage", coverage);
-		}
+		this.vitest.report("onTestRunEnd", modules, [...errors], state);
 	}
 	hasFailed(modules) {
-		if (!modules.length) return !this.vitest.config.passWithNoTests;
-		return modules.some((m) => !m.ok());
+		return modules.length ? modules.some((m) => !m.ok()) : !this.vitest.config.passWithNoTests;
 	}
 	async reportEvent(id, event, data) {
-		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-prepare" && entity.type === "suite") return await this.vitest.report("onTestSuiteReady", entity);
+		const task = this.vitest.state.idMap.get(id), entity = task && this.vitest.state.getReportedEntity(task);
+		if (assert$1(task && entity, `Entity must be found for task ${task?.name || id}`), 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") {
-			assert$1(entity.type === "suite" || entity.type === "module", "Entity type must be suite or module");
-			if (entity.state() === "skipped")
+			if (assert$1(entity.type === "suite" || entity.type === "module", "Entity type must be suite or module"), entity.state() === "skipped")
  // everything inside suite or a module is skipped,
 			// so we won't get any children events
 			// we need to report everything manually
@@ -8920,8 +8722,7 @@ class TestRun {
 		if (event === "test-prepare" && entity.type === "test") return await this.vitest.report("onTestCaseReady", entity);
 		if (event === "test-finished" && entity.type === "test") return await this.vitest.report("onTestCaseResult", entity);
 		if (event.startsWith("before-hook") || event.startsWith("after-hook")) {
-			const isBefore = event.startsWith("before-hook");
-			const hook = entity.type === "test" ? {
+			const isBefore = event.startsWith("before-hook"), hook = entity.type === "test" ? {
 				name: isBefore ? "beforeEach" : "afterEach",
 				entity
 			} : {
@@ -8933,37 +8734,25 @@ class TestRun {
 			// this can only happen in --merge-reports, and annotation is already resolved
 			if (event === "test-annotation") {
 				const annotation = data?.annotation;
-				assert$1(annotation && entity.type === "test");
-				await this.vitest.report("onTestCaseAnnotate", entity, annotation);
+				assert$1(annotation && entity.type === "test"), await this.vitest.report("onTestCaseAnnotate", entity, annotation);
 			}
 		}
 	}
 	async resolveTestAttachment(test, annotation) {
-		const project = test.project;
-		const attachment = annotation.attachment;
+		const project = test.project, attachment = annotation.attachment;
 		if (!attachment) return attachment;
 		const path = attachment.path;
 		if (path && !path.startsWith("http://") && !path.startsWith("https://")) {
-			const currentPath = resolve(project.config.root, path);
-			const hash = createHash("sha1").update(currentPath).digest("hex");
-			const newPath = resolve(project.config.attachmentsDir, `${sanitizeFilePath(annotation.message)}-${hash}${extname(currentPath)}`);
-			await mkdir(dirname(newPath), { recursive: true });
-			await copyFile(currentPath, newPath);
-			attachment.path = newPath;
+			const currentPath = resolve(project.config.root, path), hash = createHash("sha1").update(currentPath).digest("hex"), newPath = resolve(project.config.attachmentsDir, `${sanitizeFilePath(annotation.message)}-${hash}${extname(currentPath)}`);
+			await mkdir(dirname(newPath), { recursive: true }), await copyFile(currentPath, newPath), attachment.path = newPath;
 			const contentType = attachment.contentType ?? mime.getType(basename(currentPath));
 			attachment.contentType = contentType || void 0;
 		}
 		return attachment;
 	}
 	async reportChildren(children) {
-		for (const child of children) if (child.type === "test") {
-			await this.vitest.report("onTestCaseReady", child);
-			await this.vitest.report("onTestCaseResult", child);
-		} else {
-			await this.vitest.report("onTestSuiteReady", child);
-			await this.reportChildren(child.children);
-			await this.vitest.report("onTestSuiteResult", child);
-		}
+		for (const child of children) if (child.type === "test") await this.vitest.report("onTestCaseReady", child), await this.vitest.report("onTestCaseResult", child);
+		else await this.vitest.report("onTestSuiteReady", child), await this.reportChildren(child.children), await this.vitest.report("onTestSuiteResult", child);
 	}
 }
 function sanitizeFilePath(s) {
@@ -8991,23 +8780,15 @@ class VitestWatcher {
 	* @internal
 	*/
 	onWatcherRerun(cb) {
-		this._onRerun.push(cb);
-		return this;
+		return this._onRerun.push(cb), this;
 	}
 	unregisterWatcher = noop;
 	registerWatcher() {
 		const watcher = this.vitest.vite.watcher;
 		if (this.vitest.config.forceRerunTriggers.length) watcher.add(this.vitest.config.forceRerunTriggers);
-		watcher.on("change", this.onChange);
-		watcher.on("unlink", this.onUnlink);
-		watcher.on("add", this.onAdd);
-		this.unregisterWatcher = () => {
-			watcher.off("change", this.onChange);
-			watcher.off("unlink", this.onUnlink);
-			watcher.off("add", this.onAdd);
-			this.unregisterWatcher = noop;
-		};
-		return this;
+		return watcher.on("change", this.onChange), watcher.on("unlink", this.onUnlink), watcher.on("add", this.onAdd), this.unregisterWatcher = () => {
+			watcher.off("change", this.onChange), watcher.off("unlink", this.onUnlink), watcher.off("add", this.onAdd), this.unregisterWatcher = noop;
+		}, this;
 	}
 	scheduleRerun(file) {
 		this._onRerun.forEach((cb) => cb(file));
@@ -9015,25 +8796,17 @@ class VitestWatcher {
 	getTestFilesFromWatcherTrigger(id) {
 		if (!this.vitest.config.watchTriggerPatterns) return false;
 		let triggered = false;
-		this.vitest.config.watchTriggerPatterns.forEach((definition) => {
+		return this.vitest.config.watchTriggerPatterns.forEach((definition) => {
 			const exec = definition.pattern.exec(id);
 			if (exec) {
 				const files = definition.testsToRun(id, exec);
-				if (Array.isArray(files)) {
-					triggered = true;
-					files.forEach((file) => this.changedTests.add(resolve(this.vitest.config.root, file)));
-				} else if (typeof files === "string") {
-					triggered = true;
-					this.changedTests.add(resolve(this.vitest.config.root, files));
-				}
+				if (Array.isArray(files)) triggered = true, files.forEach((file) => this.changedTests.add(resolve(this.vitest.config.root, file)));
+				else if (typeof files === "string") triggered = true, this.changedTests.add(resolve(this.vitest.config.root, files));
 			}
-		});
-		return triggered;
+		}), triggered;
 	}
 	onChange = (id) => {
-		id = slash(id);
-		this.vitest.logger.clearHighlightCache(id);
-		this.vitest.invalidateFile(id);
+		id = slash(id), this.vitest.logger.clearHighlightCache(id), this.vitest.invalidateFile(id);
 		const testFiles = this.getTestFilesFromWatcherTrigger(id);
 		if (testFiles) this.scheduleRerun(id);
 		else {
@@ -9042,21 +8815,10 @@ class VitestWatcher {
 		}
 	};
 	onUnlink = (id) => {
-		id = slash(id);
-		this.vitest.logger.clearHighlightCache(id);
-		this.invalidates.add(id);
-		if (this.vitest.state.filesMap.has(id)) {
-			this.vitest.projects.forEach((project) => project._removeCachedTestFile(id));
-			this.vitest.state.filesMap.delete(id);
-			this.vitest.cache.results.removeFromCache(id);
-			this.vitest.cache.stats.removeStats(id);
-			this.changedTests.delete(id);
-			this.vitest.report("onTestRemoved", id);
-		}
+		if (id = slash(id), this.vitest.logger.clearHighlightCache(id), this.invalidates.add(id), this.vitest.state.filesMap.has(id)) this.vitest.projects.forEach((project) => project._removeCachedTestFile(id)), this.vitest.state.filesMap.delete(id), this.vitest.cache.results.removeFromCache(id), this.vitest.cache.stats.removeStats(id), this.changedTests.delete(id), this.vitest.report("onTestRemoved", id);
 	};
 	onAdd = (id) => {
-		id = slash(id);
-		this.vitest.invalidateFile(id);
+		id = slash(id), this.vitest.invalidateFile(id);
 		const testFiles = this.getTestFilesFromWatcherTrigger(id);
 		if (testFiles) {
 			this.scheduleRerun(id);
@@ -9064,13 +8826,10 @@ class VitestWatcher {
 		}
 		let fileContent;
 		const matchingProjects = [];
-		this.vitest.projects.forEach((project) => {
+		if (this.vitest.projects.forEach((project) => {
 			if (project.matchesTestGlob(id, () => fileContent ??= readFileSync(id, "utf-8"))) matchingProjects.push(project);
-		});
-		if (matchingProjects.length > 0) {
-			this.changedTests.add(id);
-			this.scheduleRerun(id);
-		} else {
+		}), matchingProjects.length > 0) this.changedTests.add(id), this.scheduleRerun(id);
+		else {
 			// it's possible that file was already there but watcher triggered "add" event instead
 			const needsRerun = this.handleFileChanged(id);
 			if (needsRerun) this.scheduleRerun(id);
@@ -9078,51 +8837,33 @@ class VitestWatcher {
 	};
 	handleSetupFile(filepath) {
 		let isSetupFile = false;
-		this.vitest.projects.forEach((project) => {
-			if (!project.config.setupFiles.includes(filepath)) return;
-			this.vitest.state.filesMap.forEach((files) => {
+		return this.vitest.projects.forEach((project) => {
+			project.config.setupFiles.includes(filepath) && this.vitest.state.filesMap.forEach((files) => {
 				files.forEach((file) => {
-					if (file.projectName === project.name) {
-						isSetupFile = true;
-						this.changedTests.add(file.filepath);
-					}
+					if (file.projectName === project.name) isSetupFile = true, this.changedTests.add(file.filepath);
 				});
 			});
-		});
-		return isSetupFile;
+		}), isSetupFile;
 	}
 	/**
 	* @returns A value indicating whether rerun is needed (changedTests was mutated)
 	*/
 	handleFileChanged(filepath) {
 		if (this.changedTests.has(filepath) || this.invalidates.has(filepath)) return false;
-		if (pm.isMatch(filepath, this.vitest.config.forceRerunTriggers)) {
-			this.vitest.state.getFilepaths().forEach((file) => this.changedTests.add(file));
-			return true;
-		}
+		if (pm.isMatch(filepath, this.vitest.config.forceRerunTriggers)) return this.vitest.state.getFilepaths().forEach((file) => this.changedTests.add(file)), true;
 		if (this.handleSetupFile(filepath)) return true;
 		const projects = this.vitest.projects.filter((project) => {
 			const moduleGraph = project.browser?.vite.moduleGraph || project.vite.moduleGraph;
 			return moduleGraph.getModulesByFile(filepath)?.size;
 		});
-		if (!projects.length) {
-			// if there are no modules it's possible that server was restarted
-			// we don't have information about importers anymore, so let's check if the file is a test file at least
-			if (this.vitest.state.filesMap.has(filepath) || this.vitest.projects.some((project) => project._isCachedTestFile(filepath))) {
-				this.changedTests.add(filepath);
-				return true;
-			}
-			return false;
-		}
+		if (!projects.length) return this.vitest.state.filesMap.has(filepath) || this.vitest.projects.some((project) => project._isCachedTestFile(filepath)) ? (this.changedTests.add(filepath), true) : false;
 		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;
-			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)) {
-				this.changedTests.add(filepath);
-				files.push(filepath);
+			if (this.invalidates.add(filepath), this.vitest.state.filesMap.has(filepath) || project._isCachedTestFile(filepath)) {
+				this.changedTests.add(filepath), files.push(filepath);
 				continue;
 			}
 			let rerun = false;
@@ -9179,9 +8920,9 @@ class Vitest {
 	/** @internal */ _browserSessions = new BrowserSessions();
 	/** @internal */ _cliOptions = {};
 	/** @internal */ reporters = [];
-	/** @internal */ vitenode = void 0;
-	/** @internal */ runner = void 0;
+	/** @internal */ runner;
 	/** @internal */ _testRun = void 0;
+	/** @internal */ _resolver;
 	isFirstRun = true;
 	restartsCount = 0;
 	specifications;
@@ -9193,12 +8934,7 @@ class Vitest {
 	_cache;
 	_snapshot;
 	constructor(mode, cliOptions, options = {}) {
-		this.mode = mode;
-		this._cliOptions = cliOptions;
-		this.logger = new Logger(this, options.stdout, options.stderr);
-		this.packageInstaller = options.packageInstaller || new VitestPackageInstaller();
-		this.specifications = new VitestSpecifications(this);
-		this.watcher = new VitestWatcher(this).onWatcherRerun((file) => this.scheduleRerun([file]));
+		this.mode = mode, this._cliOptions = cliOptions, this.logger = new Logger(this, options.stdout, options.stderr), this.packageInstaller = options.packageInstaller || new VitestPackageInstaller(), this.specifications = new VitestSpecifications(this), this.watcher = new VitestWatcher(this).onWatcherRerun((file) => this.scheduleRerun([file]));
 	}
 	_onRestartListeners = [];
 	_onClose = [];
@@ -9218,8 +8954,7 @@ class Vitest {
 	* The global config.
 	*/
 	get config() {
-		assert(this._config, "config");
-		return this._config;
+		return assert(this._config, "config"), this._config;
 	}
 	/** @deprecated use `vitest.vite` instead */
 	get server() {
@@ -9229,30 +8964,26 @@ class Vitest {
 	* Global Vite's dev server instance.
 	*/
 	get vite() {
-		assert(this._vite, "vite", "server");
-		return this._vite;
+		return assert(this._vite, "vite", "server"), this._vite;
 	}
 	/**
 	* The global test state manager.
 	* @experimental The State API is experimental and not subject to semver.
 	*/
 	get state() {
-		assert(this._state, "state");
-		return this._state;
+		return assert(this._state, "state"), this._state;
 	}
 	/**
 	* The global snapshot manager. You can access the current state on `snapshot.summary`.
 	*/
 	get snapshot() {
-		assert(this._snapshot, "snapshot", "snapshot manager");
-		return this._snapshot;
+		return assert(this._snapshot, "snapshot", "snapshot manager"), this._snapshot;
 	}
 	/**
 	* Test results and test file stats cache. Primarily used by the sequencer to sort tests.
 	*/
 	get cache() {
-		assert(this._cache, "cache");
-		return this._cache;
+		return assert(this._cache, "cache"), this._cache;
 	}
 	/** @deprecated internal */
 	setServer(options, server) {
@@ -9260,57 +8991,21 @@ class Vitest {
 	}
 	/** @internal */
 	async _setServer(options, server) {
-		this.watcher.unregisterWatcher();
-		clearTimeout(this._rerunTimer);
-		this.restartsCount += 1;
-		this.pool?.close?.();
-		this.pool = void 0;
-		this.closingPromise = void 0;
-		this.projects = [];
-		this.coverageProvider = void 0;
-		this.runningPromise = void 0;
-		this.coreWorkspaceProject = void 0;
-		this.specifications.clearCache();
-		this._onUserTestsRerun = [];
-		this._vite = server;
+		this.watcher.unregisterWatcher(), clearTimeout(this._rerunTimer), this.restartsCount += 1, this.pool?.close?.(), this.pool = void 0, this.closingPromise = void 0, this.projects = [], this.coverageProvider = void 0, this.runningPromise = void 0, this.coreWorkspaceProject = void 0, this.specifications.clearCache(), this._onUserTestsRerun = [], this._vite = server;
 		const resolved = resolveConfig(this, options, server.config);
-		this._config = resolved;
-		this._state = new StateManager({ onUnhandledError: resolved.onUnhandledError });
-		this._cache = new VitestCache(this.version);
-		this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
-		this._testRun = new TestRun(this);
-		if (this.config.watch) this.watcher.registerWatcher();
-		this.vitenode = new ViteNodeServer(server, this.config.server);
-		const node = this.vitenode;
-		this.runner = new ViteNodeRunner({
-			root: server.config.root,
-			base: server.config.base,
-			fetchModule(id) {
-				return node.fetchModule(id);
-			},
-			resolveId(id, importer) {
-				return node.resolveId(id, importer);
-			}
-		});
-		if (this.config.watch) {
+		if (this._config = resolved, this._state = new StateManager({ onUnhandledError: resolved.onUnhandledError }), this._cache = new VitestCache(this.version), this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions }), this._testRun = new TestRun(this), this.config.watch) this.watcher.registerWatcher();
+		this._resolver = new VitestResolver(server.config.cacheDir, resolved);
+		const environment = server.environments.__vitest__;
+		if (this.runner = new ServerModuleRunner(environment, this._resolver, resolved), this.config.watch) {
 			// hijack server restart
 			const serverRestart = server.restart;
-			server.restart = async (...args) => {
-				await Promise.all(this._onRestartListeners.map((fn) => fn()));
-				this.report("onServerRestart");
-				await this.close();
-				await serverRestart(...args);
-			};
 			// since we set `server.hmr: false`, Vite does not auto restart itself
-			server.watcher.on("change", async (file) => {
+			server.restart = async (...args) => {
+				await Promise.all(this._onRestartListeners.map((fn) => fn())), this.report("onServerRestart"), await this.close(), await serverRestart(...args);
+			}, server.watcher.on("change", async (file) => {
 				file = normalize(file);
 				const isConfig = file === server.config.configFile || this.projects.some((p) => p.vite.config.configFile === file);
-				if (isConfig) {
-					await Promise.all(this._onRestartListeners.map((fn) => fn("config")));
-					this.report("onServerRestart", "config");
-					await this.close();
-					await serverRestart();
-				}
+				if (isConfig) await Promise.all(this._onRestartListeners.map((fn) => fn("config"))), this.report("onServerRestart", "config"), await this.close(), await serverRestart();
 			});
 		}
 		this.cache.results.setConfig(resolved.root, resolved.cache);
@@ -9318,28 +9013,24 @@ class Vitest {
 			await this.cache.results.readFromCache();
 		} catch {}
 		const projects = await this.resolveProjects(this._cliOptions);
-		this.projects = projects;
-		await Promise.all(projects.flatMap((project) => {
+		if (this.projects = projects, await Promise.all(projects.flatMap((project) => {
 			const hooks = project.vite.config.getSortedPluginHooks("configureVitest");
 			return hooks.map((hook) => hook({
 				project,
 				vitest: this,
 				injectTestProjects: this.injectTestProject
 			}));
-		}));
-		if (this._cliOptions.browser?.enabled) {
+		})), this._cliOptions.browser?.enabled) {
 			const browserProjects = this.projects.filter((p) => p.config.browser.enabled);
 			if (!browserProjects.length) throw new Error(`Vitest received --browser flag, but no project had a browser configuration.`);
 		}
 		if (!this.projects.length) {
 			const filter = toArray(resolved.project).join("\", \"");
-			if (filter) throw new Error(`No projects matched the filter "${filter}".`);
-			else throw new Error(`Vitest wasn't able to resolve any project.`);
+			throw filter ? new Error(`No projects matched the filter "${filter}".`) : new Error(`Vitest wasn't able to resolve any project.`);
 		}
 		if (!this.coreWorkspaceProject) this.coreWorkspaceProject = TestProject._createBasicProject(this);
 		if (this.config.testNamePattern) this.configOverride.testNamePattern = this.config.testNamePattern;
-		this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this);
-		await Promise.all(this._onSetServer.map((fn) => fn()));
+		this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this), await Promise.all(this._onSetServer.map((fn) => fn()));
 	}
 	/**
 	* Inject new test projects into the workspace.
@@ -9347,10 +9038,8 @@ class Vitest {
 	* @returns An array of new test projects. Can be empty if the name was filtered out.
 	*/
 	injectTestProject = async (config) => {
-		const currentNames = new Set(this.projects.map((p) => p.name));
-		const projects = await resolveProjects(this, this._cliOptions, void 0, Array.isArray(config) ? config : [config], currentNames);
-		this.projects.push(...projects);
-		return projects;
+		const currentNames = new Set(this.projects.map((p) => p.name)), projects = await resolveProjects(this, this._cliOptions, void 0, Array.isArray(config) ? config : [config], currentNames);
+		return this.projects.push(...projects), projects;
 	};
 	/**
 	* Provide a value to the test context. This value will be available to all tests with `inject`.
@@ -9366,9 +9055,7 @@ class Vitest {
 	}
 	/** @internal */
 	_ensureRootProject() {
-		if (this.coreWorkspaceProject) return this.coreWorkspaceProject;
-		this.coreWorkspaceProject = TestProject._createBasicProject(this);
-		return this.coreWorkspaceProject;
+		return this.coreWorkspaceProject ||= TestProject._createBasicProject(this), this.coreWorkspaceProject;
 	}
 	/** @deprecated use `getRootProject` instead */
 	getCoreWorkspaceProject() {
@@ -9385,8 +9072,7 @@ class Vitest {
 	* @deprecated use Reported Task API instead
 	*/
 	getProjectByTaskId(taskId) {
-		const task = this.state.idMap.get(taskId);
-		const projectName = task.projectName || task?.file?.projectName || "";
+		const task = this.state.idMap.get(taskId), projectName = task.projectName || task?.file?.projectName || "";
 		return this.getProjectByName(projectName);
 	}
 	getProjectByName(name) {
@@ -9399,7 +9085,7 @@ class Vitest {
 	* @param moduleId The ID of the module in Vite module graph
 	*/
 	import(moduleId) {
-		return this.runner.executeId(moduleId);
+		return this.runner.import(moduleId);
 	}
 	async resolveProjects(cliOptions) {
 		const names = /* @__PURE__ */ new Set();
@@ -9408,8 +9094,7 @@ class Vitest {
 		// user can filter projects with --project flag, `getDefaultTestProject`
 		// returns the project only if it matches the filter
 		const project = getDefaultTestProject(this);
-		if (!project) return [];
-		return resolveBrowserProjects(this, new Set([project.name]), [project]);
+		return project ? resolveBrowserProjects(this, new Set([project.name]), [project]) : [];
 	}
 	/**
 	* Glob test files in every project and create a TestSpecification for each file and pool.
@@ -9419,13 +9104,10 @@ class Vitest {
 		return this.specifications.globTestSpecifications(filters);
 	}
 	async initCoverageProvider() {
-		if (this.coverageProvider !== void 0) return;
-		this.coverageProvider = await getCoverageProvider(this.config.coverage, this.runner);
-		if (this.coverageProvider) {
-			await this.coverageProvider.initialize(this);
-			this.config.coverage = this.coverageProvider.resolveOptions();
+		if (this.coverageProvider === void 0) {
+			if (this.coverageProvider = await getCoverageProvider(this.config.coverage, this.runner), this.coverageProvider) await this.coverageProvider.initialize(this), this.config.coverage = this.coverageProvider.resolveOptions();
+			return this.coverageProvider;
 		}
-		return this.coverageProvider;
 	}
 	/**
 	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
@@ -9438,23 +9120,15 @@ class Vitest {
 			errors,
 			coverages,
 			executionTimes
-		};
-		await this.report("onInit", this);
-		await this.report("onPathsCollected", files.flatMap((f) => f.filepath));
+		}, await this.report("onInit", this);
 		const specifications = [];
 		for (const file of files) {
-			const project = this.getProjectByName(file.projectName || "");
-			const specification = project.createSpecification(file.filepath, void 0, file.pool);
+			const project = this.getProjectByName(file.projectName || ""), specification = project.createSpecification(file.filepath, void 0, file.pool);
 			specifications.push(specification);
 		}
-		await this.report("onSpecsCollected", specifications.map((spec) => spec.toJSON()));
 		await this._testRun.start(specifications).catch(noop);
 		for (const file of files) await this._reportFileTask(file);
-		this._checkUnhandledErrors(errors);
-		await this._testRun.end(specifications, errors).catch(noop);
-		await this.initCoverageProvider();
-		await this.coverageProvider?.mergeReports?.(coverages);
-		return {
+		return this._checkUnhandledErrors(errors), await this._testRun.end(specifications, errors).catch(noop), await this.initCoverageProvider(), await this.coverageProvider?.mergeReports?.(coverages), {
 			testModules: this.state.getTestModules(),
 			unhandledErrors: this.state.getUnhandledErrors()
 		};
@@ -9462,10 +9136,8 @@ class Vitest {
 	/** @internal */
 	async _reportFileTask(file) {
 		const project = this.getProjectByName(file.projectName || "");
-		await this._testRun.enqueued(project, file).catch(noop);
-		await this._testRun.collected(project, [file]).catch(noop);
-		const logs = [];
-		const { packs, events } = convertTasksToEvents(file, (task) => {
+		await this._testRun.enqueued(project, file).catch(noop), await this._testRun.collected(project, [file]).catch(noop);
+		const logs = [], { packs, events } = convertTasksToEvents(file, (task) => {
 			if (task.logs) logs.push(...task.logs);
 		});
 		logs.sort((log1, log2) => log1.time - log2.time);
@@ -9474,12 +9146,10 @@ class Vitest {
 	}
 	async collect(filters) {
 		const files = await this.specifications.getRelevantTestSpecifications(filters);
-		// if run with --changed, don't exit if no tests are found
-		if (!files.length) return {
+		return files.length ? this.collectTests(files) : {
 			testModules: [],
 			unhandledErrors: []
 		};
-		return this.collectTests(files);
 	}
 	/** @deprecated use `getRelevantTestSpecifications` instead */
 	listFiles(filters) {
@@ -9502,8 +9172,7 @@ class Vitest {
 	*/
 	async start(filters) {
 		try {
-			await this.initCoverageProvider();
-			await this.coverageProvider?.clean(this.config.coverage.clean);
+			await this.initCoverageProvider(), await this.coverageProvider?.clean(this.config.coverage.clean);
 		} finally {
 			await this.report("onInit", this);
 		}
@@ -9513,20 +9182,13 @@ class Vitest {
 		if (!files.length) {
 			await this._testRun.start([]);
 			const coverage = await this.coverageProvider?.generateCoverage?.({ allTestsRun: true });
-			await this._testRun.end([], [], coverage);
-			// Report coverage for uncovered files
-			await this.reportCoverage(coverage, true);
-			if (!this.config.watch || !(this.config.changed || this.config.related?.length)) throw new FilesNotFoundError(this.mode);
+			if (await this._testRun.end([], [], coverage), await this.reportCoverage(coverage, true), !this.config.watch || !(this.config.changed || this.config.related?.length)) throw new FilesNotFoundError(this.mode);
 		}
 		let testModules = {
 			testModules: [],
 			unhandledErrors: []
 		};
-		if (files.length) {
-			// populate once, update cache on watch
-			await this.cache.stats.populateStats(this.config.root, files);
-			testModules = await this.runFiles(files, true);
-		}
+		if (files.length) await this.cache.stats.populateStats(this.config.root, files), testModules = await this.runFiles(files, true);
 		if (this.config.watch) await this.report("onWatcherStart");
 		return testModules;
 	}
@@ -9536,14 +9198,11 @@ class Vitest {
 	*/
 	async init() {
 		try {
-			await this.initCoverageProvider();
-			await this.coverageProvider?.clean(this.config.coverage.clean);
+			await this.initCoverageProvider(), await this.coverageProvider?.clean(this.config.coverage.clean);
 		} finally {
 			await this.report("onInit", this);
 		}
-		// populate test files cache so watch mode can trigger a file rerun
-		await this.globTestSpecifications();
-		if (this.config.watch) await this.report("onWatcherStart");
+		if (await this.globTestSpecifications(), this.config.watch) await this.report("onWatcherStart");
 	}
 	/**
 	* @deprecated remove when vscode extension supports "getModuleSpecifications"
@@ -9576,8 +9235,7 @@ class Vitest {
 	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
 	*/
 	runTestSpecifications(specifications, allTestsRun = false) {
-		specifications.forEach((spec) => this.specifications.ensureSpecificationCached(spec));
-		return this.runFiles(specifications, allTestsRun);
+		return specifications.forEach((spec) => this.specifications.ensureSpecificationCached(spec)), this.runFiles(specifications, allTestsRun);
 	}
 	/**
 	* Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
@@ -9589,24 +9247,14 @@ class Vitest {
 		const files = specifications.map((spec) => spec.moduleId);
 		await Promise.all([this.report("onWatcherRerun", files, "rerun test"), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
 		const result = await this.runTestSpecifications(specifications, allTestsRun);
-		await this.report("onWatcherStart", this.state.getFiles(files));
-		return result;
+		return await this.report("onWatcherStart", this.state.getFiles(files)), result;
 	}
 	async runFiles(specs, allTestsRun) {
-		await this._testRun.start(specs);
-		// previous run
-		await this.runningPromise;
-		this._onCancelListeners = [];
-		this.isCancelling = false;
-		// schedule the new run
-		this.runningPromise = (async () => {
+		return await this._testRun.start(specs), await this.runningPromise, this._onCancelListeners = [], this.isCancelling = false, this.runningPromise = (async () => {
 			try {
 				if (!this.pool) this.pool = createPool(this);
 				const invalidates = Array.from(this.watcher.invalidates);
-				this.watcher.invalidates.clear();
-				this.snapshot.clear();
-				this.state.clearErrors();
-				if (!this.isFirstRun && this.config.coverage.cleanOnRerun) await this.coverageProvider?.clean();
+				if (this.watcher.invalidates.clear(), this.snapshot.clear(), this.state.clearErrors(), !this.isFirstRun && this.config.coverage.cleanOnRerun) await this.coverageProvider?.clean();
 				await this.initializeGlobalSetup(specs);
 				try {
 					await this.pool.runTests(specs, invalidates);
@@ -9623,21 +9271,12 @@ class Vitest {
 					unhandledErrors: this.state.getUnhandledErrors()
 				};
 			} finally {
-				// TODO: wait for coverage only if `onFinished` is defined
-				const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun });
-				const errors = this.state.getUnhandledErrors();
-				this._checkUnhandledErrors(errors);
-				await this._testRun.end(specs, errors, coverage);
-				await this.reportCoverage(coverage, allTestsRun);
+				const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun }), errors = this.state.getUnhandledErrors();
+				this._checkUnhandledErrors(errors), await this._testRun.end(specs, errors, coverage), await this.reportCoverage(coverage, allTestsRun);
 			}
 		})().finally(() => {
-			this.runningPromise = void 0;
-			this.isFirstRun = false;
-			// all subsequent runs will treat this as a fresh run
-			this.config.changed = false;
-			this.config.related = void 0;
-		});
-		return await this.runningPromise;
+			this.runningPromise = void 0, this.isFirstRun = false, this.config.changed = false, this.config.related = void 0;
+		}), await this.runningPromise;
 	}
 	/**
 	* Collect tests in specified modules. Vitest will run the files to collect tests.
@@ -9645,19 +9284,10 @@ class Vitest {
 	*/
 	async collectTests(specifications) {
 		const filepaths = specifications.map((spec) => spec.moduleId);
-		this.state.collectPaths(filepaths);
-		// previous run
-		await this.runningPromise;
-		this._onCancelListeners = [];
-		this.isCancelling = false;
-		// schedule the new run
-		this.runningPromise = (async () => {
+		return this.state.collectPaths(filepaths), await this.runningPromise, this._onCancelListeners = [], this.isCancelling = false, this.runningPromise = (async () => {
 			if (!this.pool) this.pool = createPool(this);
 			const invalidates = Array.from(this.watcher.invalidates);
-			this.watcher.invalidates.clear();
-			this.snapshot.clear();
-			this.state.clearErrors();
-			await this.initializeGlobalSetup(specifications);
+			this.watcher.invalidates.clear(), this.snapshot.clear(), this.state.clearErrors(), await this.initializeGlobalSetup(specifications);
 			try {
 				await this.pool.collectTests(specifications, invalidates);
 			} catch (err) {
@@ -9672,28 +9302,21 @@ class Vitest {
 				unhandledErrors: this.state.getUnhandledErrors()
 			};
 		})().finally(() => {
-			this.runningPromise = void 0;
-			// all subsequent runs will treat this as a fresh run
-			this.config.changed = false;
-			this.config.related = void 0;
-		});
-		return await this.runningPromise;
+			this.runningPromise = void 0, this.config.changed = false, this.config.related = void 0;
+		}), await this.runningPromise;
 	}
 	/**
 	* Gracefully cancel the current test run. Vitest will wait until all running tests are finished before cancelling.
 	*/
 	async cancelCurrentRun(reason) {
-		this.isCancelling = true;
-		await Promise.all(this._onCancelListeners.splice(0).map((listener) => listener(reason)));
-		await this.runningPromise;
+		this.isCancelling = true, await Promise.all(this._onCancelListeners.splice(0).map((listener) => listener(reason))), await this.runningPromise;
 	}
 	/** @internal */
 	async _initBrowserServers() {
 		await Promise.all(this.projects.map((p) => p._initBrowserServer()));
 	}
 	async initializeGlobalSetup(paths) {
-		const projects = new Set(paths.map((spec) => spec.project));
-		const coreProject = this.getRootProject();
+		const projects = new Set(paths.map((spec) => spec.project)), coreProject = this.getRootProject();
 		if (!projects.has(coreProject)) projects.add(coreProject);
 		for (const project of projects) await project._initializeGlobalSetup();
 	}
@@ -9707,8 +9330,7 @@ class Vitest {
 		const specifications = files.flatMap((file) => this.getModuleSpecifications(file));
 		await Promise.all([this.report("onWatcherRerun", files, trigger), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
 		const testResult = await this.runFiles(specifications, allTestsRun);
-		await this.report("onWatcherStart", this.state.getFiles(files));
-		return testResult;
+		return await this.report("onWatcherStart", this.state.getFiles(files)), testResult;
 	}
 	/** @internal */
 	async rerunTask(id) {
@@ -9728,9 +9350,8 @@ class Vitest {
 		// Empty test name pattern should reset filename pattern as well
 		if (pattern === "") this.filenamePattern = void 0;
 		const testNamePattern = pattern ? new RegExp(pattern) : void 0;
-		this.configOverride.testNamePattern = testNamePattern;
 		// filter only test files that have tests matching the pattern
-		if (testNamePattern) files = files.filter((filepath) => {
+		if (this.configOverride.testNamePattern = testNamePattern, testNamePattern) files = files.filter((filepath) => {
 			const files = this.state.getFiles([filepath]);
 			return !files.length || files.some((file) => {
 				const tasks = getTasks(file);
@@ -9754,9 +9375,7 @@ class Vitest {
 	* @param files The list of files on the file system
 	*/
 	async updateSnapshot(files) {
-		// default to failed files
-		files = files || [...this.state.getFailedFilepaths(), ...this.snapshot.summary.uncheckedKeysByFile.map((s) => s.filePath)];
-		this.enableSnapshotUpdate();
+		files = files || [...this.state.getFailedFilepaths(), ...this.snapshot.summary.uncheckedKeysByFile.map((s) => s.filePath)], this.enableSnapshotUpdate();
 		try {
 			return await this.rerunFiles(files, "update snapshot", false);
 		} finally {
@@ -9774,15 +9393,13 @@ class Vitest {
 		this.configOverride.snapshotOptions = {
 			updateSnapshot: "all",
 			snapshotEnvironment: null
-		};
-		this.snapshot.options.updateSnapshot = "all";
+		}, this.snapshot.options.updateSnapshot = "all";
 	}
 	/**
 	* Disable the mode that allows updating snapshots when running tests.
 	*/
 	resetSnapshotUpdate() {
-		delete this.configOverride.snapshotOptions;
-		this.snapshot.options.updateSnapshot = this.config.snapshotOptions.updateSnapshot;
+		delete this.configOverride.snapshotOptions, this.snapshot.options.updateSnapshot = this.config.snapshotOptions.updateSnapshot;
 	}
 	/**
 	* Set the global test name pattern to a regexp.
@@ -9802,51 +9419,37 @@ class Vitest {
 	// we can't use a single `triggerId` yet because vscode extension relies on this
 	async scheduleRerun(triggerId) {
 		const currentCount = this.restartsCount;
-		clearTimeout(this._rerunTimer);
-		await this.runningPromise;
-		clearTimeout(this._rerunTimer);
-		// server restarted
-		if (this.restartsCount !== currentCount) return;
-		this._rerunTimer = setTimeout(async () => {
+		clearTimeout(this._rerunTimer), await this.runningPromise, clearTimeout(this._rerunTimer), this.restartsCount === currentCount && (this._rerunTimer = setTimeout(async () => {
 			if (this.watcher.changedTests.size === 0) {
 				this.watcher.invalidates.clear();
 				return;
 			}
 			// server restarted
 			if (this.restartsCount !== currentCount) return;
-			this.isFirstRun = false;
-			this.snapshot.clear();
+			this.isFirstRun = false, this.snapshot.clear();
 			let files = Array.from(this.watcher.changedTests);
 			if (this.filenamePattern) {
 				const filteredFiles = await this.globTestSpecifications(this.filenamePattern);
-				files = files.filter((file) => filteredFiles.some((f) => f.moduleId === file));
 				// A file that does not match the current filename pattern was changed
-				if (files.length === 0) return;
+				if (files = files.filter((file) => filteredFiles.some((f) => f.moduleId === file)), files.length === 0) return;
 			}
 			this.watcher.changedTests.clear();
-			const triggerIds = new Set(triggerId.map((id) => relative(this.config.root, id)));
-			const triggerLabel = Array.from(triggerIds).join(", ");
-			// get file specifications and filter them if needed
-			const specifications = files.flatMap((file) => this.getModuleSpecifications(file)).filter((specification) => {
-				if (this._onFilterWatchedSpecification.length === 0) return true;
-				return this._onFilterWatchedSpecification.every((fn) => fn(specification));
+			const triggerIds = new Set(triggerId.map((id) => relative(this.config.root, id))), triggerLabel = Array.from(triggerIds).join(", "), specifications = files.flatMap((file) => this.getModuleSpecifications(file)).filter((specification) => {
+				return this._onFilterWatchedSpecification.length === 0 ? true : this._onFilterWatchedSpecification.every((fn) => fn(specification));
 			});
-			await Promise.all([this.report("onWatcherRerun", files, triggerLabel), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
-			await this.runFiles(specifications, false);
-			await this.report("onWatcherStart", this.state.getFiles(files));
-		}, WATCHER_DEBOUNCE);
+			await Promise.all([this.report("onWatcherRerun", files, triggerLabel), ...this._onUserTestsRerun.map((fn) => fn(specifications))]), await this.runFiles(specifications, false), await this.report("onWatcherStart", this.state.getFiles(files));
+		}, WATCHER_DEBOUNCE));
 	}
 	/**
 	* Invalidate a file in all projects.
 	*/
 	invalidateFile(filepath) {
 		this.projects.forEach(({ vite, browser }) => {
-			const serverMods = vite.moduleGraph.getModulesByFile(filepath);
-			serverMods?.forEach((mod) => vite.moduleGraph.invalidateModule(mod));
-			if (browser) {
-				const browserMods = browser.vite.moduleGraph.getModulesByFile(filepath);
-				browserMods?.forEach((mod) => browser.vite.moduleGraph.invalidateModule(mod));
-			}
+			const environments = [...Object.values(vite.environments), ...Object.values(browser?.vite.environments || {})];
+			environments.forEach(({ moduleGraph }) => {
+				const modules = moduleGraph.getModulesByFile(filepath);
+				modules?.forEach((module) => moduleGraph.invalidateModule(module));
+			});
 		});
 	}
 	/** @deprecated use `invalidateFile` */
@@ -9859,8 +9462,7 @@ class Vitest {
 	}
 	async reportCoverage(coverage, allTestsRun) {
 		if (this.state.getCountOfFailedTests() > 0) {
-			await this.coverageProvider?.onTestFailure?.();
-			if (!this.config.coverage.reportOnFailure) return;
+			if (await this.coverageProvider?.onTestFailure?.(), !this.config.coverage.reportOnFailure) return;
 		}
 		if (this.coverageProvider) {
 			await this.coverageProvider.reportCoverage(coverage, { allTestsRun });
@@ -9883,11 +9485,9 @@ class Vitest {
 			// it's possible that it's not initialized at all because it's not running any tests
 			if (this.coreWorkspaceProject && !this.projects.includes(this.coreWorkspaceProject)) closePromises.push(this.coreWorkspaceProject.close().then(() => this._vite = void 0));
 			if (this.pool) closePromises.push((async () => {
-				await this.pool?.close?.();
-				this.pool = void 0;
+				await this.pool?.close?.(), this.pool = void 0;
 			})());
-			closePromises.push(...this._onClose.map((fn) => fn()));
-			return Promise.allSettled(closePromises).then((results) => {
+			return closePromises.push(...this._onClose.map((fn) => fn())), Promise.allSettled(closePromises).then((results) => {
 				results.forEach((r) => {
 					if (r.status === "rejected") this.logger.error("error during close", r.reason);
 				});
@@ -9900,11 +9500,9 @@ class Vitest {
 	* @param force If true, the process will exit immediately after closing the projects.
 	*/
 	async exit(force = false) {
-		setTimeout(() => {
+		if (setTimeout(() => {
 			this.report("onProcessTimeout").then(() => {
-				console.warn(`close timed out after ${this.config.teardownTimeout}ms`);
-				this.state.getProcessTimeoutCauses().forEach((cause) => console.warn(cause));
-				if (!this.pool) {
+				if (console.warn(`close timed out after ${this.config.teardownTimeout}ms`), this.state.getProcessTimeoutCauses().forEach((cause) => console.warn(cause)), !this.pool) {
 					const runningServers = [this._vite, ...this.projects.map((p) => p._vite)].filter(Boolean).length;
 					if (runningServers === 1) console.warn("Tests closed successfully but something prevents Vite server from exiting");
 					else if (runningServers > 1) console.warn(`Tests closed successfully but something prevents ${runningServers} Vite servers from exiting`);
@@ -9913,9 +9511,7 @@ class Vitest {
 				}
 				process.exit();
 			});
-		}, this.config.teardownTimeout).unref();
-		await this.close();
-		if (force) process.exit();
+		}, this.config.teardownTimeout).unref(), await this.close(), force) process.exit();
 	}
 	/** @internal */
 	async report(name, ...args) {
@@ -9997,9 +9593,7 @@ class Vitest {
 	*/
 	matchesProjectFilter(name) {
 		const projects = this._config?.project || this._cliOptions?.project;
-		// no filters applied, any project can be included
-		if (!projects || !projects.length) return true;
-		return toArray(projects).some((project) => {
+		return !projects || !projects.length ? true : toArray(projects).some((project) => {
 			const regexp = wildcardPatternToRegExp(project);
 			return regexp.test(name);
 		});
@@ -10012,8 +9606,7 @@ function assert(condition, property, name = property) {
 async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(options))) {
 	const userConfig = deepMerge({}, options);
 	async function UIPlugin() {
-		await vitest.packageInstaller.ensureInstalled("@vitest/ui", options.root || process.cwd(), vitest.version);
-		return (await import('@vitest/ui')).default(vitest);
+		return await vitest.packageInstaller.ensureInstalled("@vitest/ui", options.root || process.cwd(), vitest.version), (await import('@vitest/ui')).default(vitest);
 	}
 	return [
 		{
@@ -10039,14 +9632,9 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				let open = false;
 				if (testConfig.ui && testConfig.open) open = testConfig.uiBase ?? "/__vitest__/";
 				const resolveOptions = getDefaultResolveOptions();
-				const config = {
+				let config = {
 					root: viteConfig.test?.root || options.root,
 					define: { "process.env.NODE_ENV": "process.env.NODE_ENV" },
-					esbuild: viteConfig.esbuild === false ? false : {
-						target: viteConfig.esbuild?.target || "node18",
-						sourcemap: "external",
-						legalComments: "inline"
-					},
 					resolve: {
 						...resolveOptions,
 						alias: testConfig.alias
@@ -10063,7 +9651,10 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 						outDir: "dummy-non-existing-folder",
 						emptyOutDir: false
 					},
-					environments: { ssr: { resolve: resolveOptions } },
+					environments: {
+						ssr: { resolve: resolveOptions },
+						__vitest__: { dev: {} }
+					},
 					test: {
 						poolOptions: {
 							threads: { isolate: options.poolOptions?.threads?.isolate ?? options.isolate ?? testConfig.poolOptions?.threads?.isolate ?? viteConfig.test?.isolate },
@@ -10073,33 +9664,29 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 						deps: testConfig.deps ?? viteConfig.test?.deps
 					}
 				};
+				if ("rolldownVersion" in vite) config = {
+					...config,
+					oxc: viteConfig.oxc === false ? false : { target: viteConfig.oxc?.target || "node18" }
+				};
+				else config = {
+					...config,
+					esbuild: viteConfig.esbuild === false ? false : {
+						target: viteConfig.esbuild?.target || "node18",
+						sourcemap: "external",
+						legalComments: "inline"
+					}
+				};
 				// inherit so it's available in VitestOptimizer
 				// I cannot wait to rewrite all of this in Vitest 4
 				if (options.cache != null) config.test.cache = options.cache;
 				if (vitest.configOverride.project)
  // project filter was set by the user, so we need to filter the project
 				options.project = vitest.configOverride.project;
-				config.customLogger = createViteLogger(vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false });
-				config.customLogger = silenceImportViteIgnoreWarning(config.customLogger);
-				// we want inline dependencies to be resolved by analyser plugin so module graph is populated correctly
-				if (viteConfig.ssr?.noExternal !== true) {
-					const inline = testConfig.server?.deps?.inline;
-					if (inline === true) config.ssr = { noExternal: true };
-					else {
-						const noExternal = viteConfig.ssr?.noExternal;
-						const noExternalArray = typeof noExternal !== "undefined" ? toArray(noExternal) : void 0;
-						// filter the same packages
-						const uniqueInline = inline && noExternalArray ? inline.filter((dep) => !noExternalArray.includes(dep)) : inline;
-						config.ssr = { noExternal: uniqueInline };
-					}
-				}
 				// chokidar fsevents is unstable on macos when emitting "ready" event
-				if (process.platform === "darwin" && false);
+				if (config.customLogger = createViteLogger(vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false }), config.customLogger = silenceImportViteIgnoreWarning(config.customLogger), process.platform === "darwin" && false);
 				const classNameStrategy = typeof testConfig.css !== "boolean" && testConfig.css?.modules?.classNameStrategy || "stable";
 				if (classNameStrategy !== "scoped") {
-					config.css ??= {};
-					config.css.modules ??= {};
-					if (config.css.modules) config.css.modules.generateScopedName = (name, filename) => {
+					if (config.css ??= {}, config.css.modules ??= {}, config.css.modules) config.css.modules.generateScopedName = (name, filename) => {
 						const root = vitest.config.root || options.root || process.cwd();
 						return generateScopedClassName(classNameStrategy, name, relative(root, filename));
 					};
@@ -10110,17 +9697,11 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				const viteConfigTest = viteConfig.test || {};
 				if (viteConfigTest.watch === false) viteConfigTest.run = true;
 				if ("alias" in viteConfigTest) delete viteConfigTest.alias;
-				// viteConfig.test is final now, merge it for real
-				options = deepMerge({}, configDefaults, viteConfigTest, options);
-				options.api = resolveApiServerConfig(options, defaultPort);
+				options = deepMerge({}, configDefaults, viteConfigTest, options), options.api = resolveApiServerConfig(options, defaultPort);
 				// we replace every "import.meta.env" with "process.env"
 				// to allow reassigning, so we need to put all envs on process.env
 				const { PROD, DEV,...envs } = viteConfig.env;
-				// process.env can have only string values and will cast string on it if we pass other type,
-				// so we are making them truthy
-				process.env.PROD ??= PROD ? "1" : "";
-				process.env.DEV ??= DEV ? "1" : "";
-				for (const name in envs) process.env[name] ??= envs[name];
+				for (const name in process.env.PROD ??= PROD ? "1" : "", process.env.DEV ??= DEV ? "1" : "", envs) process.env[name] ??= envs[name];
 				// don't watch files in run mode
 				if (!options.watch) viteConfig.server.watch = null;
 				if (options.ui)
@@ -10140,20 +9721,20 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				order: "post",
 				async handler(server) {
 					if (options.watch && false);
-					await vitest._setServer(options, server);
-					if (options.api && options.watch) (await Promise.resolve().then(function () { return setup$1; })).setup(vitest);
+					if (await vitest._setServer(options, server), options.api && options.watch) (await Promise.resolve().then(function () { return setup$1; })).setup(vitest);
 					// #415, in run mode we don't need the watcher, close it would improve the performance
 					if (!options.watch) await server.watcher.close();
 				}
 			}
 		},
-		SsrReplacerPlugin(),
+		MetaEnvReplacerPlugin(),
 		...CSSEnablerPlugin(vitest),
 		CoverageTransform(vitest),
 		VitestCoreResolver(vitest),
 		...MocksPlugins(),
 		VitestOptimizer(),
-		NormalizeURLPlugin()
+		NormalizeURLPlugin(),
+		ModuleRunnerTransform()
 	].filter(notNullish);
 }
 function removeUndefinedValues(obj) {
@@ -10162,25 +9743,19 @@ function removeUndefinedValues(obj) {
 }
 
 async function createVitest(mode, options, viteOverrides = {}, vitestOptions = {}) {
-	const ctx = new Vitest(mode, deepClone(options), vitestOptions);
-	const root = slash(resolve$1(options.root || process.cwd()));
-	const configPath = options.config === false ? false : options.config ? resolve$1(root, options.config) : await findUp(configFiles, { cwd: root });
+	const ctx = new Vitest(mode, deepClone(options), vitestOptions), root = slash(resolve$1(options.root || process.cwd())), configPath = options.config === false ? false : options.config ? resolve$1(root, options.config) : await findUp(configFiles, { cwd: root });
 	options.config = configPath;
-	const { browser: _removeBrowser,...restOptions } = options;
-	const config = {
+	const { browser: _removeBrowser,...restOptions } = options, config = {
 		configFile: configPath,
 		configLoader: options.configLoader,
 		mode: options.mode || mode,
 		plugins: await VitestPlugin(restOptions, ctx)
-	};
-	const server = await createViteServer(mergeConfig(config, mergeConfig(viteOverrides, { root: options.root })));
+	}, server = await createViteServer(mergeConfig(config, mergeConfig(viteOverrides, { root: options.root })));
 	if (ctx.config.api?.port) await server.listen();
 	return ctx;
 }
 
-const MAX_RESULT_COUNT = 10;
-const SELECTION_MAX_INDEX = 7;
-const ESC = "\x1B[";
+const MAX_RESULT_COUNT = 10, SELECTION_MAX_INDEX = 7, ESC = "\x1B[";
 class WatchFilter {
 	filterRL;
 	currentKeyword = void 0;
@@ -10191,23 +9766,17 @@ class WatchFilter {
 	stdin;
 	stdout;
 	constructor(message, stdin = process.stdin, stdout$1 = stdout()) {
-		this.message = message;
-		this.stdin = stdin;
-		this.stdout = stdout$1;
-		this.filterRL = readline.createInterface({
+		if (this.message = message, this.stdin = stdin, this.stdout = stdout$1, this.filterRL = readline.createInterface({
 			input: this.stdin,
 			escapeCodeTimeout: 50
-		});
-		readline.emitKeypressEvents(this.stdin, this.filterRL);
-		if (this.stdin.isTTY) this.stdin.setRawMode(true);
+		}), readline.emitKeypressEvents(this.stdin, this.filterRL), this.stdin.isTTY) this.stdin.setRawMode(true);
 	}
 	async filter(filterFunc) {
 		this.write(this.promptLine());
 		const resultPromise = createDefer();
 		this.onKeyPress = this.filterHandler(filterFunc, (result) => {
 			resultPromise.resolve(result);
-		});
-		this.stdin.on("keypress", this.onKeyPress);
+		}), this.stdin.on("keypress", this.onKeyPress);
 		try {
 			return await resultPromise;
 		} finally {
@@ -10223,13 +9792,11 @@ class WatchFilter {
 					break;
 				case key?.ctrl && key?.name === "c":
 				case key?.name === "escape":
-					this.write(`${ESC}1G${ESC}0J`);
-					onSubmit(void 0);
+					this.write(`${ESC}1G${ESC}0J`), onSubmit(void 0);
 					return;
 				case key?.name === "enter":
 				case key?.name === "return":
-					onSubmit(this.results[this.selectionIndex] || this.currentKeyword || "");
-					this.currentKeyword = void 0;
+					onSubmit(this.results[this.selectionIndex] || this.currentKeyword || ""), this.currentKeyword = void 0;
 					break;
 				case key?.name === "up":
 					if (this.selectionIndex && this.selectionIndex > 0) this.selectionIndex--;
@@ -10256,17 +9823,13 @@ class WatchFilter {
 			const resultCountLine = this.results.length === 1 ? `Pattern matches ${this.results.length} result` : `Pattern matches ${this.results.length} results`;
 			let resultBody = "";
 			if (this.results.length > MAX_RESULT_COUNT) {
-				const offset = this.selectionIndex > SELECTION_MAX_INDEX ? this.selectionIndex - SELECTION_MAX_INDEX : 0;
-				const displayResults = this.results.slice(offset, MAX_RESULT_COUNT + offset);
-				const remainingResultCount = this.results.length - offset - displayResults.length;
-				resultBody = `${displayResults.map((result, index) => index + offset === this.selectionIndex ? c.green(` › ${result}`) : c.dim(` › ${result}`)).join("\n")}`;
-				if (remainingResultCount > 0) resultBody += `
+				const offset = this.selectionIndex > SELECTION_MAX_INDEX ? this.selectionIndex - SELECTION_MAX_INDEX : 0, displayResults = this.results.slice(offset, MAX_RESULT_COUNT + offset), remainingResultCount = this.results.length - offset - displayResults.length;
+				if (resultBody = `${displayResults.map((result, index) => index + offset === this.selectionIndex ? c.green(` › ${result}`) : c.dim(` › ${result}`)).join("\n")}`, remainingResultCount > 0) resultBody += `
 ${c.dim(`   ...and ${remainingResultCount} more ${remainingResultCount === 1 ? "result" : "results"}`)}`;
 			} else resultBody = this.results.map((result, index) => index === this.selectionIndex ? c.green(` › ${result}`) : c.dim(` › ${result}`)).join("\n");
 			printStr += `\n${resultCountLine}\n${resultBody}`;
 		}
-		this.eraseAndPrint(printStr);
-		this.restoreCursor();
+		this.eraseAndPrint(printStr), this.restoreCursor();
 	}
 	keywordOffset() {
 		return `? ${this.message} › `.length + 1;
@@ -10282,14 +9845,10 @@ ${c.dim(`   ...and ${remainingResultCount} more ${remainingResultCount === 1 ? "
 			// We have to take care of screen width in case of long lines
 			rows += 1 + Math.floor(Math.max(stripVTControlCharacters(line).length - 1, 0) / columns);
 		}
-		this.write(`${ESC}1G`);
-		this.write(`${ESC}J`);
-		this.write(str);
-		this.write(`${ESC}${rows - 1}A`);
+		this.write(`${ESC}1G`), this.write(`${ESC}J`), this.write(str), this.write(`${ESC}${rows - 1}A`);
 	}
 	close() {
-		this.filterRL.close();
-		if (this.onKeyPress) this.stdin.removeListener("keypress", this.onKeyPress);
+		if (this.filterRL.close(), this.onKeyPress) this.stdin.removeListener("keypress", this.onKeyPress);
 		if (this.stdin.isTTY) this.stdin.setRawMode(false);
 	}
 	restoreCursor() {
@@ -10314,8 +9873,7 @@ const keys = [
 	["w", "filter by a project name"],
 	["b", "start the browser server if not started yet"],
 	["q", "quit"]
-];
-const cancelKeys = [
+], cancelKeys = [
 	"space",
 	"c",
 	"h",
@@ -10333,17 +9891,12 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 		// Cancel run and exit when ctrl-c or esc is pressed.
 		// If cancelling takes long and key is pressed multiple times, exit forcefully.
 		if (str === "" || str === "\x1B" || key && key.ctrl && key.name === "c") {
-			if (!ctx.isCancelling) {
-				ctx.logger.log(c.red("Cancelling test run. Press CTRL+c again to exit forcefully.\n"));
-				process.exitCode = 130;
-				await ctx.cancelCurrentRun("keyboard-input");
-			}
+			if (!ctx.isCancelling) ctx.logger.log(c.red("Cancelling test run. Press CTRL+c again to exit forcefully.\n")), process.exitCode = 130, await ctx.cancelCurrentRun("keyboard-input");
 			return ctx.exit(true);
 		}
 		// window not support suspend
 		if (!isWindows && key && key.ctrl && key.name === "z") {
-			process.kill(process.ppid, "SIGTSTP");
-			process.kill(process.pid, "SIGTSTP");
+			process.kill(process.ppid, "SIGTSTP"), process.kill(process.pid, "SIGTSTP");
 			return;
 		}
 		const name = key?.name;
@@ -10372,24 +9925,17 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 		if (name === "t") return inputNamePattern();
 		// change fileNamePattern
 		if (name === "p") return inputFilePattern();
-		if (name === "b") {
-			await ctx._initBrowserServers();
-			ctx.projects.forEach((project) => {
-				ctx.logger.log();
-				ctx.logger.printBrowserBanner(project);
-			});
-			return null;
-		}
+		if (name === "b") return await ctx._initBrowserServers(), ctx.projects.forEach((project) => {
+			ctx.logger.log(), ctx.logger.printBrowserBanner(project);
+		}), null;
 	}
 	async function keypressHandler(str, key) {
 		await _keypressHandler(str, key);
 	}
 	async function inputNamePattern() {
 		off();
-		const watchFilter = new WatchFilter("Input test name pattern (RegExp)", stdin, stdout);
-		const filter = await watchFilter.filter((str) => {
-			const files = ctx.state.getFiles();
-			const tests = getTests(files);
+		const watchFilter = new WatchFilter("Input test name pattern (RegExp)", stdin, stdout), filter = await watchFilter.filter((str) => {
+			const files = ctx.state.getFiles(), tests = getTests(files);
 			try {
 				const reg = new RegExp(str);
 				return tests.map((test) => test.name).filter((testName) => testName.match(reg));
@@ -10398,11 +9944,8 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 				return [];
 			}
 		});
-		on();
-		if (typeof filter === "undefined") return;
-		const files = ctx.state.getFilepaths();
-		// if running in standalone mode, Vitest instance doesn't know about any test file
-		const cliFiles = ctx.config.standalone && !files.length ? await ctx._globTestFilepaths() : void 0;
+		if (on(), typeof filter === "undefined") return;
+		const files = ctx.state.getFilepaths(), cliFiles = ctx.config.standalone && !files.length ? await ctx._globTestFilepaths() : void 0;
 		await ctx.changeNamePattern(filter?.trim() || "", cliFiles, "change pattern");
 	}
 	async function inputProjectName() {
@@ -10413,41 +9956,31 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 			message: "Input a single project name",
 			initial: ctx.config.project[0] || ""
 		}]);
-		on();
-		await ctx.changeProjectName(filter.trim());
+		on(), await ctx.changeProjectName(filter.trim());
 	}
 	async function inputFilePattern() {
 		off();
-		const watchFilter = new WatchFilter("Input filename pattern", stdin, stdout);
-		const filter = await watchFilter.filter(async (str) => {
+		const watchFilter = new WatchFilter("Input filename pattern", stdin, stdout), filter = await watchFilter.filter(async (str) => {
 			const files = await ctx.globTestFiles([str]);
 			return files.map((file) => relative(ctx.config.root, file[1])).filter((file, index, all) => all.indexOf(file) === index);
 		});
-		on();
-		if (typeof filter === "undefined") return;
+		if (on(), typeof filter === "undefined") return;
 		latestFilename = filter?.trim() || "";
 		const lastResults = watchFilter.getLastResults();
 		await ctx.changeFilenamePattern(latestFilename, filter && lastResults.length ? lastResults.map((i) => resolve(ctx.config.root, i)) : void 0);
 	}
 	let rl;
 	function on() {
-		off();
-		rl = readline.createInterface({
+		if (off(), rl = readline.createInterface({
 			input: stdin,
 			escapeCodeTimeout: 50
-		});
-		readline.emitKeypressEvents(stdin, rl);
-		if (stdin.isTTY) stdin.setRawMode(true);
+		}), readline.emitKeypressEvents(stdin, rl), stdin.isTTY) stdin.setRawMode(true);
 		stdin.on("keypress", keypressHandler);
 	}
 	function off() {
-		rl?.close();
-		rl = void 0;
-		stdin.removeListener("keypress", keypressHandler);
-		if (stdin.isTTY) stdin.setRawMode(false);
+		if (rl?.close(), rl = void 0, stdin.removeListener("keypress", keypressHandler), stdin.isTTY) stdin.setRawMode(false);
 	}
-	on();
-	return function cleanup() {
+	return on(), function cleanup() {
 		off();
 	};
 }
@@ -10458,20 +9991,14 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 * Returns a Vitest instance if initialized successfully.
 */
 async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, vitestOptions) {
-	const root = resolve(options.root || process.cwd());
-	const ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions, cliFilters);
+	const root = resolve(options.root || process.cwd()), ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions, cliFilters);
 	if (mode === "test" && ctx.config.coverage.enabled) {
-		const provider = ctx.config.coverage.provider || "v8";
-		const requiredPackages = CoverageProviderMap[provider];
+		const provider = ctx.config.coverage.provider || "v8", requiredPackages = CoverageProviderMap[provider];
 		if (requiredPackages) {
-			if (!await ctx.packageInstaller.ensureInstalled(requiredPackages, root, ctx.version)) {
-				process.exitCode = 1;
-				return ctx;
-			}
+			if (!await ctx.packageInstaller.ensureInstalled(requiredPackages, root, ctx.version)) return process.exitCode = 1, ctx;
 		}
 	}
-	const stdin = vitestOptions?.stdin || process.stdin;
-	const stdout = vitestOptions?.stdout || process.stdout;
+	const stdin = vitestOptions?.stdin || process.stdin, stdout = vitestOptions?.stdout || process.stdout;
 	let stdinCleanup;
 	if (stdin.isTTY && ctx.config.watch) stdinCleanup = registerConsoleShortcuts(ctx, stdin, stdout);
 	ctx.onAfterSetServer(() => {
@@ -10483,55 +10010,27 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
 		else if (ctx.config.standalone) await ctx.init();
 		else await ctx.start(cliFilters);
 	} catch (e) {
-		if (e instanceof FilesNotFoundError) return ctx;
-		if (e instanceof GitNotFoundError) {
-			ctx.logger.error(e.message);
-			return ctx;
-		}
-		if (e instanceof IncludeTaskLocationDisabledError || e instanceof RangeLocationFilterProvidedError || e instanceof LocationFilterFileNotFoundError) {
-			ctx.logger.printError(e, { verbose: false });
-			return ctx;
-		}
-		process.exitCode = 1;
-		ctx.logger.printError(e, {
+		return e instanceof FilesNotFoundError ? ctx : e instanceof GitNotFoundError ? (ctx.logger.error(e.message), ctx) : e instanceof IncludeTaskLocationDisabledError || e instanceof RangeLocationFilterProvidedError || e instanceof LocationFilterFileNotFoundError ? (ctx.logger.printError(e, { verbose: false }), ctx) : (process.exitCode = 1, ctx.logger.printError(e, {
 			fullStack: true,
 			type: "Unhandled Error"
-		});
-		ctx.logger.error("\n\n");
-		return ctx;
+		}), ctx.logger.error("\n\n"), ctx);
 	}
-	if (ctx.shouldKeepServer()) return ctx;
-	stdinCleanup?.();
-	await ctx.close();
-	return ctx;
+	return ctx.shouldKeepServer() ? ctx : (stdinCleanup?.(), await ctx.close(), ctx);
 }
 async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions, cliFilters) {
-	process.env.TEST = "true";
-	process.env.VITEST = "true";
-	process.env.NODE_ENV ??= "test";
-	if (options.run) options.watch = false;
+	if (process.env.TEST = "true", process.env.VITEST = "true", process.env.NODE_ENV ??= "test", options.run) options.watch = false;
 	if (options.standalone && (cliFilters?.length || 0) > 0) options.standalone = false;
 	// this shouldn't affect _application root_ that can be changed inside config
-	const root = resolve(options.root || process.cwd());
-	const ctx = await createVitest(mode, options, viteOverrides, vitestOptions);
-	const environmentPackage = getEnvPackageName(ctx.config.environment);
-	if (environmentPackage && !await ctx.packageInstaller.ensureInstalled(environmentPackage, root)) {
-		process.exitCode = 1;
-		return ctx;
-	}
-	return ctx;
+	const root = resolve(options.root || process.cwd()), ctx = await createVitest(mode, options, viteOverrides, vitestOptions), environmentPackage = getEnvPackageName(ctx.config.environment);
+	return environmentPackage && !await ctx.packageInstaller.ensureInstalled(environmentPackage, root) && (process.exitCode = 1), ctx;
 }
 function processCollected(ctx, files, options) {
 	let errorsPrinted = false;
-	forEachSuite(files, (suite) => {
+	if (forEachSuite(files, (suite) => {
 		suite.errors().forEach((error) => {
-			errorsPrinted = true;
-			ctx.logger.printError(error, { project: suite.project });
+			errorsPrinted = true, ctx.logger.printError(error, { project: suite.project });
 		});
-	});
-	if (errorsPrinted) return;
-	if (typeof options.json !== "undefined") return processJsonOutput(files, options);
-	return formatCollectedAsString(files).forEach((test) => console.log(test));
+	}), !errorsPrinted) return typeof options.json === "undefined" ? formatCollectedAsString(files).forEach((test) => console.log(test)) : processJsonOutput(files, options);
 }
 function outputFileList(files, options) {
 	if (typeof options.json !== "undefined") return outputJsonFileList(files, options);
@@ -10541,8 +10040,7 @@ function outputJsonFileList(files, options) {
 	if (typeof options.json === "boolean") return console.log(JSON.stringify(formatFilesAsJSON(files), null, 2));
 	if (typeof options.json === "string") {
 		const jsonPath = resolve(options.root || process.cwd(), options.json);
-		mkdirSync(dirname(jsonPath), { recursive: true });
-		writeFileSync(jsonPath, JSON.stringify(formatFilesAsJSON(files), null, 2));
+		mkdirSync(dirname(jsonPath), { recursive: true }), writeFileSync(jsonPath, JSON.stringify(formatFilesAsJSON(files), null, 2));
 	}
 }
 function formatFilesAsJSON(files) {
@@ -10563,8 +10061,7 @@ function processJsonOutput(files, options) {
 	if (typeof options.json === "boolean") return console.log(JSON.stringify(formatCollectedAsJSON(files), null, 2));
 	if (typeof options.json === "string") {
 		const jsonPath = resolve(options.root || process.cwd(), options.json);
-		mkdirSync(dirname(jsonPath), { recursive: true });
-		writeFileSync(jsonPath, JSON.stringify(formatCollectedAsJSON(files), null, 2));
+		mkdirSync(dirname(jsonPath), { recursive: true }), writeFileSync(jsonPath, JSON.stringify(formatCollectedAsJSON(files), null, 2));
 	}
 }
 function forEachSuite(modules, callback) {
@@ -10575,7 +10072,7 @@ function forEachSuite(modules, callback) {
 }
 function formatCollectedAsJSON(files) {
 	const results = [];
-	files.forEach((file) => {
+	return files.forEach((file) => {
 		for (const test of file.children.allTests()) {
 			if (test.result().state === "skipped") continue;
 			const result = {
@@ -10586,19 +10083,17 @@ function formatCollectedAsJSON(files) {
 			if (test.location) result.location = test.location;
 			results.push(result);
 		}
-	});
-	return results;
+	}), results;
 }
 function formatCollectedAsString(testModules) {
 	const results = [];
-	testModules.forEach((testModule) => {
+	return testModules.forEach((testModule) => {
 		for (const test of testModule.children.allTests()) {
 			if (test.result().state === "skipped") continue;
 			const fullName = `${test.module.task.name} > ${test.fullName}`;
 			results.push((test.project.name ? `[${test.project.name}] ` : "") + fullName);
 		}
-	});
-	return results;
+	}), results;
 }
 const envPackageNames = {
 	"jsdom": "jsdom",
@@ -10606,10 +10101,7 @@ const envPackageNames = {
 	"edge-runtime": "@edge-runtime/vm"
 };
 function getEnvPackageName(env) {
-	if (env === "node") return null;
-	if (env in envPackageNames) return envPackageNames[env];
-	if (env[0] === "." || isAbsolute(env)) return null;
-	return `vitest-environment-${env}`;
+	return env === "node" ? null : env in envPackageNames ? envPackageNames[env] : env[0] === "." || isAbsolute(env) ? null : `vitest-environment-${env}`;
 }
 
 var cliApi = /*#__PURE__*/Object.freeze({