vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/chunks/worker.d.B_Fd9M_w.d.ts

@@ -0,0 +1,100 @@
+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.B_LthbQq.js';
+import { F as FetchCachedFileSystemResult, R as ResolveFunctionResult, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.BsToaxti.js';
+import { SnapshotResult } from '@vitest/snapshot';
+
+type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcFn<T> = PromisifyFn<T> & {
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+};
+type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+} & {
+    $functions: LocalFunctions;
+    $close: (error?: Error) => void;
+    $closed: boolean;
+    $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
+};
+type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
+interface PromiseEntry {
+    resolve: (arg: any) => void;
+    reject: (error: any) => void;
+    method: string;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}
+declare const setTimeout: typeof globalThis.setTimeout;
+
+interface RuntimeRPC {
+	fetch: (id: string, importer: string | undefined, environment: string, options?: FetchFunctionOptions) => Promise<FetchResult | FetchCachedFileSystemResult>;
+	resolve: (id: string, importer: string | undefined, environment: string) => Promise<ResolveFunctionResult | null>;
+	transform: (id: string) => Promise<{
+		code?: string;
+	}>;
+	onUserConsoleLog: (log: UserConsoleLog) => void;
+	onUnhandledError: (err: unknown, type: string) => void;
+	onQueued: (file: File) => void;
+	onCollected: (files: File[]) => Promise<void>;
+	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+	onTaskAnnotate: (testId: string, annotation: TestAnnotation) => Promise<TestAnnotation>;
+	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	onCancel: (reason: CancelReason) => void;
+	getCountOfFailedTests: () => number;
+	snapshotSaved: (snapshot: SnapshotResult) => void;
+	resolveSnapshotPath: (testPath: string) => string;
+}
+interface RunnerRPC {
+	onCancel: (reason: CancelReason) => void;
+}
+
+type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
+interface ContextTestEnvironment {
+	name: string;
+	options: Record<string, any> | null;
+}
+type TestExecutionMethod = "run" | "collect";
+interface ContextRPC {
+	pool: string;
+	workerId: number;
+	config: SerializedConfig;
+	projectName: string;
+	files: string[] | FileSpecification[];
+	environment: ContextTestEnvironment;
+	providedContext: Record<string, any>;
+	invalidates?: string[];
+}
+interface WorkerGlobalState {
+	ctx: ContextRPC;
+	config: SerializedConfig;
+	rpc: WorkerRPC;
+	current?: Task;
+	filepath?: string;
+	metaEnv: {
+		[key: string]: any;
+		BASE_URL: string;
+		MODE: string;
+		DEV: boolean;
+		PROD: boolean;
+		SSR: boolean;
+	};
+	environment: Environment;
+	environmentTeardownRun?: boolean;
+	onCancel: Promise<CancelReason>;
+	evaluatedModules: EvaluatedModules;
+	resolvingModules: Set<string>;
+	moduleExecutionInfo: Map<string, any>;
+	onCleanup: (listener: () => unknown) => void;
+	providedContext: Record<string, any>;
+	durations: {
+		environment: number;
+		prepare: number;
+	};
+	onFilterStackTrace?: (trace: string) => string;
+}
+
+export type { BirpcReturn as B, ContextRPC as C, RunnerRPC as R, TestExecutionMethod as T, WorkerGlobalState as W, RuntimeRPC as a, ContextTestEnvironment as b };

package/dist/chunks/worker.rPGLlbkW.js

@@ -0,0 +1,200 @@
+import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
+import { ModuleRunner, EvaluatedModules } from 'vite/module-runner';
+import { readFileSync } from 'node:fs';
+import { isBuiltin } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'pathe';
+import { b as VitestTransport } from './startModuleRunner.oAuCu1yL.js';
+import { e as environments } from './index.DIWhzsUh.js';
+import { s as setupInspect } from './inspector.CvQD-Nie.js';
+import { c as createRuntimeRpc, a as rpcDone } from './rpc.jKGRSXIH.js';
+import { i as isChildProcess } from './utils.DGKhod2J.js';
+
+function isBuiltinEnvironment(env) {
+	return env in environments;
+}
+const isWindows = process.platform === "win32", _loaders = /* @__PURE__ */ new Map();
+async function createEnvironmentLoader(root, rpc) {
+	const cachedLoader = _loaders.get(root);
+	if (!cachedLoader || cachedLoader.isClosed()) {
+		_loaders.delete(root);
+		const moduleRunner = new ModuleRunner({
+			hmr: false,
+			sourcemapInterceptor: "prepareStackTrace",
+			transport: new VitestTransport({
+				async fetchModule(id, importer, options) {
+					const result = await rpc.fetch(id, importer, "__vitest__", options);
+					if ("cached" in result) {
+						const code = readFileSync(result.tmp, "utf-8");
+						return {
+							code,
+							...result
+						};
+					}
+					if (isWindows && "externalize" in result)
+ // TODO: vitest returns paths for external modules, but Vite returns file://
+					// https://github.com/vitejs/vite/pull/20449
+					result.externalize = isBuiltin(id) || /^(?:node:|data:|http:|https:|file:)/.test(id) ? result.externalize : pathToFileURL(result.externalize).toString();
+					return result;
+				},
+				async resolveId(id, importer) {
+					return rpc.resolve(id, importer, "__vitest__");
+				}
+			})
+		});
+		_loaders.set(root, moduleRunner), await moduleRunner.import("/@vite/env");
+	}
+	return _loaders.get(root);
+}
+async function loadEnvironment(ctx, rpc) {
+	const name = ctx.environment.name;
+	if (isBuiltinEnvironment(name)) return { environment: environments[name] };
+	const root = ctx.config.root, loader = await createEnvironmentLoader(root, rpc), packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__"))?.id ?? resolve(root, name), pkg = await loader.import(packageId);
+	if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
+	const environment = pkg.default;
+	if (environment.transformMode != null && environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web", received "${environment.transformMode}".`);
+	if (environment.transformMode)
+ // keep for backwards compat
+	console.warn(`The Vitest environment ${environment.name} defines the "transformMode". This options was deprecated in Vitest 4 and will be removed in the next major version. Please, use "viteEnvironment" instead.`), environment.viteEnvironment ??= environment.transformMode === "ssr" ? "ssr" : "client";
+	return {
+		environment,
+		loader
+	};
+}
+
+const REGEXP_WRAP_PREFIX = "$$vitest:", processSend = process.send?.bind(process), processOn = process.on?.bind(process), processOff = process.off?.bind(process), dispose = [];
+function createThreadsRpcOptions({ port }) {
+	return {
+		post: (v) => {
+			port.postMessage(v);
+		},
+		on: (fn) => {
+			port.addListener("message", fn);
+		}
+	};
+}
+function disposeInternalListeners() {
+	for (const fn of dispose) try {
+		fn();
+	} catch {}
+	dispose.length = 0;
+}
+function createForksRpcOptions(nodeV8) {
+	return {
+		serialize: nodeV8.serialize,
+		deserialize: (v) => nodeV8.deserialize(Buffer.from(v)),
+		post(v) {
+			processSend(v);
+		},
+		on(fn) {
+			const handler = (message, ...extras) => {
+				if (!message?.__tinypool_worker_message__) return fn(message, ...extras);
+			};
+			processOn("message", handler), dispose.push(() => processOff("message", handler));
+		}
+	};
+}
+/**
+* Reverts the wrapping done by `utils/config-helpers.ts`'s `wrapSerializableConfig`
+*/
+function unwrapSerializableConfig(config) {
+	if (config.testNamePattern && typeof config.testNamePattern === "string") {
+		const testNamePattern = config.testNamePattern;
+		if (testNamePattern.startsWith(REGEXP_WRAP_PREFIX)) config.testNamePattern = parseRegexp(testNamePattern.slice(9));
+	}
+	if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
+		const { keys, original } = config.defines, defines = {};
+		// Apply all keys from the original. Entries which had undefined value are missing from original now
+		for (const key of keys) defines[key] = original[key];
+		config.defines = defines;
+	}
+	return config;
+}
+function parseRegexp(input) {
+	// Parse input
+	// eslint-disable-next-line regexp/no-misleading-capturing-group
+	const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
+	// Create the regular expression
+	return m ? m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3]) ? new RegExp(input) : new RegExp(m[2], m[3]) : /$^/;
+}
+
+if (isChildProcess()) {
+	const isProfiling = process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"));
+	if (isProfiling)
+ // Work-around for nodejs/node#55094
+	process.on("SIGTERM", () => {
+		process.exit();
+	});
+}
+const resolvingModules = /* @__PURE__ */ new Set(), globalListeners = /* @__PURE__ */ new Set();
+// this is what every pool executes when running tests
+async function execute(method, ctx, worker) {
+	disposeInternalListeners();
+	const prepareStart = performance.now(), cleanups = [setupInspect(ctx)];
+	process.env.VITEST_WORKER_ID = String(ctx.workerId);
+	const poolId = process.__tinypool_state__?.workerId;
+	process.env.VITEST_POOL_ID = String(poolId);
+	let environmentLoader;
+	try {
+		if (!worker.getRpcOptions || typeof worker.getRpcOptions !== "function") throw new TypeError(`Test worker should expose "getRpcOptions" method. Received "${typeof worker.getRpcOptions}".`);
+		// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
+		const { rpc, onCancel } = createRuntimeRpc(worker.getRpcOptions(ctx));
+		// do not close the RPC channel so that we can get the error messages sent to the main thread
+		cleanups.push(async () => {
+			await Promise.all(rpc.$rejectPendingCalls(({ method, reject }) => {
+				reject(/* @__PURE__ */ new Error(`[vitest-worker]: Closing rpc while "${method}" was pending`));
+			}));
+		});
+		const beforeEnvironmentTime = performance.now(), { environment, loader } = await loadEnvironment(ctx, rpc);
+		environmentLoader = loader;
+		const state = {
+			ctx,
+			evaluatedModules: new EvaluatedModules(),
+			resolvingModules,
+			moduleExecutionInfo: /* @__PURE__ */ new Map(),
+			config: ctx.config,
+			onCancel,
+			environment,
+			durations: {
+				environment: beforeEnvironmentTime,
+				prepare: prepareStart
+			},
+			rpc,
+			onCleanup: (listener) => globalListeners.add(listener),
+			providedContext: ctx.providedContext,
+			onFilterStackTrace(stack) {
+				return createStackString(parseStacktrace(stack));
+			},
+			metaEnv: createImportMetaEnvProxy()
+		}, methodName = method === "collect" ? "collectTests" : "runTests";
+		if (!worker[methodName] || typeof worker[methodName] !== "function") throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
+		await worker[methodName](state);
+	} finally {
+		await Promise.all(cleanups.map((fn) => fn())), await rpcDone().catch(() => {}), environmentLoader?.close();
+	}
+}
+async function teardown() {
+	const promises = [...globalListeners].map((l) => l());
+	await Promise.all(promises);
+}
+function createImportMetaEnvProxy() {
+	// packages/vitest/src/node/plugins/index.ts:146
+	const booleanKeys = [
+		"DEV",
+		"PROD",
+		"SSR"
+	];
+	return new Proxy(process.env, {
+		get(_, key) {
+			return typeof key === "string" ? booleanKeys.includes(key) ? !!process.env[key] : process.env[key] : void 0;
+		},
+		set(_, key, value) {
+			if (typeof key !== "string") return true;
+			if (booleanKeys.includes(key)) process.env[key] = value ? "1" : "";
+			else process.env[key] = value;
+			return true;
+		}
+	});
+}
+
+export { createThreadsRpcOptions as a, createForksRpcOptions as c, execute as e, teardown as t, unwrapSerializableConfig as u };

package/dist/cli.js

@@ -1,27 +1,29 @@
-import { c as createCLI } from './chunks/cac.D3EzDDZd.js';
-import '@vitest/utils';
+import { c as createCLI } from './chunks/cac.elvK37c9.js';
+import '@vitest/utils/helpers';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
-import './chunks/constants.DnKduX2e.js';
-import './chunks/index.CZI_8rVt.js';
+import './chunks/constants.D_Q9UYh-.js';
+import './chunks/index.BwBttQPf.js';
 import 'node:fs';
 import 'node:fs/promises';
-import './chunks/typechecker.CVytUJuF.js';
+import './chunks/typechecker.gXq-5P3n.js';
 import 'node:os';
 import 'node:perf_hooks';
-import '@vitest/utils/source-map';
 import 'tinyexec';
 import './path.js';
 import 'node:path';
 import 'node:url';
 import '@vitest/runner/utils';
 import 'vite';
+import '@vitest/utils/source-map';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
 import 'node:util';
 import 'node:console';
 import 'node:stream';
+import '@vitest/utils/display';
+import '@vitest/utils/offset';
 import 'node:module';
 
 createCLI().parse();

package/dist/config.cjs

@@ -4,19 +4,14 @@ var os = require('node:os');
 var stdEnv = require('std-env');
 var vite = require('vite');
 
-// if changed, update also jsdocs and docs
-const defaultBrowserPort = 63315;
-const extraInlineDeps = [
-	/^(?!.*node_modules).*\.mjs$/,
-	/^(?!.*node_modules).*\.cjs\.js$/,
-	/vite\w*\/dist\/client\/env.mjs/
-];
-
 const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
 const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
 (isNode || isDeno) && process.platform === "win32";
 (isNode || isDeno) && process.stdout?.isTTY && !stdEnv.isCI;
 
+// if changed, update also jsdocs and docs
+const defaultBrowserPort = 63315;
+
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
 const defaultExclude = ["**/node_modules/**", "**/.git/**"];
 // These are the generic defaults for coverage. Providers may also set some provider specific defaults.
@@ -98,4 +93,3 @@ exports.defaultExclude = defaultExclude;
 exports.defaultInclude = defaultInclude;
 exports.defineConfig = defineConfig;
 exports.defineProject = defineProject;
-exports.extraInlineDeps = extraInlineDeps;

package/dist/config.d.ts

@@ -1,33 +1,30 @@
 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.DxZg19fy.js';
-export { a as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.DxZg19fy.js';
-import { V as VitestPluginContext } from './chunks/plugin.d.C2EcJUjo.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d.HJdfX-8k.js';
+import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.CVzhsTvK.js';
+export { a as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.CVzhsTvK.js';
+import { V as VitestPluginContext } from './chunks/plugin.d.C5phQR6o.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.B_LthbQq.js';
 import '@vitest/runner';
-import './chunks/environment.d.CUq4cUgQ.js';
 import '@vitest/utils';
+import './chunks/environment.d.BsToaxti.js';
 import 'node:stream';
-import 'node:console';
-import './chunks/browser.d.q8Z0P0q1.js';
-import './chunks/worker.d.DoNjFAiv.js';
-import '@vitest/snapshot';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
+import './chunks/browser.d.Dx7DO_Ce.js';
+import './chunks/worker.d.B_Fd9M_w.js';
+import 'vite/module-runner';
+import '@vitest/snapshot';
 import '@vitest/pretty-format';
 import '@vitest/utils/diff';
-import 'vite-node';
-import 'chai';
+import '@vitest/expect';
 import 'vitest/optional-types.js';
-import './chunks/benchmark.d.BwvBVTda.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';
 import 'tinybench';
-import './chunks/coverage.d.S9RMNXIe.js';
-import 'vite-node/client';
+import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
-
-/* eslint-disable unused-imports/no-unused-vars */
+import 'node:console';
 
 type VitestInlineConfig = InlineConfig;
 declare module "vite" {
@@ -43,50 +40,48 @@ declare module "vite" {
 }
 
 declare const defaultBrowserPort = 63315;
-declare const extraInlineDeps: RegExp[];
 
 declare const defaultInclude: string[];
 declare const defaultExclude: string[];
-// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
 declare const coverageConfigDefaults: ResolvedCoverageOptions;
 declare const configDefaults: Readonly<{
-	allowOnly: boolean
-	isolate: boolean
-	watch: boolean
-	globals: boolean
-	environment: "node"
-	pool: "forks"
-	clearMocks: boolean
-	restoreMocks: boolean
-	mockReset: boolean
-	unstubGlobals: boolean
-	unstubEnvs: boolean
-	include: string[]
-	exclude: string[]
-	teardownTimeout: number
-	forceRerunTriggers: string[]
-	update: boolean
-	reporters: never[]
-	silent: boolean
-	hideSkippedTests: boolean
-	api: boolean
-	ui: boolean
-	uiBase: string
-	open: boolean
+	allowOnly: boolean;
+	isolate: boolean;
+	watch: boolean;
+	globals: boolean;
+	environment: "node";
+	pool: "forks";
+	clearMocks: boolean;
+	restoreMocks: boolean;
+	mockReset: boolean;
+	unstubGlobals: boolean;
+	unstubEnvs: boolean;
+	include: string[];
+	exclude: string[];
+	teardownTimeout: number;
+	forceRerunTriggers: string[];
+	update: boolean;
+	reporters: never[];
+	silent: boolean;
+	hideSkippedTests: boolean;
+	api: boolean;
+	ui: boolean;
+	uiBase: string;
+	open: boolean;
 	css: {
-		include: never[]
-	}
-	coverage: CoverageV8Options
-	fakeTimers: FakeTimerInstallOpts
-	maxConcurrency: number
-	dangerouslyIgnoreUnhandledErrors: boolean
+		include: never[];
+	};
+	coverage: CoverageV8Options;
+	fakeTimers: FakeTimerInstallOpts;
+	maxConcurrency: number;
+	dangerouslyIgnoreUnhandledErrors: boolean;
 	typecheck: {
-		checker: "tsc"
-		include: string[]
-		exclude: string[]
-	}
-	slowTestThreshold: number
-	disableConsoleIntercept: boolean
+		checker: "tsc";
+		include: string[];
+		exclude: string[];
+	};
+	slowTestThreshold: number;
+	disableConsoleIntercept: boolean;
 }>;
 
 type ViteUserConfigFnObject = (env: ConfigEnv) => UserConfig;
@@ -102,5 +97,5 @@ declare function defineProject(config: Promise<UserWorkspaceConfig>): Promise<Us
 declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn;
 declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
 
-export { UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, extraInlineDeps };
+export { UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject };
 export type { ViteUserConfigExport, ViteUserConfigFn, ViteUserConfigFnObject, ViteUserConfigFnPromise };

package/dist/config.js

@@ -1,6 +1,6 @@
-export { d as defaultBrowserPort, e as extraInlineDeps } from './chunks/constants.DnKduX2e.js';
 export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.CXFFjsi8.js';
 export { mergeConfig } from 'vite';
+export { d as defaultBrowserPort } from './chunks/constants.D_Q9UYh-.js';
 import 'node:os';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';

package/dist/coverage.d.ts

@@ -1,28 +1,27 @@
-import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, b as ReportContext } from './chunks/reporters.d.DxZg19fy.js';
+import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, b as ReportContext } from './chunks/reporters.d.CVzhsTvK.js';
 import { TransformResult } from 'vite';
-import { A as AfterSuiteRunMeta } from './chunks/environment.d.CUq4cUgQ.js';
+import { A as AfterSuiteRunMeta } from './chunks/environment.d.BsToaxti.js';
 import '@vitest/runner';
 import '@vitest/utils';
 import 'node:stream';
-import 'node:console';
-import './chunks/browser.d.q8Z0P0q1.js';
-import './chunks/worker.d.DoNjFAiv.js';
-import './chunks/config.d.HJdfX-8k.js';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import './chunks/browser.d.Dx7DO_Ce.js';
+import './chunks/worker.d.B_Fd9M_w.js';
+import 'vite/module-runner';
+import './chunks/config.d.B_LthbQq.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
-import '@vitest/mocker';
-import '@vitest/utils/source-map';
-import 'vite-node';
-import 'chai';
+import '@vitest/expect';
 import 'vitest/optional-types.js';
-import './chunks/benchmark.d.BwvBVTda.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';
 import 'tinybench';
-import './chunks/coverage.d.S9RMNXIe.js';
-import 'vite-node/client';
+import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
+import 'node:console';
 
 type Threshold = "lines" | "functions" | "statements" | "branches";
 interface ResolvedThreshold {
@@ -46,8 +45,8 @@ interface ResolvedThreshold {
 * "project-b": ...
 * ```
 */
-type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["transformMode"], {
-	[TestFilenames: string]: string
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["environment"], {
+	[TestFilenames: string]: string;
 }>>;
 declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"istanbul" | "v8">> {
 	ctx: Vitest;
@@ -58,30 +57,32 @@ declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"ista
 	coverageFiles: CoverageFiles;
 	pendingPromises: Promise<void>[];
 	coverageFilesDirectory: string;
+	roots: string[];
 	_initialize(ctx: Vitest): void;
 	/**
 	* Check if file matches `coverage.include` but not `coverage.exclude`
 	*/
-	isIncluded(_filename: string): boolean;
+	isIncluded(_filename: string, root?: string): boolean;
+	private getUntestedFilesByRoot;
 	getUntestedFiles(testedFiles: string[]): Promise<string[]>;
 	createCoverageMap(): CoverageMap;
 	generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
 	parseConfigModule(_: string): Promise<{
 		generate: () => {
-			code: string
-		}
+			code: string;
+		};
 	}>;
 	resolveOptions(): Options;
 	clean(clean?: boolean): Promise<void>;
-	onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+	onAfterSuiteRun({ coverage, environment, projectName, testFiles }: AfterSuiteRunMeta): void;
 	readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
 		/** Callback invoked with a single coverage result */
-		onFileRead: (data: CoverageType) => void
+		onFileRead: (data: CoverageType) => void;
 		/** Callback invoked once all results of a project for specific transform mode are read */
-		onFinished: (project: Vitest["projects"][number], transformMode: AfterSuiteRunMeta["transformMode"]) => Promise<void>
+		onFinished: (project: Vitest["projects"][number], environment: string) => Promise<void>;
 		onDebug: ((...logs: any[]) => void) & {
-			enabled: boolean
-		}
+			enabled: boolean;
+		};
 	}): Promise<void>;
 	cleanAfterRun(): Promise<void>;
 	onTestFailure(): Promise<void>;
@@ -101,9 +102,9 @@ declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"ista
 	* Check if current coverage is above configured thresholds and bump the thresholds if needed
 	*/
 	updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
-		thresholds: ResolvedThreshold[]
-		configurationFile: unknown
-		onUpdate: () => void
+		thresholds: ResolvedThreshold[];
+		configurationFile: unknown;
+		onUpdate: () => void;
 	}): Promise<void>;
 	mergeReports(coverageMaps: unknown[]): Promise<void>;
 	hasTerminalReporter(reporters: ResolvedCoverageOptions["reporter"]): boolean;

package/dist/coverage.js

@@ -1,17 +1,16 @@
-export { B as BaseCoverageProvider } from './chunks/coverage.Cwa-XhJt.js';
+export { B as BaseCoverageProvider } from './chunks/coverage.CG6Uhorw.js';
 import 'node:fs';
 import 'node:path';
+import '@vitest/utils/helpers';
 import 'pathe';
 import 'picomatch';
 import 'tinyglobby';
 import 'tinyrainbow';
-import 'vite-node/utils';
 import './chunks/defaults.CXFFjsi8.js';
 import 'node:os';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
 import 'node:crypto';
-import '@vitest/utils';
 import 'node:module';
 import 'node:process';
 import 'node:fs/promises';
@@ -20,16 +19,15 @@ import 'node:assert';
 import 'node:v8';
 import 'node:util';
 import 'vite';
-import './chunks/constants.DnKduX2e.js';
+import './chunks/constants.D_Q9UYh-.js';
 import 'node:tty';
 import 'node:events';
-import './chunks/index.B521nVV-.js';
+import './chunks/index.Bgo3tNWt.js';
 import 'tinypool';
-import './chunks/typechecker.CVytUJuF.js';
+import './chunks/typechecker.gXq-5P3n.js';
 import 'node:perf_hooks';
-import '@vitest/utils/source-map';
 import 'tinyexec';
 import './path.js';
 import '@vitest/runner/utils';
 import 'node:worker_threads';
-import './chunks/coverage.DVF1vEu8.js';
+import './chunks/coverage.D_JHT54q.js';