vitest 4.0.0-beta.9 → 4.0.1

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

@@ -1,301 +1,60 @@
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import process$1 from 'node:process';
-import { promises } from 'node:fs';
+import { resolve, isAbsolute, dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import 'node:module';
+import 'node:url';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import require$$0 from 'readline';
 import require$$0$1 from 'events';
 
-function _mergeNamespaces(n, m) {
-	m.forEach(function (e) {
-		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-			if (k !== 'default' && !(k in n)) {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	});
-	return Object.freeze(n);
-}
-
-/*
-How it works:
-`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+/**
+* Resolve an absolute path from {@link root}, but only
+* if {@link input} isn't already absolute.
+*
+* @param input The path to resolve.
+* @param root The base path; default = process.cwd()
+* @returns The resolved absolute path.
 */
-
-class Node {
-	value;
-	next;
-
-	constructor(value) {
-		this.value = value;
-	}
-}
-
-class Queue {
-	#head;
-	#tail;
-	#size;
-
-	constructor() {
-		this.clear();
-	}
-
-	enqueue(value) {
-		const node = new Node(value);
-
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-
-		this.#size++;
-	}
-
-	dequeue() {
-		const current = this.#head;
-		if (!current) {
-			return;
-		}
-
-		this.#head = this.#head.next;
-		this.#size--;
-		return current.value;
-	}
-
-	clear() {
-		this.#head = undefined;
-		this.#tail = undefined;
-		this.#size = 0;
-	}
-
-	get size() {
-		return this.#size;
-	}
-
-	* [Symbol.iterator]() {
-		let current = this.#head;
-
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-}
-
-function pLimit(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
-	}
-
-	const queue = new Queue();
-	let activeCount = 0;
-
-	const next = () => {
-		activeCount--;
-
-		if (queue.size > 0) {
-			queue.dequeue()();
-		}
-	};
-
-	const run = async (fn, resolve, args) => {
-		activeCount++;
-
-		const result = (async () => fn(...args))();
-
-		resolve(result);
-
-		try {
-			await result;
-		} catch {}
-
-		next();
-	};
-
-	const enqueue = (fn, resolve, args) => {
-		queue.enqueue(run.bind(undefined, fn, resolve, args));
-
-		(async () => {
-			// This function needs to wait until the next microtask before comparing
-			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-			// when the run function is dequeued and called. The comparison in the if-statement
-			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-			await Promise.resolve();
-
-			if (activeCount < concurrency && queue.size > 0) {
-				queue.dequeue()();
-			}
-		})();
-	};
-
-	const generator = (fn, ...args) => new Promise(resolve => {
-		enqueue(fn, resolve, args);
-	});
-
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount,
-		},
-		pendingCount: {
-			get: () => queue.size,
-		},
-		clearQueue: {
-			value: () => {
-				queue.clear();
-			},
-		},
-	});
-
-	return generator;
-}
-
-class EndError extends Error {
-	constructor(value) {
-		super();
-		this.value = value;
-	}
+function absolute(input, root) {
+	return isAbsolute(input) ? input : resolve(root || ".", input);
 }
 
-// The input can also be a promise, so we await it.
-const testElement = async (element, tester) => tester(await element);
-
-// The input can also be a promise, so we `Promise.all()` them both.
-const finder = async element => {
-	const values = await Promise.all(element);
-	if (values[1] === true) {
-		throw new EndError(values[0]);
-	}
-
-	return false;
-};
-
-async function pLocate(
-	iterable,
-	tester,
-	{
-		concurrency = Number.POSITIVE_INFINITY,
-		preserveOrder = true,
-	} = {},
-) {
-	const limit = pLimit(concurrency);
-
-	// Start all the promises concurrently with optional limit.
-	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
-
-	// Check the promises either serially or concurrently.
-	const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
-
-	try {
-		await Promise.all(items.map(element => checkLimit(finder, element)));
-	} catch (error) {
-		if (error instanceof EndError) {
-			return error.value;
-		}
-
-		throw error;
-	}
-}
-
-const typeMappings = {
-	directory: 'isDirectory',
-	file: 'isFile',
-};
-
-function checkType(type) {
-	if (Object.hasOwnProperty.call(typeMappings, type)) {
-		return;
+/**
+* Get all parent directories of {@link base}.
+* Stops after {@link Options['last']} is processed.
+*
+* @returns An array of absolute paths of all parent directories.
+*/
+function up(base, options) {
+	let { last, cwd } = options || {};
+	let tmp = absolute(base, cwd);
+	let root = absolute(last || "/", cwd);
+	let prev, arr = [];
+	while (prev !== root) {
+		arr.push(tmp);
+		tmp = dirname(prev = tmp);
+		if (tmp === prev) break;
 	}
-
-	throw new Error(`Invalid type specified: ${type}`);
+	return arr;
 }
 
-const matchType = (type, stat) => stat[typeMappings[type]]();
-
-const toPath$1 = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-async function locatePath(
-	paths,
-	{
-		cwd = process$1.cwd(),
-		type = 'file',
-		allowSymlinks = true,
-		concurrency,
-		preserveOrder,
-	} = {},
-) {
-	checkType(type);
-	cwd = toPath$1(cwd);
-
-	const statFunction = allowSymlinks ? promises.stat : promises.lstat;
-
-	return pLocate(paths, async path_ => {
-		try {
-			const stat = await statFunction(path.resolve(cwd, path_));
-			return matchType(type, stat);
-		} catch {
-			return false;
-		}
-	}, {concurrency, preserveOrder});
-}
-
-const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-const findUpStop = Symbol('findUpStop');
-
-async function findUpMultiple(name, options = {}) {
-	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();
-
-	const runMatcher = async locateOptions => {
-		if (typeof name !== 'function') {
-			return locatePath(paths, locateOptions);
-		}
-
-		const foundPath = await name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePath([foundPath], locateOptions);
-		}
-
-		return foundPath;
-	};
-
-	const matches = [];
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		// eslint-disable-next-line no-await-in-loop
-		const foundPath = await runMatcher({...options, cwd: directory});
-
-		if (foundPath === findUpStop) {
-			break;
-		}
-
-		if (foundPath) {
-			matches.push(path.resolve(directory, foundPath));
-		}
-
-		if (directory === stopAt || matches.length >= limit) {
-			break;
+/**
+* Get the first path that matches any of the names provided.
+*
+* > [NOTE]
+* > The order of {@link names} is respected.
+*
+* @param names The item names to find.
+* @returns The absolute path of the first item found, if any.
+*/
+function any(names, options) {
+	let dir, start = options && options.cwd || "";
+	let j = 0, len = names.length, tmp;
+	for (dir of up(start, options)) {
+		for (j = 0; j < len; j++) {
+			tmp = join(dir, names[j]);
+			if (existsSync(tmp)) return tmp;
 		}
-
-		directory = path.dirname(directory);
 	}
-
-	return matches;
-}
-
-async function findUp(name, options = {}) {
-	const matches = await findUpMultiple(name, {...options, limit: 1});
-	return matches[0];
 }
 
 var prompts$2 = {};
@@ -6576,9 +6335,9 @@ function requirePrompts () {
 var promptsExports = requirePrompts();
 var prompt = /*@__PURE__*/getDefaultExportFromCjs(promptsExports);
 
-var index = /*#__PURE__*/_mergeNamespaces({
+var index = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	default: prompt
-}, [promptsExports]);
+});
 
-export { findUp as f, index as i, prompt as p };
+export { any as a, index as i, prompt as p };

package/dist/chunks/{index.C832ioot.js → index.RwjEGCQ0.js}

@@ -1,15 +1,15 @@
-import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.BB37KeLx.js';
-import { b as bench } from './benchmark.CJUa-Hsa.js';
+import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.BZvkKVkM.js';
+import { b as bench } from './benchmark.DHKMYAts.js';
+import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
-import { EvaluatedModules } from 'vite/module-runner';
 import { chai } from '@vitest/expect';
 
 const assertType = function assertType() {};
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  EvaluatedModules: EvaluatedModules,
+  EvaluatedModules: VitestEvaluatedModules,
   afterAll: afterAll,
   afterEach: afterEach,
   assert: assert,

package/dist/chunks/init-forks.WglB-sfY.js

@@ -0,0 +1,54 @@
+import v8 from 'node:v8';
+import { i as init } from './init.94FWN9pW.js';
+
+if (!process.send) throw new Error("Expected worker to be run in node:child_process");
+// Store globals in case tests overwrite them
+const processExit = process.exit.bind(process), processSend = process.send.bind(process), processOn = process.on.bind(process), processOff = process.off.bind(process), processRemoveAllListeners = process.removeAllListeners.bind(process);
+// Work-around for nodejs/node#55094
+if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"))) processOn("SIGTERM", () => processExit());
+function workerInit(options) {
+	const { runTests } = options;
+	init({
+		post: (v) => processSend(v),
+		on: (cb) => processOn("message", cb),
+		off: (cb) => processOff("message", cb),
+		teardown: () => processRemoveAllListeners("message"),
+		serialize: v8.serialize,
+		deserialize: (v) => v8.deserialize(Buffer.from(v)),
+		runTests: (state) => executeTests("run", state),
+		collectTests: (state) => executeTests("collect", state)
+	});
+	async function executeTests(method, state) {
+		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
+		try {
+			await runTests(method, state);
+		} finally {
+			process.exit = processExit;
+		}
+	}
+}
+/**
+* Reverts the wrapping done by `wrapSerializableConfig` in {@link file://./../../node/pool/runtimes/forks.ts}
+*/
+function unwrapSerializableConfig(config) {
+	if (config.testNamePattern && typeof config.testNamePattern === "string") {
+		const testNamePattern = config.testNamePattern;
+		if (testNamePattern.startsWith("$$vitest:")) 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]) : /$^/;
+}
+
+export { workerInit as w };

package/dist/chunks/init-threads.Czek6eA5.js

@@ -0,0 +1,17 @@
+import { isMainThread, parentPort } from 'node:worker_threads';
+import { i as init } from './init.94FWN9pW.js';
+
+if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
+function workerInit(options) {
+	const { runTests } = options;
+	init({
+		post: (response) => parentPort.postMessage(response),
+		on: (callback) => parentPort.on("message", callback),
+		off: (callback) => parentPort.off("message", callback),
+		teardown: () => parentPort.removeAllListeners("message"),
+		runTests: async (state) => runTests("run", state),
+		collectTests: async (state) => runTests("collect", state)
+	});
+}
+
+export { workerInit as w };

package/dist/chunks/init.94FWN9pW.js

@@ -0,0 +1,213 @@
+import { serializeError } from '@vitest/utils/error';
+import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
+import { readFileSync } from 'node:fs';
+import { isBuiltin } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'pathe';
+import { ModuleRunner } from 'vite/module-runner';
+import { b as VitestTransport } from './startModuleRunner.iF1E9Bt4.js';
+import { e as environments } from './index.CbWINfS7.js';
+import { s as setupInspect } from './inspector.DLZxSeU3.js';
+import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
+import { c as createRuntimeRpc, a as rpcDone } from './rpc.cD77ENhU.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) return {
+						code: readFileSync(result.tmp, "utf-8"),
+						...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 resolvingModules = /* @__PURE__ */ new Set(), globalListeners = /* @__PURE__ */ new Set();
+async function execute(method, ctx, worker) {
+	const prepareStart = performance.now(), cleanups = [setupInspect(ctx)];
+	let environmentLoader;
+	// 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);
+	try {
+		// 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 VitestEvaluatedModules(),
+			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 rpcDone().catch(() => {}), await Promise.all(cleanups.map((fn) => fn())).catch(() => {}), await environmentLoader?.close();
+	}
+}
+function run(ctx, worker) {
+	return execute("run", ctx, worker);
+}
+function collect(ctx, worker) {
+	return execute("collect", ctx, worker);
+}
+async function teardown() {
+	await Promise.all([...globalListeners].map((l) => l()));
+}
+function createImportMetaEnvProxy() {
+	// packages/vitest/src/node/plugins/index.ts:146
+	const booleanKeys = [
+		"DEV",
+		"PROD",
+		"SSR"
+	];
+	return new Proxy(process.env, {
+		get(_, key) {
+			if (typeof key === "string") return booleanKeys.includes(key) ? !!process.env[key] : process.env[key];
+		},
+		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;
+		}
+	});
+}
+
+const __vitest_worker_response__ = true, memoryUsage = process.memoryUsage.bind(process);
+let reportMemory = false;
+/** @experimental */
+function init(worker) {
+	worker.on(onMessage);
+	let runPromise, isRunning = false;
+	function send(response) {
+		worker.post(worker.serialize ? worker.serialize(response) : response);
+	}
+	async function onMessage(rawMessage) {
+		const message = worker.deserialize ? worker.deserialize(rawMessage) : rawMessage;
+		if (message?.__vitest_worker_request__ === true) switch (message.type) {
+			case "start":
+				reportMemory = message.options.reportMemory, send({
+					type: "started",
+					__vitest_worker_response__
+				});
+				break;
+			case "run":
+				// Prevent concurrent execution if worker is already running
+				if (isRunning) {
+					send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error: serializeError(/* @__PURE__ */ new Error("[vitest-worker]: Worker is already running tests"))
+					});
+					return;
+				}
+				isRunning = true, process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
+				try {
+					runPromise = run(message.context, worker).catch((error) => serializeError(error));
+					const error = await runPromise;
+					send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error,
+						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+					});
+				} finally {
+					runPromise = void 0, isRunning = false;
+				}
+				break;
+			case "collect":
+				// Prevent concurrent execution if worker is already running
+				if (isRunning) {
+					send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error: serializeError(/* @__PURE__ */ new Error("[vitest-worker]: Worker is already running tests"))
+					});
+					return;
+				}
+				isRunning = true, process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
+				try {
+					runPromise = collect(message.context, worker).catch((error) => serializeError(error));
+					const error = await runPromise;
+					send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error,
+						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+					});
+				} finally {
+					runPromise = void 0, isRunning = false;
+				}
+				break;
+			case "stop": {
+				await runPromise;
+				const error = await teardown().catch((error) => serializeError(error));
+				send({
+					type: "stopped",
+					error,
+					__vitest_worker_response__
+				}), worker.teardown?.();
+				break;
+			}
+		}
+	}
+}
+
+export { init as i };

package/dist/chunks/{inspector.CvQD-Nie.js → inspector.DLZxSeU3.js}

@@ -10,10 +10,7 @@ let inspector, session;
 function setupInspect(ctx) {
 	const config = ctx.config, isEnabled = config.inspector.enabled;
 	if (isEnabled) {
-		inspector = __require("node:inspector");
-		// Inspector may be open already if "isolate: false" is used
-		const isOpen = inspector.url() !== void 0;
-		if (!isOpen) {
+		if (inspector = __require("node:inspector"), !(inspector.url() !== void 0)) {
 			if (inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger), config.inspectBrk) {
 				const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
 				// Stop at first test file
@@ -35,8 +32,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, isIsolatedSingleFork = config.pool === "forks" && config.poolOptions?.forks?.isolate === false && config.poolOptions?.forks?.singleFork;
-	return config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);
+	return config.watch && config.isolate === false && config.maxWorkers === 1;
 }
 
 export { closeInspector as c, setupInspect as s };