vitest 5.0.4 → 5.0.5

package/dist/browser.js

@@ -1,6 +1,6 @@
 export { s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/coverage.-bm5IxnW.js';
-export { p as collectTests, a as processError, s as startTests } from './chunks/run.Cm2sd7-x.js';
-export { l as loadDiffConfig, a as loadSnapshotSerializers, s as setupCommonEnv, b as setupEnv } from './chunks/setup-common.BABL3z3m.js';
+export { p as collectTests, a as processError, s as startTests } from './chunks/run.BPv-BBRv.js';
+export { l as loadDiffConfig, a as loadSnapshotSerializers, s as setupCommonEnv, b as setupEnv } from './chunks/setup-common.HGAqWOnX.js';
 export { s as SpyModule } from './chunks/spy.DDMXghXv.js';
 export { f as format, i as inspect, s as stringify } from './chunks/display.BlTmubjj.js';
 export { g as getType } from './chunks/pathe.M-eThtNZ.Ba-7h1rE.js';

package/dist/chunks/{base.CYbb9pQW.js → base.CzXt2BO_.js}

@@ -1,22 +1,22 @@
 import { runInThisContext } from 'node:vm';
 import { s as spyModule } from './spy.DDMXghXv.js';
-import { r as resolveTestRunner, a as resolveSnapshotEnvironment, d as detectAsyncLeaks, s as setupChaiConfig } from './index.GYMZ12wH.js';
-import { l as loadEnvironment, e as emitModuleRunner, a as listenForErrors } from './init.DrHtV5zd.js';
+import { r as resolveTestRunner, a as resolveSnapshotEnvironment, d as detectAsyncLeaks, s as setupChaiConfig } from './index.CoUIxZd4.js';
+import { l as loadEnvironment, e as emitModuleRunner, a as listenForErrors } from './init.PvxYpuCm.js';
 import { n as nativeImports, g as getEvaluatedImports, c as collectDependencies } from './module-dependencies.CwNPkcV4.js';
 import { Traces } from '../traces.js';
 import { V as VitestEvaluatedModules } from './rpc.DpkUyY1N.js';
-import { s as startVitestModuleRunner, c as createNodeImportMeta } from './index.CPNMO3h-.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta } from './index.CK-t0WMg.js';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './coverage.-bm5IxnW.js';
-import { i as index, g as globalExpect, v as vi } from './index.uwTEEBsB.js';
+import { i as index, g as globalExpect, v as vi } from './index.aTZaPVhf.js';
 import { c as closeInspector } from './inspector.CvyFGlXm.js';
-import { s as startTests, p as publicCollect } from './run.Cm2sd7-x.js';
+import { s as startTests, p as publicCollect } from './run.BPv-BBRv.js';
 import { createRequire } from 'node:module';
 import timers from 'node:timers';
 import timersPromises from 'node:timers/promises';
 import util from 'node:util';
 import { K as KNOWN_ASSET_TYPES } from './pathe.M-eThtNZ.Ba-7h1rE.js';
-import { s as setupCommonEnv, b as setupEnv } from './setup-common.BABL3z3m.js';
+import { s as setupCommonEnv, b as setupEnv } from './setup-common.HGAqWOnX.js';
 import { g as getWorkerState, r as resetModules, p as provideWorkerState, a as getSafeWorkerState } from './utils.DYj33du9.js';
 
 // this should only be used in Node
@@ -102,6 +102,7 @@ async function run(method, files, config, moduleRunner, environment, traces) {
 				vi.resetConfig();
 				// mocks should not affect different files
 				vi.restoreAllMocks();
+				moduleRunner.mocker?.reset();
 			}
 		});
 	} finally {
@@ -126,7 +127,7 @@ async function startModuleRunner(options) {
 		let mocker;
 		if (options.state.config.experimental.nodeLoader !== false) {
 			// this additionally imports acorn/magic-string
-			const { NativeModuleMocker } = await import('./nativeModuleMocker.D8f4cW4A.js');
+			const { NativeModuleMocker } = await import('./nativeModuleMocker.BxrHJNAF.js');
 			mocker = new NativeModuleMocker({
 				async resolveId(id, importer) {
 					// TODO: use import.meta.resolve instead

package/dist/chunks/{cac.DTXWs6Ni.js → cac.CLrZKo1g.js}

@@ -620,7 +620,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "5.0.4";
+var version = "5.0.5";
 
 const apiConfig = (port) => ({
 	port: {
@@ -2364,7 +2364,7 @@ function normalizeCliOptions(cliFilters, argv) {
 }
 async function start(cliFilters, options) {
 	try {
-		const { startVitest } = await import('./cli-api.Bx28WXzL.js').then(function (n) { return n.g; });
+		const { startVitest } = await import('./cli-api.De07GUeT.js').then(function (n) { return n.g; });
 		const ctx = await startVitest(cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
 		if (!ctx.shouldKeepServer()) await ctx.exit();
 	} catch (e) {
@@ -2378,7 +2378,7 @@ async function start(cliFilters, options) {
 }
 async function doctorCommand(cliFilters, options) {
 	try {
-		const { doctor } = await import('./doctor.Bqc8NDDb.js');
+		const { doctor } = await import('./doctor.BK86Cncq.js');
 		await doctor(cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
 		process.exit();
 	} catch (e) {
@@ -2395,12 +2395,12 @@ async function init(project) {
 		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.CLL8QFMS.js');
+	const { create } = await import('./creator.C5g4egeG.js');
 	await create();
 }
 async function collect(cliFilters, options) {
 	try {
-		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.Bx28WXzL.js').then(function (n) { return n.g; });
+		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.De07GUeT.js').then(function (n) { return n.g; });
 		const ctx = await prepareVitest({
 			...normalizeCliOptions(cliFilters, options),
 			watch: false,

package/dist/chunks/{cli-api.Bx28WXzL.js → cli-api.De07GUeT.js}

@@ -1,12 +1,12 @@
 import * as fs from 'node:fs';
 import fs__default, { promises, existsSync, writeFileSync, mkdirSync, readFileSync, statSync, readdirSync } from 'node:fs';
 import { r as resolveCoverageProviderModule, g as getCoverageFilesDirectory, C as CoverageProviderMap } from './coverage.cTDc4uSS.js';
-import { o as parse, s as stringify, k as isFileServingAllowed, f as createDebugger, q as hash, t as resolveCoverageReporters, u as createIndexLocationsMap, v as getOutputFile, w as groupBy, x as generateCodeFrame, y as printStack, z as getSpecificationDocblock, A as resolveStaticMocks, C as getStaticMocks, R as RangeLocationFilterProvidedError, I as IncludeTaskLocationDisabledError, D as LocationFilterFileNotFoundError, E as GitCommandError, G as GitNotFoundError, H as VitestResolver, M as ModuleTransformService, l as resolveConfig$1, J as createClusterServer, S as ServerModuleRunner, K as attachProjectsFromEntries, N as TestProject, O as resolveAndAttachProjects, Q as RandomSequencer, b as FilesNotFoundError, U as createPool, W as astCollectTests, X as createFailedFileTask, Y as matchesProjectFilter, Z as nanoid, L as Logger, V as VitestPackageInstaller, P as PluginHarness, _ as stdout, p as prompt } from './index.B8VfM7Mf.js';
+import { o as parse, s as stringify, k as isFileServingAllowed, f as createDebugger, q as hash, t as resolveCoverageReporters, u as createIndexLocationsMap, v as getOutputFile, w as groupBy, x as generateCodeFrame, y as printStack, z as getSpecificationDocblock, A as resolveStaticMocks, C as getStaticMocks, R as RangeLocationFilterProvidedError, I as IncludeTaskLocationDisabledError, D as LocationFilterFileNotFoundError, E as GitCommandError, G as GitNotFoundError, H as VitestResolver, M as ModuleTransformService, l as resolveConfig$1, J as createClusterServer, S as ServerModuleRunner, K as attachProjectsFromEntries, N as TestProject, O as resolveAndAttachProjects, Q as RandomSequencer, b as FilesNotFoundError, U as createPool, W as astCollectTests, X as createFailedFileTask, Y as matchesProjectFilter, Z as nanoid, L as Logger, V as VitestPackageInstaller, P as PluginHarness, _ as stdout, p as prompt } from './index.1TqnEahn.js';
 import { rm, readFile, writeFile, rename, stat, unlink, mkdir, readdir, copyFile } from 'node:fs/promises';
 import os__default, { tmpdir, hostname } from 'node:os';
 import { j as join, b as basename, d as dirname, i as isAbsolute, r as resolve, D as noop, e as createDefer, a as relative, c as cleanUrl, s as slash, F as sanitizeFilePath, t as toArray, G as deepMerge, m as isPrimitive, f as extname, n as normalize, p as deepClone } from './pathe.M-eThtNZ.Ba-7h1rE.js';
 import { T as TraceMap, o as originalPositionFor, p as parseStacktrace, e as parseErrorStacktrace, b as serializeValue } from './source-map.DdKI5IHB.js';
-import { v as version } from './cac.DTXWs6Ni.js';
+import { v as version } from './cac.CLrZKo1g.js';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { c as createBirpc } from './index.DmDMHCg8.js';
 import require$$0$3 from 'events';
@@ -25,7 +25,7 @@ import { A as API_PATH, d as defaultBrowserPort } from './constants.-juJ8b_4.js'
 import { i as isBuiltin } from './modules.BJuCwlRJ.js';
 import crypto, { createHash } from 'node:crypto';
 import { distDir } from '../path.js';
-import { z as limitConcurrency, A as createTagsFilter } from './run.Cm2sd7-x.js';
+import { z as limitConcurrency, A as createTagsFilter } from './run.BPv-BBRv.js';
 import { N as NativeModuleRunner } from './nativeModuleRunner.xi64Afb2.js';
 import { getTestName, hasFailed, hasFailedSnapshot, getTests, getSuites, getTasks, getFullName, createFileTask, generateFileHash, interpretTaskModes, convertTasksToEvents } from '../task-utils.js';
 import { Traces } from '../traces.js';
@@ -5485,12 +5485,19 @@ class WebSocketReporter {
 class BrowserSessions {
 	sessions = /* @__PURE__ */ new Map();
 	sessionIds = /* @__PURE__ */ new Set();
+	// a page can outlive the close of its session and reconnect
+	closedSessionIds = /* @__PURE__ */ new Set();
 	getSession(sessionId) {
 		return this.sessions.get(sessionId);
 	}
 	destroySession(sessionId) {
 		this.sessions.delete(sessionId);
 	}
+	close(sessionId) {
+		this.sessions.delete(sessionId);
+		this.sessionIds.delete(sessionId);
+		this.closedSessionIds.add(sessionId);
+	}
 	createSession(sessionId, project, pool, options) {
 		// this promise waits until the orchestrator is ready to accept RPC calls
 		const defer = createDefer();
@@ -11796,7 +11803,7 @@ class TestRun {
 	}
 	hasFailed(modules) {
 		if (!modules.length) return !this.vitest.config.passWithNoTests;
-		return modules.some((m) => !m.ok());
+		return modules.some((m) => !m.ok() || m.state() === "pending");
 	}
 	// make sure the error always has a "stacks" property
 	syncUpdateStacks(update) {
@@ -11906,7 +11913,7 @@ class GitVCSProvider {
 			if (error instanceof NonZeroExitError) throw new GitCommandError(args, error.output?.stderr.trim() || error.message);
 			throw error;
 		}
-		return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
+		return result.stdout.split("\0").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
 	}
 	async findChangedFiles(options) {
 		const root = this.root || await this.getRoot(options.root);
@@ -11932,6 +11939,7 @@ class GitVCSProvider {
 		return this.resolveFilesWithGitCommand([
 			"diff",
 			"--name-only",
+			"-z",
 			`${hash}...HEAD`
 		]);
 	}
@@ -11939,12 +11947,14 @@ class GitVCSProvider {
 		return this.resolveFilesWithGitCommand([
 			"diff",
 			"--cached",
-			"--name-only"
+			"--name-only",
+			"-z"
 		]);
 	}
 	getUnstagedFiles() {
 		return this.resolveFilesWithGitCommand([
 			"ls-files",
+			"-z",
 			"--other",
 			"--modified",
 			"--exclude-standard"
@@ -13210,11 +13220,16 @@ class Vitest {
 			// after the caller already cleaned up the test files
 			clearTimeout(this._rerunTimer);
 			await this.runningPromise?.catch(noop);
-			const teardownProjects = [...this.projects];
-			if (this.coreWorkspaceProject && !teardownProjects.includes(this.coreWorkspaceProject)) teardownProjects.push(this.coreWorkspaceProject);
+			const teardownProjects = /* @__PURE__ */ new Set();
+			for (const project of this.projects) {
+				// the project that declares browser instances runs their global setup
+				if (project._instanceParent) teardownProjects.add(project._instanceParent);
+				teardownProjects.add(project);
+			}
+			if (this.coreWorkspaceProject) teardownProjects.add(this.coreWorkspaceProject);
 			const teardownErrors = [];
 			// do teardown before closing the server
-			for (const project of teardownProjects.reverse()) await project._teardownGlobalSetup().catch((error) => {
+			for (const project of [...teardownProjects].reverse()) await project._teardownGlobalSetup().catch((error) => {
 				teardownErrors.push(error);
 			});
 			// close the pool (and the browser pages with it) BEFORE the Vite

package/dist/chunks/{creator.CLL8QFMS.js → creator.C5g4egeG.js}

@@ -2,7 +2,7 @@ import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { resolve, dirname, relative } from 'node:path';
 import { detectPackageManager, installPackage } from './index.BoyTG_B7.js';
-import { p as prompt, n as findConfigFile } from './index.B8VfM7Mf.js';
+import { p as prompt, n as findConfigFile } from './index.1TqnEahn.js';
 import { x } from 'tinyexec';
 import { $ } from './tinyrainbow.Do8I1XRG.js';
 import 'node:process';
@@ -32,7 +32,7 @@ import './display.BlTmubjj.js';
 import './index.D0heQG4v.js';
 import 'node:perf_hooks';
 import './source-map.DdKI5IHB.js';
-import './run.Cm2sd7-x.js';
+import './run.BPv-BBRv.js';
 import '../task-utils.js';
 import 'obug';
 import './resolver.CtCcxIy1.js';
@@ -48,7 +48,7 @@ import 'node:events';
 import './index.DmDMHCg8.js';
 import 'node:child_process';
 import 'node:worker_threads';
-import './cac.DTXWs6Ni.js';
+import './cac.CLrZKo1g.js';
 import 'events';
 import 'readline';
 

package/dist/chunks/{doctor.Bqc8NDDb.js → doctor.BK86Cncq.js}

@@ -100,7 +100,7 @@ function log(...args) {
 	console.log(...args);
 }
 async function doctor(cliFilters, options) {
-	const { prepareVitest } = await import('./cli-api.Bx28WXzL.js').then(function (n) { return n.g; });
+	const { prepareVitest } = await import('./cli-api.De07GUeT.js').then(function (n) { return n.g; });
 	log();
 	log($.inverse($.bold($.blue(" DOCTOR "))), "resolving the current configuration...");
 	const ctx = await prepareVitest({

package/dist/chunks/{globals.CTWMSIPL.js → globals.CXEE6_2C.js}

@@ -1,6 +1,6 @@
 import { g as globalApis } from './constants.-juJ8b_4.js';
-import { i as index } from './index.uwTEEBsB.js';
-import './run.Cm2sd7-x.js';
+import { i as index } from './index.aTZaPVhf.js';
+import './run.BPv-BBRv.js';
 import './index.D0heQG4v.js';
 import './tinyrainbow.Do8I1XRG.js';
 import './display.BlTmubjj.js';

package/dist/chunks/{index.B8VfM7Mf.js → index.1TqnEahn.js}

@@ -1,4 +1,4 @@
-import { promises, existsSync, mkdirSync, readFileSync, writeFileSync, linkSync, renameSync, rmSync, chmodSync, statfsSync, realpathSync, statSync, readdirSync } from 'node:fs';
+import { promises, existsSync, mkdirSync, writeFileSync, linkSync, renameSync, rmSync, chmodSync, readFileSync, statfsSync, realpathSync, statSync, readdirSync } from 'node:fs';
 import url, { pathToFileURL, fileURLToPath } from 'node:url';
 import { c as cleanUrl, r as resolve, f as extname, d as dirname, j as join, h as KNOWN_ASSET_RE, H as withTrailingSlash, I as wrapId, i as isAbsolute, J as isExternalUrl, L as unwrapId, a as relative, z as unique, s as slash, t as toArray, b as basename, m as isPrimitive, n as normalize, G as deepMerge, e as createDefer, p as deepClone } from './pathe.M-eThtNZ.Ba-7h1rE.js';
 import { N as NativeModuleRunner, i as isPackageExists, r as resolveModule } from './nativeModuleRunner.xi64Afb2.js';
@@ -24,7 +24,7 @@ import { i as inspect } from './display.BlTmubjj.js';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { T as TraceMap, o as originalPositionFor, i as generatedPositionFor, j as eachMapping, k as stackIgnorePatterns, e as parseErrorStacktrace } from './source-map.DdKI5IHB.js';
 import { x } from 'tinyexec';
-import { B as validateTags, z as limitConcurrency, C as shuffle } from './run.Cm2sd7-x.js';
+import { B as validateTags, z as limitConcurrency, C as shuffle } from './run.BPv-BBRv.js';
 import { createDebug } from 'obug';
 import { createFileTask as createFileTask$1, createTaskName, calculateSuiteHash, convertTasksToEvents, hasFailed, generateFileHash } from '../task-utils.js';
 import { readFile, mkdir, writeFile, rm, stat } from 'node:fs/promises';
@@ -45,7 +45,7 @@ import EventEmitter$1, { EventEmitter } from 'node:events';
 import { c as createBirpc } from './index.DmDMHCg8.js';
 import { fork } from 'node:child_process';
 import { Worker } from 'node:worker_threads';
-import { v as version$1 } from './cac.DTXWs6Ni.js';
+import { v as version$1 } from './cac.CLrZKo1g.js';
 import { g as getDefaultExportFromCjs } from './index.D0heQG4v.js';
 import require$$0 from 'readline';
 import require$$0$1 from 'events';
@@ -1865,7 +1865,12 @@ async function createClusterServer(vitest, viteConfig, config, children) {
 	// listen on startup only for `api`/`ui`, otherwise on the first browser launch
 	// (collect-only processes never listen, so Vite never starts a dependency scan)
 	if (config._apiRequested) await server.listen(config.api.port);
-	else deferredListen.set(server, { port: config.api.port });
+	else {
+		deferredListen.set(server, { port: config.api.port });
+		// Vite runs plugin buildStart hooks on listen; global setup and --changed
+		// transform modules before the first browser launch
+		await server.environments.client.pluginContainer.buildStart();
+	}
 	contribution.setupRpc(parent);
 	return {
 		server,
@@ -1883,6 +1888,70 @@ function generateScopedClassName(strategy, name, filename) {
 	return `_${name}_${generateCssFilenameHash(filename)}`;
 }
 
+const API_TOKEN_FILE = ".vitest-secret-token";
+// Follows env-paths' user data directory conventions:
+// https://github.com/sindresorhus/env-paths/blob/v4.0.0/index.js
+function getUserDataDir() {
+	if (process.platform === "win32") return process.env.LOCALAPPDATA || join(homedir(), "AppData/Local");
+	if (process.platform === "darwin") return join(homedir(), "Library/Application Support");
+	return process.env.XDG_DATA_HOME || join(homedir(), ".local/share");
+}
+function readPublishedToken(tokenPath) {
+	try {
+		return readFileSync(tokenPath, "utf-8").trim() || void 0;
+	} catch {
+		return;
+	}
+}
+function resolveTokenFromPath(tokenPath) {
+	const published = readPublishedToken(tokenPath);
+	if (published) return {
+		token: published,
+		tokenCreated: false
+	};
+	const dir = dirname(tokenPath);
+	mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const token = crypto.randomUUID();
+	const pendingPath = join(dir, `${API_TOKEN_FILE}.${process.pid}.${crypto.randomUUID()}`);
+	writeFileSync(pendingPath, `${token}\n`, { mode: 384 });
+	let tokenCreated = true;
+	try {
+		// linking fails when another process already published, which keeps a single winner
+		linkSync(pendingPath, tokenPath);
+	} catch (error) {
+		if (error.code === "EEXIST") tokenCreated = false;
+		else renameSync(pendingPath, tokenPath);
+	} finally {
+		rmSync(pendingPath, { force: true });
+	}
+	const winner = readPublishedToken(tokenPath);
+	if (!tokenCreated && !winner) {
+		writeFileSync(tokenPath, `${token}\n`, { mode: 384 });
+		tokenCreated = true;
+	}
+	try {
+		chmodSync(dir, 448);
+		chmodSync(tokenPath, 384);
+	} catch {}
+	return {
+		token: (tokenCreated ? token : winner) ?? token,
+		tokenCreated
+	};
+}
+function resolveApiToken(root) {
+	const tokenPaths = [join(getUserDataDir(), "vitest", API_TOKEN_FILE), join(searchForWorkspaceRoot(root), "node_modules/.vitest", API_TOKEN_FILE)];
+	for (const tokenPath of tokenPaths) try {
+		return {
+			...resolveTokenFromPath(tokenPath),
+			tokenPath
+		};
+	} catch {}
+	throw new Error(`Failed to create Vitest API token at ${tokenPaths.join(" or ")}`);
+}
+
 function resolveTestCacheDir(root, testConfig, viteCacheDir) {
 	const name = testConfig.name;
 	const label = typeof name === "string" ? name : name?.label || "";
@@ -1976,6 +2045,23 @@ function deleteDefineConfig(viteConfig) {
 		scriptDefines
 	};
 }
+// TODO: use Vite's own defaults once they are exported (request upstream)
+// copied from Vite 8.3 https://github.com/vitejs/vite/blob/v8.3.4/packages/vite/src/node/server/index.ts#L1254-L1261
+const VITE_DEFAULT_FS_DENY = [
+	".env",
+	".env.*",
+	"*.{crt,pem,key,p12,pfx,cer,der}",
+	".npmrc",
+	".yarnrc.yml",
+	"**/.git/**"
+];
+// Vite drops its default `server.fs.deny` once any value is set,
+// so the defaults are kept explicitly when the user didn't set one.
+function appendApiTokenFsDeny(viteConfig) {
+	viteConfig.server ??= {};
+	viteConfig.server.fs ??= {};
+	viteConfig.server.fs.deny = [...viteConfig.server.fs.deny ?? VITE_DEFAULT_FS_DENY, API_TOKEN_FILE];
+}
 function resolveFsAllow(projectRoot, rootConfigFile) {
 	if (!rootConfigFile) return [searchForWorkspaceRoot(projectRoot), rootDir];
 	return [
@@ -3558,6 +3644,7 @@ function VitestCorePlugin(harness) {
 				order: "post",
 				handler(viteConfig) {
 					const root = resolve(viteConfig.test?.root || viteConfig.root || process.cwd());
+					appendApiTokenFsDeny(viteConfig);
 					return {
 						base: "/",
 						root,
@@ -3783,70 +3870,6 @@ function processWildcard(dep, moduleDirectories) {
 	return dep;
 }
 
-const API_TOKEN_FILE = ".vitest-secret-token";
-// Follows env-paths' user data directory conventions:
-// https://github.com/sindresorhus/env-paths/blob/v4.0.0/index.js
-function getUserDataDir() {
-	if (process.platform === "win32") return process.env.LOCALAPPDATA || join(homedir(), "AppData/Local");
-	if (process.platform === "darwin") return join(homedir(), "Library/Application Support");
-	return process.env.XDG_DATA_HOME || join(homedir(), ".local/share");
-}
-function readPublishedToken(tokenPath) {
-	try {
-		return readFileSync(tokenPath, "utf-8").trim() || void 0;
-	} catch {
-		return;
-	}
-}
-function resolveTokenFromPath(tokenPath) {
-	const published = readPublishedToken(tokenPath);
-	if (published) return {
-		token: published,
-		tokenCreated: false
-	};
-	const dir = dirname(tokenPath);
-	mkdirSync(dir, {
-		recursive: true,
-		mode: 448
-	});
-	const token = crypto.randomUUID();
-	const pendingPath = join(dir, `${API_TOKEN_FILE}.${process.pid}.${crypto.randomUUID()}`);
-	writeFileSync(pendingPath, `${token}\n`, { mode: 384 });
-	let tokenCreated = true;
-	try {
-		// linking fails when another process already published, which keeps a single winner
-		linkSync(pendingPath, tokenPath);
-	} catch (error) {
-		if (error.code === "EEXIST") tokenCreated = false;
-		else renameSync(pendingPath, tokenPath);
-	} finally {
-		rmSync(pendingPath, { force: true });
-	}
-	const winner = readPublishedToken(tokenPath);
-	if (!tokenCreated && !winner) {
-		writeFileSync(tokenPath, `${token}\n`, { mode: 384 });
-		tokenCreated = true;
-	}
-	try {
-		chmodSync(dir, 448);
-		chmodSync(tokenPath, 384);
-	} catch {}
-	return {
-		token: (tokenCreated ? token : winner) ?? token,
-		tokenCreated
-	};
-}
-function resolveApiToken(root) {
-	const tokenPaths = [join(getUserDataDir(), "vitest", API_TOKEN_FILE), join(searchForWorkspaceRoot(root), "node_modules/.vitest", API_TOKEN_FILE)];
-	for (const tokenPath of tokenPaths) try {
-		return {
-			...resolveTokenFromPath(tokenPath),
-			tokenPath
-		};
-	} catch {}
-	throw new Error(`Failed to create Vitest API token at ${tokenPaths.join(" or ")}`);
-}
-
 function ProjectRootPlugin(projectRoot) {
 	return {
 		name: "vitest:project-root",
@@ -3872,16 +3895,14 @@ function WorkspaceVitestPlugin(harness, globalViteConfig) {
 			config(viteConfig) {
 				const testConfig = viteConfig.test || {};
 				const root = testConfig.root || viteConfig.root;
+				appendApiTokenFsDeny(viteConfig);
 				return {
 					base: "/",
 					root,
 					cacheDir: resolveTestCacheDir(resolve(root || process.cwd()), testConfig, viteConfig.cacheDir),
 					server: {
 						open: false,
-						fs: {
-							allow: globalViteConfig.server.fs.allow,
-							deny: [API_TOKEN_FILE]
-						}
+						fs: { allow: globalViteConfig.server.fs.allow }
 					}
 				};
 			},
@@ -4272,7 +4293,7 @@ class RangeLocationFilterProvidedError extends Error {
 }
 
 const debug$1 = createDebugger("vitest:browser:pool");
-const PROVIDER_CLOSE_TIMEOUT = 1e4;
+const PROVIDER_CLOSE_TIMEOUT = 3e4;
 function createBrowserPool(vitest) {
 	// every browser instance is a worker; at most `maxWorkers` of them are open
 	const workers = /* @__PURE__ */ new Map();
@@ -4420,7 +4441,9 @@ function createBrowserPool(vitest) {
 		await Promise.all([...stopping, ...exitPromises]);
 		// pages can be opened outside of the pool (`vitest.standalone`)
 		await Promise.all(vitest.projects.map((project) => closeProvider(project)));
-		vitest._browserSessions.sessionIds.clear();
+		vitest._browserSessions.sessionIds.forEach((sessionId) => {
+			vitest._browserSessions.close(sessionId);
+		});
 		vitest.projects.forEach((project) => {
 			project.browser?.state.orchestrators.forEach((orchestrator) => {
 				orchestrator.$close();
@@ -4638,8 +4661,7 @@ class BrowserWorker {
 		this.busySessions.clear();
 		this.readySessions.clear();
 		await closeProvider(this.project, options);
-		// the pages are closed now, so a late reconnect is not reported as an unknown session
-		sessionIds.forEach((sessionId) => sessions.sessionIds.delete(sessionId));
+		sessionIds.forEach((sessionId) => sessions.close(sessionId));
 		orchestrators.forEach((orchestrator) => orchestrator?.$close());
 	}
 	async openPage(sessionId, options) {
@@ -6478,10 +6500,8 @@ class TestProject {
 	*/
 	getProvidedContext() {
 		if (this.isRootProject()) return this._provided;
-		// globalSetup can run even if core workspace is not part of the test run
-		// so we need to inherit its provided context
 		return {
-			...this.vitest.getRootProject().getProvidedContext(),
+			...(this._instanceParent ?? this.vitest.getRootProject()).getProvidedContext(),
 			...this._provided
 		};
 	}
@@ -6534,10 +6554,14 @@ class TestProject {
 	/** @internal */
 	async _initializeGlobalSetup() {
 		if (this._globalSetups) return;
+		// the project that declares browser instances runs their inherited global setup once
+		const parent = this._instanceParent;
+		await parent?._initializeGlobalSetup();
+		const globalSetup = parent ? toArray(this.config.globalSetup).filter((file) => !parent.config.globalSetup.includes(file)) : this.config.globalSetup;
 		const native = this.runner instanceof NativeModuleRunner;
 		// global setup is imported by this process, so its imports are only known to a resolve hook
 		const canRecord = !native || !this.vitest.config.experimental.recordDependencies || !this.config.globalSetup.length || trackNativeImports();
-		this._globalSetups = await loadGlobalSetupFiles(this.runner, this.config.globalSetup);
+		this._globalSetups = await loadGlobalSetupFiles(this.runner, globalSetup);
 		if (canRecord) this.vitest.cache._dependencies.recordGlobalSetup(this, collectDependencies(native ? nativeImports.getImports : getEvaluatedImports(this.runner.evaluatedModules), this.config.globalSetup));
 		for (const globalSetupFile of this._globalSetups) {
 			const teardown = await globalSetupFile.setup?.(this);
@@ -6655,6 +6679,10 @@ class TestProject {
 	_parentBrowser;
 	/** @internal */
 	_parent;
+	/** @internal */
+	get _instanceParent() {
+		return this._parent?._parentBrowser ? this._parent : void 0;
+	}
 	/**
 	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
 	* If the resources are needed again, create a new project.
@@ -9242,7 +9270,6 @@ async function resolveConfig(options = {}, viteOverrides = {}, pluginsHarness =
 	const rootConfig = resolveTestConfig(pluginsHarness.logger, rootViteConfig.test || {}, rootViteConfig);
 	rootViteConfig.test = rootConfig;
 	rootViteConfig.server.fs.allow.push(...resolveFsAllow(rootViteConfig.root, rootViteConfig.configFile));
-	rootViteConfig.server.fs.deny.push(API_TOKEN_FILE);
 	// the server has been created, we don't need to override vite.server options
 	const { token, tokenCreated } = resolveApiToken(rootViteConfig.root);
 	rootConfig.api.token = token;

package/dist/chunks/{index.CPNMO3h-.js → index.CK-t0WMg.js}

@@ -48,7 +48,9 @@ class BareModuleMocker {
 		return this.registries.get(suite);
 	}
 	reset() {
+		for (const registry of this.registries.values()) for (const url of registry.keys()) this.invalidateModuleById(registry.get(url).id);
 		this.registries.clear();
+		BareModuleMocker.pendingIds = [];
 	}
 	invalidateModuleById(_id) {
 		// implemented by mockers that control the module runner
@@ -304,9 +306,6 @@ class VitestMocker extends BareModuleMocker {
 		if (this.spyModule) return;
 		this.spyModule = await this.moduleRunner.import(spyModulePath);
 	}
-	reset() {
-		this.registries.clear();
-	}
 	invalidateModuleById(id) {
 		const mockId = this.getMockPath(id);
 		const node = this.evaluatedModules.getModuleById(mockId);
@@ -373,7 +372,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			const Object = this.primitives.Object;
 			return this.mockObject(mod, Object.create(Object.prototype), mock.type);
 		}
-		if (mock.type === "manual") return this.callFunctionMock(id, url, mock);
+		if (mock.type === "manual") return this.callFunctionMock(this.getMockPath(id), this.getMockPath(url), mock);
 		const node = await this.moduleRunner.fetchModule(mock.redirect);
 		return this.moduleRunner.cachedRequest(mock.redirect, node, [importer], void 0, true);
 	}
@@ -578,7 +577,6 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 		if (ignoreMock) return this._cachedRequest(url, mod, callstack, metadata);
 		let mocked;
 		if (mod.meta && "mockedModule" in mod.meta) {
-			const mockedModule = mod.meta.mockedModule;
 			const mockId = this.mocker.getMockPath(mod.id);
 			const currentMock = this.mocker.getDependencyMock(mod.id);
 			// bypass mock and force "importActual" behavior when:
@@ -591,7 +589,7 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 				const node = await this.fetchModule(injectQuery(url, "_vitest_original"));
 				return this._cachedRequest(node.url, node, callstack, metadata);
 			}
-			if ((currentMock.type === "automock" || currentMock.type === "autospy") && currentMock !== mockedModule) {
+			if (currentMock.type === "automock" || currentMock.type === "autospy") {
 				const freshNode = await this.fetchModule(injectQuery(url, "_vitest_original"));
 				mocked = await this.mocker.requestWithMockedModule(url, freshNode, callstack, currentMock);
 			} else mocked = await this.mocker.requestWithMockedModule(url, mod, callstack, currentMock);
@@ -769,7 +767,8 @@ function startVitestModuleRunner(options) {
 							id: resolvedMock.id,
 							url: resolvedMock.url,
 							invalidate: false,
-							mockedModule: resolvedMock
+							// the module node outlives the test file, so it must not keep the mock factory alive
+							mockedModule: true
 						};
 					}
 					if (isBuiltin(rawId)) return {

package/dist/chunks/{index.GYMZ12wH.js → index.CoUIxZd4.js}

@@ -2,9 +2,9 @@ import * as chai from 'chai';
 import { createHook } from 'node:async_hooks';
 import { t as takeCoverageInsideWorker } from './coverage.-bm5IxnW.js';
 import { r as rpc } from './rpc.DpkUyY1N.js';
-import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.BABL3z3m.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.HGAqWOnX.js';
 import { g as getWorkerState } from './utils.DYj33du9.js';
-import { T as TestRunner } from './index.uwTEEBsB.js';
+import { T as TestRunner } from './index.aTZaPVhf.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
@@ -50,6 +50,8 @@ function detectAsyncLeaks(testFile, projectName) {
 			} finally {
 				Error.stackTraceLimit = limit;
 			}
+			// a builtin loaded on first use can create pending promises at the module level
+			if (stack.includes("node:internal/bootstrap/realm")) return;
 			if (!stack.includes(testFile)) {
 				const trigger = resources.get(triggerAsyncId);
 				if (!trigger) return;

package/dist/chunks/{index.uwTEEBsB.js → index.aTZaPVhf.js}

@@ -1,4 +1,4 @@
-import { b as printDiffOrStringify, d as diff, a as processError, T as TestSyntaxError, g as getCurrentTest, c as createTaskCollector, e as getCurrentSuite, f as createChainable, h as getHooks, i as getFn, m as matchesTags, j as afterAll, k as afterEach, l as aroundAll, n as aroundEach, o as beforeAll, q as beforeEach, r as describe, t as it, u as onTestFailed, v as onTestFinished, w as recordArtifact, x as suite, y as test } from './run.Cm2sd7-x.js';
+import { b as printDiffOrStringify, d as diff, a as processError, T as TestSyntaxError, g as getCurrentTest, c as createTaskCollector, e as getCurrentSuite, f as createChainable, h as getHooks, i as getFn, m as matchesTags, j as afterAll, k as afterEach, l as aroundAll, n as aroundEach, o as beforeAll, q as beforeEach, r as describe, t as it, u as onTestFailed, v as onTestFinished, w as recordArtifact, x as suite, y as test } from './run.BPv-BBRv.js';
 import { i as isChildProcess, r as resetModules, g as getWorkerState } from './utils.DYj33du9.js';
 import { e as parseErrorStacktrace, a as getSafeTimers, f as parseSingleStack, h as delay } from './source-map.DdKI5IHB.js';
 import { i as isMockFunction, f as fn, a as spyOn, r as restoreAllMocks, b as resetAllMocks, c as clearAllMocks } from './spy.DDMXghXv.js';

package/dist/chunks/{init-forks.CbYYa5xq.js → init-forks.CRxIPOJR.js}

@@ -1,4 +1,4 @@
-import { i as init } from './init.DrHtV5zd.js';
+import { i as init } from './init.PvxYpuCm.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them

package/dist/chunks/{init-threads.DtjdvxPl.js → init-threads.Dv3kwST_.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.DrHtV5zd.js';
+import { i as init } from './init.PvxYpuCm.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {