@orkestrel/probe 0.0.12 → 0.0.13

package/dist/src/server/index.js

@@ -4,14 +4,14 @@ 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, isRecord, schemaToParameters } from "@orkestrel/contract";
-import { CLAIM_SHAPE, LINT_DEADLINE, PROBE_DEADLINE, PROBE_KEYS, PROBE_SPECIFICATIONS, ProbeError, RUNTIME_PLUGIN, computeReceipt, createDestroyedError, formatCheck, formatReceipt, formatSpecification, formatVerdict, isClaim, isDraft, isProbeError, isVerdict, matchesSpecification } from "../core/index.js";
+import { CLAIM_SHAPE, LINT_DEADLINE, PROBE_DEADLINE, PROBE_KEYS, PROBE_SPECIFICATIONS, ProbeError, RUNTIME_PLUGIN, TYPE_MIRROR, computeReceipt, createDestroyedError, formatCheck, formatReceipt, formatSpecification, formatVerdict, isClaim, isDraft, isProbeError, isVerdict, matchesSpecification } from "../core/index.js";
 import { Emitter } from "@orkestrel/emitter";
 import { createQueue } from "@orkestrel/queue";
 import { createTimeout } from "@orkestrel/timeout";
 import { createLSPClient } from "@orkestrel/lsp";
 import { createStdioClientTransport } from "@orkestrel/lsp/server";
 import { PassThrough } from "node:stream";
-import { setTimeout } from "node:timers/promises";
+import { spawn, spawnSync } from "node:child_process";
 import { createMCPLegacy, createMCPServer, isBoundedJSON } from "@orkestrel/mcp";
 import { createStdioServer } from "@orkestrel/mcp/server";
 import { createTool, createToolManager } from "@orkestrel/tool";
@@ -324,6 +324,65 @@ function relativeWorkspaceMessage(workspace, message) {
 	return text;
 }
 /**
+* Scans the plain-text output of one compiler run into the diagnostics it reported.
+*
+* @remarks
+* Reads the shape `tsc --pretty false` prints: `path(line,column): error TSnnnn: message` for a
+* diagnostic about a file, and `error TSnnnn: message` for one about a project. A line that carries
+* neither prefix and begins with whitespace is an elaboration of the diagnostic above it and joins
+* that message with a newline; any other line is skipped, so a runtime's own failure text yields no
+* diagnostic and a caller reads that as the fault it is. The compiler counts lines and columns from
+* one and columns in UTF-16 code units, so each location is lowered to the zero-based UTF-16 point
+* `Diagnostic.range` fixes and `end` resolves to `start`, which is the extent this output carries.
+* A warning reads as a diagnostic, because the workspace's own gate reports it the same way. The
+* `TS\d+` token that follows `error` or `warning` is what recognizes the line; nothing is captured
+* from it, because `Diagnostic` carries no field for it.
+*
+* @param text - The compiler's output
+* @returns One record per reported diagnostic, in the compiler's own order
+*
+* @example
+* ```ts
+* scanDiagnostics("src/a.ts(1,14): error TS2322: Type 'string' is not assignable to type 'number'.")
+* // [{ path: 'src/a.ts', range: { start: { line: 0, character: 13 }, end: { line: 0, character: 13 } }, message: "Type 'string' is not assignable to type 'number'." }]
+* scanDiagnostics('error TS5058: The specified path does not exist.')
+* // [{ message: 'The specified path does not exist.' }]
+* ```
+*/
+function scanDiagnostics(text) {
+	const diagnostics = [];
+	for (const line of text.split(/\r\n|\n/)) {
+		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;
+		}
+		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 diagnostics;
+}
+/**
 * Resolves one installed module from the target workspace.
 *
 * @param workspace - The target workspace root
@@ -349,18 +408,35 @@ function resolveWorkspaceModule(workspace, specifier) {
 		cause: error
 	});
 }
-function loadWorkspaceModule(workspace, specifier) {
+/**
+* Loads the installed `vitest/node` module from a target workspace.
+*
+* @remarks
+* The only tool this package drives in process. The compiler is a process this package spawns
+* rather than a module it loads, so `typescript` is resolved through {@link resolveWorkspaceBinary}
+* instead.
+*
+* @param workspace - The target workspace root
+* @returns The installed `vitest/node` module
+* @throws When the workspace cannot load `vitest/node`
+*
+* @example
+* ```ts
+* const vitest = loadWorkspaceVitest(process.cwd())
+* typeof vitest.createVitest === 'function' // true
+* ```
+*/
+function loadWorkspaceVitest(workspace) {
 	const outcome = attempt(() => {
-		const require = createRequire(resolve(workspace, "package.json"));
-		return specifier === "typescript" ? require("typescript") : require("vitest/node");
+		return createRequire(resolve(workspace, "package.json"))("vitest/node");
 	});
 	if (outcome.success) return outcome.value;
 	const error = outcome.error;
 	const missing = readFaultCode(error) === "MODULE_NOT_FOUND";
-	throw new ProbeError(`The workspace cannot load ${specifier}`, {
+	throw new ProbeError("The workspace cannot load vitest/node", {
 		origin: "workspace",
 		code: missing ? "missing" : "malformed",
-		context: { name: specifier },
+		context: { name: "vitest/node" },
 		cause: error
 	});
 }
@@ -433,20 +509,26 @@ function readWorkspaceManifest(workspace, name) {
 /**
 * Resolves a package's portable JavaScript binary from the target workspace.
 *
+* @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.
+* Default: the package name.
+*
 * @param workspace - The target workspace root
-* @param name - The installed package name and binary key
+* @param name - The installed package name
+* @param command - The `bin` key to read. Default: `name`
 * @returns The absolute JavaScript entry named by the package's `bin` field
-* @throws When the package does not publish a binary under the requested name
+* @throws When the package does not publish a binary under the requested key
 *
 * @example
 * ```ts
 * relativeWorkspaceFile(process.cwd(), resolveWorkspaceBinary(process.cwd(), 'oxlint'))
 * // 'node_modules/oxlint/bin/oxlint'
-* resolveWorkspaceBinary(process.cwd(), 'typescript')
-* // throws: typescript does not publish the typescript binary
+* relativeWorkspaceFile(process.cwd(), resolveWorkspaceBinary(process.cwd(), 'typescript', 'tsc'))
+* // 'node_modules/typescript/bin/tsc'
 * ```
 */
-function resolveWorkspaceBinary(workspace, name) {
+function resolveWorkspaceBinary(workspace, name, command = name) {
 	const manifest = readWorkspaceManifest(workspace, name);
 	const bin = manifest.contents.bin;
 	if (bin === void 0) throw new ProbeError(`${name} does not publish a bin field`, {
@@ -455,13 +537,13 @@ function resolveWorkspaceBinary(workspace, name) {
 		context: { name }
 	});
 	if (typeof bin === "string") return resolve(manifest.path, "..", bin);
-	if (!isRecord(bin) || !(name in bin)) throw new ProbeError(`${name} does not publish the ${name} binary`, {
+	if (!isRecord(bin) || !(command in bin)) throw new ProbeError(`${name} does not publish the ${command} binary`, {
 		origin: "workspace",
 		code: "missing",
 		context: { name }
 	});
-	const entry = bin[name];
-	if (typeof entry !== "string") throw new ProbeError(`${name} publishes an invalid ${name} binary`, {
+	const entry = bin[command];
+	if (typeof entry !== "string") throw new ProbeError(`${name} publishes an invalid ${command} binary`, {
 		origin: "workspace",
 		code: "malformed",
 		context: {
@@ -562,6 +644,39 @@ function buildRevisionPath(workspace, path, revision) {
 	return `${extension === "" ? file : file.slice(0, -extension.length)}.probe-${revision}${extension}`;
 }
 /**
+* Filters one issue list to the distinct issues it carries, in the order they arrived.
+*
+* @remarks
+* A stage that reads one candidate through more than one tool run reports that candidate's
+* diagnostic once per run. Two issues are the same issue when their party, path, message, and range
+* all agree, because those are every value an issue carries.
+*
+* @param issues - The issues to filter
+* @returns The distinct issues, in the order the list carried them
+*
+* @example
+* ```ts
+* const issue: Issue = { origin: 'claimant', path: 'src/core/greeting.ts', message: 'not assignable' }
+* filterUniqueIssues([issue, { ...issue }]).length // 1
+* ```
+*/
+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;
+}
+/**
 * Reports whether a path is a workspace module Vitest can cache.
 *
 * @param path - The candidate file path
@@ -577,6 +692,75 @@ function matchesWorkspaceModule(path) {
 	return /\.(?:[cm]?[jt]sx?|vue|json)$/.test(path);
 }
 /**
+* Reports whether the host that wrote one file is still running.
+*
+* @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.
+*
+* @param id - The process id a file's own revision names
+* @returns True if that process is running or cannot be judged; false otherwise
+*
+* @example
+* ```ts
+* matchesLiveProcess(process.pid) // true
+* matchesLiveProcess(0) // true
+* ```
+*/
+function matchesLiveProcess(id) {
+	if (!Number.isSafeInteger(id) || id <= 0) return true;
+	try {
+		process.kill(id, 0);
+		return true;
+	} catch (error) {
+		return readFaultCode(error) === "EPERM";
+	}
+}
+/**
+* Collects every regular file a target workspace holds, skipping the trees no inspection reads.
+*
+* @remarks
+* Skips a directory named `.git`, `dist`, or `node_modules` at any depth, and the directory
+* {@link TYPE_MIRROR} names, which would otherwise carry this package's own mirror into the walk. A
+* directory this host cannot list is skipped rather than raised, so one unreadable directory in a
+* consumer's tree is not a reason to refuse the whole walk. A symbolic link is not carried, whether
+* it names a file or a directory, so a file reached only through one is absent from the result; a
+* `Dirent` that is neither a directory nor a regular file is skipped the same way.
+*
+* @param workspace - The target workspace root
+* @returns The absolute path of every regular file the walk found
+*
+* @example
+* ```ts
+* collectWorkspaceFiles(process.cwd()).some((path) => path.endsWith('package.json')) // true
+* ```
+*/
+function collectWorkspaceFiles(workspace) {
+	const excluded = normalizePath(resolveWorkspaceFile(workspace, TYPE_MIRROR));
+	const files = [];
+	const directories = [resolve(workspace)];
+	while (directories.length > 0) {
+		const directory = directories.pop();
+		if (directory === void 0) break;
+		let entries = [];
+		try {
+			entries = readdirSync(directory, { withFileTypes: true });
+		} catch {}
+		for (const entry of entries) {
+			if (entry.name === ".git" || entry.name === "dist" || entry.name === "node_modules") continue;
+			const path = join(directory, entry.name);
+			if (entry.isDirectory()) {
+				if (normalizePath(path) !== excluded) directories.push(path);
+				continue;
+			}
+			if (entry.isFile()) files.push(path);
+		}
+	}
+	return files;
+}
+/**
 * Normalizes a caught or foreign error into readable text.
 *
 * @param value - The value to describe
@@ -595,9 +779,9 @@ function describeUnknown(value) {
 	return String(value);
 }
 /**
-* Guards one resident-stage operation with the stage failure contract.
+* Guards one stage operation with the stage failure contract.
 *
-* @param stage - The resident stage serving the operation
+* @param stage - The stage serving the operation
 * @param operation - The operation to settle
 * @returns The operation's fulfilled value
 * @throws The original `ProbeError`, or an instrument-owned malformed failure retaining the cause
@@ -669,12 +853,12 @@ function findRefusedPaths(value) {
 * sorts every record's keys.
 *
 * @remarks
-* A parsed TypeScript project carries the absolute root it was parsed at, so the same commit
-* checked out at two paths produces two values that describe one configuration. Rewriting those
-* members makes the value portable and stops a host path leaking into anything derived from it. 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 parser's, not the configuration's, so
-* sorting removes a difference that means nothing.
+* `tsc --showConfig` spells a path relative to the project file, so a printed record carries an
+* absolute path only where a project itself declares one. Rewriting a contained absolute path to
+* 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.
 *
 * @param workspace - The target workspace root
 * @param value - The value to rewrite
@@ -775,9 +959,66 @@ function releaseListeners(emitter, capture) {
 	}
 }
 //#endregion
+//#region src/server/parsers.ts
+/**
+* Parses the configuration one compiler run printed for a TypeScript project.
+*
+* @remarks
+* Reads what `tsc --showConfig` writes: a JSON record carrying the resolved `compilerOptions`
+* beside the project's own file selection. `compilerOptions` is carried unvalidated, because a
+* caller digests it rather than reading a member out of it. `files` and `include` are read only
+* where the printed record carries one whose entries are all strings, so a member the compiler
+* printed in another shape reads as absent rather than as an empty selection. Text that is not a
+* JSON record, including the diagnostic the compiler prints for a project it refuses, yields
+* `undefined`.
+*
+* @param text - The compiler's printed configuration
+* @returns The project's resolved configuration, or `undefined` when the text carries no record
+*
+* @example
+* ```ts
+* parseProjectConfig('{"compilerOptions":{"strict":true}}')?.compilerOptions // { strict: true }
+* parseProjectConfig("error TS5058: The specified path does not exist.") // undefined
+* ```
+*/
+function parseProjectConfig(text) {
+	const parsed = attempt(() => JSON.parse(text));
+	if (!parsed.success || !isRecord(parsed.value)) return void 0;
+	const files = parsed.value.files;
+	const include = parsed.value.include;
+	return {
+		compilerOptions: parsed.value.compilerOptions,
+		...isArray(files) && files.every((entry) => typeof entry === "string") ? { files } : {},
+		...isArray(include) && include.every((entry) => typeof entry === "string") ? { include } : {}
+	};
+}
+/**
+* Parses the process id one revision identity names.
+*
+* @remarks
+* Every file and directory this package writes into a target carries the writing host's process id
+* and a fresh UUID, joined by `-`. A sweep reads that id to decide whether the host that wrote the
+* name is gone. The whole identity must match, so a name carrying anything else yields `undefined`
+* and the sweep leaves what it found alone.
+*
+* @param revision - The revision identity a name carries
+* @returns The process id it names, or `undefined` when the text is not a revision identity
+*
+* @example
+* ```ts
+* parseRevisionOwner('4821-1b4e28ba-2fa1-11d2-883f-0016d3cca427') // 4821
+* parseRevisionOwner('4821-9f0c') // undefined
+* ```
+*/
+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
 /**
-* Holds the candidate drafts one inspection substitutes for the files a tool would read from disk.
+* 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.
 *
 * @remarks
 * One overlay belongs to one inspection: the inspection creates it, records every candidate it
@@ -786,55 +1027,44 @@ function releaseListeners(emitter, capture) {
 * is what makes a resident tool re-read a path this overlay holds, so two inspections that supply
 * different text for one path never share a cached answer.
 *
-* This overlay matches a lookup key the way the host its stage declares to its tool matches file
-* names. A host that resolves two spellings of one file name to one file leaves the tool holding
-* whichever spelling it met first — the disk one, where the file is on disk — and the tool asks
-* under that, so an overlay matching keys exactly answers nothing and the tool reads the committed
-* file instead. Mint the overlay with the sensitivity the stage declares, and one reading decides
-* both. The recorded spelling is what `paths` reports and what `covers` matches a directory
-* against, so a folded key never reaches the paths a tool is handed and containment stays an exact
-* comparison.
+* A lookup key matches a recorded path exactly, after both pass through `normalizePath`, so a tool
+* that reports its own paths with backslashes still reaches a candidate recorded with forward
+* slashes. Case is never folded: the recorded spelling is what `paths` reports, what `covers`
+* compares a directory against, and what `text` answers under. A stage whose tool resolves two
+* spellings of one file name to one file therefore reports the path its tool served rather than
+* matching the two spellings here.
 *
 * @example
 * ```ts
 * const overlay = new Overlay()
-* overlay.set('/srv/checkout/src/core/greeting.ts', "export const GREETING = 'hi'\n")
-* console.log(overlay.text('/srv/checkout/src/core/greeting.ts'))
+* const path = '/srv/checkout/src/core/factories.ts'
+* overlay.set(path, "export function createGreeting(): string {\n\treturn 'hi'\n}\n")
+* console.log(overlay.text(path))
 * overlay.clear()
 * ```
 */
 var Overlay = class {
 	#revision = randomUUID();
-	#sensitive;
 	#candidates = /* @__PURE__ */ new Map();
-	/**
-	* Creates an empty candidate set under a fresh identity.
-	*
-	* @param options - Construction options
-	*/
-	constructor(options = {}) {
-		this.#sensitive = options.sensitive ?? true;
-	}
 	get revision() {
 		return this.#revision;
 	}
 	get paths() {
-		return [...this.#candidates.values()].map(([path]) => path);
+		return [...this.#candidates.keys()];
 	}
 	/**
 	* Records one candidate's text against the absolute path it stands in for.
 	*
 	* @remarks
-	* Recording a candidate under a path this overlay's own matching reads as one already recorded
-	* replaces that candidate, the way one file holds one text.
+	* Recording a candidate under a path this overlay already holds replaces that candidate, the way
+	* one file holds one text.
 	*
 	* @param path - The absolute path the candidate replaces
 	* @param text - The candidate's full contents
 	* @returns Nothing
 	*/
 	set(path, text) {
-		const recorded = normalizePath(path);
-		this.#candidates.set(this.#key(recorded), [recorded, text]);
+		this.#candidates.set(normalizePath(path), text);
 	}
 	/**
 	* Reads the candidate text recorded for one absolute path.
@@ -843,7 +1073,7 @@ var Overlay = class {
 	* @returns The recorded text, or `undefined` when this overlay holds no candidate there
 	*/
 	text(path) {
-		return this.#candidates.get(this.#key(normalizePath(path)))?.[1];
+		return this.#candidates.get(normalizePath(path));
 	}
 	/**
 	* Checks whether a candidate sits beneath one directory.
@@ -852,16 +1082,14 @@ var Overlay = class {
 	* The answer is derived from the paths the overlay holds rather than stored, so it stops being
 	* true exactly when the inspection that declared those candidates clears them. Both sides pass
 	* through `normalizePath` first, because a tool that normalizes its own paths asks about a
-	* directory in a spelling the recorded path may not share. Case is never folded here: this is a
-	* containment comparison, and it reads the recorded spelling whatever an overlay minted for a
-	* case-folding host matches its lookup keys by.
+	* directory in a spelling the recorded path may not share.
 	*
 	* @param directory - The absolute directory path to check
 	* @returns True if a candidate path sits beneath the directory; false otherwise
 	*/
 	covers(directory) {
 		const base = `${normalizePath(directory).replace(/\/+$/, "")}/`;
-		for (const [path] of this.#candidates.values()) if (path.startsWith(base)) return true;
+		for (const path of this.#candidates.keys()) if (path.startsWith(base)) return true;
 		return false;
 	}
 	/**
@@ -872,15 +1100,12 @@ var Overlay = class {
 	clear() {
 		this.#candidates.clear();
 	}
-	#key(path) {
-		return this.#sensitive ? path : path.toLowerCase();
-	}
 };
 //#endregion
 //#region package.json
-var version = "0.0.12";
+var version = "0.0.13";
 var peerDependencies = {
-	"oxlint": "^1.80.0",
+	"oxlint": "^1.82.0",
 	"typescript": "^6.0.3",
 	"vitest": "^4.1.11"
 };
@@ -1165,7 +1390,7 @@ var RuntimeStage = class {
 	*/
 	constructor(workspace = process.cwd()) {
 		this.#workspace = workspace;
-		const vitest = loadWorkspaceModule(this.#workspace, "vitest/node");
+		const vitest = loadWorkspaceVitest(this.#workspace);
 		this.#store(this.#warm(vitest.createVitest));
 	}
 	get stage() {
@@ -1174,9 +1399,29 @@ var RuntimeStage = class {
 	get progress() {
 		return this.#progress;
 	}
+	/**
+	* Inspects one case.
+	*
+	* @param subject - The candidate drafts and test to inspect
+	* @returns One outcome for this stage
+	* @throws When the workspace's own tool cannot start or has already been destroyed
+	*/
 	inspect(subject) {
 		return guardStage(this.stage, this.#inspect(subject));
 	}
+	/**
+	* Tears down the resident tool or the mirror and releases its resources.
+	*
+	* @remarks
+	* A stage abandons every inspection it holds rather than waiting behind one, so teardown never
+	* waits for an inspection to return. An abandoned inspection rejects, either at the stage's own
+	* guard or as the owned tool closes. Teardown is bounded whatever the stage's own tool does: a
+	* tool that answers neither its warming exchange nor its ending is signalled and released at the
+	* stage's own deadline. A coordinator replaces a stage whose worker no longer returns because
+	* teardown neither waits for an inspection nor waits past that deadline.
+	*
+	* @returns A promise that settles after the resident tool or the mirror releases its resources
+	*/
 	destroy() {
 		if (this.#closing !== void 0) return this.#closing;
 		this.#closing = guardStage(this.stage, this.#destroy());
@@ -1520,13 +1765,13 @@ var RuntimeStage = class {
 		const current = this.#vitest;
 		if (current !== void 0 && this.#specifications < PROBE_SPECIFICATIONS) return current;
 		if (current !== void 0) return this.#store(this.#replace(current));
-		const runner = loadWorkspaceModule(this.#workspace, "vitest/node");
+		const runner = loadWorkspaceVitest(this.#workspace);
 		return this.#store(this.#specifications < PROBE_SPECIFICATIONS ? this.#warm(runner.createVitest) : this.#replace(void 0, runner.createVitest));
 	}
 	async #replace(current, create) {
 		if (current !== void 0) await (await current).close();
 		if (this.#closing !== void 0) throw createDestroyedError("runtime stage");
-		const runner = create ?? loadWorkspaceModule(this.#workspace, "vitest/node").createVitest;
+		const runner = create ?? loadWorkspaceVitest(this.#workspace).createVitest;
 		const replacement = await this.#warm(runner);
 		this.#specifications = 0;
 		return replacement;
@@ -1570,7 +1815,7 @@ var RuntimeStage = class {
 	}
 	#snapshot() {
 		const modules = /* @__PURE__ */ new Map();
-		for (const path of this.#walk()) {
+		for (const path of collectWorkspaceFiles(this.#workspace)) {
 			if (!matchesWorkspaceModule(path)) continue;
 			try {
 				const digest = createHash("sha256").update(readFileSync(path)).digest("hex");
@@ -1581,12 +1826,12 @@ var RuntimeStage = class {
 		return modules;
 	}
 	#sweep() {
-		for (const path of this.#walk()) {
+		for (const path of collectWorkspaceFiles(this.#workspace)) {
 			const match = [...basename(path).matchAll(/\.probe-((\d+)-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?=\.|$)/gu)].at(-1);
 			const revision = match?.[1];
 			const owner = match?.[2];
 			if (revision === void 0 || owner === void 0) continue;
-			if (this.#alive(Number.parseInt(owner, 10))) continue;
+			if (matchesLiveProcess(Number.parseInt(owner, 10))) continue;
 			if (!this.#owned(path, revision)) continue;
 			try {
 				unlinkSync(resolveWorkspaceFile(this.#workspace, relative(this.#workspace, path), true));
@@ -1597,35 +1842,6 @@ var RuntimeStage = class {
 		const outcome = attempt(() => readFileSync(path, "utf8"));
 		return outcome.success && matchesSpecification(outcome.value, revision);
 	}
-	#alive(id) {
-		if (!Number.isSafeInteger(id) || id <= 0) return true;
-		try {
-			process.kill(id, 0);
-			return true;
-		} catch (error) {
-			return readFaultCode(error) === "EPERM";
-		}
-	}
-	*#walk() {
-		const directories = [resolve(this.#workspace)];
-		while (directories.length > 0) {
-			const directory = directories.pop();
-			if (directory === void 0) break;
-			let entries = [];
-			try {
-				entries = readdirSync(directory, { withFileTypes: true });
-			} catch {}
-			for (const entry of entries) {
-				if (entry.name === ".git" || entry.name === "dist" || entry.name === "node_modules") continue;
-				const path = join(directory, entry.name);
-				if (entry.isDirectory()) {
-					directories.push(path);
-					continue;
-				}
-				if (entry.isFile()) yield path;
-			}
-		}
-	}
 	#issues(result, file, original) {
 		const specification = this.#real(file);
 		const issues = [];
@@ -1741,21 +1957,32 @@ var RuntimeStage = class {
 //#endregion
 //#region src/server/stages/TypeStage.ts
 /**
-* Inspects TypeScript source through resident language services from the target workspace.
+* Inspects TypeScript source by running the target workspace's own compiler over a mirror of it.
 *
 * @remarks
-* Construction starts loading the workspace's compiler and warming one service per project the
-* workspace declares. A candidate draft is checked against the project a call names, or
-* against its own scoped environment project when a call names none, while the test uses the root
-* project. Disk snapshots use their modification time as the service version so dependency edits
-* cannot leave a warm answer stale. Candidate text lives in an overlay the inspection owns, and
-* the language-service host answers existence, reads, and versions from it, so a candidate that
-* exists only as text is importable and a candidate that shadows a disk file is checked as the
-* text the case supplied. A project outside the declared set holds one recycled slot, so a caller
-* varying the project cannot grow the resident set. A language service checks one candidate
-* synchronously, so the stage hands the host's event loop back at each candidate boundary: a
-* caller's deadline is answered within one candidate's check rather than after the whole
-* inspection, and an inspection abandoned at that deadline stops at the next boundary.
+* 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. Construction sweeps a
+* mirror an earlier host left behind, copies the workspace into a fresh one under
+* {@link TYPE_MIRROR}, and builds each declared project's incremental state there, so the first
+* inspection is warm.
+*
+* Every inspection refreshes the mirror by content digest, writes each candidate draft and the test
+* at its mirrored declared path, and runs `tsc --noEmit --pretty false` once per distinct selected
+* project. A draft therefore shadows the file it replaces: a consumer of that path is checked
+* against the draft's text, and a draft importing a sibling draft resolves to the sibling draft.
+* Nothing is written outside `tmp/`, and the workspace's own copy of a drafted file never moves.
+*
+* Each run reads a scratch project this stage writes beside the mirrored project it extends, so
+* every relative path the project declares — its own `rootDir`, `include`, `paths`, and the
+* projects it extends — resolves inside the mirror without being rewritten. The scratch adds the
+* drafts as `files`, which the project's own `exclude` does not reach, and its incremental state
+* lives in the mirror so reuse survives the refresh.
+*
+* The diagnostics decide the outcome, never the exit code, which the supported compiler majors
+* disagree on. A diagnostic naming a project file, and one naming no file at all, is the target
+* tree's own configuration fault and raises rather than reporting, unless the `.json` file is one
+* the claim itself drafted; every other diagnostic is a claimant issue at the point the compiler
+* reported, which is the extent the plain-text output carries.
 *
 * @example
 * ```ts
@@ -1766,26 +1993,27 @@ var RuntimeStage = class {
 */
 var TypeStage = class {
 	#workspace;
-	#typescript;
-	#services = /* @__PURE__ */ new Map();
-	#resident = /* @__PURE__ */ new Set();
-	#options = /* @__PURE__ */ new Map();
-	#files = /* @__PURE__ */ new Map();
-	#diagnostics = /* @__PURE__ */ new Map();
-	#overlay = new Overlay();
-	#recycled;
+	#compiler;
+	#revision = `${process.pid}-${randomUUID()}`;
+	#mirror;
+	#configs = /* @__PURE__ */ new Map();
+	#mirrored = /* @__PURE__ */ new Map();
+	#drafts = /* @__PURE__ */ new Set();
+	#children = /* @__PURE__ */ new Set();
+	#warming;
 	#closing;
 	#progress = 0;
 	/**
-	* Starts warming the target workspace's TypeScript service.
+	* Resolves the target workspace's compiler and starts warming its mirror.
 	*
 	* @param workspace - The target workspace root. Default: the current working directory
 	*/
 	constructor(workspace = process.cwd()) {
 		this.#workspace = workspace;
-		const typescript = loadWorkspaceModule(this.#workspace, "typescript");
-		this.#typescript = this.#warm(typescript);
-		this.#typescript.catch(() => {});
+		this.#compiler = resolveWorkspaceBinary(workspace, "typescript", "tsc");
+		this.#mirror = resolveWorkspaceFile(workspace, `${TYPE_MIRROR}/${this.#revision}`);
+		this.#warming = this.#warm();
+		this.#warming.catch(() => {});
 	}
 	get stage() {
 		return "type";
@@ -1805,7 +2033,8 @@ var TypeStage = class {
 	* @param project - The workspace-relative TypeScript project the candidate drafts are checked
 	* against. Default: the scoped project each candidate path infers
 	* @returns One outcome for this stage
-	* @throws When the resident compiler cannot start or the stage has already been destroyed
+	* @throws When the workspace refuses the mirror, when a project the run reads is malformed, or
+	* when the stage has already been destroyed
 	*/
 	inspect(subject, project) {
 		return guardStage(this.stage, this.#inspect(subject, project));
@@ -1814,15 +2043,15 @@ var TypeStage = class {
 	* Resolves one project to the path and digest this stage applies for it.
 	*
 	* @remarks
-	* Reads the parse this stage itself applies, filling its cache when the project is not already
-	* resident, so the reported digest is the configuration the inspection is judged under rather
-	* than a second parse a caller ran. The returned record is a value copy, so a later eviction
-	* does not move it.
+	* Reads the configuration the compiler itself prints for the project as the mirror holds it,
+	* 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.
 	*
 	* @param project - The workspace-relative TypeScript project to resolve
 	* @returns The resolved workspace-relative path and the digest of its compiler options
-	* @throws When the project escapes the workspace, cannot be parsed, or the stage has already
-	* been destroyed
+	* @throws When the project escapes the workspace, when the compiler refuses it, or when the
+	* stage has already been destroyed
 	*/
 	resolve(project) {
 		return guardStage(this.stage, this.#resolve(project));
@@ -1833,81 +2062,76 @@ var TypeStage = class {
 		return this.#closing;
 	}
 	async #inspect(subject, project) {
-		if (this.#closing !== void 0) throw createDestroyedError("type stage");
+		this.#refuseDestroyed();
 		const started = performance.now();
-		const typescript = await this.#typescript;
-		if (this.#closing !== void 0) throw createDestroyedError("type stage");
-		const selections = subject.files.map((draft) => ({
+		await this.#warming;
+		this.#refuseDestroyed();
+		const test = resolveWorkspaceFile(this.#workspace, subject.test.path);
+		const resolved = subject.files.map((draft) => ({
 			draft,
 			path: resolveWorkspaceFile(this.#workspace, draft.path)
-		})).map((candidate) => ({
-			draft: candidate.draft,
-			project: project ?? inferTypeProject(relativeWorkspaceFile(this.#workspace, candidate.path))
 		}));
-		const root = this.#service(typescript, "tsconfig.json");
-		this.#configure(root, "tsconfig.json");
-		await this.#unblock();
-		for (const selection of selections) {
-			this.#configure(this.#service(typescript, selection.project), selection.project);
-			await this.#unblock();
+		const groups = /* @__PURE__ */ new Map([[this.#contain("tsconfig.json"), [subject.test]]]);
+		for (const candidate of resolved) {
+			const selected = this.#contain(project ?? inferTypeProject(relativeWorkspaceFile(this.#workspace, candidate.path)));
+			const drafts = groups.get(selected);
+			if (drafts === void 0) groups.set(selected, [candidate.draft]);
+			else drafts.push(candidate.draft);
 		}
-		const overlay = new Overlay({ sensitive: this.#caseSensitive(typescript) });
-		this.#overlay = overlay;
+		this.#progress += 1;
+		for (const selected of groups.keys()) await this.#configure(selected);
+		this.#refuseDestroyed();
 		try {
-			this.#record(subject.test, overlay);
-			for (const draft of subject.files) this.#record(draft, overlay);
-			this.#progress += 1;
+			this.#refresh();
+			this.#drafts.add(this.#place(subject.test.text, test));
+			for (const candidate of resolved) this.#drafts.add(this.#place(candidate.draft.text, candidate.path));
 			const issues = [];
-			const projects = /* @__PURE__ */ new Set();
-			issues.push(...this.#issues(typescript, root, subject.test, "tsconfig.json", false, true));
-			projects.add("tsconfig.json");
-			await this.#unblock();
-			for (const selection of selections) {
-				const draft = selection.draft;
-				const selected = selection.project;
-				const service = this.#service(typescript, selected);
-				issues.push(...this.#issues(typescript, service, draft, selected, project !== void 0, !projects.has(selected)));
-				projects.add(selected);
-				await this.#unblock();
+			for (const [selected, drafts] of groups) {
+				this.#refuseDestroyed();
+				issues.push(...await this.#check(selected, drafts));
 			}
 			return {
 				stage: this.stage,
 				elapsed: Math.round(performance.now() - started),
-				issues
+				issues: filterUniqueIssues(issues)
 			};
 		} finally {
-			overlay.clear();
+			this.#release();
 		}
 	}
 	async #resolve(project) {
-		if (this.#closing !== void 0) throw createDestroyedError("type stage");
-		const typescript = await this.#typescript;
-		if (this.#closing !== void 0) throw createDestroyedError("type stage");
-		const resolved = resolveWorkspaceFile(this.#workspace, project);
+		this.#refuseDestroyed();
+		const contained = this.#contain(project);
 		this.#progress += 1;
-		this.#service(typescript, project);
-		await this.#unblock();
+		const config = await this.#configure(contained);
 		return {
-			path: relativeWorkspaceFile(this.#workspace, resolved),
-			digest: computeDigest(this.#workspace, this.#options.get(resolved) ?? {})
+			path: contained,
+			digest: computeDigest(this.#workspace, config.compilerOptions)
 		};
 	}
 	async #destroy() {
-		await this.#typescript.catch(() => void 0);
-		for (const service of this.#services.values()) service.dispose();
-		this.#services.clear();
-		this.#resident.clear();
-		this.#recycled = void 0;
-		this.#options.clear();
-		this.#files.clear();
-		this.#diagnostics.clear();
-	}
-	async #warm(typescript) {
-		for (const project of this.#projects()) {
-			this.#resident.add(resolveWorkspaceFile(this.#workspace, project));
-			this.#service(typescript, project);
-		}
-		return typescript;
+		const children = [...this.#children];
+		this.#children.clear();
+		for (const child of children) this.#terminate(child);
+		await this.#warming.catch(() => void 0);
+		try {
+			rmSync(this.#mirror, {
+				recursive: true,
+				force: true,
+				maxRetries: 5,
+				retryDelay: 20
+			});
+		} catch {}
+		this.#configs.clear();
+		this.#mirrored.clear();
+		this.#drafts.clear();
+	}
+	async #warm() {
+		this.#sweep();
+		this.#createMirror();
+		this.#refresh();
+		this.#refuseDestroyed();
+		await Promise.all(this.#projects().map((project) => this.#check(project, [])));
 	}
 	#projects() {
 		const projects = ["tsconfig.json"];
@@ -1923,162 +2147,291 @@ var TypeStage = class {
 		}
 		return projects;
 	}
-	async #unblock() {
-		await setTimeout(0);
+	#refuseDestroyed() {
 		if (this.#closing !== void 0) throw createDestroyedError("type stage");
 	}
-	#record(draft, overlay) {
-		overlay.set(resolveWorkspaceFile(this.#workspace, draft.path), draft.text);
-	}
-	#service(typescript, project) {
-		const path = resolveWorkspaceFile(this.#workspace, project);
-		const existing = this.#services.get(path);
-		if (existing !== void 0) return existing;
-		const spelling = normalizePath(path);
-		const config = typescript.readConfigFile(spelling, typescript.sys.readFile);
-		if (config.error !== void 0) throw new ProbeError(this.#translate(typescript, config.error.messageText), {
-			origin: "workspace",
-			code: "malformed",
-			context: {
-				stage: this.stage,
-				project
-			}
+	#createMirror() {
+		const marker = resolveWorkspaceFile(this.#workspace, `${TYPE_MIRROR}/${this.#revision}/.probe/mirror.txt`, true);
+		mkdirSync(dirname(marker), { recursive: true });
+		writeFileSync(marker, formatSpecification("", this.#revision), {
+			encoding: "utf8",
+			flag: "wx"
 		});
-		const parsed = typescript.parseJsonConfigFileContent(config.config, typescript.sys, dirname(spelling), void 0, spelling);
-		if (parsed.errors.length > 0) throw new ProbeError(this.#translate(typescript, parsed.errors[0]?.messageText), {
-			origin: "workspace",
-			code: "malformed",
-			context: {
-				stage: this.stage,
-				project
-			}
-		});
-		this.#options.set(path, parsed.options);
-		this.#files.set(path, parsed.fileNames);
-		const host = {
-			getCompilationSettings: this.#compilationSettings.bind(this, path),
-			getScriptFileNames: this.#scriptFiles.bind(this, path),
-			getScriptVersion: this.#version.bind(this),
-			getScriptSnapshot: this.#snapshot.bind(this, typescript),
-			getCurrentDirectory: this.#directory.bind(this),
-			getDefaultLibFileName: this.#defaultLibrary.bind(this, typescript),
-			fileExists: this.#fileExists.bind(this, typescript),
-			readFile: this.#readFile.bind(this, typescript),
-			readDirectory: typescript.sys.readDirectory,
-			directoryExists: this.#directoryExists.bind(this, typescript),
-			getDirectories: typescript.sys.getDirectories,
-			useCaseSensitiveFileNames: this.#caseSensitive.bind(this, typescript),
-			getNewLine: this.#newline.bind(this, typescript)
-		};
-		const service = typescript.createLanguageService(host);
-		this.#services.set(path, service);
-		if (!this.#resident.has(path)) this.#recycle(path);
-		return service;
-	}
-	#compilationSettings(path) {
-		return this.#options.get(path) ?? {};
-	}
-	#scriptFiles(path) {
-		return [...this.#files.get(path) ?? [], ...this.#overlay.paths];
-	}
-	#directory() {
-		return this.#workspace;
-	}
-	#defaultLibrary(typescript, options) {
-		return typescript.getDefaultLibFilePath(options);
-	}
-	#fileExists(typescript, file) {
-		return this.#overlay.text(file) !== void 0 || typescript.sys.fileExists(file);
-	}
-	#readFile(typescript, file) {
-		return this.#overlay.text(file) ?? typescript.sys.readFile(file);
 	}
-	#directoryExists(typescript, directory) {
-		return typescript.sys.directoryExists(directory) || this.#overlay.covers(directory);
-	}
-	#caseSensitive(typescript) {
-		return typescript.sys.useCaseSensitiveFileNames;
+	#sweep() {
+		const root = resolveWorkspaceFile(this.#workspace, TYPE_MIRROR);
+		let entries = [];
+		try {
+			entries = readdirSync(root, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const owner = parseRevisionOwner(entry.name);
+			if (owner === void 0 || matchesLiveProcess(owner)) continue;
+			const marker = attempt(() => readFileSync(join(root, entry.name, ".probe", "mirror.txt"), "utf8"));
+			if (!marker.success || !matchesSpecification(marker.value, entry.name)) continue;
+			try {
+				rmSync(join(root, entry.name), {
+					recursive: true,
+					force: true,
+					maxRetries: 5,
+					retryDelay: 20
+				});
+			} catch {}
+		}
 	}
-	#newline(typescript) {
-		return typescript.sys.newLine;
+	#refresh() {
+		const present = /* @__PURE__ */ new Set();
+		for (const path of collectWorkspaceFiles(this.#workspace)) {
+			const contained = relativeWorkspaceFile(this.#workspace, path);
+			present.add(contained);
+			const reading = attempt(() => readFileSync(path));
+			if (!reading.success) continue;
+			const digest = createHash("sha256").update(reading.value).digest("hex");
+			if (this.#mirrored.get(contained) === digest) continue;
+			this.#place(reading.value, path);
+			this.#mirrored.set(contained, digest);
+		}
+		for (const contained of [...this.#mirrored.keys()]) {
+			if (present.has(contained)) continue;
+			this.#remove(contained);
+			this.#mirrored.delete(contained);
+		}
 	}
-	#translate(typescript, message) {
-		return relativeWorkspaceMessage(this.#workspace, typescript.flattenDiagnosticMessageText(message, "\n"));
+	#release() {
+		for (const contained of this.#drafts) {
+			this.#remove(contained);
+			this.#mirrored.delete(contained);
+		}
+		this.#drafts.clear();
+	}
+	#place(text, path) {
+		const contained = relativeWorkspaceFile(this.#workspace, path);
+		const target = this.#mirrorPath(contained);
+		if (attempt(() => {
+			mkdirSync(dirname(target), { recursive: true });
+			writeFileSync(target, text);
+		}).success) return contained;
+		this.#displace(target);
+		mkdirSync(dirname(target), { recursive: true });
+		writeFileSync(target, text);
+		return contained;
+	}
+	#displace(target) {
+		const ancestors = [];
+		let directory = dirname(target);
+		while (directory !== this.#mirror && directory !== dirname(directory)) {
+			ancestors.unshift(directory);
+			directory = dirname(directory);
+		}
+		for (const ancestor of [...ancestors, target]) {
+			const reading = attempt(() => lstatSync(ancestor));
+			if (!reading.success) continue;
+			if (ancestor !== target && reading.value.isDirectory()) continue;
+			if (ancestor === target && !reading.value.isDirectory()) continue;
+			rmSync(ancestor, {
+				recursive: true,
+				force: true,
+				maxRetries: 5,
+				retryDelay: 20
+			});
+			this.#mirrored.delete(relativeWorkspaceFile(this.#mirror, ancestor));
+		}
 	}
-	#configure(service, project) {
-		const path = resolveWorkspaceFile(this.#workspace, project);
-		if (this.#diagnostics.has(path)) return;
-		this.#diagnostics.set(path, service.getCompilerOptionsDiagnostics());
+	#mirrorPath(contained) {
+		return join(this.#mirror, contained);
 	}
-	#recycle(path) {
-		const previous = this.#recycled;
-		this.#recycled = path;
-		if (previous === void 0 || previous === path) return;
-		this.#services.get(previous)?.dispose();
-		this.#services.delete(previous);
-		this.#options.delete(previous);
-		this.#files.delete(previous);
-		this.#diagnostics.delete(previous);
+	#contain(project) {
+		return relativeWorkspaceFile(this.#workspace, resolveWorkspaceFile(this.#workspace, project));
 	}
-	#version(file) {
-		if (this.#overlay.text(file) !== void 0) return `virtual:${this.#overlay.revision}`;
+	#remove(contained) {
 		try {
-			return `disk:${statSync(file).mtimeMs}`;
-		} catch {
-			return "missing";
-		}
+			rmSync(this.#mirrorPath(contained), {
+				force: true,
+				maxRetries: 5,
+				retryDelay: 20
+			});
+		} catch {}
 	}
-	#snapshot(typescript, file) {
-		const text = this.#overlay.text(file) ?? typescript.sys.readFile(file);
-		return text === void 0 ? void 0 : typescript.ScriptSnapshot.fromString(text);
-	}
-	#issues(typescript, service, draft, project, selected, configure) {
-		const path = resolveWorkspaceFile(this.#workspace, draft.path);
-		const configuration = resolveWorkspaceFile(this.#workspace, project);
-		return [
-			...configure ? this.#diagnostics.get(configuration) ?? [] : [],
-			...service.getSyntacticDiagnostics(path),
-			...service.getSemanticDiagnostics(path)
-		].map((diagnostic) => this.#issue(typescript, diagnostic, project, selected));
-	}
-	#issue(typescript, diagnostic, project, selected) {
-		const message = this.#translate(typescript, diagnostic.messageText);
-		if (diagnostic.file === void 0) {
-			if (selected) throw new ProbeError(message, {
-				origin: "claimant",
-				code: "refused",
+	async #configure(project) {
+		const contained = this.#contain(project);
+		const existing = this.#configs.get(contained);
+		if (existing !== void 0) return existing;
+		this.#refresh();
+		const execution = await this.#spawn([
+			"--showConfig",
+			"-p",
+			contained
+		], this.#mirror);
+		this.#refuseDestroyed();
+		const config = parseProjectConfig(execution.stdout);
+		if (config === void 0) throw this.#fault(execution, contained);
+		this.#configs.set(contained, config);
+		return config;
+	}
+	async #check(project, drafts) {
+		const config = await this.#configure(project);
+		const scratch = this.#scratch(this.#contain(project), config, drafts);
+		const execution = await this.#spawn([
+			"--noEmit",
+			"--pretty",
+			"false",
+			"-p",
+			`./${scratch}`
+		], this.#mirror);
+		this.#refuseDestroyed();
+		const diagnostics = scanDiagnostics(execution.stdout);
+		if (diagnostics.length === 0 && execution.status !== 0) {
+			const stderr = execution.stderr.trim();
+			const message = stderr !== "" ? stderr : execution.status === void 0 ? "The compiler reported no diagnostic and was ended by a signal" : `The compiler reported no diagnostic and exited ${execution.status}`;
+			throw new ProbeError(this.#translate(message), {
+				origin: "instrument",
+				code: "malformed",
 				context: {
 					stage: this.stage,
 					project
 				}
 			});
-			return {
-				origin: "workspace",
-				path: project,
-				message
-			};
 		}
-		const path = relativeWorkspaceFile(this.#workspace, diagnostic.file.fileName);
-		if (diagnostic.start === void 0) return {
-			origin: "claimant",
-			path,
-			message
+		return this.#issues(diagnostics, project);
+	}
+	#scratch(project, config, drafts) {
+		const directory = dirname(project);
+		const stem = `${basename(project, extname(project))}.probe.json`;
+		const contained = directory === "." ? stem : `${directory}/${stem}`;
+		const target = this.#mirrorPath(contained);
+		const buildinfo = join(this.#mirror, ".probe", `${project.replaceAll("/", "-")}.tsbuildinfo`);
+		const files = [...(config.files ?? []).filter((entry) => existsSync(resolve(dirname(target), entry))), ...drafts.map((draft) => relativeWorkspaceFile(dirname(target), this.#mirrorPath(this.#contain(draft.path))))];
+		const body = {
+			extends: `./${basename(project)}`,
+			compilerOptions: {
+				noEmit: true,
+				declaration: false,
+				emitDeclarationOnly: false,
+				composite: false,
+				incremental: true,
+				tsBuildInfoFile: relativeWorkspaceFile(dirname(target), buildinfo)
+			},
+			...files.length === 0 ? {} : { files }
 		};
-		return {
-			origin: "claimant",
-			path,
-			message,
-			range: {
-				start: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start),
-				end: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start + (diagnostic.length ?? 0))
+		mkdirSync(dirname(target), { recursive: true });
+		writeFileSync(target, `${JSON.stringify(body, void 0, "	")}\n`, "utf8");
+		return contained;
+	}
+	#issues(diagnostics, project) {
+		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, {
+				origin: "workspace",
+				code: "malformed",
+				context: {
+					stage: this.stage,
+					project
+				}
+			});
+			const path = escapesRoot(this.#mirror, resolved) ? escapesRoot(this.#workspace, resolved) ? normalizePath(resolved) : relativeWorkspaceFile(this.#workspace, resolved) : relativeWorkspaceFile(this.#mirror, resolved);
+			issues.push({
+				origin: "claimant",
+				path,
+				message,
+				...diagnostic.range === void 0 ? {} : { range: diagnostic.range }
+			});
+		}
+		return issues;
+	}
+	#translate(message) {
+		return relativeWorkspaceMessage(this.#workspace, relativeWorkspaceMessage(this.#mirror, message));
+	}
+	#fault(execution, project) {
+		const reported = scanDiagnostics(execution.stdout).map((diagnostic) => diagnostic.message);
+		const text = reported.length > 0 ? reported.join("\n") : execution.stdout.trim();
+		return new ProbeError(this.#translate(text === "" ? "The compiler printed no configuration" : text), {
+			origin: "workspace",
+			code: "malformed",
+			context: {
+				stage: this.stage,
+				project
 			}
-		};
+		});
+	}
+	#spawn(args, cwd) {
+		this.#refuseDestroyed();
+		return new Promise((settle, refuse) => {
+			const child = spawn(process.execPath, [this.#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;
+			}
+			this.#children.add(child);
+			let stdout = "";
+			let stderr = "";
+			output.setEncoding("utf8");
+			errors.setEncoding("utf8");
+			output.on("data", (chunk) => {
+				stdout += chunk;
+			});
+			errors.on("data", (chunk) => {
+				stderr += chunk;
+			});
+			child.on("error", (error) => {
+				this.#children.delete(child);
+				refuse(new ProbeError("The workspace compiler could not be started", {
+					origin: "workspace",
+					code: "malformed",
+					context: {
+						stage: this.stage,
+						path: this.#compiler
+					},
+					cause: error
+				}));
+			});
+			child.on("close", (code) => {
+				this.#children.delete(child);
+				settle({
+					...code === null ? {} : { status: code },
+					stdout,
+					stderr
+				});
+			});
+		});
+	}
+	#terminate(child) {
+		const id = child.pid;
+		if (process.platform === "win32" && id !== void 0) {
+			spawnSync("taskkill", [
+				"/pid",
+				String(id),
+				"/t",
+				"/f"
+			], { stdio: "ignore" });
+			return;
+		}
+		child.kill("SIGTERM");
 	}
 };
 //#endregion
 //#region src/server/Probe.ts
 /**
-* Answers claims through resident TypeScript, Oxlint, and Vitest stages.
+* Answers claims through its type, lint, and runtime stages.
 *
 * @remarks
 * Construction resolves the target workspace's toolchain and begins warming every stage. The boot
@@ -2090,10 +2443,45 @@ var TypeStage = class {
 * claim costs that claim rather than the process. A failed boot is replaced the same way: the next
 * claim runs the controls again rather than inheriting a refusal.
 *
-* @example
+* @example The claim that earns a receipt
 * ```ts
-* const probe = new Probe({ workspace: '/srv/checkout' })
+* import type { Claim } from '@orkestrel/probe'
+* import { Probe } from '@orkestrel/probe/server'
+*
+* const claim: Claim = {
+* 	project: 'configs/src/tsconfig.core.json',
+* 	case: {
+* 		files: [
+* 			{
+* 				path: 'src/core/factories.ts',
+* 				text: "export function createGreeting(): string {\n\treturn 'hi'\n}\n",
+* 			},
+* 		],
+* 		test: {
+* 			path: 'tmp/probe/greeting.test.ts',
+* 			text: "import { expect, test } from 'vitest'\nimport { createGreeting } from '../../src/core/factories.js'\ntest('greets', () => expect(createGreeting()).toBe('hi'))\n",
+* 		},
+* 	},
+* 	control: {
+* 		files: [
+* 			{
+* 				path: 'src/core/factories.ts',
+* 				text: "export function createGreeting(): number {\n\treturn 'hi'\n}\n",
+* 			},
+* 		],
+* 		test: {
+* 			path: 'tmp/probe/greeting.test.ts',
+* 			text: "import { expect, test } from 'vitest'\nimport { createGreeting } from '../../src/core/factories.js'\ntest('greets', () => expect(createGreeting()).toBe('hi'))\n",
+* 		},
+* 		stage: 'type',
+* 		reason: 'a string returned as a number must not compile',
+* 	},
+* }
+*
+* const probe = new Probe({ workspace: process.cwd() })
 * const verdict = await probe.prove(claim)
+* verdict.digest // 'fcb88a2dee987b8673c1fc7107979470'
+* verdict.receipt // 'probe:fcb88a2dee987b8673c1fc7107979470:type:typescript@6.0.3:oxlint@1.82.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
 * await probe.destroy()
 * ```
 */
@@ -2114,7 +2502,7 @@ var Probe = class {
 	#arming;
 	#closing;
 	/**
-	* Resolves the target toolchain and starts warming the resident stages.
+	* Resolves the target toolchain and starts warming every stage.
 	*
 	* @param options - Workspace, deadline, and initial observation hooks
 	*/
@@ -2279,7 +2667,7 @@ var Probe = class {
 				files: [],
 				test: typeTest,
 				stage: "type",
-				reason: "the imported type changed after the resident type host cached it"
+				reason: "the imported type changed on disk between the two inspections"
 			}
 		};
 		const runtimeClaim = {
@@ -2526,7 +2914,9 @@ var Probe = class {
 //#endregion
 //#region src/server/ProbeServer.ts
 /**
-* Serves one probe over this process's Model Context Protocol stdio transport.
+* 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
+* stdio transport.
 *
 * @remarks
 * Construction creates the probe, publishes the `prove` tool, and binds the dual-era dispatcher to
@@ -2692,6 +3082,6 @@ var ProbeServer = class {
 	}
 };
 //#endregion
-export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, buildRevisionPath, captureListeners, computeDigest, describeUnknown, escapesRoot, findRefusedPaths, guardStage, inferDocumentLanguage, inferTestProject, inferTypeProject, isRefusedName, loadWorkspaceModule, matchesWorkspaceModule, normalizePath, normalizeValue, overwriteFile, readFaultCode, readWorkspaceManifest, relativeWorkspaceFile, relativeWorkspaceMessage, releaseListeners, resolveWorkspaceBinary, resolveWorkspaceFile, resolveWorkspaceModule };
+export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, buildRevisionPath, captureListeners, collectWorkspaceFiles, computeDigest, 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