vitest 4.0.0-beta.7 → 4.0.0-beta.9

package/dist/chunks/{console.B0quX7yH.js → console.7h5kHUIf.js}

@@ -4,7 +4,7 @@ import { Writable } from 'node:stream';
 import { getSafeTimers } from '@vitest/utils';
 import c from 'tinyrainbow';
 import { R as RealDate } from './date.-jtEtIeV.js';
-import { g as getWorkerState } from './utils.C7__0Iv5.js';
+import { g as getWorkerState } from './utils.D2R2NiOH.js';
 
 const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
 function getTaskIdByStack(root) {

package/dist/chunks/{coverage.Dvxug1RM.js → coverage.CDRAMTt7.js}

@@ -23,7 +23,7 @@ import { isatty } from 'node:tty';
 import EventEmitter from 'node:events';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.DSo_maXz.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.DB-fIMaH.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';
@@ -2685,8 +2685,8 @@ function createChildProcessChannel$1(project, collect = false) {
 	};
 	return channel;
 }
-function createForksPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.forks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minForks ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/forks.js"), options = {
+function createForksPool(vitest, { execArgv, env }, specifications) {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.forks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, worker = resolve(vitest.distPath, "workers/forks.js"), options = {
 		runtime: "child_process",
 		filename: resolve(vitest.distPath, "worker.js"),
 		teardown: "teardown",
@@ -2732,7 +2732,7 @@ function createForksPool(vitest, { execArgv, env }) {
 			vitest.onCancel(() => pool.cancelPendingTasks());
 			const configs = /* @__PURE__ */ new WeakMap(), getConfig = (project) => {
 				if (configs.has(project)) return configs.get(project);
-				const _config = project.getSerializableConfig(), config = wrapSerializableConfig(_config);
+				const _config = project.serializedConfig, config = wrapSerializableConfig(_config);
 				return configs.set(project, config), config;
 			}, singleFork = specs.filter((spec) => spec.project.config.poolOptions?.forks?.singleFork), multipleForks = specs.filter((spec) => !spec.project.config.poolOptions?.forks?.singleFork);
 			if (multipleForks.length) {
@@ -2792,8 +2792,8 @@ function createWorkerChannel$1(project, collect) {
 		onClose
 	};
 }
-function createThreadsPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.threads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minThreads ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/threads.js"), options = {
+function createThreadsPool(vitest, { execArgv, env }, specifications) {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.threads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, worker = resolve(vitest.distPath, "workers/threads.js"), options = {
 		filename: resolve(vitest.distPath, "worker.js"),
 		teardown: "teardown",
 		useAtomics: poolOptions.useAtomics ?? false,
@@ -3051,8 +3051,8 @@ function createChildProcessChannel(project, collect) {
 	};
 	return { channel };
 }
-function createVmForksPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.vmForks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.maxForks ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/vmForks.js"), options = {
+function createVmForksPool(vitest, { execArgv, env }, specifications) {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.vmForks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, worker = resolve(vitest.distPath, "workers/vmForks.js"), options = {
 		runtime: "child_process",
 		filename: resolve(vitest.distPath, "worker.js"),
 		maxThreads,
@@ -3146,8 +3146,8 @@ function createWorkerChannel(project, collect) {
 		onClose
 	};
 }
-function createVmThreadsPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.vmThreads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minThreads ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/vmThreads.js"), options = {
+function createVmThreadsPool(vitest, { execArgv, env }, specifications) {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.vmThreads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, worker = resolve(vitest.distPath, "workers/vmThreads.js"), options = {
 		filename: resolve(vitest.distPath, "worker.js"),
 		useAtomics: poolOptions.useAtomics ?? false,
 		maxThreads,
@@ -3294,14 +3294,14 @@ function createPool(ctx) {
 			});
 		}
 		const groupedSpecifications = {}, groups = /* @__PURE__ */ new Set(), factories = {
-			vmThreads: () => createVmThreadsPool(ctx, options),
-			vmForks: () => createVmForksPool(ctx, options),
-			threads: () => createThreadsPool(ctx, options),
-			forks: () => createForksPool(ctx, options),
+			vmThreads: (specs) => createVmThreadsPool(ctx, options, specs),
+			vmForks: (specs) => createVmForksPool(ctx, options, specs),
+			threads: (specs) => createThreadsPool(ctx, options, specs),
+			forks: (specs) => createForksPool(ctx, options, specs),
 			typescript: () => createTypecheckPool(ctx)
 		};
 		for (const spec of files) {
-			const group = spec[0].config.sequence.groupOrder ?? 0;
+			const group = spec.project.config.sequence.groupOrder ?? 0;
 			groups.add(group), groupedSpecifications[group] ??= [], groupedSpecifications[group].push(spec);
 		}
 		const Sequencer = ctx.config.sequence.sequencer, sequencer = new Sequencer(ctx);
@@ -3324,7 +3324,7 @@ function createPool(ctx) {
 				typescript: []
 			};
 			specifications.forEach((specification) => {
-				const pool = specification[2].pool;
+				const pool = specification.pool;
 				filesByPool[pool] ??= [], filesByPool[pool].push(specification);
 			}), await Promise.all(Object.entries(filesByPool).map(async (entry) => {
 				const [pool, files] = entry;
@@ -3332,7 +3332,7 @@ function createPool(ctx) {
 				const specs = await sortSpecs(files);
 				if (pool in factories) {
 					const factory = factories[pool];
-					return pools[pool] ??= factory(), pools[pool][method](specs, invalidate);
+					return pools[pool] ??= factory(specs), pools[pool][method](specs, invalidate);
 				}
 				if (pool === "browser") return pools.browser ??= await getBrowserPool(), pools.browser[method](specs, invalidate);
 				const poolHandler = await getCustomPool(pool);
@@ -3463,8 +3463,9 @@ 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.minWorkers) resolved.minWorkers = resolveInlineWorkerOption(resolved.minWorkers);
-	if (resolved.fileParallelism ??= mode !== "benchmark", !resolved.fileParallelism) resolved.maxWorkers = 1, resolved.minWorkers = 1;
+	if (resolved.fileParallelism ??= mode !== "benchmark", !resolved.fileParallelism)
+ // 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) {
 		const isSingleThread = resolved.pool === "threads" && resolved.poolOptions?.threads?.singleThread, isSingleFork = resolved.pool === "forks" && resolved.poolOptions?.forks?.singleFork;
@@ -3553,17 +3554,6 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
 		}
 	};
-	if (process.env.VITEST_MIN_THREADS) resolved.poolOptions = {
-		...resolved.poolOptions,
-		threads: {
-			...resolved.poolOptions?.threads,
-			minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-		},
-		vmThreads: {
-			...resolved.poolOptions?.vmThreads,
-			minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-		}
-	};
 	if (process.env.VITEST_MAX_FORKS) resolved.poolOptions = {
 		...resolved.poolOptions,
 		forks: {
@@ -3575,30 +3565,9 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
 		}
 	};
-	if (process.env.VITEST_MIN_FORKS) resolved.poolOptions = {
-		...resolved.poolOptions,
-		forks: {
-			...resolved.poolOptions?.forks,
-			minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-		},
-		vmForks: {
-			...resolved.poolOptions?.vmForks,
-			minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-		}
-	};
-	const poolThreadsOptions = [
-		["threads", "minThreads"],
-		["threads", "maxThreads"],
-		["vmThreads", "minThreads"],
-		["vmThreads", "maxThreads"]
-	];
+	const poolThreadsOptions = [["threads", "maxThreads"], ["vmThreads", "maxThreads"]];
 	for (const [poolOptionKey, workerOptionKey] of poolThreadsOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-	const poolForksOptions = [
-		["forks", "minForks"],
-		["forks", "maxForks"],
-		["vmForks", "minForks"],
-		["vmForks", "maxForks"]
-	];
+	const poolForksOptions = [["forks", "maxForks"], ["vmForks", "maxForks"]];
 	for (const [poolOptionKey, workerOptionKey] of poolForksOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
 	if (!builtinPools.includes(resolved.pool)) resolved.pool = resolvePath(resolved.pool, resolved.root);
 	if (mode === "benchmark") {
@@ -3749,7 +3718,7 @@ class BaseCoverageProvider {
 		if (this.ctx = ctx, ctx.version !== this.version) ctx.logger.warn(c.yellow(`Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.
 Running mixed versions is not supported and may lead into bugs
 Update your dependencies and make sure the versions match.`));
-		const config = ctx.config.coverage;
+		const config = ctx._coverageOptions;
 		this.options = {
 			...coverageConfigDefaults,
 			...config,
@@ -3872,8 +3841,8 @@ Update your dependencies and make sure the versions match.`));
 	async reportThresholds(coverageMap, allTestsRun) {
 		const resolvedThresholds = this.resolveThresholds(coverageMap);
 		if (this.checkThresholds(resolvedThresholds), this.options.thresholds?.autoUpdate && allTestsRun) {
-			if (!this.ctx.server.config.configFile) throw new Error("Missing configurationFile. The \"coverage.thresholds.autoUpdate\" can only be enabled when configuration file is used.");
-			const configFilePath = this.ctx.server.config.configFile, configModule = await this.parseConfigModule(configFilePath);
+			if (!this.ctx.vite.config.configFile) throw new Error("Missing configurationFile. The \"coverage.thresholds.autoUpdate\" can only be enabled when configuration file is used.");
+			const configFilePath = this.ctx.vite.config.configFile, configModule = await this.parseConfigModule(configFilePath);
 			await this.updateThresholds({
 				thresholds: resolvedThresholds,
 				configurationFile: configModule,

package/dist/chunks/{globals.lgsmH00r.js → globals.CJrTTbxC.js}

@@ -1,11 +1,10 @@
 import { g as globalApis } from './constants.D_Q9UYh-.js';
-import { V as VitestIndex } from './index.AR8aAkCC.js';
-import './vi.BfdOiD4j.js';
+import { i as index } from './index.C832ioot.js';
+import './vi.BB37KeLx.js';
 import '@vitest/expect';
 import '@vitest/runner';
 import '@vitest/runner/utils';
-import 'chai';
-import './utils.C7__0Iv5.js';
+import './utils.D2R2NiOH.js';
 import '@vitest/utils';
 import './_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/snapshot';
@@ -13,14 +12,14 @@ import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
 import './date.-jtEtIeV.js';
-import './benchmark.UW6Ezvxy.js';
+import './benchmark.CJUa-Hsa.js';
 import 'expect-type';
 import 'vite/module-runner';
 
 function registerApiGlobally() {
 	globalApis.forEach((api) => {
 		// @ts-expect-error I know what I am doing :P
-		globalThis[api] = VitestIndex[api];
+		globalThis[api] = index[api];
 	});
 }
 

package/dist/chunks/{index.C3EbxYwt.js → index.BIP7prJq.js}

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, promises } from 'node:fs';
 import { mkdir, writeFile, readdir, stat, readFile } from 'node:fs/promises';
 import { resolve, dirname, isAbsolute, relative, basename, normalize } from 'pathe';
-import { g as getOutputFile, h as hasFailedSnapshot, T as TypeCheckError } from './typechecker.DSo_maXz.js';
+import { g as getOutputFile, h as hasFailedSnapshot, T as TypeCheckError } from './typechecker.DB-fIMaH.js';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { getTestName, getFullName, hasFailed, getTests, getSuites, getTasks } from '@vitest/runner/utils';
 import { slash, toArray, isPrimitive, inspect, positionToOffset, lineSplitRE } from '@vitest/utils';
@@ -1156,9 +1156,13 @@ function printErrorInner(error, project, options) {
 		return;
 	}
 	const stacks = options.parseErrorStacktrace(e), nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find((stack) => {
+		// we are checking that this module was processed by us at one point
 		try {
-			const module = project._vite && project.getModuleById(stack.file);
-			return (module?.transformResult || module?.ssrTransformResult) && existsSync(stack.file);
+			const environments = [...Object.values(project._vite?.environments || {}), ...Object.values(project.browser?.vite.environments || {})], hasResult = environments.some((environment) => {
+				const modules = environment.moduleGraph.getModulesByFile(stack.file);
+				return [...modules?.values() || []].some((module) => !!module.transformResult);
+			});
+			return hasResult && existsSync(stack.file);
 		} catch {
 			return false;
 		}

package/dist/chunks/{index.D2B6d2vv.js → index.BjKEiSn0.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName } from './index.C3EbxYwt.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName } from './index.BIP7prJq.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils';
 

package/dist/chunks/{index.AR8aAkCC.js → index.C832ioot.js}

@@ -1,14 +1,13 @@
-import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.BfdOiD4j.js';
-import { b as bench } from './benchmark.UW6Ezvxy.js';
+import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.BB37KeLx.js';
+import { b as bench } from './benchmark.CJUa-Hsa.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 import { EvaluatedModules } from 'vite/module-runner';
-import * as chai from 'chai';
-import { assert, should } from 'chai';
+import { chai } from '@vitest/expect';
 
 const assertType = function assertType() {};
 
-var VitestIndex = /*#__PURE__*/Object.freeze({
+var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
   EvaluatedModules: EvaluatedModules,
   afterAll: afterAll,
@@ -34,4 +33,4 @@ var VitestIndex = /*#__PURE__*/Object.freeze({
   vitest: vitest
 });
 
-export { VitestIndex as V, assertType as a };
+export { assertType as a, index as i };

package/dist/chunks/{moduleRunner.d.CX4DuqOx.d.ts → moduleRunner.d.DxTLreRD.d.ts}

@@ -1,6 +1,7 @@
+import * as _vitest_spy from '@vitest/spy';
 import vm from 'node:vm';
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, ModuleRunner, EvaluatedModules } from 'vite/module-runner';
-import { R as RuntimeRPC, W as WorkerGlobalState } from './worker.d.DYlqbejz.js';
+import { R as RuntimeRPC, W as WorkerGlobalState } from './worker.d.B2r4Ln6p.js';
 import { R as ResolveFunctionResult } from './environment.d.2fYMoz3o.js';
 import { MockedModule, MockedModuleType } from '@vitest/mocker';
 import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './mocker.d.BE_2ls6u.js';
@@ -116,6 +117,7 @@ interface MockContext {
 }
 interface VitestMockerOptions {
 	context?: vm.Context;
+	spyModule?: typeof _vitest_spy;
 	root: string;
 	moduleDirectories: string[];
 	resolveId: (id: string, importer?: string) => Promise<{
@@ -192,6 +194,7 @@ interface VitestModuleRunnerOptions {
 	getWorkerState: () => WorkerGlobalState;
 	mocker?: VitestMocker;
 	vm?: VitestVmOptions;
+	spyModule?: typeof _vitest_spy;
 }
 interface VitestVmOptions {
 	context: vm.Context;

package/dist/chunks/{node.BOqcT2jW.js → node.CyipiPvJ.js}

@@ -1,5 +1,5 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.C7__0Iv5.js';
+import { g as getWorkerState } from './utils.D2R2NiOH.js';
 import '@vitest/utils';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {

package/dist/chunks/{plugin.d.vcD4xbMS.d.ts → plugin.d.CIk0YiKb.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.BC86JJdB.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.DmP-iHLr.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;