@orkestrel/probe 0.0.24 → 0.0.26

package/dist/src/server/index.js

@@ -4,8 +4,9 @@ import { closeSync, constants, existsSync, ftruncateSync, lstatSync, mkdirSync,
 import { createHash, randomUUID } from "node:crypto";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { attempt, compileGuard, compileSchema, isArray, isError, isNumber, isObject, isRecord, isString, parseJSON, schemaToParameters } from "@orkestrel/contract";
+import { attempt, compileGuard, compileSchema, isArray, isError, isFunction, isNumber, isObject, isRecord, isString, parseJSON, schemaToParameters } from "@orkestrel/contract";
 import { CLAIM_SHAPE, LINT_DEADLINE, LINT_TEARDOWN, PROBE_DEADLINE, PROBE_KEYS, PROBE_RESTARTS, PROBE_SPECIFICATIONS, PROBE_WARM, ProbeError, RUNTIME_PLUGIN, TYPE_MIRROR, computeReceipt, createDestroyedError, formatCheck, formatReceipt, formatSpecification, formatVerdict, isClaim, isDraft, isProbeError, isVerdict, matchesSpecification } from "../core/index.js";
+import { inspectProcess, killTree } from "@orkestrel/process/server";
 import { Emitter } from "@orkestrel/emitter";
 import { createPool, isPoolError } from "@orkestrel/pool";
 import { createLSPClient, isLSPError } from "@orkestrel/lsp";
@@ -13,10 +14,11 @@ import { addAbortListener } from "node:events";
 import { createTimeout } from "@orkestrel/timeout";
 import { createStdioClientTransport } from "@orkestrel/lsp/server";
 import { PassThrough } from "node:stream";
-import { spawn, spawnSync } from "node:child_process";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { spawn } from "node:child_process";
 import { createStdioServer } from "@orkestrel/mcp/server";
 import { createTool, createToolManager } from "@orkestrel/tool";
-//#region src/server/errors.ts
+// src/server/errors.ts
 /**
 * Creates the protocol failure returned when the MCP handshake cannot arm the probe.
 *
@@ -34,8 +36,7 @@ function createHandshakeError(error) {
 		code: error.code
 	});
 }
-//#endregion
-//#region src/server/helpers.ts
+// src/server/helpers.ts
 /**
 * Rewrites one path into the forward-slash spelling this package compares and reports paths in.
 *
@@ -150,13 +151,13 @@ function resolveWorkspaceFile(workspace, target, mutate = false) {
 	if (!mutate) return file;
 	try {
 		const canonical = realpathSync(root);
-		let descendant = root;
-		for (const segment of path.split(sep)) {
-			descendant = resolve(descendant, segment);
+		path.split(sep).reduce((parent, segment) => {
+			if (parent === void 0) return void 0;
+			const descendant = resolve(parent, segment);
 			const outcome = attempt(() => lstatSync(descendant));
 			if (!outcome.success) {
 				const code = readFaultCode(outcome.error);
-				if (code === "ENOENT" || code === "ENOTDIR") break;
+				if (code === "ENOENT" || code === "ENOTDIR") return void 0;
 				throw outcome.error;
 			}
 			if (outcome.value.isSymbolicLink()) throw new ProbeError(`Path crosses a symbolic link: ${target}`, {
@@ -164,12 +165,14 @@ function resolveWorkspaceFile(workspace, target, mutate = false) {
 				code: "refused",
 				context: { path: target }
 			});
-			if (escapesRoot(canonical, realpathSync(descendant))) throw new ProbeError(`Path escapes the workspace: ${target}`, {
+			const resolved = realpathSync(descendant);
+			if (escapesRoot(canonical, resolved)) throw new ProbeError(`Path escapes the workspace: ${target}`, {
 				origin: "claimant",
 				code: "refused",
 				context: { path: target }
 			});
-		}
+			return descendant;
+		}, root);
 	} catch (error) {
 		if (isProbeError(error)) throw error;
 		const code = readFaultCode(error);
@@ -334,14 +337,11 @@ function relativeWorkspaceMessage(workspace, message) {
 	const root = resolve(workspace);
 	const forward = normalizePath(root);
 	const url = pathToFileURL(forward).href;
-	const spellings = /* @__PURE__ */ new Set([
+	return [.../* @__PURE__ */ new Set([
 		url.endsWith("/") ? url : `${url}/`,
 		forward.endsWith("/") ? forward : `${forward}/`,
 		root.endsWith(sep) ? root : `${root}${sep}`
-	]);
-	let text = message;
-	for (const spelling of spellings) text = text.replaceAll(spelling, (match, offset, source) => /[^\s"'`()[\]{}<>,;:=|]/u.test(source.charAt(offset - 1)) ? match : "");
-	return text;
+	])].reduce((text, spelling) => text.replaceAll(spelling, (match, offset, source) => /[^\s"'`()[\]{}<>,;:=|]/u.test(source.charAt(offset - 1)) ? match : ""), message);
 }
 /**
 * Scans the plain-text output of one compiler run into the diagnostics it reported.
@@ -370,37 +370,36 @@ function relativeWorkspaceMessage(workspace, message) {
 * ```
 */
 function scanDiagnostics(text) {
-	const diagnostics = [];
-	for (const line of text.split(/\r\n|\n/)) {
+	const lines = text.split(/\r\n|\n/);
+	const headers = lines.map((line, index) => {
 		const located = /^(.+)\((\d+),(\d+)\): (?:error|warning) TS\d+: (.*)$/u.exec(line);
 		if (located !== null) {
 			const point = {
 				line: Number.parseInt(located[2] ?? "1", 10) - 1,
 				character: Number.parseInt(located[3] ?? "1", 10) - 1
 			};
-			diagnostics.push({
-				path: normalizePath(located[1] ?? ""),
-				range: {
-					start: point,
-					end: point
-				},
-				message: located[4] ?? ""
-			});
-			continue;
+			return {
+				index,
+				diagnostic: {
+					path: normalizePath(located[1] ?? ""),
+					range: {
+						start: point,
+						end: point
+					},
+					message: located[4] ?? ""
+				}
+			};
 		}
 		const bare = /^(?:error|warning) TS\d+: (.*)$/u.exec(line);
-		if (bare !== null) {
-			diagnostics.push({ message: bare[1] ?? "" });
-			continue;
-		}
-		const previous = diagnostics.at(-1);
-		if (previous === void 0 || !/^\s+\S/u.test(line)) continue;
-		diagnostics[diagnostics.length - 1] = {
-			...previous,
-			message: `${previous.message}\n${line}`
+		return bare === null ? void 0 : {
+			index,
+			diagnostic: { message: bare[1] ?? "" }
 		};
-	}
-	return diagnostics;
+	}).filter((header) => header !== void 0);
+	return headers.map((header, index) => ({
+		...header.diagnostic,
+		message: [header.diagnostic.message, ...lines.slice(header.index + 1, headers[index + 1]?.index).filter((line) => /^\s+\S/u.test(line))].join("\n")
+	}));
 }
 /**
 * Resolves one installed module from the target workspace.
@@ -475,10 +474,9 @@ function loadWorkspaceVitest(workspace) {
 * ```
 */
 function readWorkspaceManifest(workspace, name) {
-	let path;
-	try {
-		path = resolveWorkspaceModule(workspace, `${name}/package.json`);
-	} catch (error) {
+	const resolved = attempt(() => resolveWorkspaceModule(workspace, `${name}/package.json`));
+	if (!resolved.success) {
+		const error = resolved.error;
 		if (!isProbeError(error)) throw error;
 		throw new ProbeError(`${name} does not publish a readable manifest`, {
 			origin: "workspace",
@@ -487,6 +485,7 @@ function readWorkspaceManifest(workspace, name) {
 			cause: error.cause
 		});
 	}
+	const path = resolved.value;
 	const reading = attempt(() => readFileSync(path, "utf8"));
 	if (!reading.success) {
 		const error = reading.error;
@@ -502,17 +501,17 @@ function readWorkspaceManifest(workspace, name) {
 			cause: error
 		});
 	}
-	const parsing = attempt(() => JSON.parse(reading.value));
-	if (!parsing.success) throw new ProbeError(`${name} does not publish a readable manifest`, {
+	const parsed = attempt(() => JSON.parse(reading.value));
+	if (!parsed.success) throw new ProbeError(`${name} does not publish a readable manifest`, {
 		origin: "workspace",
 		code: "malformed",
 		context: {
 			name,
 			path
 		},
-		cause: parsing.error
+		cause: parsed.error
 	});
-	const contents = parsing.value;
+	const contents = parsed.value;
 	if (!isRecord(contents)) throw new ProbeError(`${name} does not publish a readable manifest`, {
 		origin: "workspace",
 		code: "malformed",
@@ -532,6 +531,8 @@ function readWorkspaceManifest(workspace, name) {
 * @remarks
 * A package publishes its binaries under keys of its own choosing, and that key is often not the
 * package name: `typescript` publishes `tsc`. Name the key as `command` wherever the two differ.
+* Resolution reads `package.json` and its `bin` field, so TypeScript 6 and 7 need no exported
+* `typescript/bin/tsc` subpath.
 * Default: the package name.
 *
 * @param workspace - The target workspace root
@@ -681,20 +682,13 @@ function buildRevisionPath(workspace, path, revision) {
 * ```
 */
 function filterUniqueIssues(issues) {
-	const seen = /* @__PURE__ */ new Set();
-	const distinct = [];
-	for (const issue of issues) {
-		const key = JSON.stringify([
-			issue.origin,
-			issue.path,
-			issue.message,
-			issue.range
-		]);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		distinct.push(issue);
-	}
-	return distinct;
+	const groups = Map.groupBy(issues, (issue) => JSON.stringify([
+		issue.origin,
+		issue.path,
+		issue.message,
+		issue.range
+	]));
+	return Iterator.from(groups.values()).flatMap((group) => group.slice(0, 1)).toArray();
 }
 /**
 * Reports whether a path is a workspace module Vitest can cache.
@@ -712,13 +706,11 @@ function matchesWorkspaceModule(path) {
 	return /\.(?:[cm]?[jt]sx?|vue|json)$/.test(path);
 }
 /**
-* Reports whether the host that wrote one file is still running.
+* Reports whether a file's owning host is running or cannot be judged.
 *
 * @remarks
-* Signal 0 delivers nothing and reports reachability alone. A process this one may not signal
-* reports `EPERM` and reads as running, and a non-positive identity names a process group rather
-* than a process, so both answer true: the safe direction is to keep a file this package cannot
-* account for.
+* Keeps a file when its identity is invalid or `inspectProcess` reports existence, denied
+* permission, or an indeterminate host failure. Only a confirmed absent process answers false.
 *
 * @param id - The process id a file's own revision names
 * @returns True if that process is running or cannot be judged; false otherwise
@@ -731,12 +723,7 @@ function matchesWorkspaceModule(path) {
 */
 function matchesLiveProcess(id) {
 	if (!isNumber(id) || !Number.isSafeInteger(id) || id <= 0) return true;
-	try {
-		process.kill(id, 0);
-		return true;
-	} catch (error) {
-		return readFaultCode(error) === "EPERM";
-	}
+	return inspectProcess(id) !== false;
 }
 /**
 * Collects every regular file a target workspace holds, skipping the trees no inspection reads.
@@ -764,10 +751,8 @@ function collectWorkspaceFiles(workspace) {
 	while (directories.length > 0) {
 		const directory = directories.pop();
 		if (directory === void 0) break;
-		let entries = [];
-		try {
-			entries = readdirSync(directory, { withFileTypes: true });
-		} catch {}
+		const reading = attempt(() => readdirSync(directory, { withFileTypes: true }));
+		const entries = reading.success ? reading.value : [];
 		for (const entry of entries) {
 			if (entry.name === ".git" || entry.name === "dist" || entry.name === "node_modules") continue;
 			const path = join(directory, entry.name);
@@ -856,17 +841,10 @@ async function guardStage(stage, operation) {
 */
 function findRefusedPaths(value) {
 	if (!compileGuard(CLAIM_SHAPE)(value)) return [];
-	const members = [];
-	for (const phase of ["case", "control"]) {
+	return ["case", "control"].flatMap((phase) => {
 		const subject = value[phase];
-		const drafts = /* @__PURE__ */ new Map([[`${phase}.test`, subject.test]]);
-		for (const [index, file] of subject.files.entries()) drafts.set(`${phase}.files.${index}`, file);
-		for (const [member, draft] of drafts) {
-			if (isDraft(draft)) continue;
-			members.push(`${member}.path`);
-		}
-	}
-	return members;
+		return [[`${phase}.test`, subject.test], ...Iterator.from(subject.files.entries()).map(([index, file]) => [`${phase}.files.${index}`, file])].flatMap(([member, draft]) => isDraft(draft) ? [] : [`${member}.path`]);
+	});
 }
 /**
 * Rewrites every workspace-contained absolute path in a value to its workspace-relative form and
@@ -878,7 +856,8 @@ function findRefusedPaths(value) {
 * its relative form keeps one commit checked out at two roots reading to one digest. A path that
 * escapes the workspace is left as it stands, because rewriting it would name a file outside the
 * tree by a relative spelling. Key order is the compiler's own and it differs between the supported
-* majors, so sorting removes a difference that means nothing.
+* majors, so sorting removes a difference that means nothing. A `__proto__` key is dropped, as
+* the earlier assignment-built record dropped it, so a digest stays the same across releases.
 *
 * @param workspace - The target workspace root
 * @param value - The value to rewrite
@@ -900,11 +879,7 @@ function normalizeValue(workspace, value) {
 		return normalizePath(path);
 	}
 	if (isArray(value)) return value.map((entry) => normalizeValue(workspace, entry));
-	if (isRecord(value)) {
-		const record = {};
-		for (const key of Object.keys(value).sort()) record[key] = normalizeValue(workspace, value[key]);
-		return record;
-	}
+	if (isRecord(value)) return Object.fromEntries(Object.keys(value).sort().filter((key) => key !== "__proto__").map((key) => [key, normalizeValue(workspace, value[key])]));
 	return value;
 }
 /**
@@ -941,9 +916,7 @@ function computeDigest(workspace, value) {
 * ```
 */
 function captureListeners(emitter, events) {
-	const capture = /* @__PURE__ */ new Map();
-	for (const event of events) capture.set(event, emitter.listeners(event));
-	return capture;
+	return new Map(Iterator.from(events).map((event) => [event, emitter.listeners(event)]));
 }
 /**
 * Removes every listener one emitter gained for the captured events since its capture.
@@ -974,12 +947,11 @@ function captureListeners(emitter, events) {
 */
 function releaseListeners(emitter, capture) {
 	for (const [event, captured] of capture) for (const listener of emitter.listeners(event)) {
-		if (captured.includes(listener)) continue;
+		if (captured.includes(listener) || !isFunction(listener)) continue;
 		emitter.removeListener(event, listener);
 	}
 }
-//#endregion
-//#region src/server/parsers.ts
+// src/server/parsers.ts
 /**
 * Parses the configuration one compiler run printed for a TypeScript project.
 *
@@ -1034,8 +1006,7 @@ function parseRevisionOwner(revision) {
 	const owner = /^(\d+)-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u.exec(revision)?.[1];
 	return owner === void 0 ? void 0 : Number.parseInt(owner, 10);
 }
-//#endregion
-//#region src/server/Overlay.ts
+// src/server/Overlay.ts
 /**
 * Implements `OverlayInterface` over a private map from normalized absolute path to candidate text,
 * minting at construction the `revision` a resident tool caches its answers against.
@@ -1121,15 +1092,13 @@ var Overlay = class {
 		this.#candidates.clear();
 	}
 };
-//#endregion
-//#region package.json
-var version = "0.0.24";
+// package.json
+var version = "0.0.26";
 var peerDependencies = {
-	"typescript": "^6.0.3",
-	"vitest": "^4.1.12"
+	"typescript": "^6.0.3 || ^7.0.2",
+	"vitest": "^4.1.12 || ^5.0.5"
 };
-//#endregion
-//#region src/server/stages/LintStage.ts
+// src/server/stages/LintStage.ts
 /**
 * Inspects virtual documents through one resident Oxlint language server.
 *
@@ -1342,12 +1311,16 @@ var LintStage = class {
 		}));
 	}
 };
-//#endregion
-//#region src/server/stages/RuntimeStage.ts
+// src/server/stages/RuntimeStage.ts
 /**
 * Inspects tests through one resident Vitest service from the target workspace.
 *
 * @remarks
+* Vitest 4.1.12 and 5.0.5 share the mode-first `createVitest` overload used by this stage.
+* Result eviction removes one file from Vitest 4's results cache. Vitest 5 exposes only a full
+* cache clear, so eviction clears its results, dependency, and filesystem module caches.
+* Warming removes termination handlers registered within the factory's async context before
+* signal delivery, while retaining handlers the host registers outside that context.
 * Starting launches Vitest with the threads pool and instruments each inline or function-declared
 * project with a Vite plugin that reads the active inspection's candidate overlay. A selected
 * string-declared project reports a workspace issue because its configuration carries no runtime
@@ -1501,14 +1474,13 @@ var RuntimeStage = class {
 			const file = sep === "\\" ? normalizePath(specification) : specification;
 			this.#specifications += 1;
 			this.#revisions.add(file);
-			let issues = [];
-			let cleanup = [];
+			const issues = [];
 			const task = project.createSpecification(file, void 0, "threads");
 			this.#progress += 1;
 			try {
 				try {
 					const result = await vitest.runTestSpecifications([task], false);
-					issues = [...this.#issues(result, file, subject.test.path), ...this.#misses(project, file)];
+					issues.push(...this.#issues(result, file, subject.test.path), ...this.#misses(project, file));
 				} catch (error) {
 					if (isProbeError(error)) throw error;
 					throw new ProbeError(`The runtime stage could not run the generated specification (${describeUnknown(error)})`, {
@@ -1525,22 +1497,22 @@ var RuntimeStage = class {
 				this.#progress -= 1;
 				process.exitCode = exitCode;
 				this.#revisions.delete(file);
-				cleanup = await this.#evict(vitest, file);
+				issues.push(...await this.#evict(vitest, file));
 				try {
 					const contained = resolveWorkspaceFile(this.#workspace, relative(this.#workspace, file), true);
 					if (existsSync(contained)) unlinkSync(contained);
 				} catch (error) {
-					cleanup = [...cleanup, {
+					issues.push({
 						origin: isProbeError(error) && error.origin === "workspace" ? "workspace" : "instrument",
 						path: relativeWorkspaceFile(this.#workspace, file),
 						message: `The runtime stage could not delete the generated specification (${describeUnknown(error)})`
-					}];
+					});
 				}
 			}
 			return {
 				stage: this.stage,
 				elapsed: Math.round(performance.now() - started),
-				issues: [...issues, ...cleanup]
+				issues
 			};
 		} finally {
 			this.#loads.clear();
@@ -1572,38 +1544,46 @@ var RuntimeStage = class {
 		this.#sweep();
 		const output = new PassThrough();
 		output.resume();
+		const scope = new AsyncLocalStorage();
+		const listener = this.#captureSignal.bind(this, scope);
 		const signals = captureListeners(process, ["SIGINT", "SIGTERM"]);
-		let warming;
+		process.on("newListener", listener);
 		try {
-			warming = factory("test", {
-				root: this.#workspace,
-				config: resolveWorkspaceFile(this.#workspace, "vite.config.ts"),
-				watch: false,
-				run: true,
-				pool: "threads",
-				reporters: [{
-					onInit() {},
-					onTestRunEnd() {}
-				}]
-			}, { plugins: [{
-				name: "orkestrel-project-instrumentation",
-				enforce: "post",
-				config: this.#configure.bind(this)
-			}] }, {
-				stdout: output,
-				stderr: process.stderr
+			return await scope.run(true, () => {
+				try {
+					return factory("test", {
+						root: this.#workspace,
+						config: resolveWorkspaceFile(this.#workspace, "vite.config.ts"),
+						watch: false,
+						run: true,
+						pool: "threads",
+						reporters: [{
+							onInit() {},
+							onTestRunEnd() {}
+						}]
+					}, { plugins: [{
+						name: "orkestrel-project-instrumentation",
+						enforce: "post",
+						config: this.#configure.bind(this)
+					}] }, {
+						stdout: output,
+						stderr: process.stderr
+					});
+				} finally {
+					releaseListeners(process, signals);
+				}
 			});
 		} catch (error) {
 			throw this.#configuration(error);
 		} finally {
-			releaseListeners(process, signals);
-		}
-		try {
-			return await warming;
-		} catch (error) {
-			throw this.#configuration(error);
+			process.off("newListener", listener);
+			scope.disable();
 		}
 	}
+	#captureSignal(scope, event, listener) {
+		if (scope.getStore() !== true || event !== "SIGINT" && event !== "SIGTERM") return;
+		queueMicrotask(() => process.off(event, listener));
+	}
 	#configure(config) {
 		const test = config.test;
 		if (test?.projects === void 0) return;
@@ -1659,47 +1639,52 @@ var RuntimeStage = class {
 		return text;
 	}
 	#specification(test) {
-		let creating = false;
-		let generated;
-		const outcome = attempt(() => {
+		const location = attempt(() => {
 			const revision = `${process.pid}-${randomUUID()}`;
-			const file = buildRevisionPath(this.#workspace, test.path, revision);
-			generated = file;
-			const target = relative(this.#workspace, file);
-			resolveWorkspaceFile(this.#workspace, target, true);
-			creating = true;
-			mkdirSync(dirname(file), { recursive: true });
-			creating = false;
+			return {
+				revision,
+				file: buildRevisionPath(this.#workspace, test.path, revision)
+			};
+		});
+		if (!location.success) return this.#specificationFault(test, location.error);
+		const { revision, file } = location.value;
+		const target = relative(this.#workspace, file);
+		const containment = attempt(() => resolveWorkspaceFile(this.#workspace, target, true));
+		if (!containment.success) return this.#specificationFault(test, containment.error, file);
+		const directory = attempt(() => mkdirSync(dirname(file), { recursive: true }));
+		if (!directory.success) return this.#specificationFault(test, directory.error, file, true);
+		const written = attempt(() => {
 			resolveWorkspaceFile(this.#workspace, target, true);
 			writeFileSync(file, formatSpecification(test.text, revision), {
 				encoding: "utf8",
 				flag: "wx"
 			});
-			return file;
 		});
-		if (outcome.success) return outcome.value;
-		if (isProbeError(outcome.error) && outcome.error.origin === "claimant") throw new ProbeError(outcome.error.message, {
-			origin: outcome.error.origin,
-			code: outcome.error.code,
+		return written.success ? file : this.#specificationFault(test, written.error, file);
+	}
+	#specificationFault(test, error, generated, directory = false) {
+		if (isProbeError(error) && error.origin === "claimant") throw new ProbeError(error.message, {
+			origin: error.origin,
+			code: error.code,
 			context: {
-				...outcome.error.context,
+				...error.context,
 				path: test.path
 			},
-			cause: outcome.error.cause
+			cause: error.cause
 		});
-		if (!creating && generated !== void 0 && isRefusedName(generated, outcome.error)) throw new ProbeError(`The runtime stage cannot write a specification beside a test path the host refuses (${describeUnknown(outcome.error)})`, {
+		if (!directory && generated !== void 0 && isRefusedName(generated, error)) throw new ProbeError(`The runtime stage cannot write a specification beside a test path the host refuses (${describeUnknown(error)})`, {
 			origin: "claimant",
 			code: "refused",
 			context: {
 				stage: this.stage,
 				path: test.path
 			},
-			cause: outcome.error
+			cause: error
 		});
 		return {
-			origin: isProbeError(outcome.error) && outcome.error.origin === "workspace" || creating ? "workspace" : "instrument",
+			origin: isProbeError(error) && error.origin === "workspace" || directory ? "workspace" : "instrument",
 			path: test.path,
-			message: `The runtime stage could not write the generated specification (${describeUnknown(outcome.error)})`
+			message: `The runtime stage could not write the generated specification (${describeUnknown(error)})`
 		};
 	}
 	#project(vitest, path) {
@@ -1730,44 +1715,35 @@ var RuntimeStage = class {
 	}
 	#misses(project, specification) {
 		const file = normalizePath(specification);
-		const issues = [];
-		for (const path of this.#overlay.paths) {
-			if (this.#reads.has(path)) continue;
-			let served = false;
-			let loaded = false;
-			for (const environment of Object.values(project.vite.environments)) {
+		return this.#overlay.paths.flatMap((path) => {
+			if (this.#reads.has(path)) return [];
+			const served = Object.values(project.vite.environments).flatMap((environment) => {
 				const modules = environment.moduleGraph.getModulesByFile(path);
-				if (modules === void 0) continue;
-				for (const module of modules) {
+				if (modules === void 0) return [];
+				return Iterator.from(modules).flatMap((module) => {
 					const pending = [...module.importers];
 					const seen = new Set(pending);
-					let reaches = false;
 					while (pending.length > 0) {
 						const importer = pending.pop();
 						if (importer === void 0) break;
-						if (importer.file !== null && normalizePath(importer.file) === file) {
-							reaches = true;
-							break;
-						}
+						if (importer.file !== null && normalizePath(importer.file) === file) return [module.id !== null && this.#loads.has(normalizePath(module.id))];
 						for (const parent of importer.importers) {
 							if (seen.has(parent)) continue;
 							seen.add(parent);
 							pending.push(parent);
 						}
 					}
-					if (!reaches) continue;
-					served = true;
-					if (module.id !== null && this.#loads.has(normalizePath(module.id))) loaded = true;
-				}
-			}
-			if (!served) continue;
-			issues.push({
+					return [];
+				}).toArray();
+			});
+			if (served.length === 0) return [];
+			const loaded = served.some((value) => value);
+			return [{
 				origin: loaded ? "instrument" : "workspace",
 				path: relativeWorkspaceFile(this.#workspace, path),
 				message: loaded ? "The runtime overlay did not resolve this module" : "The workspace configuration served this module before the runtime overlay"
-			});
-		}
-		return issues;
+			}];
+		});
 	}
 	async #evict(vitest, file) {
 		try {
@@ -1797,8 +1773,16 @@ var RuntimeStage = class {
 			}
 			vitest.watcher.onFileDelete(file);
 			vitest.watcher.invalidates.delete(file);
-			vitest.cache.results.removeFromCache(normalizePath(relative(this.#workspace, file)));
-			await vitest.cache.results.writeToCache();
+			const results = "results" in vitest.cache ? vitest.cache.results : void 0;
+			if (isObject(results) && "removeFromCache" in results && typeof results.removeFromCache === "function" && "writeToCache" in results && typeof results.writeToCache === "function") {
+				results.removeFromCache(normalizePath(relative(this.#workspace, file)));
+				await results.writeToCache();
+			} else if ("clearCache" in vitest && typeof vitest.clearCache === "function") await vitest.clearCache();
+			else throw new ProbeError("Vitest exposes no cache eviction API", {
+				origin: "instrument",
+				code: "malformed",
+				context: { stage: this.stage }
+			});
 			return [];
 		} catch (error) {
 			return [{
@@ -2001,12 +1985,13 @@ var RuntimeStage = class {
 		};
 	}
 };
-//#endregion
-//#region src/server/stages/TypeStage.ts
+// src/server/stages/TypeStage.ts
 /**
 * Inspects TypeScript source by running the target workspace's own compiler over a mirror of it.
 *
 * @remarks
+* TypeScript 6 and 7 run through the `tsc` entry in their package manifest; neither a compiler API
+* nor an exported binary subpath is required.
 * The compiler is a process this stage spawns rather than a module it loads, so nothing here holds
 * a resident program and the host's event loop is free for the whole check. Starting sweeps a
 * mirror an earlier host left behind, copies the workspace into a fresh one under
@@ -2044,6 +2029,7 @@ var TypeStage = class {
 	#revision = `${process.pid}-${randomUUID()}`;
 	#mirror;
 	#configs = /* @__PURE__ */ new Map();
+	#validated = /* @__PURE__ */ new Set();
 	#mirrored = /* @__PURE__ */ new Map();
 	#drafts = /* @__PURE__ */ new Set();
 	#children = /* @__PURE__ */ new Set();
@@ -2097,6 +2083,8 @@ var TypeStage = class {
 	* refreshed from the workspace first on a cache miss, so the digest names the configuration the
 	* check applies. The reading is cached per project for the life of the stage, so a draft written
 	* afterward cannot move it.
+	* Before returning the identity, validates the project with `--noEmit` unless an unoverlaid check
+	* already validated it. TypeScript 7's `--showConfig` can succeed for a malformed project.
 	*
 	* @param project - The workspace-relative TypeScript project to resolve
 	* @returns The resolved workspace-relative path and the digest of its compiler options
@@ -2106,6 +2094,14 @@ var TypeStage = class {
 	resolve(project) {
 		return guardStage(this.stage, this.#resolve(project));
 	}
+	/**
+	* Tears down the compiler processes and releases the mirror without awaiting inspections.
+	*
+	* @remarks
+	* On Windows, awaits each tree termination attempt before removing the mirror. Each attempt
+	* uses `PROBE_DEADLINE`, the existing default inspection budget, as its utility timeout.
+	* On POSIX, sends `SIGTERM` to each compiler. Warming settles before the mirror is removed.
+	*/
 	destroy() {
 		if (this.#closing !== void 0) return this.#closing;
 		this.#closing = guardStage(this.stage, this.#destroy());
@@ -2156,6 +2152,10 @@ var TypeStage = class {
 		const contained = this.#contain(project);
 		this.#progress += 1;
 		const config = await this.#configure(contained);
+		if (!this.#validated.has(contained)) {
+			this.#refresh();
+			await this.#check(contained, []);
+		}
 		return {
 			path: contained,
 			digest: computeDigest(this.#workspace, config.compilerOptions)
@@ -2164,7 +2164,7 @@ var TypeStage = class {
 	async #destroy() {
 		const children = [...this.#children];
 		this.#children.clear();
-		for (const child of children) this.#terminate(child);
+		await Promise.all(children.map((child) => this.#terminate(child)));
 		await this.#warming?.catch(() => void 0);
 		try {
 			rmSync(this.#mirror, {
@@ -2175,6 +2175,7 @@ var TypeStage = class {
 			});
 		} catch {}
 		this.#configs.clear();
+		this.#validated.clear();
 		this.#mirrored.clear();
 		this.#drafts.clear();
 	}
@@ -2187,18 +2188,11 @@ var TypeStage = class {
 		await Promise.all(this.#projects().map((project) => this.#check(project, [])));
 	}
 	#projects() {
-		const projects = ["tsconfig.json"];
-		for (const axis of ["src", "app"]) {
+		return ["tsconfig.json", ...["src", "app"].flatMap((axis) => {
 			const directory = resolveWorkspaceFile(this.#workspace, `configs/${axis}`);
-			let names;
-			try {
-				names = readdirSync(directory);
-			} catch {
-				continue;
-			}
-			for (const name of names.filter((entry) => /^tsconfig\.[^.]+\.json$/.test(entry)).sort()) projects.push(`configs/${axis}/${name}`);
-		}
-		return projects;
+			const reading = attempt(() => readdirSync(directory));
+			return reading.success ? reading.value.filter((entry) => /^tsconfig\.[^.]+\.json$/.test(entry)).sort().map((name) => `configs/${axis}/${name}`) : [];
+		})];
 	}
 	#refuseDestroyed() {
 		if (this.#closing !== void 0) throw createDestroyedError("type stage");
@@ -2213,13 +2207,9 @@ var TypeStage = class {
 	}
 	#sweep() {
 		const root = resolveWorkspaceFile(this.#workspace, TYPE_MIRROR);
-		let entries = [];
-		try {
-			entries = readdirSync(root, { withFileTypes: true });
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
+		const reading = attempt(() => readdirSync(root, { withFileTypes: true }));
+		if (!reading.success) return;
+		for (const entry of reading.value) {
 			if (!entry.isDirectory()) continue;
 			const owner = parseRevisionOwner(entry.name);
 			if (owner === void 0 || matchesLiveProcess(owner)) continue;
@@ -2273,12 +2263,7 @@ var TypeStage = class {
 		return contained;
 	}
 	#displace(target) {
-		const ancestors = [];
-		let directory = dirname(target);
-		while (directory !== this.#mirror && directory !== dirname(directory)) {
-			ancestors.unshift(directory);
-			directory = dirname(directory);
-		}
+		const ancestors = relative(this.#mirror, target).split(sep).slice(0, -1).map((_segment, index, segments) => join(this.#mirror, ...segments.slice(0, index + 1)));
 		for (const ancestor of [...ancestors, target]) {
 			const reading = attempt(() => lstatSync(ancestor));
 			if (!reading.success) continue;
@@ -2348,7 +2333,9 @@ var TypeStage = class {
 				}
 			});
 		}
-		return this.#issues(diagnostics, project);
+		const issues = this.#issues(diagnostics, project, scratch);
+		if (this.#drafts.size === 0) this.#validated.add(this.#contain(project));
+		return issues;
 	}
 	#scratch(project, config, drafts) {
 		const directory = dirname(project);
@@ -2373,13 +2360,13 @@ var TypeStage = class {
 		writeFileSync(target, `${JSON.stringify(body, void 0, "	")}\n`, "utf8");
 		return contained;
 	}
-	#issues(diagnostics, project) {
+	#issues(diagnostics, project, scratch) {
 		const issues = [];
 		for (const diagnostic of diagnostics) {
 			const message = this.#translate(diagnostic.message);
 			const resolved = diagnostic.path === void 0 ? void 0 : resolve(this.#mirror, diagnostic.path);
 			const drafted = resolved !== void 0 && this.#drafts.has(escapesRoot(this.#mirror, resolved) ? relativeWorkspaceFile(this.#workspace, resolved) : relativeWorkspaceFile(this.#mirror, resolved));
-			if (resolved === void 0 || !drafted && extname(resolved) === ".json") throw new ProbeError(message, {
+			if (resolved === void 0 || !drafted && extname(resolved) === ".json") throw new ProbeError(message.replaceAll(normalizePath(scratch), normalizePath(project)), {
 				origin: "workspace",
 				code: "malformed",
 				context: {
@@ -2412,40 +2399,43 @@ var TypeStage = class {
 			}
 		});
 	}
-	#spawn(args, cwd) {
+	async #spawn(args, cwd) {
 		this.#refuseDestroyed();
 		const compiler = this.#compiler;
 		if (compiler === void 0) throw createDestroyedError("type stage");
-		return new Promise((settle, refuse) => {
-			const child = spawn(process.execPath, [compiler, ...args], {
-				cwd,
-				stdio: [
-					"ignore",
-					"pipe",
-					"pipe"
-				]
-			});
-			const output = child.stdout;
-			const errors = child.stderr;
-			if (output === null || errors === null) {
-				this.#terminate(child);
-				refuse(new ProbeError("The compiler was spawned without its own output streams", {
-					origin: "instrument",
-					code: "malformed",
-					context: { stage: this.stage }
-				}));
-				return;
+		const child = spawn(process.execPath, [compiler, ...args], {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		this.#children.add(child);
+		const output = child.stdout;
+		const errors = child.stderr;
+		if (output === null || errors === null) {
+			try {
+				await this.#terminate(child);
+			} finally {
+				this.#children.delete(child);
 			}
-			this.#children.add(child);
-			let stdout = "";
-			let stderr = "";
+			throw new ProbeError("The compiler was spawned without its own output streams", {
+				origin: "instrument",
+				code: "malformed",
+				context: { stage: this.stage }
+			});
+		}
+		return new Promise((settle, refuse) => {
+			const stdout = [];
+			const stderr = [];
 			output.setEncoding("utf8");
 			errors.setEncoding("utf8");
 			output.on("data", (chunk) => {
-				stdout += chunk;
+				stdout.push(chunk);
 			});
 			errors.on("data", (chunk) => {
-				stderr += chunk;
+				stderr.push(chunk);
 			});
 			child.on("error", (error) => {
 				this.#children.delete(child);
@@ -2463,32 +2453,28 @@ var TypeStage = class {
 				this.#children.delete(child);
 				settle({
 					...code === null ? {} : { status: code },
-					stdout,
-					stderr
+					stdout: stdout.join(""),
+					stderr: stderr.join("")
 				});
 			});
 		});
 	}
-	#terminate(child) {
+	async #terminate(child) {
 		const id = child.pid;
 		if (process.platform === "win32" && id !== void 0) {
-			spawnSync("taskkill", [
-				"/pid",
-				String(id),
-				"/t",
-				"/f"
-			], { stdio: "ignore" });
+			await killTree(id, PROBE_DEADLINE);
 			return;
 		}
 		child.kill("SIGTERM");
 	}
 };
-//#endregion
-//#region src/server/Probe.ts
+// src/server/Probe.ts
 /**
 * Answers claims through its type, lint, and runtime stages.
 *
 * @remarks
+* The workspace peers are TypeScript `^6.0.3 || ^7.0.2` and Vitest `^4.1.12 || ^5.0.5`.
+* Starting refuses TypeScript majors outside 6 and 7 before a stage starts.
 * Construction resolves the target workspace's toolchain. Starting warms every stage and waits
 * for lint and runtime; type warming and the boot controls continue behind that gate. The boot
 * controls mutate imported dependencies and refuse service unless the type and runtime stages
@@ -2537,7 +2523,7 @@ var TypeStage = class {
 * const probe = new Probe({ workspace: process.cwd() })
 * const verdict = await probe.prove(claim)
 * verdict.digest // 'bdf03e5dfd6bd413ead671c7a2940fcf'
-* verdict.receipt // 'probe:bdf03e5dfd6bd413ead671c7a2940fcf:type:typescript@6.0.3:oxlint@1.89.0:vitest@4.1.12:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
+* verdict.receipt?.startsWith(`probe:${verdict.digest}:type:`) // true
 * await probe.destroy()
 * ```
 */
@@ -2672,11 +2658,12 @@ var Probe = class {
 		return this.#starting;
 	}
 	async #start(filling, warming) {
-		let created = false;
-		try {
+		const preparation = attempt(() => {
 			this.#support();
-			if (this.#arming === void 0) created = this.#workbench();
-		} catch (error) {
+			return this.#arming === void 0 && this.#workbench();
+		});
+		if (!preparation.success) {
+			const error = preparation.error;
 			this.#surface(error);
 			throw error;
 		}
@@ -2687,7 +2674,7 @@ var Probe = class {
 			throw this.#refuseArm(error);
 		}
 		if (this.#arming === void 0) {
-			this.#arming = this.#arm(warming, created);
+			this.#arming = this.#arm(warming, preparation.value);
 			this.#arming.catch(() => {
 				if (this.#refusal === void 0) this.#arming = void 0;
 			});
@@ -3013,9 +3000,9 @@ var Probe = class {
 	#support() {
 		const version = this.#toolchain.typescript;
 		const range = peerDependencies.typescript;
-		const supported = /^\^(\d+)\./u.exec(range)?.[1];
 		const found = /^(\d+)\./u.exec(version)?.[1];
-		if (supported === void 0 || found !== supported) throw new ProbeError(`The supported TypeScript range is ${range}; found ${version}`, {
+		const supported = range.split(" || ").some((entry) => /^\^(\d+)\./u.exec(entry)?.[1] === found);
+		if (found === void 0 || !supported) throw new ProbeError(`The supported TypeScript range is ${range}; found ${version}`, {
 			origin: "workspace",
 			code: "malformed",
 			context: {
@@ -3025,8 +3012,7 @@ var Probe = class {
 		});
 	}
 };
-//#endregion
-//#region src/server/ProbeServer.ts
+// src/server/ProbeServer.ts
 /**
 * Implements `ProbeServerInterface` over a `PassThrough` stream this server owns, binding the
 * published `prove` tool and the dual-era dispatcher to this process's Model Context Protocol
@@ -3265,7 +3251,6 @@ var ProbeServer = class {
 		] : [rendered, minimal]).find((arm) => isBoundedJSON(arm, bounds)) ?? minimal;
 	}
 };
-//#endregion
 export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, buildRevisionPath, captureListeners, collectWorkspaceFiles, computeDigest, createHandshakeError, describeUnknown, escapesRoot, filterUniqueIssues, findRefusedPaths, guardStage, inferDocumentLanguage, inferTestProject, inferTypeProject, isRefusedName, loadWorkspaceVitest, matchesLiveProcess, matchesWorkspaceModule, normalizePath, normalizeValue, overwriteFile, parseProjectConfig, parseRevisionOwner, readFaultCode, readWorkspaceManifest, relativeWorkspaceFile, relativeWorkspaceMessage, releaseListeners, resolveWorkspaceBinary, resolveWorkspaceFile, resolveWorkspaceModule, scanDiagnostics };
 
 //# sourceMappingURL=index.js.map