vitest 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/chunks/{config.d.HJdfX-8k.d.ts → config.d.DZo8c7fw.d.ts}

@@ -98,68 +98,68 @@ interface SerializedConfig {
 	maxConcurrency: number;
 	defines: Record<string, any>;
 	expect: {
-		requireAssertions?: boolean
+		requireAssertions?: boolean;
 		poll?: {
-			timeout?: number
-			interval?: number
-		}
+			timeout?: number;
+			interval?: number;
+		};
 	};
 	printConsoleTrace: boolean | undefined;
 	sequence: {
-		shuffle?: boolean
-		concurrent?: boolean
-		seed: number
-		hooks: SequenceHooks
-		setupFiles: SequenceSetupFiles
+		shuffle?: boolean;
+		concurrent?: boolean;
+		seed: number;
+		hooks: SequenceHooks;
+		setupFiles: SequenceSetupFiles;
 	};
 	poolOptions: {
 		forks: {
-			singleFork: boolean
-			isolate: boolean
-		}
+			singleFork: boolean;
+			isolate: boolean;
+		};
 		threads: {
-			singleThread: boolean
-			isolate: boolean
-		}
+			singleThread: boolean;
+			isolate: boolean;
+		};
 		vmThreads: {
-			singleThread: boolean
-		}
+			singleThread: boolean;
+		};
 		vmForks: {
-			singleFork: boolean
-		}
+			singleFork: boolean;
+		};
 	};
 	deps: {
 		web: {
-			transformAssets?: boolean
-			transformCss?: boolean
-			transformGlobPattern?: RegExp | RegExp[]
-		}
+			transformAssets?: boolean;
+			transformCss?: boolean;
+			transformGlobPattern?: RegExp | RegExp[];
+		};
 		optimizer: {
 			web: {
-				enabled: boolean
-			}
+				enabled: boolean;
+			};
 			ssr: {
-				enabled: boolean
-			}
-		}
-		interopDefault: boolean | undefined
-		moduleDirectories: string[] | undefined
+				enabled: boolean;
+			};
+		};
+		interopDefault: boolean | undefined;
+		moduleDirectories: string[] | undefined;
 	};
 	snapshotOptions: {
-		updateSnapshot: SnapshotUpdateState
-		expand: boolean | undefined
-		snapshotFormat: PrettyFormatOptions | undefined
+		updateSnapshot: SnapshotUpdateState;
+		expand: boolean | undefined;
+		snapshotFormat: PrettyFormatOptions | undefined;
 		/**
 		* only exists for tests, not available in the main process
 		*/
-		snapshotEnvironment: SnapshotEnvironment
+		snapshotEnvironment: SnapshotEnvironment;
 	};
 	pool: string;
 	snapshotSerializers: string[];
 	chaiConfig: {
-		includeStack?: boolean
-		showDiff?: boolean
-		truncateThreshold?: number
+		includeStack?: boolean;
+		showDiff?: boolean;
+		truncateThreshold?: number;
 	} | undefined;
 	diff: string | SerializedDiffOptions | undefined;
 	retry: number;
@@ -167,52 +167,52 @@ interface SerializedConfig {
 	inspect: boolean | string | undefined;
 	inspectBrk: boolean | string | undefined;
 	inspector: {
-		enabled?: boolean
-		port?: number
-		host?: string
-		waitForDebugger?: boolean
+		enabled?: boolean;
+		port?: number;
+		host?: string;
+		waitForDebugger?: boolean;
 	};
 	watch: boolean;
 	env: Record<string, any>;
 	browser: {
-		name: string
-		headless: boolean
-		isolate: boolean
-		fileParallelism: boolean
-		ui: boolean
+		name: string;
+		headless: boolean;
+		isolate: boolean;
+		fileParallelism: boolean;
+		ui: boolean;
 		viewport: {
-			width: number
-			height: number
-		}
+			width: number;
+			height: number;
+		};
 		locators: {
-			testIdAttribute: string
-		}
-		screenshotFailures: boolean
+			testIdAttribute: string;
+		};
+		screenshotFailures: boolean;
 		providerOptions: {
 			// for playwright
-			actionTimeout?: number
-		}
+			actionTimeout?: number;
+		};
 	};
 	standalone: boolean;
 	logHeapUsage: boolean | undefined;
 	coverage: SerializedCoverageConfig;
 	benchmark: {
-		includeSamples: boolean
+		includeSamples: boolean;
 	} | undefined;
 }
 interface SerializedCoverageConfig {
 	provider: "istanbul" | "v8" | "custom" | undefined;
 	reportsDirectory: string;
 	htmlReporter: {
-		subdir: string | undefined
+		subdir: string | undefined;
 	} | undefined;
 	enabled: boolean;
 	customProviderModule: string | undefined;
 }
 type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookTimeout" | "clearMocks" | "mockReset" | "restoreMocks" | "fakeTimers" | "maxConcurrency" | "expect" | "printConsoleTrace"> & {
 	sequence?: {
-		hooks?: SequenceHooks
-	}
+		hooks?: SequenceHooks;
+	};
 };
 type RuntimeOptions = Partial<RuntimeConfig>;
 

package/dist/chunks/{console.CtFJOzRO.js → console.DoJHFxmj.js}

@@ -8,7 +8,7 @@ import { g as getWorkerState } from './utils.XdZDrNZV.js';
 
 const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
 function getTaskIdByStack(root) {
-	const stack = new Error("STACK_TRACE_ERROR").stack?.split("\n");
+	const stack = (/* @__PURE__ */ new Error("STACK_TRACE_ERROR")).stack?.split("\n");
 	if (!stack) return UNKNOWN_TEST_ID;
 	const index = stack.findIndex((line) => line.includes("at Console.value"));
 	const line = index === -1 ? null : stack[index + 2];
@@ -101,7 +101,7 @@ function createCustomConsole(defaultState) {
 		if (state().config.printConsoleTrace) {
 			const limit = Error.stackTraceLimit;
 			Error.stackTraceLimit = limit + 6;
-			const stack = new Error("STACK_TRACE").stack;
+			const stack = (/* @__PURE__ */ new Error("STACK_TRACE")).stack;
 			const trace = stack?.split("\n").slice(7).join("\n");
 			Error.stackTraceLimit = limit;
 			buffer.push([data, trace]);
@@ -129,7 +129,7 @@ function createCustomConsole(defaultState) {
 		if (state().config.printConsoleTrace) {
 			const limit = Error.stackTraceLimit;
 			Error.stackTraceLimit = limit + 6;
-			const stack = new Error("STACK_TRACE").stack?.split("\n");
+			const stack = (/* @__PURE__ */ new Error("STACK_TRACE")).stack?.split("\n");
 			Error.stackTraceLimit = limit;
 			const isTrace = stack?.some((line) => line.includes("at Console.trace"));
 			if (isTrace) buffer.push([data, void 0]);

package/dist/chunks/{constants.DnKduX2e.js → constants.CXzqaLmq.js}

@@ -9,7 +9,6 @@ const extraInlineDeps = [
 	/vite\w*\/dist\/client\/env.mjs/
 ];
 const CONFIG_NAMES = ["vitest.config", "vite.config"];
-const WORKSPACES_NAMES = ["vitest.workspace", "vitest.projects"];
 const CONFIG_EXTENSIONS = [
 	".ts",
 	".mts",
@@ -19,8 +18,6 @@ const CONFIG_EXTENSIONS = [
 	".cjs"
 ];
 const configFiles = CONFIG_NAMES.flatMap((name) => CONFIG_EXTENSIONS.map((ext) => name + ext));
-const WORKSPACES_EXTENSIONS = [...CONFIG_EXTENSIONS, ".json"];
-const workspacesFiles = WORKSPACES_NAMES.flatMap((name) => WORKSPACES_EXTENSIONS.map((ext) => name + ext));
 const globalApis = [
 	"suite",
 	"test",
@@ -41,4 +38,4 @@ const globalApis = [
 	"onTestFailed"
 ];
 
-export { API_PATH as A, defaultPort as a, defaultInspectPort as b, configFiles as c, defaultBrowserPort as d, extraInlineDeps as e, globalApis as g, workspacesFiles as w };
+export { API_PATH as A, defaultPort as a, defaultInspectPort as b, configFiles as c, defaultBrowserPort as d, extraInlineDeps as e, globalApis as g };

package/dist/chunks/{coverage.BjMqihzx.js → coverage.C84l9G-M.js}

@@ -16,15 +16,15 @@ import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
 import { version, mergeConfig } from 'vite';
-import { c as configFiles, w as workspacesFiles, e as extraInlineDeps, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.DnKduX2e.js';
+import { c as configFiles, e as extraInlineDeps, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.CXzqaLmq.js';
 import { a as isWindows } from './env.D4Lgay0q.js';
 import * as nodeos from 'node:os';
 import nodeos__default from 'node:os';
 import { isatty } from 'node:tty';
 import EventEmitter from 'node:events';
-import { c as createBirpc } from './index.B521nVV-.js';
+import { c as createBirpc } from './index.Bgo3tNWt.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.CVytUJuF.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.CMNPqJOo.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';
@@ -2556,11 +2556,6 @@ function createChildProcessChannel$1(project, collect = false) {
 		message: "message",
 		response: "response"
 	};
-	const channel = {
-		onMessage: (callback) => emitter.on(events.message, callback),
-		postMessage: (message) => emitter.emit(events.response, message),
-		onClose: () => emitter.removeAllListeners()
-	};
 	const rpc = createBirpc(createMethodsRPC(project, {
 		cacheFs: true,
 		collect
@@ -2584,11 +2579,17 @@ function createChildProcessChannel$1(project, collect = false) {
 		on(fn) {
 			emitter.on(events.response, fn);
 		},
-		onTimeoutError(functionName) {
-			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-		}
+		timeout: -1
 	});
 	project.vitest.onCancel((reason) => rpc.onCancel(reason));
+	const channel = {
+		onMessage: (callback) => emitter.on(events.message, callback),
+		postMessage: (message) => emitter.emit(events.response, message),
+		onClose: () => {
+			emitter.removeAllListeners();
+			rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+		}
+	};
 	return channel;
 }
 function createForksPool(vitest, { execArgv, env }) {
@@ -2717,14 +2718,18 @@ function createWorkerChannel$1(project, collect) {
 		on(fn) {
 			port.on("message", fn);
 		},
-		onTimeoutError(functionName) {
-			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-		}
+		timeout: -1
 	});
 	project.vitest.onCancel((reason) => rpc.onCancel(reason));
+	const onClose = () => {
+		port.close();
+		workerPort.close();
+		rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+	};
 	return {
 		workerPort,
-		port
+		port,
+		onClose
 	};
 }
 function createThreadsPool(vitest, { execArgv, env }) {
@@ -2757,11 +2762,7 @@ function createThreadsPool(vitest, { execArgv, env }) {
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
 			vitest.state.clearFiles(project, paths);
-			const { workerPort, port } = createWorkerChannel$1(project, name === "collect");
-			const onClose = () => {
-				port.close();
-				workerPort.close();
-			};
+			const { workerPort, onClose } = createWorkerChannel$1(project, name === "collect");
 			const workerId = ++id;
 			const data = {
 				pool: "threads",
@@ -3013,15 +3014,10 @@ function stringToBytes(input, percentageReference) {
 const suppressWarningsPath$1 = resolve(rootDir, "./suppress-warnings.cjs");
 function createChildProcessChannel(project, collect) {
 	const emitter = new EventEmitter();
-	const cleanup = () => emitter.removeAllListeners();
 	const events = {
 		message: "message",
 		response: "response"
 	};
-	const channel = {
-		onMessage: (callback) => emitter.on(events.message, callback),
-		postMessage: (message) => emitter.emit(events.response, message)
-	};
 	const rpc = createBirpc(createMethodsRPC(project, {
 		cacheFs: true,
 		collect
@@ -3045,15 +3041,18 @@ function createChildProcessChannel(project, collect) {
 		on(fn) {
 			emitter.on(events.response, fn);
 		},
-		onTimeoutError(functionName) {
-			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-		}
+		timeout: -1
 	});
 	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	return {
-		channel,
-		cleanup
+	const channel = {
+		onMessage: (callback) => emitter.on(events.message, callback),
+		postMessage: (message) => emitter.emit(events.response, message),
+		onClose: () => {
+			emitter.removeAllListeners();
+			rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+		}
 	};
+	return { channel };
 }
 function createVmForksPool(vitest, { execArgv, env }) {
 	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
@@ -3090,7 +3089,7 @@ function createVmForksPool(vitest, { execArgv, env }) {
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
 			vitest.state.clearFiles(project, paths);
-			const { channel, cleanup } = createChildProcessChannel(project, name === "collect");
+			const { channel } = createChildProcessChannel(project, name === "collect");
 			const workerId = ++id;
 			const data = {
 				pool: "forks",
@@ -3114,7 +3113,7 @@ function createVmForksPool(vitest, { execArgv, env }) {
 				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
 				else throw error;
 			} finally {
-				cleanup();
+				channel.onClose();
 			}
 		}
 		return async (specs, invalidates) => {
@@ -3165,14 +3164,17 @@ function createWorkerChannel(project, collect) {
 		on(fn) {
 			port.on("message", fn);
 		},
-		onTimeoutError(functionName) {
-			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-		}
+		timeout: -1
 	});
 	project.vitest.onCancel((reason) => rpc.onCancel(reason));
+	function onClose() {
+		workerPort.close();
+		port.close();
+		rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+	}
 	return {
 		workerPort,
-		port
+		onClose
 	};
 }
 function createVmThreadsPool(vitest, { execArgv, env }) {
@@ -3210,7 +3212,7 @@ function createVmThreadsPool(vitest, { execArgv, env }) {
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
 			vitest.state.clearFiles(project, paths);
-			const { workerPort, port } = createWorkerChannel(project, name === "collect");
+			const { workerPort, onClose } = createWorkerChannel(project, name === "collect");
 			const workerId = ++id;
 			const data = {
 				pool: "vmThreads",
@@ -3235,8 +3237,7 @@ function createVmThreadsPool(vitest, { execArgv, env }) {
 				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
 				else throw error;
 			} finally {
-				port.close();
-				workerPort.close();
+				onClose();
 			}
 		}
 		return async (specs, invalidates) => {
@@ -3438,9 +3439,7 @@ class BaseSequencer {
 	async shard(files) {
 		const { config } = this.ctx;
 		const { index, count } = config.shard;
-		const shardSize = Math.ceil(files.length / count);
-		const shardStart = shardSize * (index - 1);
-		const shardEnd = shardSize * index;
+		const [shardStart, shardEnd] = this.calculateShardRange(files.length, index, count);
 		return [...files].map((spec) => {
 			const fullPath = resolve$1(slash(config.root), slash(spec.moduleId));
 			const specPath = fullPath?.slice(config.root.length);
@@ -3473,6 +3472,20 @@ class BaseSequencer {
 			return bState.duration - aState.duration;
 		});
 	}
+	// Calculate distributed shard range [start, end] distributed equally
+	calculateShardRange(filesCount, index, count) {
+		const baseShardSize = Math.floor(filesCount / count);
+		const remainderTestFilesCount = filesCount % count;
+		if (remainderTestFilesCount >= index) {
+			const shardSize = baseShardSize + 1;
+			const shardStart = shardSize * (index - 1);
+			const shardEnd = shardSize * index;
+			return [shardStart, shardEnd];
+		}
+		const shardStart = remainderTestFilesCount * (baseShardSize + 1) + (index - remainderTestFilesCount - 1) * baseShardSize;
+		const shardEnd = shardStart + baseShardSize;
+		return [shardStart, shardEnd];
+	}
 }
 
 class RandomSequencer extends BaseSequencer {
@@ -3532,6 +3545,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.provide ??= {};
 	resolved.name = typeof options.name === "string" ? options.name : options.name?.label || "";
 	resolved.color = typeof options.name !== "string" ? options.name?.color : void 0;
+	if (resolved.environment === "browser") throw new Error(`Looks like you set "test.environment" to "browser". To enabled Browser Mode, use "test.browser.enabled" instead.`);
 	const inspector = resolved.inspect || resolved.inspectBrk;
 	resolved.inspector = {
 		...resolved.inspector,
@@ -3642,7 +3656,6 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		...resolved.include,
 		resolved.config && slash$1(resolved.config),
 		...configFiles,
-		...workspacesFiles,
 		"**/virtual:*",
 		"**/__x00__*",
 		"**/node_modules/**"
@@ -3683,7 +3696,11 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.attachmentsDir = resolve$1(resolved.root, resolved.attachmentsDir ?? ".vitest-attachments");
 	if (resolved.snapshotEnvironment) resolved.snapshotEnvironment = resolvePath(resolved.snapshotEnvironment, resolved.root);
 	resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
-	if (resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) resolved.snapshotFormat.plugins = [];
+	if (resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) {
+		resolved.snapshotFormat.plugins = [];
+		// TODO: support it via separate config (like DiffOptions) or via `Function.toString()`
+		if (typeof resolved.snapshotFormat.compareKeys === "function") throw new TypeError(`"snapshotFormat.compareKeys" function is not supported.`);
+	}
 	const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
 	resolved.snapshotOptions = {
 		expand: resolved.expandSnapshotDiff ?? false,
@@ -3755,9 +3772,6 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		["vmForks", "maxForks"]
 	];
 	for (const [poolOptionKey, workerOptionKey] of poolForksOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-	if (typeof resolved.workspace === "string")
- // if passed down from the CLI and it's relative, resolve relative to CWD
-	resolved.workspace = typeof options.workspace === "string" && options.workspace[0] === "." ? resolve$1(process.cwd(), options.workspace) : resolvePath(resolved.workspace, resolved.root);
 	if (!builtinPools.includes(resolved.pool)) resolved.pool = resolvePath(resolved.pool, resolved.root);
 	if (mode === "benchmark") {
 		resolved.benchmark = {
@@ -3948,6 +3962,7 @@ class BaseCoverageProvider {
 	coverageFiles = /* @__PURE__ */ new Map();
 	pendingPromises = [];
 	coverageFilesDirectory;
+	roots = [];
 	_initialize(ctx) {
 		this.ctx = ctx;
 		if (ctx.version !== this.version) ctx.logger.warn(c.yellow(`Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.
@@ -3971,44 +3986,55 @@ Update your dependencies and make sure the versions match.`));
 		const shard = this.ctx.config.shard;
 		const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
 		this.coverageFilesDirectory = resolve$1(this.options.reportsDirectory, tempDirectory);
+		// If --project filter is set pick only roots of resolved projects
+		this.roots = ctx.config.project?.length ? [...new Set(ctx.projects.map((project) => project.config.root))] : [ctx.config.root];
 	}
 	/**
 	* Check if file matches `coverage.include` but not `coverage.exclude`
 	*/
-	isIncluded(_filename) {
+	isIncluded(_filename, root) {
+		const roots = root ? [root] : this.roots;
 		const filename = slash(_filename);
 		const cacheHit = this.globCache.get(filename);
 		if (cacheHit !== void 0) return cacheHit;
 		// File outside project root with default allowExternal
-		if (this.options.allowExternal === false && !filename.startsWith(this.ctx.config.root)) {
+		if (this.options.allowExternal === false && roots.every((root) => !filename.startsWith(root))) {
 			this.globCache.set(filename, false);
 			return false;
 		}
-		const options = {
-			contains: true,
-			dot: true,
-			cwd: this.ctx.config.root,
-			ignore: this.options.exclude
-		};
 		// By default `coverage.include` matches all files, except "coverage.exclude"
 		const glob = this.options.include || "**";
-		const included = pm.isMatch(filename, glob, options) && existsSync(cleanUrl(filename));
+		let included = roots.some((root) => {
+			const options = {
+				contains: true,
+				dot: true,
+				cwd: root,
+				ignore: this.options.exclude
+			};
+			return pm.isMatch(filename, glob, options);
+		});
+		included &&= existsSync(cleanUrl(filename));
 		this.globCache.set(filename, included);
 		return included;
 	}
-	async getUntestedFiles(testedFiles) {
-		if (this.options.include == null) return [];
-		let includedFiles = await glob(this.options.include, {
-			cwd: this.ctx.config.root,
+	async getUntestedFilesByRoot(testedFiles, include, root) {
+		let includedFiles = await glob(include, {
+			cwd: root,
 			ignore: [...this.options.exclude, ...testedFiles.map((file) => slash(file))],
 			absolute: true,
 			dot: true,
 			onlyFiles: true
 		});
 		// Run again through picomatch as tinyglobby's exclude pattern is different ({ "exclude": ["math"] } should ignore "src/math.ts")
-		includedFiles = includedFiles.filter((file) => this.isIncluded(file));
+		includedFiles = includedFiles.filter((file) => this.isIncluded(file, root));
 		if (this.ctx.config.changed) includedFiles = (this.ctx.config.related || []).filter((file) => includedFiles.includes(file));
-		return includedFiles.map((file) => slash(path.resolve(this.ctx.config.root, file)));
+		return includedFiles.map((file) => slash(path.resolve(root, file)));
+	}
+	async getUntestedFiles(testedFiles) {
+		if (this.options.include == null) return [];
+		const rootMapper = this.getUntestedFilesByRoot.bind(this, testedFiles, this.options.include);
+		const matrix = await Promise.all(this.roots.map(rootMapper));
+		return matrix.flatMap((files) => files);
 	}
 	createCoverageMap() {
 		throw new Error("BaseReporter's createCoverageMap was not overwritten");
@@ -4268,7 +4294,9 @@ Update your dependencies and make sure the versions match.`));
 			root: project.config.root,
 			isBrowserEnabled: project.isBrowserEnabled(),
 			vitenode: project.vitenode
-		})), {
+		})), 
+		// Check core last as it will match all files anyway
+{
 			root: ctx.config.root,
 			vitenode: ctx.vitenode,
 			isBrowserEnabled: ctx.getRootProject().isBrowserEnabled()

package/dist/chunks/{coverage.d.S9RMNXIe.d.ts → coverage.d.CNYjU4GF.d.ts}

@@ -2,7 +2,7 @@ import { ModuleExecutionInfo } from 'vite-node/client';
 
 interface RuntimeCoverageModuleLoader {
 	executeId: (id: string) => Promise<{
-		default: RuntimeCoverageProviderModule
+		default: RuntimeCoverageProviderModule;
 	}>;
 	isBrowser?: boolean;
 	moduleExecutionInfo?: ModuleExecutionInfo;
@@ -16,19 +16,19 @@ interface RuntimeCoverageProviderModule {
 	* Executed before tests are run in the worker thread.
 	*/
 	startCoverage?: (runtimeOptions: {
-		isolate: boolean
+		isolate: boolean;
 	}) => unknown | Promise<unknown>;
 	/**
 	* Executed on after each run in the worker thread. Possible to return a payload passed to the provider
 	*/
 	takeCoverage?: (runtimeOptions?: {
-		moduleExecutionInfo?: ModuleExecutionInfo
+		moduleExecutionInfo?: ModuleExecutionInfo;
 	}) => unknown | Promise<unknown>;
 	/**
 	* Executed after all tests have been run in the worker thread.
 	*/
 	stopCoverage?: (runtimeOptions: {
-		isolate: boolean
+		isolate: boolean;
 	}) => unknown | Promise<unknown>;
 }