vitest 4.0.0-beta.17 → 4.0.0-beta.19

package/dist/browser.d.ts

@@ -1,7 +1,7 @@
-import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/config.d.C4PpNy7v.js';
+import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/config.d.u2CUDWwS.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.aXWuQhZN.js';
+import { V as VitestModuleRunner } from './chunks/moduleRunner.d.YtNsMIoJ.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.DSgBAZPX.js';
+import './chunks/worker.d.BFk-vvBU.js';
 import './chunks/environment.d.CrsxCzP1.js';
 import '@vitest/mocker';
 import './chunks/mocker.d.BE_2ls6u.js';

package/dist/browser.js

@@ -1,4 +1,4 @@
-export { l as loadDiffConfig, b as loadSnapshotSerializers, c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/setup-common.BewgbkTd.js';
+export { l as loadDiffConfig, b as loadSnapshotSerializers, c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/setup-common.DR1sucx6.js';
 export { collectTests, startTests } from '@vitest/runner';
 import * as spyModule from '@vitest/spy';
 export { spyModule as SpyModule };

package/dist/{worker-base.js → chunks/base.CtHM3ryk.js}

@@ -1,48 +1,21 @@
-import { c as createForksRpcOptions, u as unwrapSerializableConfig, a as createThreadsRpcOptions, e as execute, t as teardown$1 } from './chunks/worker.DVTUM2IW.js';
-import v8 from 'node:v8';
 import { runInThisContext } from 'node:vm';
 import * as spyModule from '@vitest/spy';
-import { EvaluatedModules } from 'vite/module-runner';
-import { s as startVitestModuleRunner, c as createNodeImportMeta } from './chunks/startModuleRunner.DPBo3mme.js';
+import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startModuleRunner.C2tTvmF9.js';
 import { performance } from 'node:perf_hooks';
 import { startTests, collectTests } from '@vitest/runner';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './chunks/resolveSnapshotEnvironment.BsJpmVZR.js';
-import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './chunks/setup-common.BewgbkTd.js';
-import { g as globalExpect, v as vi } from './chunks/vi.B2--mG9U.js';
-import { c as closeInspector } from './chunks/inspector.Br76Q2Mb.js';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './resolveSnapshotEnvironment.DJJKMKxb.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';
 import { createRequire } from 'node:module';
 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 './chunks/index.Dnl38iQ_.js';
-import { g as getWorkerState, r as resetModules, p as provideWorkerState } from './chunks/utils.CG9h5ccR.js';
-import '@vitest/utils/source-map';
-import 'node:fs';
-import 'node:url';
-import 'pathe';
-import './chunks/index.Bt-upxGS.js';
-import 'node:console';
-import './chunks/rpc.cD77ENhU.js';
-import './chunks/index.Bgo3tNWt.js';
-import '@vitest/utils/helpers';
-import './path.js';
-import 'node:path';
-import '@vitest/utils/serialize';
-import './module-evaluator.js';
-import '@vitest/mocker';
-import '@vitest/expect';
-import './chunks/test.CTuWuHYH.js';
-import './chunks/benchmark.DHKMYAts.js';
-import '@vitest/runner/utils';
-import '@vitest/utils/error';
-import './chunks/coverage.D_JHT54q.js';
-import '@vitest/snapshot';
-import '@vitest/utils/offset';
-import './chunks/_commonjsHelpers.BFTU3MAI.js';
-import './chunks/date.-jtEtIeV.js';
-import 'expect-type';
+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;
@@ -74,7 +47,7 @@ function resolveAsset(mod, url) {
 	mod.exports = url;
 }
 async function setupConsoleLogSpy() {
-	const { createCustomConsole } = await import('./chunks/console.CTJL2nuH.js');
+	const { createCustomConsole } = await import('./console.CTJL2nuH.js');
 	globalThis.console = createCustomConsole();
 }
 async function withEnv({ environment }, options, fn) {
@@ -90,30 +63,31 @@ async function withEnv({ environment }, options, fn) {
 }
 
 // browser shouldn't call this!
-async function run$1(method, files, config, environment, moduleRunner) {
-	const workerState = getWorkerState(), isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true), isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true), isolate = isIsolatedThreads || isIsolatedForks;
-	if (await setupGlobalEnv(config, environment, moduleRunner), await startCoverageInsideWorker(config.coverage, moduleRunner, { isolate }), config.chaiConfig) setupChaiConfig(config.chaiConfig);
+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 (isolate) moduleRunner.mocker.reset(), resetModules(workerState.evaluatedModules, true);
+			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 });
+		await stopCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.isolate });
 	}), workerState.environmentTeardownRun = true;
 }
 
 let _moduleRunner;
-const evaluatedModules = new EvaluatedModules(), moduleExecutionInfo = /* @__PURE__ */ new Map();
+const evaluatedModules = new VitestEvaluatedModules(), moduleExecutionInfo = /* @__PURE__ */ new Map();
 function startModuleRunner(options) {
 	return _moduleRunner || (_moduleRunner = startVitestModuleRunner(options), _moduleRunner);
 }
+/** @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) => {
@@ -145,57 +119,10 @@ async function runBaseTests(method, state) {
 	} catch (error) {
 		throw new Error(`Failed to load custom "defines": ${error.message}`);
 	}
-	await run$1(method, fileSpecs, ctx.config, {
+	await run(method, fileSpecs, ctx.config, {
 		environment: state.environment,
 		options: ctx.environment.options
 	}, executor);
 }
 
-class ForksBaseWorker {
-	getRpcOptions() {
-		return createForksRpcOptions(v8);
-	}
-	async executeTests(method, state) {
-		// TODO: don't rely on reassigning process.exit
-		// https://github.com/vitest-dev/vitest/pull/4441#discussion_r1443771486
-		const exit = process.exit;
-		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
-		try {
-			await runBaseTests(method, state);
-		} finally {
-			process.exit = exit;
-		}
-	}
-	runTests(state) {
-		return this.executeTests("run", state);
-	}
-	collectTests(state) {
-		return this.executeTests("collect", state);
-	}
-}
-const worker$1 = new ForksBaseWorker();
-
-class ThreadsBaseWorker {
-	getRpcOptions(ctx) {
-		return createThreadsRpcOptions(ctx);
-	}
-	runTests(state) {
-		return runBaseTests("run", state);
-	}
-	collectTests(state) {
-		return runBaseTests("collect", state);
-	}
-}
-const worker = new ThreadsBaseWorker();
-
-async function run(ctx) {
-	await execute("run", ctx, ctx.pool === "forks" ? worker$1 : worker);
-}
-async function collect(ctx) {
-	await execute("collect", ctx, ctx.pool === "forks" ? worker$1 : worker);
-}
-async function teardown() {
-	await teardown$1();
-}
-
-export { collect, run, teardown };
+export { runBaseTests as r };

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

@@ -1,4 +1,5 @@
-import { T as TestExecutionMethod } from './worker.d.DSgBAZPX.js';
+import { FileSpecification } from '@vitest/runner';
+import { T as TestExecutionMethod } from './worker.d.BFk-vvBU.js';
 
 type SerializedTestSpecification = [project: {
 	name: string | undefined;
@@ -10,7 +11,7 @@ type SerializedTestSpecification = [project: {
 
 interface BrowserTesterOptions {
 	method: TestExecutionMethod;
-	files: string[];
+	files: FileSpecification[];
 	providedContext: string;
 }
 

package/dist/chunks/{cac.BO_6jvrs.js → cac.DCrQhweU.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.DehVUBn4.js';
+import { R as ReportersMap } from './index.CcRZ6fUh.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.0-beta.17";
+var version = "4.0.0-beta.19";
 
 const apiConfig = (port) => ({
 	port: {
@@ -632,24 +632,7 @@ const apiConfig = (port) => ({
 	},
 	strictPort: { description: "Set to true to exit if port is already in use, instead of automatically trying the next available port" },
 	middlewareMode: null
-}), poolThreadsCommands = {
-	isolate: { description: "Isolate tests in threads pool (default: `true`)" },
-	singleThread: { description: "Run tests inside a single thread (default: `false`)" },
-	maxThreads: {
-		description: "Maximum number or percentage of threads to run tests in",
-		argument: "<workers>"
-	},
-	useAtomics: { description: "Use Atomics to synchronize threads. This can improve performance in some cases, but might cause segfault in older Node versions (default: `false`)" },
-	execArgv: null
-}, poolForksCommands = {
-	isolate: { description: "Isolate tests in forks pool (default: `true`)" },
-	singleFork: { description: "Run tests inside a single child_process (default: `false`)" },
-	maxForks: {
-		description: "Maximum number or percentage of processes to run tests in",
-		argument: "<workers>"
-	},
-	execArgv: null
-};
+});
 function watermarkTransform(value) {
 	return typeof value === "string" ? value.split(",").map(Number) : value;
 }
@@ -901,43 +884,13 @@ const cliOptionsConfig = {
 		argument: "<pool>",
 		subcommands: null
 	},
-	poolOptions: {
-		description: "Specify pool options",
-		argument: "<options>",
-		subcommands: {
-			threads: {
-				description: "Specify threads pool options",
-				argument: "<options>",
-				subcommands: poolThreadsCommands
-			},
-			vmThreads: {
-				description: "Specify VM threads pool options",
-				argument: "<options>",
-				subcommands: {
-					...poolThreadsCommands,
-					memoryLimit: {
-						description: "Memory limit for VM threads pool. If you see memory leaks, try to tinker this value.",
-						argument: "<limit>"
-					}
-				}
-			},
-			forks: {
-				description: "Specify forks pool options",
-				argument: "<options>",
-				subcommands: poolForksCommands
-			},
-			vmForks: {
-				description: "Specify VM forks pool options",
-				argument: "<options>",
-				subcommands: {
-					...poolForksCommands,
-					memoryLimit: {
-						description: "Memory limit for VM forks pool. If you see memory leaks, try to tinker this value.",
-						argument: "<limit>"
-					}
-				}
-			}
-		}
+	execArgv: {
+		description: "Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.",
+		argument: "<option>"
+	},
+	vmMemoryLimit: {
+		description: "Memory limit for VM pools. If you see memory leaks, try to tinker this value.",
+		argument: "<limit>"
 	},
 	fileParallelism: { description: "Should all test files run in parallel. Use `--no-file-parallelism` to disable (default: `true`)" },
 	maxWorkers: {
@@ -1341,22 +1294,22 @@ function normalizeCliOptions(cliFilters, argv) {
 }
 async function start(mode, cliFilters, options) {
 	try {
-		const { startVitest } = await import('./cli-api.BvCJGado.js').then(function (n) { return n.h; }), ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
+		const { startVitest } = await import('./cli-api.BjHteKX0.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.DehVUBn4.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.CcRZ6fUh.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();
 	}
 }
 async function init(project) {
 	if (project !== "browser") console.error(/* @__PURE__ */ new Error("Only the \"browser\" project is supported. Use \"vitest init browser\" to create a new project.")), process.exit(1);
-	const { create } = await import('./creator.Daoa5_gR.js');
+	const { create } = await import('./creator.DucAaYBz.js');
 	await create();
 }
 async function collect(mode, cliFilters, options) {
 	try {
-		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.BvCJGado.js').then(function (n) { return n.h; }), ctx = await prepareVitest(mode, {
+		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.BjHteKX0.js').then(function (n) { return n.p; }), ctx = await prepareVitest(mode, {
 			...normalizeCliOptions(cliFilters, options),
 			watch: false,
 			run: true
@@ -1374,7 +1327,7 @@ async function collect(mode, cliFilters, options) {
 		}
 		await ctx.close();
 	} catch (e) {
-		const { errorBanner } = await import('./index.DehVUBn4.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.CcRZ6fUh.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();
 	}