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

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 };

package/dist/chunks/{vi.BfdOiD4j.js → vi.BB37KeLx.js}

@@ -1,8 +1,7 @@
-import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
+import { chai as chai$1, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
 import { getCurrentTest } from '@vitest/runner';
 import { getNames, getTestName } from '@vitest/runner/utils';
-import * as chai$1 from 'chai';
-import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.C7__0Iv5.js';
+import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.D2R2NiOH.js';
 import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
@@ -359,7 +358,6 @@ function createExpect(test) {
 		isExpectingAssertionsError: null,
 		expectedAssertionsNumber: null,
 		expectedAssertionsNumberErrorGen: null,
-		environment: getCurrentEnvironment(),
 		get testPath() {
 			return getWorkerState().filepath;
 		},
@@ -394,6 +392,8 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
 	writable: true,
 	configurable: true
 });
+const assert = chai$1.assert;
+const should = chai$1.should;
 
 /**
 * Gives access to injected context provided from the main thread.
@@ -3677,11 +3677,11 @@ function waitUntil(callback, options = {}) {
 
 function createVitest() {
 	let _config = null;
-	const workerState = getWorkerState();
+	const state = () => getWorkerState();
 	let _timers;
 	const timers = () => _timers ||= new FakeTimers({
 		global: globalThis,
-		config: workerState.config.fakeTimers
+		config: state().config.fakeTimers
 	}), _stubsGlobal = /* @__PURE__ */ new Map(), _stubsEnv = /* @__PURE__ */ new Map(), _envBooleans = [
 		"PROD",
 		"DEV",
@@ -3689,13 +3689,13 @@ function createVitest() {
 	], utils = {
 		useFakeTimers(config) {
 			if (isChildProcess()) {
-				if (config?.toFake?.includes("nextTick") || workerState.config?.fakeTimers?.toFake?.includes("nextTick")) throw new Error("vi.useFakeTimers({ toFake: [\"nextTick\"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.");
+				if (config?.toFake?.includes("nextTick") || state().config?.fakeTimers?.toFake?.includes("nextTick")) throw new Error("vi.useFakeTimers({ toFake: [\"nextTick\"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.");
 			}
 			if (config) timers().configure({
-				...workerState.config.fakeTimers,
+				...state().config.fakeTimers,
 				...config
 			});
-			else timers().configure(workerState.config.fakeTimers);
+			else timers().configure(state().config.fakeTimers);
 			return timers().useFakeTimers(), utils;
 		},
 		isFakeTimers() {
@@ -3808,7 +3808,7 @@ function createVitest() {
 			}), utils;
 		},
 		stubEnv(name, value) {
-			const state = getWorkerState(), env = state.metaEnv;
+			const env = state().metaEnv;
 			if (!_stubsEnv.has(name)) _stubsEnv.set(name, env[name]);
 			if (_envBooleans.includes(name)) env[name] = value ? "1" : "";
 			else if (value === void 0) delete env[name];
@@ -3822,24 +3822,24 @@ function createVitest() {
 			}), _stubsGlobal.clear(), utils;
 		},
 		unstubAllEnvs() {
-			const state = getWorkerState(), env = state.metaEnv;
+			const env = state().metaEnv;
 			return _stubsEnv.forEach((original, name) => {
 				if (original === void 0) delete env[name];
 				else env[name] = original;
 			}), _stubsEnv.clear(), utils;
 		},
 		resetModules() {
-			return resetModules(workerState.evaluatedModules), utils;
+			return resetModules(state().evaluatedModules), utils;
 		},
 		async dynamicImportSettled() {
 			return waitForImportsToResolve();
 		},
 		setConfig(config) {
-			if (!_config) _config = { ...workerState.config };
-			Object.assign(workerState.config, config);
+			if (!_config) _config = { ...state().config };
+			Object.assign(state().config, config);
 		},
 		resetConfig() {
-			if (_config) Object.assign(workerState.config, _config);
+			if (_config) Object.assign(state().config, _config);
 		}
 	};
 	return utils;
@@ -3859,4 +3859,4 @@ function getImporter(name) {
 	return stack?.file || "";
 }
 
-export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, inject as i, vi as v };
+export { getSnapshotClient as a, assert as b, createExpect as c, vitest as d, globalExpect as g, inject as i, should as s, vi as v };

package/dist/chunks/{vm.BHBje7cC.js → vm.CjLTDaST.js}

@@ -1,16 +1,16 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import vm, { isContext } from 'node:vm';
+import vm, { isContext, runInContext } from 'node:vm';
 import { dirname, basename, extname, normalize, resolve } from 'pathe';
 import { distDir } from '../path.js';
-import { createCustomConsole } from './console.B0quX7yH.js';
+import { createCustomConsole } from './console.7h5kHUIf.js';
 import fs from 'node:fs';
 import { createRequire, Module, isBuiltin } from 'node:module';
 import { CSS_LANGS_RE, KNOWN_ASSET_RE, toArray, isBareImport } from '@vitest/utils';
 import { f as findNearestPackageData } from './resolver.Bx6lE0iq.js';
 import { dirname as dirname$1 } from 'node:path';
 import { getDefaultRequestStubs } from '../module-evaluator.js';
-import { s as startVitestModuleRunner, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.C8TW8zTN.js';
-import { p as provideWorkerState } from './utils.C7__0Iv5.js';
+import { s as startVitestModuleRunner, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.BDRvKSdz.js';
+import { p as provideWorkerState } from './utils.D2R2NiOH.js';
 
 function interopCommonJsModule(interopDefault, mod) {
 	if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) return {
@@ -611,13 +611,13 @@ async function runVmTests(method, state) {
 		packageCache,
 		transform: rpc.transform,
 		viteClientModule: stubs["/@vite/client"]
-	}), moduleRunner = await startVitestModuleRunner({
+	}), moduleRunner = startVitestModuleRunner({
 		context,
 		evaluatedModules: state.evaluatedModules,
 		state,
 		externalModulesExecutor
 	});
-	Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
+	if (Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
 		value: {
 			context,
 			externalModulesExecutor
@@ -625,7 +625,12 @@ async function runVmTests(method, state) {
 		configurable: true,
 		enumerable: false,
 		writable: false
-	}), context.__vitest_mocker__ = moduleRunner.mocker;
+	}), context.__vitest_mocker__ = moduleRunner.mocker, ctx.config.serializedDefines) try {
+		runInContext(ctx.config.serializedDefines, context, { filename: "virtual:load-defines.js" });
+	} catch (error) {
+		throw new Error(`Failed to load custom "defines": ${error.message}`);
+	}
+	await moduleRunner.mocker.initializeSpyModule();
 	const { run } = await moduleRunner.import(entryFile), fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
 		filepath: f,
 		testLocations: void 0

package/dist/chunks/{worker.d.DYlqbejz.d.ts → worker.d.B2r4Ln6p.d.ts}

@@ -1,6 +1,6 @@
 import { CancelReason, File, TestAnnotation, TaskResultPack, TaskEventPack, FileSpecification, Task } from '@vitest/runner';
 import { FetchFunctionOptions, FetchResult, EvaluatedModules } from 'vite/module-runner';
-import { a as SerializedConfig } from './config.d._GBBbReY.js';
+import { a as SerializedConfig } from './config.d.DacWrqWe.js';
 import { F as FetchCachedFileSystemResult, R as ResolveFunctionResult, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.2fYMoz3o.js';
 import { SnapshotResult } from '@vitest/snapshot';
 

package/dist/chunks/{worker.d.BKu8cnnX.d.ts → worker.d.DJ6qxO2w.d.ts}

@@ -1,5 +1,5 @@
 import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.d.DYlqbejz.js';
+import { C as ContextRPC } from './worker.d.B2r4Ln6p.js';
 
 interface WorkerContext extends ContextRPC {
 	port: MessagePort;

package/dist/cli.js

@@ -1,13 +1,13 @@
-import { c as createCLI } from './chunks/cac.Dsn7ixFt.js';
+import { c as createCLI } from './chunks/cac.Dt7e1TIu.js';
 import '@vitest/utils';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
 import './chunks/constants.D_Q9UYh-.js';
-import './chunks/index.C3EbxYwt.js';
+import './chunks/index.BIP7prJq.js';
 import 'node:fs';
 import 'node:fs/promises';
-import './chunks/typechecker.DSo_maXz.js';
+import './chunks/typechecker.DB-fIMaH.js';
 import 'node:os';
 import 'node:perf_hooks';
 import '@vitest/utils/source-map';

package/dist/config.d.ts

@@ -1,23 +1,22 @@
 import { HookHandler, ConfigEnv, UserConfig } from 'vite';
 export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.BC86JJdB.js';
-export { a as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.BC86JJdB.js';
-import { V as VitestPluginContext } from './chunks/plugin.d.vcD4xbMS.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d._GBBbReY.js';
+import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.DmP-iHLr.js';
+export { a as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.DmP-iHLr.js';
+import { V as VitestPluginContext } from './chunks/plugin.d.CIk0YiKb.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.DacWrqWe.js';
 import '@vitest/runner';
 import '@vitest/utils';
 import './chunks/environment.d.2fYMoz3o.js';
 import 'node:stream';
-import 'node:console';
-import './chunks/browser.d.DOMmqJQx.js';
-import './chunks/worker.d.DYlqbejz.js';
-import 'vite/module-runner';
-import '@vitest/snapshot';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
+import './chunks/browser.d.DtfyY9yS.js';
+import './chunks/worker.d.B2r4Ln6p.js';
+import 'vite/module-runner';
+import '@vitest/snapshot';
 import '@vitest/pretty-format';
 import '@vitest/utils/diff';
-import 'chai';
+import '@vitest/expect';
 import 'vitest/optional-types.js';
 import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';
@@ -25,6 +24,7 @@ import 'tinybench';
 import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
+import 'node:console';
 
 /* eslint-disable unused-imports/no-unused-vars */