vitest 4.0.0-beta.8 → 4.0.0-beta.9

package/dist/chunks/{index.BuwjkI-q.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.AzwzFtyi.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.CHe6slQs.d.ts → plugin.d.CIk0YiKb.d.ts}

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

package/dist/chunks/{reporters.d.37tJQ2uV.d.ts → reporters.d.DmP-iHLr.d.ts}

@@ -5,12 +5,12 @@ import { Writable } from 'node:stream';
 import { ViteDevServer, TransformResult as TransformResult$1, DepOptimizationConfig, ServerOptions, UserConfig as UserConfig$1, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
-import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.DOMmqJQx.js';
-import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d._GBBbReY.js';
+import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.DtfyY9yS.js';
+import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.DacWrqWe.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import * as chai from 'chai';
+import { chai } from '@vitest/expect';
 import { happyDomTypes, jsdomTypes } from 'vitest/optional-types.js';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
 import { a as RuntimeCoverageProviderModule } from './coverage.d.BZtK59WP.js';
@@ -460,8 +460,6 @@ interface ResolvedPoolOptions extends PoolOptions {
 	vmForks?: ResolvedForksOptions & VmOptions;
 }
 interface ThreadsOptions {
-	/** Minimum amount of threads to use */
-	minThreads?: number | string;
 	/** Maximum amount of threads to use */
 	maxThreads?: number | string;
 	/**
@@ -480,12 +478,9 @@ interface ThreadsOptions {
 	useAtomics?: boolean;
 }
 interface ResolvedThreadsOptions extends ThreadsOptions {
-	minThreads?: number;
 	maxThreads?: number;
 }
 interface ForksOptions {
-	/** Minimum amount of child processes to use */
-	minForks?: number | string;
 	/** Maximum amount of child processes to use */
 	maxForks?: number | string;
 	/**
@@ -496,7 +491,6 @@ interface ForksOptions {
 	singleFork?: boolean;
 }
 interface ResolvedForksOptions extends ForksOptions {
-	minForks?: number;
 	maxForks?: number;
 }
 interface WorkerContextOptions {
@@ -1790,6 +1784,10 @@ declare class Vitest {
 	*/
 	setGlobalTestNamePattern(pattern: string | RegExp): void;
 	/**
+	* Returns the regexp used for the global test name pattern.
+	*/
+	getGlobalTestNamePattern(): RegExp | undefined;
+	/**
 	* Resets the global test name pattern. This method doesn't run any tests.
 	*/
 	resetGlobalTestNamePattern(): void;
@@ -2495,12 +2493,8 @@ interface InlineConfig {
 	*/
 	maxWorkers?: number | string;
 	/**
-	* Minimum number or percentage of workers to run tests in. `poolOptions.{threads,vmThreads}.minThreads`/`poolOptions.forks.minForks` has higher priority.
-	*/
-	minWorkers?: number | string;
-	/**
 	* Should all test files run in parallel. Doesn't affect tests running in the same file.
-	* Setting this to `false` will override `maxWorkers` and `minWorkers` options to `1`.
+	* Setting this to `false` will override `maxWorkers` option to `1`.
 	*
 	* @default true
 	*/
@@ -3073,9 +3067,8 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config"
 	};
 	runner?: string;
 	maxWorkers: number;
-	minWorkers: number;
 }
-type NonProjectOptions = "shard" | "watch" | "run" | "cache" | "update" | "reporters" | "outputFile" | "teardownTimeout" | "silent" | "forceRerunTriggers" | "testNamePattern" | "ui" | "open" | "uiBase" | "snapshotFormat" | "resolveSnapshotPath" | "passWithNoTests" | "onConsoleLog" | "onStackTrace" | "dangerouslyIgnoreUnhandledErrors" | "slowTestThreshold" | "inspect" | "inspectBrk" | "coverage" | "maxWorkers" | "minWorkers" | "fileParallelism" | "watchTriggerPatterns";
+type NonProjectOptions = "shard" | "watch" | "run" | "cache" | "update" | "reporters" | "outputFile" | "teardownTimeout" | "silent" | "forceRerunTriggers" | "testNamePattern" | "ui" | "open" | "uiBase" | "snapshotFormat" | "resolveSnapshotPath" | "passWithNoTests" | "onConsoleLog" | "onStackTrace" | "dangerouslyIgnoreUnhandledErrors" | "slowTestThreshold" | "inspect" | "inspectBrk" | "coverage" | "maxWorkers" | "fileParallelism" | "watchTriggerPatterns";
 interface ServerDepsOptions {
 	/**
 	* Externalize means that Vite will bpass the package to native Node.

package/dist/chunks/{index.CsFXYRkW.js → resolveSnapshotEnvironment.Bvv2zr69.js}

@@ -1,30 +1,15 @@
-import * as chai from 'chai';
-import { resolve, join } from 'node:path';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.hLGRxhC8.js';
-import { distDir } from '../path.js';
-import { r as rpc } from './rpc.RpPylpp0.js';
-import { g as getWorkerState } from './utils.C7__0Iv5.js';
+import { chai } from '@vitest/expect';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.B7I37Tji.js';
+import { r as rpc } from './rpc.BKr6mtxz.js';
+import { g as getWorkerState } from './utils.D2R2NiOH.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.BAlBebnP.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
 }
 
-async function resolveSnapshotEnvironment(config, executor) {
-	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.BOqcT2jW.js');
-		return new VitestNodeSnapshotEnvironment();
-	}
-	const mod = await executor.import(config.snapshotEnvironment);
-	if (typeof mod.default !== "object" || !mod.default) throw new Error("Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`");
-	return mod.default;
-}
-
-const runnersFile = resolve(distDir, "runners.js");
 async function getTestRunnerConstructor(config, moduleRunner) {
-	if (!config.runner) {
-		const { VitestTestRunner, NodeBenchmarkRunner } = await moduleRunner.import(join("/@fs/", runnersFile));
-		return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
-	}
+	if (!config.runner) return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
 	const mod = await moduleRunner.import(config.runner);
 	if (!mod.default && typeof mod.default !== "function") throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
 	return mod.default;
@@ -83,4 +68,14 @@ async function resolveTestRunner(config, moduleRunner) {
 	}, testRunner;
 }
 
+async function resolveSnapshotEnvironment(config, executor) {
+	if (!config.snapshotEnvironment) {
+		const { VitestNodeSnapshotEnvironment } = await import('./node.CyipiPvJ.js');
+		return new VitestNodeSnapshotEnvironment();
+	}
+	const mod = await executor.import(config.snapshotEnvironment);
+	if (typeof mod.default !== "object" || !mod.default) throw new Error("Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`");
+	return mod.default;
+}
+
 export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };

package/dist/chunks/{rpc.RpPylpp0.js → rpc.BKr6mtxz.js}

@@ -1,6 +1,6 @@
 import { getSafeTimers } from '@vitest/utils';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { g as getWorkerState } from './utils.C7__0Iv5.js';
+import { g as getWorkerState } from './utils.D2R2NiOH.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {

package/dist/chunks/{setup-common.hLGRxhC8.js → setup-common.B7I37Tji.js}

@@ -1,7 +1,7 @@
 import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 import { addSerializer } from '@vitest/snapshot';
 import { setSafeTimers } from '@vitest/utils';
-import { g as getWorkerState } from './utils.C7__0Iv5.js';
+import { g as getWorkerState } from './utils.D2R2NiOH.js';
 
 async function startCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
@@ -18,10 +18,10 @@ async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
-	if (setupDefines(config.defines), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.lgsmH00r.js')).registerApiGlobally();
+	if (setupDefines(config), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.CJrTTbxC.js')).registerApiGlobally();
 }
-function setupDefines(defines) {
-	for (const key in defines) globalThis[key] = defines[key];
+function setupDefines(config) {
+	for (const key in config.defines) globalThis[key] = config.defines[key];
 }
 function setupEnv(env) {
 	const state = getWorkerState(), { PROD, DEV,...restEnvs } = env;

package/dist/chunks/{startModuleRunner.C8TW8zTN.js → startModuleRunner.BDRvKSdz.js}

@@ -233,6 +233,7 @@ class VitestMocker {
 			Array,
 			Map
 		};
+		if (options.spyModule) this.spyModule = options.spyModule;
 		const Symbol = this.primitives.Symbol;
 		this.filterPublicKeys = [
 			"__esModule",
@@ -500,6 +501,7 @@ class VitestModuleRunner extends ModuleRunner {
 			evaluatedModules,
 			sourcemapInterceptor: "prepareStackTrace"
 		}, options.evaluator), this.options = options, this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo, this.mocker = options.mocker || new VitestMocker(this, {
+			spyModule: options.spyModule,
 			context: options.vm?.context,
 			resolveId: options.transport.resolveId,
 			get root() {
@@ -561,7 +563,7 @@ class VitestModuleRunner extends ModuleRunner {
 const { readFileSync } = fs, browserExternalId = "__vite-browser-external", browserExternalLength = 24;
 const VITEST_VM_CONTEXT_SYMBOL = "__vitest_vm_context__";
 const cwd = process.cwd(), isWindows = process.platform === "win32";
-async function startVitestModuleRunner(options) {
+function startVitestModuleRunner(options) {
 	const state = () => globalThis.__vitest_worker__ || options.state, rpc = () => state().rpc;
 	process.exit = (code = process.exitCode || 0) => {
 		throw new Error(`process.exit unexpectedly called with "${code}"`);
@@ -581,6 +583,7 @@ async function startVitestModuleRunner(options) {
 		},
 		getCurrentTestFilepath: () => state().filepath
 	}), moduleRunner = new VitestModuleRunner({
+		spyModule: options.spyModule,
 		evaluatedModules: options.evaluatedModules,
 		evaluator,
 		mocker: options.mocker,
@@ -644,7 +647,9 @@ async function startVitestModuleRunner(options) {
 		getWorkerState: state,
 		vm
 	});
-	return await moduleRunner.import("/@vite/env"), await moduleRunner.mocker.initializeSpyModule(), moduleRunner;
+	// await moduleRunner.import('/@vite/env')
+	// await moduleRunner.mocker.initializeSpyModule()
+	return moduleRunner;
 }
 function toBuiltin(id) {
 	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);

package/dist/chunks/test.BAlBebnP.js

@@ -0,0 +1,214 @@
+import { updateTask } from '@vitest/runner';
+import { createDefer, getSafeTimers } from '@vitest/utils';
+import { a as getBenchOptions, g as getBenchFn } from './benchmark.CJUa-Hsa.js';
+import { g as getWorkerState } from './utils.D2R2NiOH.js';
+import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
+import { getTests, getNames, getTestName } from '@vitest/runner/utils';
+import { processError } from '@vitest/utils/error';
+import { normalize } from 'pathe';
+import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.BB37KeLx.js';
+import { r as rpc } from './rpc.BKr6mtxz.js';
+
+function createBenchmarkResult(name) {
+	return {
+		name,
+		rank: 0,
+		rme: 0,
+		samples: []
+	};
+}
+const benchmarkTasks = /* @__PURE__ */ new WeakMap();
+async function runBenchmarkSuite(suite, runner) {
+	const { Task, Bench } = await runner.importTinybench(), start = performance.now(), benchmarkGroup = [], benchmarkSuiteGroup = [];
+	for (const task of suite.tasks) {
+		if (task.mode !== "run" && task.mode !== "queued") continue;
+		if (task.meta?.benchmark) benchmarkGroup.push(task);
+		else if (task.type === "suite") benchmarkSuiteGroup.push(task);
+	}
+	// run sub suites sequentially
+	for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
+	if (benchmarkGroup.length) {
+		const defer = createDefer();
+		suite.result = {
+			state: "run",
+			startTime: start,
+			benchmark: createBenchmarkResult(suite.name)
+		}, updateTask$1("suite-prepare", suite);
+		const addBenchTaskListener = (task, benchmark) => {
+			task.addEventListener("complete", (e) => {
+				const task = e.task, taskRes = task.result, result = benchmark.result.benchmark;
+				benchmark.result.state = "pass", Object.assign(result, taskRes);
+				// compute extra stats and free raw samples as early as possible
+				const samples = result.samples;
+				if (result.sampleCount = samples.length, result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2, !runner.config.benchmark?.includeSamples) result.samples.length = 0;
+				updateTask$1("test-finished", benchmark);
+			}, { once: true }), task.addEventListener("error", (e) => {
+				const task = e.task;
+				defer.reject(benchmark ? task.result.error : e);
+			}, { once: true });
+		};
+		benchmarkGroup.forEach((benchmark) => {
+			const options = getBenchOptions(benchmark), benchmarkInstance = new Bench(options), benchmarkFn = getBenchFn(benchmark);
+			benchmark.result = {
+				state: "run",
+				startTime: start,
+				benchmark: createBenchmarkResult(benchmark.name)
+			};
+			const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
+			benchmarkTasks.set(benchmark, task), addBenchTaskListener(task, benchmark);
+		});
+		const { setTimeout } = getSafeTimers(), tasks = [];
+		for (const benchmark of benchmarkGroup) {
+			const task = benchmarkTasks.get(benchmark);
+			updateTask$1("test-prepare", benchmark), await task.warmup(), tasks.push([await new Promise((resolve) => setTimeout(async () => {
+				resolve(await task.run());
+			})), benchmark]);
+		}
+		suite.result.duration = performance.now() - start, suite.result.state = "pass", updateTask$1("suite-finished", suite), defer.resolve(null), await defer;
+	}
+	function updateTask$1(event, task) {
+		updateTask(event, task, runner);
+	}
+}
+class NodeBenchmarkRunner {
+	moduleRunner;
+	constructor(config) {
+		this.config = config;
+	}
+	async importTinybench() {
+		return await import('tinybench');
+	}
+	importFile(filepath, source) {
+		if (source === "setup") {
+			const moduleNode = getWorkerState().evaluatedModules.getModuleById(filepath);
+			if (moduleNode) getWorkerState().evaluatedModules.invalidateModule(moduleNode);
+		}
+		return this.moduleRunner.import(filepath);
+	}
+	async runSuite(suite) {
+		await runBenchmarkSuite(suite, this);
+	}
+	async runTask() {
+		throw new Error("`test()` and `it()` is only available in test mode.");
+	}
+}
+
+// import type { VitestExecutor } from '../execute'
+// worker context is shared between all tests
+const workerContext = Object.create(null);
+class VitestTestRunner {
+	snapshotClient = getSnapshotClient();
+	workerState = getWorkerState();
+	moduleRunner;
+	cancelRun = false;
+	assertionsErrors = /* @__PURE__ */ new WeakMap();
+	pool = this.workerState.ctx.pool;
+	constructor(config) {
+		this.config = config;
+	}
+	importFile(filepath, source) {
+		if (source === "setup") {
+			const moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);
+			if (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);
+		}
+		return this.moduleRunner.import(filepath);
+	}
+	onCollectStart(file) {
+		this.workerState.current = file;
+	}
+	onCleanupWorkerContext(listener) {
+		this.workerState.onCleanup(listener);
+	}
+	onAfterRunFiles() {
+		this.snapshotClient.clear(), this.workerState.current = void 0;
+	}
+	getWorkerContext() {
+		return workerContext;
+	}
+	async onAfterRunSuite(suite) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
+		if (suite.mode !== "skip" && "filepath" in suite) {
+			// mark snapshots in skipped tests as not obsolete
+			for (const test of getTests(suite)) if (test.mode === "skip") {
+				const name = getNames(test).slice(1).join(" > ");
+				this.snapshotClient.skipTest(suite.file.filepath, name);
+			}
+			const result = await this.snapshotClient.finish(suite.file.filepath);
+			if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
+				let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
+				for (const key of result.uncheckedKeys) message += `· ${key}\n`;
+				suite.result.errors ??= [], suite.result.errors.push(processError(new Error(message))), suite.result.state = "fail";
+			}
+			await rpc().snapshotSaved(result);
+		}
+		this.workerState.current = suite.suite || suite.file;
+	}
+	onAfterRunTask(test) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
+		this.workerState.current = test.suite || test.file;
+	}
+	cancel(_reason) {
+		this.cancelRun = true;
+	}
+	injectValue(key) {
+		// inject has a very limiting type controlled by ProvidedContext
+		// some tests override it which causes the build to fail
+		return inject(key);
+	}
+	async onBeforeRunTask(test) {
+		if (this.cancelRun) test.mode = "skip";
+		test.mode !== "run" && test.mode !== "queued" || (this.workerState.current = test);
+	}
+	async onBeforeRunSuite(suite) {
+		if (this.cancelRun) suite.mode = "skip";
+		// initialize snapshot state before running file suite
+		if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
+		this.workerState.current = suite;
+	}
+	onBeforeTryTask(test) {
+		clearModuleMocks(this.config), this.snapshotClient.clearTest(test.file.filepath, test.id), setState({
+			assertionCalls: 0,
+			isExpectingAssertions: false,
+			isExpectingAssertionsError: null,
+			expectedAssertionsNumber: null,
+			expectedAssertionsNumberErrorGen: null,
+			currentTestName: getTestName(test),
+			snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
+		}, globalThis[GLOBAL_EXPECT]);
+	}
+	onAfterTryTask(test) {
+		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
+		if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
+		if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
+	}
+	extendTaskContext(context) {
+		// create error during the test initialization so we have a nice stack trace
+		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
+		let _expect;
+		return Object.defineProperty(context, "expect", { get() {
+			if (!_expect) _expect = createExpect(context.task);
+			return _expect;
+		} }), Object.defineProperty(context, "_local", { get() {
+			return _expect != null;
+		} }), context;
+	}
+	getImportDurations() {
+		const entries = [...this.workerState.moduleExecutionInfo?.entries() ?? []];
+		return Object.fromEntries(entries.map(([filepath, { duration, selfTime }]) => [normalize(filepath), {
+			selfTime,
+			totalTime: duration
+		}]));
+	}
+}
+function clearModuleMocks(config) {
+	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+	// since each function calls another, we can just call one
+	if (restoreMocks) vi.restoreAllMocks();
+	else if (mockReset) vi.resetAllMocks();
+	else if (clearMocks) vi.clearAllMocks();
+	if (unstubEnvs) vi.unstubAllEnvs();
+	if (unstubGlobals) vi.unstubAllGlobals();
+}
+
+export { NodeBenchmarkRunner as N, VitestTestRunner as V };

package/dist/chunks/{typechecker.DSo_maXz.js → typechecker.DB-fIMaH.js}

@@ -30,6 +30,49 @@ function wrapSerializableConfig(config) {
 		defines
 	};
 }
+function createDefinesScript(define) {
+	if (!define) return "";
+	const serializedDefine = serializeDefine(define);
+	return serializedDefine === "{}" ? "" : `
+const defines = ${serializeDefine(define)}
+Object.keys(defines).forEach((key) => {
+  const segments = key.split('.')
+  let target = globalThis
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+    if (i === segments.length - 1) {
+      target[segment] = defines[key]
+    } else {
+      target = target[segment] || (target[segment] = {})
+    }
+  }
+})
+  `;
+}
+/**
+* Like `JSON.stringify` but keeps raw string values as a literal
+* in the generated code. For example: `"window"` would refer to
+* the global `window` object directly.
+*/
+function serializeDefine(define) {
+	const userDefine = {};
+	for (const key in define) {
+		// vitest sets this to avoid vite:client-inject plugin
+		if (key === "process.env.NODE_ENV" && define[key] === "process.env.NODE_ENV") continue;
+		// import.meta.env.* is handled in `importAnalysis` plugin
+		if (!key.startsWith("import.meta.env.")) userDefine[key] = define[key];
+	}
+	let res = `{`;
+	const keys = Object.keys(userDefine).sort();
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i], val = userDefine[key];
+		if (res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`, i !== keys.length - 1) res += `, `;
+	}
+	return `${res}}`;
+}
+function handleDefineValue(value) {
+	return typeof value === "undefined" ? "undefined" : typeof value === "string" ? value : JSON.stringify(value);
+}
 
 function hasFailedSnapshot(suite) {
 	return getTests(suite).some((s) => {
@@ -759,4 +802,4 @@ function findGeneratedPosition(traceMap, { line, column, source }) {
 	};
 }
 
-export { TypeCheckError as T, Typechecker as a, ancestor as b, convertTasksToEvents as c, getOutputFile as g, hasFailedSnapshot as h, wrapSerializableConfig as w };
+export { TypeCheckError as T, Typechecker as a, ancestor as b, createDefinesScript as c, convertTasksToEvents as d, getOutputFile as g, hasFailedSnapshot as h, wrapSerializableConfig as w };

package/dist/chunks/{utils.C7__0Iv5.js → utils.D2R2NiOH.js}

@@ -18,18 +18,9 @@ function provideWorkerState(context, state) {
 		enumerable: false
 	}), state;
 }
-function getCurrentEnvironment() {
-	const state = getWorkerState();
-	return state?.environment.name;
-}
 function isChildProcess() {
 	return typeof process !== "undefined" && !!process.send;
 }
-function setProcessTitle(title) {
-	try {
-		process.title = `node (${title})`;
-	} catch {}
-}
 function resetModules(modules, resetMocks = false) {
 	const skipPaths = [
 		/\/vitest\/dist\//,
@@ -52,4 +43,4 @@ async function waitForImportsToResolve() {
 	!promises.length && !resolvingCount || (await Promise.allSettled(promises), await waitForImportsToResolve());
 }
 
-export { getCurrentEnvironment as a, getWorkerState as g, isChildProcess as i, provideWorkerState as p, resetModules as r, setProcessTitle as s, waitForImportsToResolve as w };
+export { getWorkerState as g, isChildProcess as i, provideWorkerState as p, resetModules as r, waitForImportsToResolve as w };