vitest 3.2.0-beta.1 → 3.2.0-beta.3

package/dist/chunks/{index.DbWBPwtH.js → index.CbT4iuwc.js}

@@ -1,9 +1,9 @@
 import * as chai from 'chai';
 import { resolve } from 'node:path';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.BP6KrF_Z.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.CF-O-dZX.js';
 import { distDir } from '../path.js';
-import { r as rpc } from './rpc.D9_013TY.js';
-import { g as getWorkerState } from './utils.CgTj3MsC.js';
+import { r as rpc } from './rpc.BKExFSRG.js';
+import { g as getWorkerState } from './utils.BlI4TC7Y.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
@@ -11,7 +11,7 @@ function setupChaiConfig(config) {
 
 async function resolveSnapshotEnvironment(config, executor) {
 	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.3xsWotC9.js');
+		const { VitestNodeSnapshotEnvironment } = await import('./node.Be-ntJnD.js');
 		return new VitestNodeSnapshotEnvironment();
 	}
 	const mod = await executor.executeId(config.snapshotEnvironment);
@@ -36,6 +36,7 @@ async function getTestRunnerConstructor(config, executor) {
 async function resolveTestRunner(config, executor) {
 	const TestRunner = await getTestRunnerConstructor(config, executor);
 	const testRunner = new TestRunner(config);
+	// inject private executor to every runner
 	Object.defineProperty(testRunner, "__vitest_executor", {
 		value: executor,
 		enumerable: false,
@@ -49,6 +50,7 @@ async function resolveTestRunner(config, executor) {
 	}
 	const [diffOptions] = await Promise.all([loadDiffConfig(config, executor), loadSnapshotSerializers(config, executor)]);
 	testRunner.config.diffOptions = diffOptions;
+	// patch some methods, so custom runners don't need to call RPC
 	const originalOnTaskUpdate = testRunner.onTaskUpdate;
 	testRunner.onTaskUpdate = async (task, events) => {
 		const p = rpc().onTaskUpdate(task, events);
@@ -66,6 +68,7 @@ async function resolveTestRunner(config, executor) {
 		files.forEach((file) => {
 			file.prepareDuration = state.durations.prepare;
 			file.environmentLoad = state.durations.environment;
+			// should be collected only for a single test file in a batch
 			state.durations.prepare = 0;
 			state.durations.environment = 0;
 		});

package/dist/chunks/index.D3XRDfWc.js

@@ -0,0 +1,213 @@
+import process from 'node:process';
+import fs from 'node:fs/promises';
+import path, { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { x } from 'tinyexec';
+
+const AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "bun",
+  "deno"
+];
+const LOCKS = {
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "deno.lock": "deno",
+  "pnpm-lock.yaml": "pnpm",
+  "pnpm-workspace.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+const INSTALL_METADATA = {
+  "node_modules/.deno/": "deno",
+  "node_modules/.pnpm/": "pnpm",
+  "node_modules/.yarn-state.yml": "yarn",
+  // yarn v2+ (node-modules)
+  "node_modules/.yarn_integrity": "yarn",
+  // yarn v1
+  "node_modules/.package-lock.json": "npm",
+  ".pnp.cjs": "yarn",
+  // yarn v3+ (pnp)
+  ".pnp.js": "yarn",
+  // yarn v2 (pnp)
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
+
+async function pathExists(path2, type) {
+  try {
+    const stat = await fs.stat(path2);
+    return type === "file" ? stat.isFile() : stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function* lookup(cwd = process.cwd()) {
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = path.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, onUnknown) {
+  return !filepath || !pathExists(filepath, "file") ? null : await handlePackageManager(filepath, onUnknown);
+}
+async function detect(options = {}) {
+  const {
+    cwd,
+    strategies = ["lockfile", "packageManager-field", "devEngines-field"],
+    onUnknown
+  } = options;
+  let stopDir;
+  if (typeof options.stopDir === "string") {
+    const resolved = path.resolve(options.stopDir);
+    stopDir = (dir) => dir === resolved;
+  } else {
+    stopDir = options.stopDir;
+  }
+  for (const directory of lookup(cwd)) {
+    for (const strategy of strategies) {
+      switch (strategy) {
+        case "lockfile": {
+          for (const lock of Object.keys(LOCKS)) {
+            if (await pathExists(path.join(directory, lock), "file")) {
+              const name = LOCKS[lock];
+              const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+              if (result)
+                return result;
+              else
+                return { name, agent: name };
+            }
+          }
+          break;
+        }
+        case "packageManager-field":
+        case "devEngines-field": {
+          const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+          if (result)
+            return result;
+          break;
+        }
+        case "install-metadata": {
+          for (const metadata of Object.keys(INSTALL_METADATA)) {
+            const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+            if (await pathExists(path.join(directory, metadata), fileOrDir)) {
+              const name = INSTALL_METADATA[metadata];
+              const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+              return { name, agent };
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (stopDir?.(directory))
+      break;
+  }
+  return null;
+}
+function getNameAndVer(pkg) {
+  const handelVer = (version) => version?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version;
+  if (typeof pkg.packageManager === "string") {
+    const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+    return { name, ver: handelVer(ver) };
+  }
+  if (typeof pkg.devEngines?.packageManager?.name === "string") {
+    return {
+      name: pkg.devEngines.packageManager.name,
+      ver: handelVer(pkg.devEngines.packageManager.version)
+    };
+  }
+  return void 0;
+}
+async function handlePackageManager(filepath, onUnknown) {
+  try {
+    const pkg = JSON.parse(await fs.readFile(filepath, "utf8"));
+    let agent;
+    const nameAndVer = getNameAndVer(pkg);
+    if (nameAndVer) {
+      const name = nameAndVer.name;
+      const ver = nameAndVer.ver;
+      let version = ver;
+      if (name === "yarn" && ver && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version = "berry";
+        return { name, agent, version };
+      } else if (name === "pnpm" && ver && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version };
+      } else {
+        return onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function isMetadataYarnClassic(metadataPath) {
+  return metadataPath.endsWith(".yarn_integrity");
+}
+
+// src/detect.ts
+async function detectPackageManager(cwd = process.cwd()) {
+  const result = await detect({
+    cwd,
+    onUnknown(packageManager) {
+      console.warn("[@antfu/install-pkg] Unknown packageManager:", packageManager);
+      return void 0;
+    }
+  });
+  return result?.agent || null;
+}
+async function installPackage(names, options = {}) {
+  const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
+  const [agent] = detectedAgent.split("@");
+  if (!Array.isArray(names))
+    names = [names];
+  const args = (typeof options.additionalArgs === "function" ? options.additionalArgs(agent, detectedAgent) : options.additionalArgs) || [];
+  if (options.preferOffline) {
+    if (detectedAgent === "yarn@berry")
+      args.unshift("--cached");
+    else
+      args.unshift("--prefer-offline");
+  }
+  if (agent === "pnpm") {
+    args.unshift(
+      /**
+       * Prevent pnpm from removing installed devDeps while `NODE_ENV` is `production`
+       * @see https://pnpm.io/cli/install#--prod--p
+       */
+      "--prod=false"
+    );
+    if (existsSync(resolve(options.cwd ?? process.cwd(), "pnpm-workspace.yaml"))) {
+      args.unshift("-w");
+    }
+  }
+  return x(
+    agent,
+    [
+      agent === "yarn" ? "add" : "install",
+      options.dev ? "-D" : "",
+      ...args,
+      ...names
+    ].filter(Boolean),
+    {
+      nodeOptions: {
+        stdio: options.silent ? "ignore" : "inherit",
+        cwd: options.cwd
+      },
+      throwOnError: true
+    }
+  );
+}
+
+export { detectPackageManager, installPackage };

package/dist/chunks/{index.BPc7M5ni.js → index.DNgLEKsQ.js}

@@ -1,20 +1,14 @@
-import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.BFR5YIgu.js';
-import { i as isFirstRun, a as runOnce } from './run-once.Dimr7O9f.js';
-import { b as bench } from './benchmark.BoF7jW0Q.js';
+import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.pkoYCV6A.js';
+import { b as bench } from './benchmark.Cf_PACH1.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 import * as chai from 'chai';
 import { assert, should } from 'chai';
 
-function getRunningMode() {
-	return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
-}
-function isWatchMode() {
-	return getRunningMode() === "watch";
-}
-
 const assertType = function assertType() {};
 
+// TODO: deprecate <reference types="vitest" /> in favor of `<reference types="vitest/config" />`
+
 var VitestIndex = /*#__PURE__*/Object.freeze({
   __proto__: null,
   afterAll: afterAll,
@@ -29,14 +23,10 @@ var VitestIndex = /*#__PURE__*/Object.freeze({
   describe: describe,
   expect: globalExpect,
   expectTypeOf: expectTypeOf,
-  getRunningMode: getRunningMode,
   inject: inject,
-  isFirstRun: isFirstRun,
-  isWatchMode: isWatchMode,
   it: it,
   onTestFailed: onTestFailed,
   onTestFinished: onTestFinished,
-  runOnce: runOnce,
   should: should,
   suite: suite,
   test: test,
@@ -44,4 +34,4 @@ var VitestIndex = /*#__PURE__*/Object.freeze({
   vitest: vitest
 });
 
-export { VitestIndex as V, assertType as a, getRunningMode as g, isWatchMode as i };
+export { VitestIndex as V, assertType as a };

package/dist/chunks/index.JOzufsrU.js

@@ -0,0 +1,276 @@
+import fs from 'node:fs';
+import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
+import * as pathe from 'pathe';
+import c from 'tinyrainbow';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName } from './index.Bter3jj9.js';
+import { stripVTControlCharacters } from 'node:util';
+import { notNullish } from '@vitest/utils';
+
+function createBenchmarkJsonReport(files) {
+	const report = { files: [] };
+	for (const file of files) {
+		const groups = [];
+		for (const task of getTasks(file)) {
+			if (task?.type === "suite") {
+				const benchmarks = [];
+				for (const t of task.tasks) {
+					const benchmark = t.meta.benchmark && t.result?.benchmark;
+					if (benchmark) {
+						benchmarks.push({
+							id: t.id,
+							...benchmark,
+							samples: []
+						});
+					}
+				}
+				if (benchmarks.length) {
+					groups.push({
+						fullName: getFullName(task, " > "),
+						benchmarks
+					});
+				}
+			}
+		}
+		report.files.push({
+			filepath: file.filepath,
+			groups
+		});
+	}
+	return report;
+}
+function flattenFormattedBenchmarkReport(report) {
+	const flat = {};
+	for (const file of report.files) {
+		for (const group of file.groups) {
+			for (const t of group.benchmarks) {
+				flat[t.id] = t;
+			}
+		}
+	}
+	return flat;
+}
+
+const outputMap = new WeakMap();
+function formatNumber(number) {
+	const res = String(number.toFixed(number < 100 ? 4 : 2)).split(".");
+	return res[0].replace(/(?=(?:\d{3})+$)\B/g, ",") + (res[1] ? `.${res[1]}` : "");
+}
+const tableHead = [
+	"name",
+	"hz",
+	"min",
+	"max",
+	"mean",
+	"p75",
+	"p99",
+	"p995",
+	"p999",
+	"rme",
+	"samples"
+];
+function renderBenchmarkItems(result) {
+	return [
+		result.name,
+		formatNumber(result.hz || 0),
+		formatNumber(result.min || 0),
+		formatNumber(result.max || 0),
+		formatNumber(result.mean || 0),
+		formatNumber(result.p75 || 0),
+		formatNumber(result.p99 || 0),
+		formatNumber(result.p995 || 0),
+		formatNumber(result.p999 || 0),
+		`±${(result.rme || 0).toFixed(2)}%`,
+		(result.sampleCount || 0).toString()
+	];
+}
+function computeColumnWidths(results) {
+	const rows = [tableHead, ...results.map((v) => renderBenchmarkItems(v))];
+	return Array.from(tableHead, (_, i) => Math.max(...rows.map((row) => stripVTControlCharacters(row[i]).length)));
+}
+function padRow(row, widths) {
+	return row.map((v, i) => i ? v.padStart(widths[i], " ") : v.padEnd(widths[i], " "));
+}
+function renderTableHead(widths) {
+	return " ".repeat(3) + padRow(tableHead, widths).map(c.bold).join("  ");
+}
+function renderBenchmark(result, widths) {
+	const padded = padRow(renderBenchmarkItems(result), widths);
+	return [
+		padded[0],
+		c.blue(padded[1]),
+		c.cyan(padded[2]),
+		c.cyan(padded[3]),
+		c.cyan(padded[4]),
+		c.cyan(padded[5]),
+		c.cyan(padded[6]),
+		c.cyan(padded[7]),
+		c.cyan(padded[8]),
+		c.dim(padded[9]),
+		c.dim(padded[10])
+	].join("  ");
+}
+function renderTable(options) {
+	const output = [];
+	const benchMap = {};
+	for (const task of options.tasks) {
+		if (task.meta.benchmark && task.result?.benchmark) {
+			benchMap[task.id] = {
+				current: task.result.benchmark,
+				baseline: options.compare?.[task.id]
+			};
+		}
+	}
+	const benchCount = Object.entries(benchMap).length;
+	const columnWidths = computeColumnWidths(Object.values(benchMap).flatMap((v) => [v.current, v.baseline]).filter(notNullish));
+	let idx = 0;
+	const padding = "  ".repeat(1 );
+	for (const task of options.tasks) {
+		const duration = task.result?.duration;
+		const bench = benchMap[task.id];
+		let prefix = "";
+		if (idx === 0 && task.meta?.benchmark) {
+			prefix += `${renderTableHead(columnWidths)}\n${padding}`;
+		}
+		prefix += ` ${getStateSymbol(task)} `;
+		let suffix = "";
+		if (task.type === "suite") {
+			suffix += c.dim(` (${getTests(task).length})`);
+		}
+		if (task.mode === "skip" || task.mode === "todo") {
+			suffix += c.dim(c.gray(" [skipped]"));
+		}
+		if (duration != null) {
+			const color = duration > options.slowTestThreshold ? c.yellow : c.green;
+			suffix += color(` ${Math.round(duration)}${c.dim("ms")}`);
+		}
+		if (options.showHeap && task.result?.heap != null) {
+			suffix += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
+		}
+		if (bench) {
+			let body = renderBenchmark(bench.current, columnWidths);
+			if (options.compare && bench.baseline) {
+				if (bench.current.hz) {
+					const diff = bench.current.hz / bench.baseline.hz;
+					const diffFixed = diff.toFixed(2);
+					if (diffFixed === "1.0.0") {
+						body += c.gray(`  [${diffFixed}x]`);
+					}
+					if (diff > 1) {
+						body += c.blue(`  [${diffFixed}x] ⇑`);
+					} else {
+						body += c.red(`  [${diffFixed}x] ⇓`);
+					}
+				}
+				output.push(padding + prefix + body + suffix);
+				const bodyBaseline = renderBenchmark(bench.baseline, columnWidths);
+				output.push(`${padding}   ${bodyBaseline}  ${c.dim("(baseline)")}`);
+			} else {
+				if (bench.current.rank === 1 && benchCount > 1) {
+					body += c.bold(c.green("   fastest"));
+				}
+				if (bench.current.rank === benchCount && benchCount > 2) {
+					body += c.bold(c.gray("   slowest"));
+				}
+				output.push(padding + prefix + body + suffix);
+			}
+		} else {
+			output.push(padding + prefix + task.name + suffix);
+		}
+		if (task.result?.state !== "pass" && outputMap.get(task) != null) {
+			let data = outputMap.get(task);
+			if (typeof data === "string") {
+				data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop());
+				if (data === "") {
+					data = undefined;
+				}
+			}
+			if (data != null) {
+				const out = `   ${"  ".repeat(options.level)}${F_RIGHT} ${data}`;
+				output.push(c.gray(truncateString(out, options.columns)));
+			}
+		}
+		idx++;
+	}
+	return output.filter(Boolean).join("\n");
+}
+
+class BenchmarkReporter extends DefaultReporter {
+	compare;
+	async onInit(ctx) {
+		super.onInit(ctx);
+		if (this.ctx.config.benchmark?.compare) {
+			const compareFile = pathe.resolve(this.ctx.config.root, this.ctx.config.benchmark?.compare);
+			try {
+				this.compare = flattenFormattedBenchmarkReport(JSON.parse(await fs.promises.readFile(compareFile, "utf-8")));
+			} catch (e) {
+				this.error(`Failed to read '${compareFile}'`, e);
+			}
+		}
+	}
+	onTaskUpdate(packs) {
+		for (const pack of packs) {
+			const task = this.ctx.state.idMap.get(pack[0]);
+			if (task?.type === "suite" && task.result?.state !== "run") {
+				task.tasks.filter((task) => task.result?.benchmark).sort((benchA, benchB) => benchA.result.benchmark.mean - benchB.result.benchmark.mean).forEach((bench, idx) => {
+					bench.result.benchmark.rank = Number(idx) + 1;
+				});
+			}
+		}
+	}
+	onTestSuiteResult(testSuite) {
+		super.onTestSuiteResult(testSuite);
+		this.printSuiteTable(testSuite);
+	}
+	printTestModule(testModule) {
+		this.printSuiteTable(testModule);
+	}
+	printSuiteTable(testTask) {
+		const state = testTask.state();
+		if (state === "pending" || state === "queued") {
+			return;
+		}
+		const benches = testTask.task.tasks.filter((t) => t.meta.benchmark);
+		const duration = testTask.task.result?.duration || 0;
+		if (benches.length > 0 && benches.every((t) => t.result?.state !== "run" && t.result?.state !== "queued")) {
+			let title = `\n ${getStateSymbol(testTask.task)} ${formatProjectName(testTask.project)}${getFullName(testTask.task, c.dim(" > "))}`;
+			if (duration != null && duration > this.ctx.config.slowTestThreshold) {
+				title += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
+			}
+			this.log(title);
+			this.log(renderTable({
+				tasks: benches,
+				level: 1,
+				columns: this.ctx.logger.getColumns(),
+				compare: this.compare,
+				showHeap: this.ctx.config.logHeapUsage,
+				slowTestThreshold: this.ctx.config.slowTestThreshold
+			}));
+		}
+	}
+	async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
+		super.onFinished(files, errors);
+		// write output for future comparison
+		let outputFile = this.ctx.config.benchmark?.outputJson;
+		if (outputFile) {
+			outputFile = pathe.resolve(this.ctx.config.root, outputFile);
+			const outputDirectory = pathe.dirname(outputFile);
+			if (!fs.existsSync(outputDirectory)) {
+				await fs.promises.mkdir(outputDirectory, { recursive: true });
+			}
+			const output = createBenchmarkJsonReport(files);
+			await fs.promises.writeFile(outputFile, JSON.stringify(output, null, 2));
+			this.log(`Benchmark report written to ${outputFile}`);
+		}
+	}
+}
+
+class VerboseBenchmarkReporter extends BenchmarkReporter {
+	verbose = true;
+}
+
+const BenchmarkReportsMap = {
+	default: BenchmarkReporter,
+	verbose: VerboseBenchmarkReporter
+};
+
+export { BenchmarkReporter as B, VerboseBenchmarkReporter as V, BenchmarkReportsMap as a };

package/dist/chunks/{index.DBIGubLC.js → index.X0nbfr6-.js}

@@ -1,4 +1,4 @@
-import p from 'node:path';
+import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import process$1 from 'node:process';
 import { promises } from 'node:fs';
@@ -237,7 +237,7 @@ async function locatePath(
 
 	return pLocate(paths, async path_ => {
 		try {
-			const stat = await statFunction(p.resolve(cwd, path_));
+			const stat = await statFunction(path.resolve(cwd, path_));
 			return matchType(type, stat);
 		} catch {
 			return false;
@@ -250,9 +250,9 @@ const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath)
 const findUpStop = Symbol('findUpStop');
 
 async function findUpMultiple(name, options = {}) {
-	let directory = p.resolve(toPath(options.cwd) || '');
-	const {root} = p.parse(directory);
-	const stopAt = p.resolve(directory, options.stopAt || root);
+	let directory = path.resolve(toPath(options.cwd) || '');
+	const {root} = path.parse(directory);
+	const stopAt = path.resolve(directory, options.stopAt || root);
 	const limit = options.limit || Number.POSITIVE_INFINITY;
 	const paths = [name].flat();
 
@@ -280,14 +280,14 @@ async function findUpMultiple(name, options = {}) {
 		}
 
 		if (foundPath) {
-			matches.push(p.resolve(directory, foundPath));
+			matches.push(path.resolve(directory, foundPath));
 		}
 
 		if (directory === stopAt || matches.length >= limit) {
 			break;
 		}
 
-		directory = p.dirname(directory);
+		directory = path.dirname(directory);
 	}
 
 	return matches;

package/dist/chunks/{inspector.DbDkSkFn.js → inspector.BFsh5KO0.js}

@@ -13,11 +13,13 @@ function setupInspect(ctx) {
 	const isEnabled = config.inspector.enabled;
 	if (isEnabled) {
 		inspector = __require("node:inspector");
+		// Inspector may be open already if "isolate: false" is used
 		const isOpen = inspector.url() !== undefined;
 		if (!isOpen) {
 			inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger);
 			if (config.inspectBrk) {
 				const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
+				// Stop at first test file
 				if (firstTestFile) {
 					session = new inspector.Session();
 					session.connect();
@@ -46,6 +48,7 @@ function closeInspector(config) {
 	}
 }
 function shouldKeepOpen(config) {
+	// In watch mode the inspector can persist re-runs if isolation is disabled and a single worker is used
 	const isIsolatedSingleThread = config.pool === "threads" && config.poolOptions?.threads?.isolate === false && config.poolOptions?.threads?.singleThread;
 	const isIsolatedSingleFork = config.pool === "forks" && config.poolOptions?.forks?.isolate === false && config.poolOptions?.forks?.singleFork;
 	return config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);

package/dist/chunks/{node.3xsWotC9.js → node.Be-ntJnD.js}

@@ -1,5 +1,5 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.CgTj3MsC.js';
+import { g as getWorkerState } from './utils.BlI4TC7Y.js';
 import '@vitest/utils';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {