@orkestrel/probe 0.0.25 → 0.0.27

package/dist/src/server/index.js

@@ -5,19 +5,20 @@ 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, 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 { CLAIM_SHAPE, LINT_DEADLINE, LINT_TEARDOWN, PROBE_DEADLINE, PROBE_KEYS, PROBE_RESTARTS, PROBE_SPECIFICATIONS, PROBE_WARM, ProbeError, RUNTIME_PLUGIN, TYPE_MIRROR, computeReceipt, createDestroyedError, formatReceipt, formatSpecification, formatStageResult, 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";
 import { addAbortListener } from "node:events";
 import { createTimeout } from "@orkestrel/timeout";
-import { createStdioClientTransport } from "@orkestrel/lsp/server";
+import { createLSPStdioTransport } from "@orkestrel/lsp/server";
 import { PassThrough } from "node:stream";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { spawn, spawnSync } from "node:child_process";
+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.
 *
@@ -35,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.
 *
@@ -151,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}`, {
@@ -165,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);
@@ -335,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.
@@ -371,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.
@@ -476,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",
@@ -488,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;
@@ -503,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",
@@ -684,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.
@@ -715,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
@@ -734,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.
@@ -767,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);
@@ -859,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
@@ -881,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
@@ -903,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;
 }
 /**
@@ -924,10 +896,10 @@ function normalizeValue(workspace, value) {
 *
 * @example
 * ```ts
-* computeDigest('/srv/checkout', { strict: true }).length // 32
+* computeWorkspaceDigest('/srv/checkout', { strict: true }).length // 32
 * ```
 */
-function computeDigest(workspace, value) {
+function computeWorkspaceDigest(workspace, value) {
 	return createHash("sha256").update(JSON.stringify(normalizeValue(workspace, value))).digest("hex").slice(0, 32);
 }
 /**
@@ -944,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.
@@ -981,8 +951,7 @@ function releaseListeners(emitter, capture) {
 		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.
 *
@@ -1037,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.
@@ -1124,21 +1092,19 @@ var Overlay = class {
 		this.#candidates.clear();
 	}
 };
-//#endregion
-//#region package.json
-var version = "0.0.25";
+// package.json
+var version = "0.0.27";
 var peerDependencies = {
 	"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.
 *
 * @remarks
 * Starting launches the target workspace's Oxlint binary with its Language Server Protocol mode
-* and hands the conversation to `@orkestrel/lsp`: `createStdioClientTransport` owns the child
+* and hands the conversation to `@orkestrel/lsp`: `createLSPStdioTransport` owns the child
 * process and its bytes, and `createLSPClient` owns the framing, the request correlation, the
 * capabilities this stage advertises, and the choice between pulled and pushed diagnostics. This
 * stage owns the workspace, the candidate identity, and the projection from a diagnostic to an
@@ -1166,7 +1132,7 @@ var peerDependencies = {
 * @example
 * ```ts
 * const stage = new LintStage('/srv/checkout')
-* const check = await stage.inspect(subject, { signal: AbortSignal.timeout(30_000) })
+* const result = await stage.inspect(subject, { signal: AbortSignal.timeout(30_000) })
 * await stage.destroy()
 * ```
 */
@@ -1239,7 +1205,7 @@ var LintStage = class {
 	}
 	async #warm() {
 		const binary = resolveWorkspaceBinary(this.#workspace, "oxlint");
-		const transport = createStdioClientTransport({
+		const transport = createLSPStdioTransport({
 			server: {
 				command: [
 					process.execPath,
@@ -1345,8 +1311,7 @@ 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.
 *
@@ -1408,7 +1373,7 @@ var LintStage = class {
 * @example
 * ```ts
 * const stage = new RuntimeStage('/srv/checkout')
-* const check = await stage.inspect(subject)
+* const result = await stage.inspect(subject)
 * await stage.destroy()
 * ```
 */
@@ -1509,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)})`, {
@@ -1533,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();
@@ -1675,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) {
@@ -1746,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 {
@@ -2025,8 +1985,7 @@ 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.
 *
@@ -2060,7 +2019,7 @@ var RuntimeStage = class {
 * @example
 * ```ts
 * const stage = new TypeStage('/srv/checkout')
-* const check = await stage.inspect(subject, 'configs/src/tsconfig.core.json')
+* const result = await stage.inspect(subject, 'configs/src/tsconfig.core.json')
 * await stage.destroy()
 * ```
 */
@@ -2135,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());
@@ -2191,13 +2158,13 @@ var TypeStage = class {
 		}
 		return {
 			path: contained,
-			digest: computeDigest(this.#workspace, config.compilerOptions)
+			digest: computeWorkspaceDigest(this.#workspace, config.compilerOptions)
 		};
 	}
 	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, {
@@ -2221,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");
@@ -2247,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;
@@ -2307,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;
@@ -2448,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);
@@ -2499,28 +2453,22 @@ 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.
 *
@@ -2661,7 +2609,7 @@ var Probe = class {
 			const started = performance.now();
 			const id = randomUUID();
 			const project = await this.#resolve(claim);
-			const digest = computeDigest(this.#workspace, {
+			const digest = computeWorkspaceDigest(this.#workspace, {
 				case: claim.case,
 				control: claim.control
 			});
@@ -2710,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;
 		}
@@ -2725,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;
 			});
@@ -2824,21 +2773,21 @@ var Probe = class {
 			const beforeType = await this.#inspect(typeClaim.case, typeClaim);
 			const beforeRuntime = await this.#inspect(runtimeClaim.case, runtimeClaim);
 			const before = [...beforeType, ...beforeRuntime];
-			if (before.some((check) => check.issues.length > 0)) throw new ProbeError(`The probe boot control did not begin clean\n${before.map(formatCheck).join("\n")}`, {
+			if (before.some((result) => result.issues.length > 0)) throw new ProbeError(`The probe boot control did not begin clean\n${before.map(formatStageResult).join("\n")}`, {
 				origin: "instrument",
 				code: "malformed"
 			});
 			resolveWorkspaceFile(this.#workspace, relative(this.#workspace, typeDependency), true);
 			overwriteFile(typeDependency, formatSpecification("export type Signal = number\n", revision));
 			const afterType = await this.#inspect(typeClaim.control, typeClaim);
-			const type = afterType.find((check) => check.stage === typeClaim.control.stage);
-			const tolerant = afterType.find((check) => check.stage === "runtime");
-			if (type === void 0 || type.issues.length === 0) throw new ProbeError(`The probe boot type control did not detect a mutated dependency\n${afterType.map(formatCheck).join("\n")}`, {
+			const type = afterType.find((result) => result.stage === typeClaim.control.stage);
+			const tolerant = afterType.find((result) => result.stage === "runtime");
+			if (type === void 0 || type.issues.length === 0) throw new ProbeError(`The probe boot type control did not detect a mutated dependency\n${afterType.map(formatStageResult).join("\n")}`, {
 				origin: "instrument",
 				code: "malformed",
 				context: { stage: typeClaim.control.stage }
 			});
-			if (tolerant === void 0 || tolerant.issues.length > 0) throw new ProbeError(`The probe boot type control did not remain runtime-clean\n${afterType.map(formatCheck).join("\n")}`, {
+			if (tolerant === void 0 || tolerant.issues.length > 0) throw new ProbeError(`The probe boot type control did not remain runtime-clean\n${afterType.map(formatStageResult).join("\n")}`, {
 				origin: "instrument",
 				code: "malformed",
 				context: { stage: "runtime" }
@@ -2846,8 +2795,8 @@ var Probe = class {
 			resolveWorkspaceFile(this.#workspace, relative(this.#workspace, runtimeDependency), true);
 			overwriteFile(runtimeDependency, formatSpecification("export const SIGNAL = 'after'\n", revision));
 			const afterRuntime = await this.#inspect(runtimeClaim.control, runtimeClaim);
-			const runtime = afterRuntime.find((check) => check.stage === runtimeClaim.control.stage);
-			if (runtime === void 0 || runtime.issues.length === 0) throw new ProbeError(`The probe boot runtime control did not detect a mutated dependency\n${afterRuntime.map(formatCheck).join("\n")}`, {
+			const runtime = afterRuntime.find((result) => result.stage === runtimeClaim.control.stage);
+			if (runtime === void 0 || runtime.issues.length === 0) throw new ProbeError(`The probe boot runtime control did not detect a mutated dependency\n${afterRuntime.map(formatStageResult).join("\n")}`, {
 				origin: "instrument",
 				code: "malformed",
 				context: { stage: runtimeClaim.control.stage }
@@ -3063,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
@@ -3303,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 };
+export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, buildRevisionPath, captureListeners, collectWorkspaceFiles, computeWorkspaceDigest, 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