vitest 4.0.5 → 4.0.7

package/dist/browser.d.ts

@@ -1,7 +1,7 @@
-import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/config.d.u2CUDWwS.js';
+import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/config.d.BTfZNUu9.js';
 import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.BZtK59WP.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { V as VitestModuleRunner } from './chunks/moduleRunner.d.YtNsMIoJ.js';
+import { V as VitestModuleRunner } from './chunks/moduleRunner.d.DEkTotCv.js';
 export { collectTests, startTests } from '@vitest/runner';
 import * as _vitest_spy from '@vitest/spy';
 export { _vitest_spy as SpyModule };
@@ -15,7 +15,7 @@ import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import 'node:vm';
 import 'vite/module-runner';
-import './chunks/worker.d.BFk-vvBU.js';
+import './chunks/worker.d.D25zYZ7N.js';
 import './chunks/environment.d.CrsxCzP1.js';
 import '@vitest/mocker';
 import './chunks/mocker.d.BE_2ls6u.js';

package/dist/chunks/{base.RFExFinv.js → base.D3GxgUMI.js}

@@ -1,10 +1,11 @@
 import { runInThisContext } from 'node:vm';
 import * as spyModule from '@vitest/spy';
+import { r as resolveTestRunner, a as resolveSnapshotEnvironment, s as setupChaiConfig } from './index.DEPqWSIZ.js';
+import { l as loadEnvironment } from './init.fmH9J833.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
-import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startModuleRunner.BqQUfEjB.js';
-import { performance } from 'node:perf_hooks';
+import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startModuleRunner.Cn7hCL7D.js';
+import { performance as performance$1 } from 'node:perf_hooks';
 import { startTests, collectTests } from '@vitest/runner';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './resolveSnapshotEnvironment.BZzLjzkh.js';
 import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.DR1sucx6.js';
 import { g as globalExpect, v as vi } from './vi.BZvkKVkM.js';
 import { c as closeInspector } from './inspector.DLZxSeU3.js';
@@ -13,20 +14,16 @@ import timers from 'node:timers';
 import timersPromises from 'node:timers/promises';
 import util from 'node:util';
 import { KNOWN_ASSET_TYPES } from '@vitest/utils/constants';
-import { getSafeTimers } from '@vitest/utils/timers';
 import { i as index } from './index.RwjEGCQ0.js';
 import { g as getWorkerState, r as resetModules, p as provideWorkerState } from './utils.CG9h5ccR.js';
 
 // this should only be used in Node
 let globalSetup = false;
-async function setupGlobalEnv(config, { environment }, moduleRunner) {
-	await setupCommonEnv(config), Object.defineProperty(globalThis, "__vitest_index__", {
+async function setupGlobalEnv(config, environment) {
+	if (await setupCommonEnv(config), Object.defineProperty(globalThis, "__vitest_index__", {
 		value: index,
 		enumerable: false
-	});
-	const state = getWorkerState();
-	if (!state.config.snapshotOptions.snapshotEnvironment) state.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, moduleRunner);
-	if (!globalSetup) {
+	}), globalExpect.setState({ environment: environment.name }), !globalSetup) {
 		if (globalSetup = true, (environment.viteEnvironment || environment.name) === "client") {
 			const _require = createRequire(import.meta.url);
 			_require.extensions[".css"] = resolveCss, _require.extensions[".scss"] = resolveCss, _require.extensions[".sass"] = resolveCss, _require.extensions[".less"] = resolveCss, KNOWN_ASSET_TYPES.forEach((type) => {
@@ -50,36 +47,28 @@ async function setupConsoleLogSpy() {
 	const { createCustomConsole } = await import('./console.CTJL2nuH.js');
 	globalThis.console = createCustomConsole();
 }
-async function withEnv({ environment }, options, fn) {
-	globalThis.__vitest_environment__ = environment.name, globalExpect.setState({ environment: environment.name });
-	const env = await environment.setup(globalThis, options);
-	try {
-		await fn();
-	} finally {
-		// Run possible setTimeouts, e.g. the onces used by ConsoleLogSpy
-		const { setTimeout } = getSafeTimers();
-		await new Promise((resolve) => setTimeout(resolve)), await env.teardown(globalThis);
-	}
-}
 
 // browser shouldn't call this!
-async function run(method, files, config, environment, moduleRunner) {
-	const workerState = getWorkerState();
-	if (await setupGlobalEnv(config, environment, moduleRunner), await startCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.isolate }), config.chaiConfig) setupChaiConfig(config.chaiConfig);
-	const runner = await resolveTestRunner(config, moduleRunner);
-	workerState.onCancel.then((reason) => {
-		closeInspector(config), runner.cancel?.(reason);
-	}), workerState.durations.prepare = performance.now() - workerState.durations.prepare, workerState.durations.environment = performance.now(), await withEnv(environment, environment.options || config.environmentOptions || {}, async () => {
-		workerState.durations.environment = performance.now() - workerState.durations.environment;
-		for (const file of files) {
-			if (config.isolate) moduleRunner.mocker.reset(), resetModules(workerState.evaluatedModules, true);
-			if (workerState.filepath = file.filepath, method === "run") await startTests([file], runner);
-			else await collectTests([file], runner);
-			// mocks should not affect different files
-			vi.resetConfig(), vi.restoreAllMocks();
-		}
-		await stopCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.isolate });
-	}), workerState.environmentTeardownRun = true;
+async function run(method, files, config, moduleRunner, environment) {
+	const workerState = getWorkerState(), [testRunner] = await Promise.all([
+		resolveTestRunner(config, moduleRunner),
+		setupGlobalEnv(config, environment),
+		startCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.isolate }),
+		(async () => {
+			if (!workerState.config.snapshotOptions.snapshotEnvironment) workerState.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, moduleRunner);
+		})()
+	]);
+	workerState.onCancel((reason) => {
+		closeInspector(config), testRunner.cancel?.(reason);
+	}), workerState.durations.prepare = performance$1.now() - workerState.durations.prepare;
+	for (const file of files) {
+		if (config.isolate) moduleRunner.mocker.reset(), resetModules(workerState.evaluatedModules, true);
+		if (workerState.filepath = file.filepath, method === "run") await startTests([file], testRunner);
+		else await collectTests([file], testRunner);
+		// mocks should not affect different files
+		vi.resetConfig(), vi.restoreAllMocks();
+	}
+	await stopCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.isolate });
 }
 
 let _moduleRunner;
@@ -87,29 +76,36 @@ const evaluatedModules = new VitestEvaluatedModules(), moduleExecutionInfo = /*
 function startModuleRunner(options) {
 	return _moduleRunner || (_moduleRunner = startVitestModuleRunner(options), _moduleRunner);
 }
+let _currentEnvironment, _environmentTime;
+async function setupEnvironment(context) {
+	const startTime = performance.now(), { environment: { name: environmentName, options: environmentOptions }, rpc, config } = context, { environment, loader } = await loadEnvironment(environmentName, config.root, rpc);
+	_currentEnvironment = environment;
+	const env = await environment.setup(globalThis, environmentOptions || config.environmentOptions || {});
+	if (_environmentTime = performance.now() - startTime, config.chaiConfig) setupChaiConfig(config.chaiConfig);
+	return async () => {
+		await env.teardown(globalThis), await loader?.close();
+	};
+}
 /** @experimental */
 async function runBaseTests(method, state) {
 	const { ctx } = state;
-	if (state.evaluatedModules = evaluatedModules, state.moduleExecutionInfo = moduleExecutionInfo, provideWorkerState(globalThis, state), ctx.invalidates) ctx.invalidates.forEach((filepath) => {
+	if (state.environment = _currentEnvironment, state.durations.environment = _environmentTime, state.evaluatedModules = evaluatedModules, state.moduleExecutionInfo = moduleExecutionInfo, provideWorkerState(globalThis, state), ctx.invalidates) ctx.invalidates.forEach((filepath) => {
 		(state.evaluatedModules.fileToModulesMap.get(filepath) || []).forEach((module) => {
 			state.evaluatedModules.invalidateModule(module);
 		});
 	});
 	ctx.files.forEach((i) => {
-		const filepath = typeof i === "string" ? i : i.filepath;
+		const filepath = i.filepath;
 		(state.evaluatedModules.fileToModulesMap.get(filepath) || []).forEach((module) => {
 			state.evaluatedModules.invalidateModule(module);
 		});
 	});
-	const executor = startModuleRunner({
+	const moduleRunner = startModuleRunner({
 		state,
 		evaluatedModules: state.evaluatedModules,
 		spyModule,
 		createImportMeta: createNodeImportMeta
-	}), fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
-		filepath: f,
-		testLocations: void 0
-	} : f);
+	});
 	// we could load @vite/env, but it would take ~8ms, while this takes ~0,02ms
 	if (ctx.config.serializedDefines) try {
 		runInThisContext(`(() =>{\n${ctx.config.serializedDefines}})()`, {
@@ -119,10 +115,7 @@ async function runBaseTests(method, state) {
 	} catch (error) {
 		throw new Error(`Failed to load custom "defines": ${error.message}`);
 	}
-	await run(method, fileSpecs, ctx.config, {
-		environment: state.environment,
-		options: ctx.environment.options
-	}, executor);
+	await run(method, ctx.files, ctx.config, moduleRunner, _currentEnvironment);
 }
 
-export { runBaseTests as r };
+export { runBaseTests as r, setupEnvironment as s };

package/dist/chunks/{browser.d.B9iJzZyn.d.ts → browser.d.-LKfRopd.d.ts}

@@ -1,5 +1,5 @@
 import { FileSpecification } from '@vitest/runner';
-import { T as TestExecutionMethod } from './worker.d.BFk-vvBU.js';
+import { T as TestExecutionMethod } from './worker.d.D25zYZ7N.js';
 
 type SerializedTestSpecification = [project: {
 	name: string | undefined;

package/dist/chunks/{cac.Be29vze6.js → cac.G9DAn-c7.js}

@@ -3,7 +3,7 @@ import { EventEmitter } from 'events';
 import { normalize } from 'pathe';
 import c from 'tinyrainbow';
 import { a as defaultPort, d as defaultBrowserPort } from './constants.D_Q9UYh-.js';
-import { R as ReportersMap } from './index.CcRZ6fUh.js';
+import { R as ReportersMap } from './index.CVpyv-Zg.js';
 
 function toArr(any) {
 	return any == null ? [] : Array.isArray(any) ? any : [any];
@@ -619,7 +619,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "4.0.5";
+var version = "4.0.7";
 
 const apiConfig = (port) => ({
 	port: {
@@ -886,7 +886,8 @@ const cliOptionsConfig = {
 	},
 	execArgv: {
 		description: "Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.",
-		argument: "<option>"
+		argument: "<option>",
+		array: true
 	},
 	vmMemoryLimit: {
 		description: "Memory limit for VM pools. If you see memory leaks, try to tinker this value.",
@@ -1294,10 +1295,10 @@ function normalizeCliOptions(cliFilters, argv) {
 }
 async function start(mode, cliFilters, options) {
 	try {
-		const { startVitest } = await import('./cli-api.6GYRwzrM.js').then(function (n) { return n.p; }), ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
+		const { startVitest } = await import('./cli-api.Csks4as1.js').then(function (n) { return n.p; }), ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
 		if (!ctx.shouldKeepServer()) await ctx.exit();
 	} catch (e) {
-		const { errorBanner } = await import('./index.CcRZ6fUh.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.CVpyv-Zg.js').then(function (n) { return n.u; });
 		if (console.error(`\n${errorBanner("Startup Error")}`), console.error(e), console.error("\n\n"), process.exitCode == null) process.exitCode = 1;
 		process.exit();
 	}
@@ -1309,7 +1310,7 @@ async function init(project) {
 }
 async function collect(mode, cliFilters, options) {
 	try {
-		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.6GYRwzrM.js').then(function (n) { return n.p; }), ctx = await prepareVitest(mode, {
+		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.Csks4as1.js').then(function (n) { return n.p; }), ctx = await prepareVitest(mode, {
 			...normalizeCliOptions(cliFilters, options),
 			watch: false,
 			run: true
@@ -1327,7 +1328,7 @@ async function collect(mode, cliFilters, options) {
 		}
 		await ctx.close();
 	} catch (e) {
-		const { errorBanner } = await import('./index.CcRZ6fUh.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.CVpyv-Zg.js').then(function (n) { return n.u; });
 		if (console.error(`\n${errorBanner("Collect Error")}`), console.error(e), console.error("\n\n"), process.exitCode == null) process.exitCode = 1;
 		process.exit();
 	}

package/dist/chunks/{cli-api.6GYRwzrM.js → cli-api.Csks4as1.js}

@@ -4,7 +4,7 @@ import { C as CoverageProviderMap } from './coverage.D_JHT54q.js';
 import path, { resolve as resolve$1 } from 'node:path';
 import { noop, createDefer, slash, isExternalUrl, unwrapId, nanoid, withTrailingSlash, cleanUrl, wrapId, toArray, deepMerge, deepClone, isPrimitive, notNullish } from '@vitest/utils/helpers';
 import { a as any, p as prompt } from './index.Dc3xnDvT.js';
-import { h as hash, R as RandomSequencer, i as isPackageExists, c as isBrowserEnabled, r as resolveConfig, g as getCoverageProvider, a as resolveApiServerConfig, d as resolveModule } from './coverage.DT47gDHj.js';
+import { h as hash, R as RandomSequencer, i as isPackageExists, c as isBrowserEnabled, r as resolveConfig, g as getCoverageProvider, a as resolveApiServerConfig, d as resolveModule } from './coverage.C2LA1DSL.js';
 import * as vite from 'vite';
 import { parseAst, fetchModule, version, searchForWorkspaceRoot, mergeConfig, createServer } from 'vite';
 import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.D_Q9UYh-.js';
@@ -12,9 +12,9 @@ import * as nodeos from 'node:os';
 import nodeos__default, { tmpdir } from 'node:os';
 import { generateHash as generateHash$1, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, hasFailed, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, getTasks, isTestCase } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { v as version$1 } from './cac.Be29vze6.js';
+import { v as version$1 } from './cac.G9DAn-c7.js';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { p as parse, d as stringify, e as TraceMap, o as originalPositionFor, h as ancestor, i as printError, f as formatProjectName, w as withLabel, j as errorBanner, k as divider, l as Typechecker, m as generateCodeFrame, n as createDefinesScript, R as ReportersMap, B as BlobReporter, r as readBlobs, q as convertTasksToEvents, H as HangingProcessReporter } from './index.CcRZ6fUh.js';
+import { p as parse, d as stringify, e as TraceMap, o as originalPositionFor, h as ancestor, i as printError, f as formatProjectName, w as withLabel, j as errorBanner, k as divider, l as Typechecker, m as generateCodeFrame, n as createDefinesScript, R as ReportersMap, B as BlobReporter, r as readBlobs, q as convertTasksToEvents, H as HangingProcessReporter } from './index.CVpyv-Zg.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -51,7 +51,7 @@ import { c as configDefaults } from './defaults.BOqNVLsY.js';
 import { KNOWN_ASSET_RE } from '@vitest/utils/constants';
 import { findNearestPackageData } from '@vitest/utils/resolver';
 import * as esModuleLexer from 'es-module-lexer';
-import { a as BenchmarkReportsMap } from './index.BdSLhLDZ.js';
+import { a as BenchmarkReportsMap } from './index.jMQYiEWE.js';
 import assert$1 from 'node:assert';
 import { serializeValue } from '@vitest/utils/serialize';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
@@ -6449,7 +6449,15 @@ class PoolRunner {
 				this.postMessage({
 					type: "start",
 					__vitest_worker_request__: true,
-					options: { reportMemory: this.worker.reportMemory ?? false }
+					options: { reportMemory: this.worker.reportMemory ?? false },
+					context: {
+						environment: {
+							name: this.environment.name,
+							options: this.environment.options
+						},
+						config: this.project.serializedConfig,
+						pool: this.worker.name
+					}
 				}), await startPromise, this._state = RunnerState.STARTED;
 			} catch (error) {
 				throw this._state = RunnerState.IDLE, error;
@@ -6512,9 +6520,10 @@ class PoolRunner {
 		this._eventEmitter.emit("error", error);
 	};
 	waitForStart() {
-		return new Promise((resolve) => {
+		return new Promise((resolve, reject) => {
 			const onStart = (message) => {
-				if (message.type === "started") this.off("message", onStart), resolve();
+				if (message.type === "started") if (this.off("message", onStart), message.error) reject(message.error);
+				else resolve();
 			};
 			this.on("message", onStart);
 		});
@@ -6555,13 +6564,7 @@ class ForksPoolWorker {
 		this.fork.off(event, callback);
 	}
 	send(message) {
-		if ("context" in message) message = {
-			...message,
-			context: {
-				...message.context,
-				config: wrapSerializableConfig(message.context.config)
-			}
-		};
+		if ("context" in message && "config" in message.context) message.context.config = wrapSerializableConfig(message.context.config);
 		this.fork.send(v8.serialize(message));
 	}
 	async start() {
@@ -6712,7 +6715,7 @@ async function onMessage(message, project) {
 			error: await runPromise,
 			__vitest_worker_response__
 		};
-		case "stop": return await runPromise, await project.typechecker?.stop(), {
+		case "stop": return await runPromise, {
 			type: "stopped",
 			__vitest_worker_response__
 		};
@@ -6770,6 +6773,8 @@ function createRunner(vitest) {
 				resolve(false), clearInterval(_i);
 			}, 500).unref();
 		});
+		// Re-run but wasn't triggered by tsc
+		if (promisesMap.has(project) && !triggered) return promisesMap.get(project);
 		if (project.typechecker && !triggered) {
 			const testFiles = project.typechecker.getTestFiles();
 			for (const file of testFiles) await vitest._testRun.enqueued(project, file);
@@ -6917,7 +6922,7 @@ catch (error) {
 			distPath: this.options.distPath,
 			project: task.project,
 			method,
-			environment: task.context.environment.name,
+			environment: task.environment,
 			env: task.env,
 			execArgv: task.execArgv
 		};
@@ -6958,7 +6963,7 @@ function formatFiles(task) {
 }
 function isEqualRunner(runner, task) {
 	if (task.isolate) throw new Error("Isolated tasks should not share runners");
-	return runner.worker.name === task.worker && runner.project === task.project && runner.environment === task.context.environment.name && (!runner.worker.canReuse || runner.worker.canReuse(task));
+	return runner.worker.name === task.worker && runner.project === task.project && runner.environment.name === task.environment.name && (!runner.worker.canReuse || runner.worker.canReuse(task));
 }
 
 const suppressWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
@@ -7011,18 +7016,15 @@ function createPool(ctx) {
 				if (!execArgv) execArgv = [...options.execArgv, ...project.config.execArgv], projectExecArgvs.set(project, execArgv);
 				taskGroup.push({
 					context: {
-						pool,
-						config: project.serializedConfig,
 						files: specs.map((spec) => ({
 							filepath: spec.moduleId,
 							testLocations: spec.testLines
 						})),
 						invalidates,
-						environment,
-						projectName: project.name,
 						providedContext: project.getProvidedContext(),
 						workerId: workerId++
 					},
+					environment,
 					project,
 					env,
 					execArgv,
@@ -7058,7 +7060,11 @@ function createPool(ctx) {
 		runTests: (files, invalidates) => executeTests("run", files, invalidates),
 		collectTests: (files, invalidates) => executeTests("collect", files, invalidates),
 		async close() {
-			await Promise.all([pool.close(), browserPool?.close?.()]);
+			await Promise.all([
+				pool.close(),
+				browserPool?.close?.(),
+				...ctx.projects.map((project) => project.typechecker?.stop())
+			]);
 		}
 	};
 }
@@ -7079,8 +7085,7 @@ function resolveOptions(ctx) {
 			...process.execArgv.filter((execArg) => execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir")),
 			...conditions,
 			"--experimental-import-meta-resolve",
-			"--require",
-			suppressWarningsPath
+			...globalThis.Deno ? [] : ["--require", suppressWarningsPath]
 		],
 		env: {
 			TEST: "true",
@@ -7123,10 +7128,10 @@ function groupSpecs(specs, environments) {
 			typechecks[spec.project.name] ||= [], typechecks[spec.project.name].push(spec);
 			return;
 		}
-		const order = spec.project.config.sequence.groupOrder;
+		const order = spec.project.config.sequence.groupOrder, isolate = spec.project.config.isolate;
 		// Files that have disabled parallelism and default groupOrder are set into their own group
-		if (order === 0 && spec.project.config.fileParallelism === false) return sequential.specs.push([spec]);
-		const maxWorkers = resolveMaxWorkers(spec.project), isolate = spec.project.config.isolate;
+		if (isolate === true && order === 0 && spec.project.config.maxWorkers === 1) return sequential.specs.push([spec]);
+		const maxWorkers = resolveMaxWorkers(spec.project);
 		// Multiple projects with different maxWorkers but same groupOrder
 		if (groups[order] ||= {
 			specs: [],
@@ -7162,7 +7167,6 @@ function serializeConfig(project) {
 		environmentOptions: config.environmentOptions,
 		mode: config.mode,
 		isolate: config.isolate,
-		fileParallelism: config.fileParallelism,
 		maxWorkers: config.maxWorkers,
 		base: config.base,
 		logHeapUsage: config.logHeapUsage,

package/dist/chunks/{config.d.u2CUDWwS.d.ts → config.d.BTfZNUu9.d.ts}

@@ -78,7 +78,6 @@ interface SerializedConfig {
 	disableConsoleIntercept: boolean | undefined;
 	runner: string | undefined;
 	isolate: boolean;
-	fileParallelism: boolean;
 	maxWorkers: number;
 	mode: "test" | "benchmark";
 	bail: number | undefined;

package/dist/chunks/{coverage.DT47gDHj.js → coverage.C2LA1DSL.js}

@@ -1,6 +1,6 @@
 import fs, { statSync, realpathSync, existsSync, promises, readdirSync, writeFileSync } from 'node:fs';
 import path, { win32, dirname, join } from 'node:path';
-import { slash, shuffle, toArray, cleanUrl } from '@vitest/utils/helpers';
+import { slash, shuffle, toArray } from '@vitest/utils/helpers';
 import { isAbsolute, resolve, relative, normalize } from 'pathe';
 import pm from 'picomatch';
 import { glob } from 'tinyglobby';
@@ -2374,6 +2374,14 @@ class BaseSequencer {
 	async sort(files) {
 		const cache = this.ctx.cache;
 		return [...files].sort((a, b) => {
+			// "sequence.groupOrder" is higher priority
+			const groupOrderDiff = a.project.config.sequence.groupOrder - b.project.config.sequence.groupOrder;
+			if (groupOrderDiff !== 0) return groupOrderDiff;
+			// Projects run sequential
+			if (a.project.name !== b.project.name) return a.project.name < b.project.name ? -1 : 1;
+			// Isolated run first
+			if (a.project.config.isolate && !b.project.config.isolate) return -1;
+			if (!a.project.config.isolate && b.project.config.isolate) return 1;
 			const keyA = `${a.project.name}:${relative(this.ctx.config.root, a.moduleId)}`, keyB = `${b.project.name}:${relative(this.ctx.config.root, b.moduleId)}`, aState = cache.getFileTestResults(keyA), bState = cache.getFileTestResults(keyB);
 			if (!aState || !bState) {
 				const statsA = cache.getFileStats(keyA), statsB = cache.getFileStats(keyB);
@@ -2468,12 +2476,12 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	if (resolved.standalone && !resolved.watch) throw new Error(`Vitest standalone mode requires --watch`);
 	if (resolved.mergeReports && resolved.watch) throw new Error(`Cannot merge reports with --watch enabled`);
 	if (resolved.maxWorkers) resolved.maxWorkers = resolveInlineWorkerOption(resolved.maxWorkers);
-	if (resolved.fileParallelism ??= mode !== "benchmark", !resolved.fileParallelism)
+	if (!(options.fileParallelism ?? mode !== "benchmark"))
  // ignore user config, parallelism cannot be implemented without limiting workers
 	resolved.maxWorkers = 1;
 	if (resolved.maxConcurrency === 0) logger.console.warn(c.yellow(`The option "maxConcurrency" cannot be set to 0. Using default value ${configDefaults.maxConcurrency} instead.`)), resolved.maxConcurrency = configDefaults.maxConcurrency;
 	if (resolved.inspect || resolved.inspectBrk) {
-		if (resolved.fileParallelism) {
+		if (resolved.maxWorkers !== 1) {
 			const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
 			throw new Error(`You cannot use ${inspectOption} without "--no-file-parallelism"`);
 		}
@@ -2647,7 +2655,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		...configDefaults.typecheck,
 		...resolved.typecheck
 	}, resolved.typecheck ??= {}, resolved.typecheck.enabled ??= false, resolved.typecheck.enabled) logger.console.warn(c.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."));
-	if (resolved.browser.enabled ??= false, resolved.browser.headless ??= isCI, resolved.browser.isolate ??= true, resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark", resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI, resolved.browser.commands ??= {}, resolved.browser.screenshotDirectory) resolved.browser.screenshotDirectory = resolve(resolved.root, resolved.browser.screenshotDirectory);
+	if (resolved.browser.enabled ??= false, resolved.browser.headless ??= isCI, resolved.browser.isolate ??= resolved.isolate ?? true, resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark", resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI, resolved.browser.commands ??= {}, resolved.browser.screenshotDirectory) resolved.browser.screenshotDirectory = resolve(resolved.root, resolved.browser.screenshotDirectory);
 	if (resolved.inspector.enabled) resolved.browser.trackUnhandledErrors ??= false;
 	if (resolved.browser.viewport ??= {}, resolved.browser.viewport.width ??= 414, resolved.browser.viewport.height ??= 896, resolved.browser.locators ??= {}, resolved.browser.locators.testIdAttribute ??= "data-testid", typeof resolved.browser.provider === "string") {
 		const source = `@vitest/browser-${resolved.browser.provider}`;
@@ -2763,17 +2771,12 @@ Update your dependencies and make sure the versions match.`));
 		// File outside project root with default allowExternal
 		if (this.options.allowExternal === false && roots.every((root) => !filename.startsWith(root))) return this.globCache.set(filename, false), false;
 		// By default `coverage.include` matches all files, except "coverage.exclude"
-		const glob = this.options.include || "**";
-		let included = roots.some((root) => {
-			const options = {
-				contains: true,
-				dot: true,
-				cwd: root,
-				ignore: this.options.exclude
-			};
-			return pm.isMatch(filename, glob, options);
+		const glob = this.options.include || "**", included = pm.isMatch(filename, glob, {
+			contains: true,
+			dot: true,
+			ignore: this.options.exclude
 		});
-		return included &&= existsSync(cleanUrl(filename)), this.globCache.set(filename, included), included;
+		return this.globCache.set(filename, included), included;
 	}
 	async getUntestedFilesByRoot(testedFiles, include, root) {
 		let includedFiles = await glob(include, {

package/dist/chunks/{global.d.BgJSTpgQ.d.ts → global.d.DxtanrNO.d.ts}

@@ -2,7 +2,7 @@ import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
 import { Plugin } from '@vitest/pretty-format';
 import { SnapshotState } from '@vitest/snapshot';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
-import { U as UserConsoleLog } from './worker.d.BFk-vvBU.js';
+import { U as UserConsoleLog } from './worker.d.D25zYZ7N.js';
 
 interface SnapshotMatcher<T> {
 	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;

package/dist/chunks/{index.CcRZ6fUh.js → index.CVpyv-Zg.js}

@@ -387,12 +387,12 @@ function countTestErrors(tasks) {
 }
 function getStateString$1(tasks, name = "tests", showTotal = true) {
 	if (tasks.length === 0) return c.dim(`no ${name}`);
-	const passed = tasks.filter((i) => i.result?.state === "pass"), failed = tasks.filter((i) => i.result?.state === "fail"), skipped = tasks.filter((i) => i.mode === "skip"), todo = tasks.filter((i) => i.mode === "todo");
+	const passed = tasks.reduce((acc, i) => i.result?.state === "pass" ? acc + 1 : acc, 0), failed = tasks.reduce((acc, i) => i.result?.state === "fail" ? acc + 1 : acc, 0), skipped = tasks.reduce((acc, i) => i.mode === "skip" ? acc + 1 : acc, 0), todo = tasks.reduce((acc, i) => i.mode === "todo" ? acc + 1 : acc, 0);
 	return [
-		failed.length ? c.bold(c.red(`${failed.length} failed`)) : null,
-		passed.length ? c.bold(c.green(`${passed.length} passed`)) : null,
-		skipped.length ? c.yellow(`${skipped.length} skipped`) : null,
-		todo.length ? c.gray(`${todo.length} todo`) : null
+		failed ? c.bold(c.red(`${failed} failed`)) : null,
+		passed ? c.bold(c.green(`${passed} passed`)) : null,
+		skipped ? c.yellow(`${skipped} skipped`) : null,
+		todo ? c.gray(`${todo} todo`) : null
 	].filter(Boolean).join(c.dim(" | ")) + (showTotal ? c.gray(` (${tasks.length})`) : "");
 }
 function getStateSymbol(task) {
@@ -704,6 +704,7 @@ class BaseReporter {
 	}
 	printErrorsSummary(files, errors) {
 		const suites = getSuites(files), tests = getTests(files), failedSuites = suites.filter((i) => i.result?.errors), failedTests = tests.filter((i) => i.result?.state === "fail"), failedTotal = countTestErrors(failedSuites) + countTestErrors(failedTests);
+		// TODO: error divider should take into account merged errors for counting
 		let current = 1;
 		const errorDivider = () => this.error(`${c.red(c.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}\n`);
 		if (failedSuites.length) this.error(`\n${errorBanner(`Failed Suites ${failedSuites.length}`)}\n`), this.printTaskErrors(failedSuites, errorDivider);
@@ -733,7 +734,7 @@ class BaseReporter {
 		task.result?.errors?.forEach((error) => {
 			let previous;
 			if (error?.stack) previous = errorsQueue.find((i) => {
-				if (i[0]?.stack !== error.stack) return false;
+				if (i[0]?.stack !== error.stack || i[0]?.diff !== error.diff) return false;
 				const currentProjectName = task?.projectName || task.file?.projectName || "", projectName = i[1][0]?.projectName || i[1][0].file?.projectName || "", currentAnnotations = task.type === "test" && task.annotations, itemAnnotations = i[1][0].type === "test" && i[1][0].annotations;
 				return projectName === currentProjectName && deepEqual(currentAnnotations, itemAnnotations);
 			});
@@ -1015,7 +1016,7 @@ class SummaryReporter {
 				name: testFile.projectName,
 				color: testFile.projectColor
 			}) + typecheck + testFile.filename + c.dim(!testFile.completed && !testFile.total ? " [queued]" : ` ${testFile.completed}/${testFile.total}`));
-			const slowTasks = [testFile.hook, ...Array.from(testFile.tests.values())].filter((t) => t != null && t.visible);
+			const slowTasks = [testFile.hook, ...testFile.tests.values()].filter((t) => t != null && t.visible);
 			for (const [index, task] of slowTasks.entries()) {
 				const elapsed = this.currentTime - task.startTime, icon = index === slowTasks.length - 1 ? F_TREE_NODE_END : F_TREE_NODE_MIDDLE;
 				if (summary.push(c.bold(c.yellow(`   ${icon} `)) + task.name + c.bold(c.yellow(` ${formatTime(Math.max(0, elapsed))}`))), task.hook?.visible) summary.push(c.bold(c.yellow(`      ${F_TREE_NODE_END} `)) + task.hook.name);
@@ -2597,13 +2598,12 @@ function printErrorInner(error, project, options) {
 			}
 		});
 	}
-	const testPath = e.VITEST_TEST_PATH, testName = e.VITEST_TEST_NAME, afterEnvTeardown = e.VITEST_AFTER_ENV_TEARDOWN;
+	const testPath = e.VITEST_TEST_PATH, testName = e.VITEST_TEST_NAME;
 	// testName has testPath inside
 	if (testPath) logger.error(c.red(`This error originated in "${c.bold(relative(project.config.root, testPath))}" test file. It doesn't mean the error was thrown inside the file itself, but while it was running.`));
 	if (testName) logger.error(c.red(`The latest test that might've caused the error is "${c.bold(testName)}". It might mean one of the following:
 - The error was thrown, while Vitest was running this test.
 - If the error occurred after the test had been completed, this was the last documented test before it was thrown.`));
-	if (afterEnvTeardown) logger.error(c.red("This error was caught after test environment was torn down. Make sure to cancel any running tasks before test finishes:\n- cancel timeouts using clearTimeout and clearInterval\n- wait for promises to resolve using the await keyword"));
 	if (typeof e.cause === "object" && e.cause && "name" in e.cause) e.cause.name = `Caused by: ${e.cause.name}`, printErrorInner(e.cause, project, {
 		showCodeFrame: false,
 		logger: options.logger,
@@ -2635,7 +2635,6 @@ const skipErrorProperties = new Set([
 	"columnNumber",
 	"VITEST_TEST_NAME",
 	"VITEST_TEST_PATH",
-	"VITEST_AFTER_ENV_TEARDOWN",
 	"__vitest_rollup_error__",
 	...Object.getOwnPropertyNames(Error.prototype),
 	...Object.getOwnPropertyNames(Object.prototype)