@orkestrel/probe 0.0.2 → 0.0.4

package/dist/src/server/index.js

@@ -1,16 +1,16 @@
 import { createRequire } from "node:module";
-import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 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, ProbeError, computeReceipt, createDestroyedError, formatCheck, formatSpecification, formatVerdict, isClaim, isDraft, isVerdict, matchesSpecification } from "../core/index.js";
+import { CLAIM_SHAPE, ProbeError, computeReceipt, createDestroyedError, formatCheck, 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 { spawn } from "node:child_process";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { PassThrough } from "node:stream";
-import { setImmediate } from "node:timers/promises";
+import { setTimeout } from "node:timers/promises";
 import { createMCPLegacy, createMCPServer } from "@orkestrel/mcp";
 import { createStdioServer } from "@orkestrel/mcp/server";
 import { createTool, createToolManager } from "@orkestrel/tool";
@@ -106,6 +106,46 @@ function resolveWorkspaceFile(workspace, target, mutate = false) {
 	return file;
 }
 /**
+* Overwrites a file that already exists, through a descriptor that refuses a symbolic link at the
+* final component.
+*
+* @remarks
+* A containment walk and the write that follows it are separate calls, so a process that swaps the
+* final component between them decides where the bytes land. `writeFileSync` opens with the default
+* `w` flag, which follows a symbolic link at that component and creates the file when it is absent,
+* so the walk's reading does not bind the write. Opening `O_WRONLY | O_TRUNC | O_NOFOLLOW` moves
+* that decision into the call that writes: a link at the final component refuses the open, and the
+* omitted `O_CREAT` fails `ENOENT` for a target that has gone since the walk saw it. This is the
+* mutating counterpart of the `wx` flag every create in this package uses. Which code the refusal
+* carries is the host's; Linux with Node v22.22.2 reported `ELOOP` on 2026-08-24.
+*
+* A directory component stays open, because Node exposes no descriptor-relative call to walk and
+* write through one set of descriptors. Where a host's Node build defines no `O_NOFOLLOW`, that flag
+* contributes nothing to the flag set and the final component is open on that host too.
+*
+* @param file - The absolute path to overwrite
+* @param text - The text to write
+* @returns Nothing
+* @throws The host's own fault when the final component is a symbolic link, when the file is
+* absent, or when the host refuses the descriptor
+*
+* @example
+* ```ts
+* const file = resolveWorkspaceFile('/srv/checkout', 'tmp/probe/arm-type.ts', true)
+* writeFileSync(file, 'export type Signal = string\n', { encoding: 'utf8', flag: 'wx' })
+* overwriteFile(file, 'export type Signal = number\n')
+* readFileSync(file, 'utf8') // 'export type Signal = number\n'
+* ```
+*/
+function overwriteFile(file, text) {
+	const descriptor = openSync(file, constants.O_WRONLY | constants.O_TRUNC | constants.O_NOFOLLOW);
+	try {
+		writeFileSync(descriptor, text, "utf8");
+	} finally {
+		closeSync(descriptor);
+	}
+}
+/**
 * Reports whether a fault means the host refuses the name a caller supplied for a file to create.
 *
 * @remarks
@@ -169,6 +209,60 @@ function relativeWorkspaceFile(workspace, file) {
 	return normalizePath(relative(resolve(workspace), resolve(file)));
 }
 /**
+* Projects the paths one tool named in a message into the forms this package's issues expose.
+*
+* @remarks
+* An issue's `path` is workspace-relative, and its message is prose a tool wrote about the same
+* tree. Left alone that prose names a file by the host's own layout, so one issue reports a path two
+* ways and a reader on another checkout is sent to a directory that is not theirs. Each spelling of
+* the root is removed: the absolute path, the backslash spelling a Windows tool writes, and the
+* `file:` URL a runtime names a module by. A root the host itself names ends in a separator, and the
+* paths beneath it continue straight from it rather than from one more separator. A path outside the
+* workspace stands as it is, because a relative spelling of it would name a file the tree does not
+* hold.
+*
+* A spelling of the root counts only where a path begins: at the start of the message, or after a
+* character no path carries. A directory whose own name ends in this root's text holds a different
+* tree, so the root inside a longer path names a file this workspace does not hold and that path
+* survives whole.
+*
+* Only the root is removed. A name is otherwise the tool's, including a `.probe-` name that reads
+* like a specification this package generates: the stage that wrote one knows the exact name it
+* wrote and renames that name itself, which is the only reading that separates its own file from a
+* file the target tree owns.
+*
+* Everything else the tool wrote survives verbatim, separators included. A message carries text
+* that is not a path — a runtime escapes a newline as a backslash when it prints a string inline,
+* and a compiler quotes a string literal with its escapes intact — so rewriting every separator
+* would corrupt the evidence the message exists to carry. The cost is that the path left behind
+* keeps the separator the tool chose, which on Windows is not the one `Issue.path` uses.
+*
+* @param workspace - The target workspace root
+* @param message - The message a tool reported
+* @returns The message with the host's own layout removed from every path that begins with it
+*
+* @example
+* ```ts
+* relativeWorkspaceMessage('/srv/checkout', 'Cannot read /srv/checkout/tsconfig.json')
+* // 'Cannot read tsconfig.json'
+* relativeWorkspaceMessage('/srv/checkout', 'Cannot read /mirror/srv/checkout/tsconfig.json')
+* // 'Cannot read /mirror/srv/checkout/tsconfig.json'
+* ```
+*/
+function relativeWorkspaceMessage(workspace, message) {
+	const root = resolve(workspace);
+	const forward = normalizePath(root);
+	const url = pathToFileURL(forward).href;
+	const spellings = /* @__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;
+}
+/**
 * Resolves one installed module from the target workspace.
 *
 * @param workspace - The target workspace root
@@ -456,6 +550,32 @@ function describeUnknown(value) {
 	return String(value);
 }
 /**
+* Guards one resident-stage operation with the stage failure contract.
+*
+* @param stage - The resident 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
+*
+* @example
+* ```ts
+* await guardStage('type', stage.inspect(subject))
+* ```
+*/
+async function guardStage(stage, operation) {
+	try {
+		return await operation;
+	} catch (error) {
+		if (error instanceof ProbeError) throw error;
+		throw new ProbeError(`The ${stage} stage could not serve (${describeUnknown(error)})`, {
+			origin: "instrument",
+			code: "malformed",
+			context: { stage },
+			cause: error
+		});
+	}
+}
+/**
 * Names every draft member of a claim-shaped value whose `path` this package's guard refuses.
 *
 * @remarks
@@ -685,7 +805,7 @@ var Overlay = class {
 };
 //#endregion
 //#region package.json
-var version = "0.0.2";
+var version = "0.0.4";
 var peerDependencies = {
 	"oxlint": "^1.77.0",
 	"typescript": "^6.0.0",
@@ -751,7 +871,16 @@ var LintStage = class {
 	get progress() {
 		return this.#progress;
 	}
-	async inspect(subject) {
+	inspect(subject) {
+		return guardStage(this.stage, this.#inspect(subject));
+	}
+	destroy() {
+		if (this.#closing !== void 0) return this.#closing;
+		this.#destroyed = true;
+		this.#closing = guardStage(this.stage, this.#destroy());
+		return this.#closing;
+	}
+	async #inspect(subject) {
 		if (this.#destroyed) throw createDestroyedError("lint stage");
 		const started = performance.now();
 		await this.#warmth;
@@ -764,12 +893,6 @@ var LintStage = class {
 			issues
 		};
 	}
-	destroy() {
-		if (this.#closing !== void 0) return this.#closing;
-		this.#destroyed = true;
-		this.#closing = this.#destroy();
-		return this.#closing;
-	}
 	async #destroy() {
 		const child = await this.#warmed();
 		this.#fail(createDestroyedError("lint stage"));
@@ -1057,6 +1180,13 @@ var LintStage = class {
 * workspace module whose disk content or candidate revision changed, runs that specification,
 * evicts its result, and deletes the file. Clearing the overlay makes the next snapshot differ from
 * the candidate revision, so the next inspection invalidates that module and reads disk again.
+* After the run, the stage checks each covered module reachable from the generated specification
+* against the overlay paths its loader served. A target-config loader that served first produces a
+* workspace issue; a module id probe's loader received but failed to match produces an instrument
+* issue.
+* The runtime overlay leaves bare specifier resolution to Vite: it replaces a bare import only
+* after Vite resolves that import to a covered file. The type stage overlays the declared test
+* path, while this stage executes a generated sibling and overlays only the candidate files.
 *
 * Vite retains one unresolved URL for every specification path, so the stage replaces its whole
 * Vitest service after 64 specifications rather than deleting from each map that service owns. Any
@@ -1080,9 +1210,12 @@ var LintStage = class {
 * test path the host refuses to create is a claimant failure with `code: 'refused'`. Each is thrown
 * rather than reported, because a test that never ran is no evidence about the candidate.
 *
-* The write path's physical-containment guarantee covers the claim inputs and the target tree as
-* inspected. A concurrent process that mutates a path component between the final inspection and
-* the write is outside that guarantee.
+* Physical containment covers the claim inputs, the target tree as the walk inspected it, and the
+* final component at the moment this stage writes or unlinks it: a specification is created with the
+* `wx` flag, which fails rather than following a symbolic link that appeared after the walk, and an
+* unlink names the final component itself rather than what it points at. A directory component
+* swapped for a symbolic link between the walk and the write stays open, because Node exposes no
+* descriptor-relative call to pin the walk and the write to one set of descriptors.
 *
 * @example
 * ```ts
@@ -1095,6 +1228,8 @@ var RuntimeStage = class {
 	#workspace;
 	#vitest;
 	#overlay = new Overlay();
+	#loads = /* @__PURE__ */ new Set();
+	#reads = /* @__PURE__ */ new Set();
 	#modules = /* @__PURE__ */ new Map();
 	#revisions = /* @__PURE__ */ new Set();
 	#specifications = 0;
@@ -1109,8 +1244,7 @@ var RuntimeStage = class {
 	constructor(workspace = process.cwd()) {
 		this.#workspace = workspace;
 		const vitest = loadWorkspaceModule(this.#workspace, "vitest/node");
-		this.#vitest = this.#warm(vitest.createVitest);
-		this.#vitest.catch(() => {});
+		this.#store(this.#warm(vitest.createVitest));
 	}
 	get stage() {
 		return "runtime";
@@ -1118,7 +1252,16 @@ var RuntimeStage = class {
 	get progress() {
 		return this.#progress;
 	}
-	async inspect(subject) {
+	inspect(subject) {
+		return guardStage(this.stage, this.#inspect(subject));
+	}
+	destroy() {
+		if (this.#closing !== void 0) return this.#closing;
+		this.#destroyed = true;
+		this.#closing = guardStage(this.stage, this.#destroy());
+		return this.#closing;
+	}
+	async #inspect(subject) {
 		if (this.#destroyed) throw createDestroyedError("runtime stage");
 		const started = performance.now();
 		const exitCode = process.exitCode;
@@ -1132,6 +1275,8 @@ var RuntimeStage = class {
 		};
 		const overlay = new Overlay();
 		this.#overlay = overlay;
+		this.#loads.clear();
+		this.#reads.clear();
 		try {
 			for (const draft of subject.files) overlay.set(resolveWorkspaceFile(this.#workspace, draft.path), draft.text);
 			this.#revalidate(vitest);
@@ -1151,7 +1296,7 @@ var RuntimeStage = class {
 			try {
 				try {
 					const result = await vitest.runTestSpecifications([task], false);
-					issues = this.#issues(result, file, subject.test.path);
+					issues = [...this.#issues(result, file, subject.test.path), ...this.#misses(project, file)];
 				} catch (error) {
 					if (error instanceof ProbeError) throw error;
 					throw new ProbeError(`The runtime stage could not run the generated specification (${describeUnknown(error)})`, {
@@ -1186,15 +1331,11 @@ var RuntimeStage = class {
 				issues: [...issues, ...cleanup]
 			};
 		} finally {
+			this.#loads.clear();
+			this.#reads.clear();
 			overlay.clear();
 		}
 	}
-	destroy() {
-		if (this.#closing !== void 0) return this.#closing;
-		this.#destroyed = true;
-		this.#closing = this.#destroy();
-		return this.#closing;
-	}
 	async #destroy() {
 		try {
 			for (const file of this.#revisions) try {
@@ -1202,13 +1343,15 @@ var RuntimeStage = class {
 				if (existsSync(contained)) unlinkSync(contained);
 			} catch {}
 			this.#revisions.clear();
-			const vitest = await this.#vitest.catch(() => void 0);
+			const vitest = await this.#vitest?.catch(() => void 0);
 			if (vitest !== void 0) {
 				vitest.cancelCurrentRun("keyboard-input").catch(() => {});
 				await vitest.close();
 			}
 		} finally {
 			this.#modules.clear();
+			this.#loads.clear();
+			this.#reads.clear();
 			this.#overlay.clear();
 		}
 	}
@@ -1217,8 +1360,9 @@ var RuntimeStage = class {
 		const output = new PassThrough();
 		output.resume();
 		const signals = captureListeners(process, ["SIGINT", "SIGTERM"]);
+		let warming;
 		try {
-			return create("test", {
+			warming = create("test", {
 				root: this.#workspace,
 				config: resolveWorkspaceFile(this.#workspace, "vite.config.ts"),
 				watch: false,
@@ -1236,9 +1380,16 @@ var RuntimeStage = class {
 				stdout: output,
 				stderr: process.stderr
 			});
+		} catch (error) {
+			throw this.#configuration(error);
 		} finally {
 			releaseListeners(process, signals);
 		}
+		try {
+			return await warming;
+		} catch (error) {
+			throw this.#configuration(error);
+		}
 	}
 	#configure(config) {
 		const test = config.test;
@@ -1265,7 +1416,7 @@ var RuntimeStage = class {
 		};
 	}
 	#resolve(id, importer) {
-		const separator = id.lastIndexOf("?");
+		const separator = id.indexOf("?");
 		const specifier = separator === -1 ? id : id.slice(0, separator);
 		const suffix = separator === -1 ? "" : id.slice(separator);
 		if (!specifier.startsWith(".") && !isAbsolute(specifier)) return void 0;
@@ -1277,17 +1428,22 @@ var RuntimeStage = class {
 		if (extension === "") candidates.push(`${imported}.ts`);
 		for (const candidate of candidates) {
 			const resolved = `${candidate}${suffix}`;
-			if (this.#load(resolved) !== void 0) return resolved;
+			if (this.#overlay.text(candidate) !== void 0) return resolved;
 		}
 	}
 	#load(id) {
-		const text = this.#overlay.text(id);
-		if (text !== void 0) return text;
-		const separator = id.lastIndexOf("?");
-		if (separator === -1) return void 0;
-		const query = id.slice(separator + 1);
-		if (!query.startsWith("v=") || query.length === 2 || query.includes("&") || query.includes("#") || query.slice(2).includes("?")) return;
-		return this.#overlay.text(id.slice(0, separator));
+		this.#loads.add(normalizePath(id));
+		const separator = id.indexOf("?");
+		const path = separator === -1 ? id : id.slice(0, separator);
+		const text = this.#overlay.text(path);
+		if (text === void 0) return void 0;
+		this.#reads.add(normalizePath(path));
+		if (separator !== -1 && /(?:^|&)raw(?:&|$)/u.test(id.slice(separator + 1))) return {
+			code: `export default ${JSON.stringify(text)}`,
+			map: { mappings: "" },
+			moduleType: "js"
+		};
+		return text;
 	}
 	#specification(test) {
 		let creating = false;
@@ -1359,6 +1515,47 @@ var RuntimeStage = class {
 		};
 		return project;
 	}
+	#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)) {
+				const modules = environment.moduleGraph.getModulesByFile(path);
+				if (modules === void 0) continue;
+				for (const module of modules) {
+					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;
+						}
+						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({
+				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 {
 			const ids = [];
@@ -1399,17 +1596,38 @@ var RuntimeStage = class {
 		}
 	}
 	#runner() {
-		if (this.#specifications < 64) return this.#vitest;
-		this.#specifications = 0;
-		this.#vitest = this.#replace(this.#vitest);
-		this.#vitest.catch(() => {});
-		return this.#vitest;
+		const current = this.#vitest;
+		if (current !== void 0 && this.#specifications < 64) return current;
+		if (current !== void 0) return this.#store(this.#replace(current));
+		const runner = loadWorkspaceModule(this.#workspace, "vitest/node");
+		return this.#store(this.#specifications < 64 ? this.#warm(runner.createVitest) : this.#replace(void 0, runner.createVitest));
 	}
-	async #replace(current) {
-		await (await current).close();
+	async #replace(current, create) {
+		if (current !== void 0) await (await current).close();
 		if (this.#destroyed) throw createDestroyedError("runtime stage");
-		const runner = loadWorkspaceModule(this.#workspace, "vitest/node");
-		return this.#warm(runner.createVitest);
+		const runner = create ?? loadWorkspaceModule(this.#workspace, "vitest/node").createVitest;
+		const replacement = await this.#warm(runner);
+		this.#specifications = 0;
+		return replacement;
+	}
+	#store(vitest) {
+		this.#vitest = vitest;
+		vitest.catch(() => {
+			if (this.#vitest === vitest) this.#vitest = void 0;
+		});
+		return vitest;
+	}
+	#configuration(error) {
+		if (isProbeError(error)) return error;
+		return new ProbeError(`The runtime stage could not load vite.config.ts (${describeUnknown(error)})`, {
+			origin: "workspace",
+			code: "malformed",
+			context: {
+				stage: this.stage,
+				path: "vite.config.ts"
+			},
+			cause: error
+		});
 	}
 	#revalidate(vitest) {
 		const modules = this.#snapshot();
@@ -1554,7 +1772,7 @@ var RuntimeStage = class {
 		return outcome.success ? outcome.value : path;
 	}
 	#issue(error, specification, original) {
-		const message = describeUnknown(error);
+		const message = relativeWorkspaceMessage(this.#workspace, describeUnknown(error)).replaceAll(basename(specification), basename(original));
 		if (typeof error !== "object" || error === null || !("stacks" in error)) return {
 			origin: "claimant",
 			path: original,
@@ -1661,7 +1879,33 @@ var TypeStage = class {
 	* @returns One outcome for this stage
 	* @throws When the resident compiler cannot start or the stage has already been destroyed
 	*/
-	async inspect(subject, project) {
+	inspect(subject, project) {
+		return guardStage(this.stage, this.#inspect(subject, project));
+	}
+	/**
+	* 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.
+	*
+	* @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
+	*/
+	resolve(project) {
+		return guardStage(this.stage, this.#resolve(project));
+	}
+	destroy() {
+		if (this.#closing !== void 0) return this.#closing;
+		this.#destroyed = true;
+		this.#closing = guardStage(this.stage, this.#destroy());
+		return this.#closing;
+	}
+	async #inspect(subject, project) {
 		if (this.#destroyed) throw createDestroyedError("type stage");
 		const started = performance.now();
 		const typescript = await this.#typescript;
@@ -1673,8 +1917,13 @@ var TypeStage = class {
 			draft: candidate.draft,
 			project: project ?? inferTypeProject(relativeWorkspaceFile(this.#workspace, candidate.path))
 		}));
-		this.#configure(this.#service(typescript, "tsconfig.json"), "tsconfig.json");
-		for (const selection of selections) this.#configure(this.#service(typescript, selection.project), selection.project);
+		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 overlay = new Overlay();
 		this.#overlay = overlay;
 		try {
@@ -1683,7 +1932,6 @@ var TypeStage = class {
 			this.#progress += 1;
 			const issues = [];
 			const projects = /* @__PURE__ */ new Set();
-			const root = this.#service(typescript, "tsconfig.json");
 			issues.push(...this.#issues(typescript, root, subject.test, "tsconfig.json", false, true));
 			projects.add("tsconfig.json");
 			await this.#unblock();
@@ -1704,37 +1952,19 @@ var TypeStage = class {
 			overlay.clear();
 		}
 	}
-	/**
-	* 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.
-	*
-	* @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
-	*/
-	async resolve(project) {
+	async #resolve(project) {
 		if (this.#destroyed) throw createDestroyedError("type stage");
 		const typescript = await this.#typescript;
 		if (this.#destroyed) throw createDestroyedError("type stage");
 		const resolved = resolveWorkspaceFile(this.#workspace, project);
+		this.#progress += 1;
 		this.#service(typescript, project);
+		await this.#unblock();
 		return {
 			path: relativeWorkspaceFile(this.#workspace, resolved),
 			digest: computeDigest(this.#workspace, this.#options.get(resolved) ?? {})
 		};
 	}
-	destroy() {
-		if (this.#closing !== void 0) return this.#closing;
-		this.#destroyed = true;
-		this.#closing = this.#destroy();
-		return this.#closing;
-	}
 	async #destroy() {
 		await this.#typescript.catch(() => void 0);
 		for (const service of this.#services.values()) service.dispose();
@@ -1767,7 +1997,7 @@ var TypeStage = class {
 		return projects;
 	}
 	async #unblock() {
-		await setImmediate();
+		await setTimeout(0);
 		if (this.#destroyed) throw createDestroyedError("type stage");
 	}
 	#record(draft, overlay) {
@@ -1779,7 +2009,7 @@ var TypeStage = class {
 		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, path), {
+		if (config.error !== void 0) throw new ProbeError(this.#translate(typescript, config.error.messageText), {
 			origin: "workspace",
 			code: "malformed",
 			context: {
@@ -1788,7 +2018,7 @@ var TypeStage = class {
 			}
 		});
 		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, path), {
+		if (parsed.errors.length > 0) throw new ProbeError(this.#translate(typescript, parsed.errors[0]?.messageText), {
 			origin: "workspace",
 			code: "malformed",
 			context: {
@@ -1798,27 +2028,55 @@ var TypeStage = class {
 		});
 		this.#options.set(path, parsed.options);
 		this.#files.set(path, parsed.fileNames);
-		const service = typescript.createLanguageService({
-			getCompilationSettings: () => this.#options.get(path) ?? {},
-			getScriptFileNames: () => [...this.#files.get(path) ?? [], ...this.#overlay.paths],
-			getScriptVersion: (file) => this.#version(file),
-			getScriptSnapshot: (file) => this.#snapshot(typescript, file),
-			getCurrentDirectory: () => this.#workspace,
-			getDefaultLibFileName: (options) => typescript.getDefaultLibFilePath(options),
-			fileExists: (file) => this.#overlay.text(file) !== void 0 || typescript.sys.fileExists(file),
-			readFile: (file) => this.#overlay.text(file) ?? typescript.sys.readFile(file),
+		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: (directory) => typescript.sys.directoryExists(directory) || this.#overlay.covers(directory),
+			directoryExists: this.#directoryExists.bind(this, typescript),
 			getDirectories: typescript.sys.getDirectories,
-			useCaseSensitiveFileNames: () => typescript.sys.useCaseSensitiveFileNames,
-			getNewLine: () => typescript.sys.newLine
-		});
+			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;
 	}
-	#translate(typescript, message, path) {
-		return normalizePath(typescript.flattenDiagnosticMessageText(message, "\n")).replaceAll(normalizePath(path), relativeWorkspaceFile(this.#workspace, path));
+	#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;
+	}
+	#newline(typescript) {
+		return typescript.sys.newLine;
+	}
+	#translate(typescript, message) {
+		return relativeWorkspaceMessage(this.#workspace, typescript.flattenDiagnosticMessageText(message, "\n"));
 	}
 	#configure(service, project) {
 		const path = resolveWorkspaceFile(this.#workspace, project);
@@ -1857,7 +2115,7 @@ var TypeStage = class {
 		].map((diagnostic) => this.#issue(typescript, diagnostic, project, selected));
 	}
 	#issue(typescript, diagnostic, project, selected) {
-		const message = typescript.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+		const message = this.#translate(typescript, diagnostic.messageText);
 		if (diagnostic.file === void 0) {
 			if (selected) throw new ProbeError(message, {
 				origin: "claimant",
@@ -1868,7 +2126,7 @@ var TypeStage = class {
 				}
 			});
 			return {
-				origin: "instrument",
+				origin: "workspace",
 				path: project,
 				message
 			};
@@ -1920,6 +2178,8 @@ var Probe = class {
 	#typeQueue;
 	#lintQueue;
 	#runtimeQueue;
+	#deadlines = /* @__PURE__ */ new WeakSet();
+	#typeTail = Promise.resolve();
 	#arming;
 	#closing;
 	#destroyed = false;
@@ -1946,17 +2206,17 @@ var Probe = class {
 		this.#typeQueue = createQueue({
 			concurrency: 1,
 			retries: 0,
-			handler: (inspection) => this.#inspectStage(this.#type, this.#type.progress, this.#type.inspect(inspection.subject, inspection.claim.project), inspection.claim)
+			handler: this.#inspectType.bind(this)
 		});
 		this.#lintQueue = createQueue({
 			concurrency: 1,
 			retries: 0,
-			handler: (inspection) => this.#inspectStage(this.#lint, this.#lint.progress, this.#lint.inspect(inspection.subject), inspection.claim)
+			handler: this.#inspectLint.bind(this)
 		});
 		this.#runtimeQueue = createQueue({
 			concurrency: 1,
 			retries: 0,
-			handler: (inspection) => this.#inspectStage(this.#runtime, this.#runtime.progress, this.#runtime.inspect(inspection.subject), inspection.claim)
+			handler: this.#inspectRuntime.bind(this)
 		});
 		this.#arming = this.#arm();
 		this.#arming.catch(() => {});
@@ -1970,11 +2230,12 @@ var Probe = class {
 	async prove(claim) {
 		try {
 			this.#support();
+			this.#admit(claim);
 			await this.#ready();
 			if (this.#destroyed) throw createDestroyedError("probe");
 			const started = performance.now();
 			const id = randomUUID();
-			const project = await this.#type.resolve(claim.project);
+			const project = await this.#resolve(claim);
 			const digest = computeDigest(this.#workspace, {
 				case: claim.case,
 				control: claim.control
@@ -2112,7 +2373,7 @@ var Probe = class {
 				code: "malformed"
 			});
 			resolveWorkspaceFile(this.#workspace, relative(this.#workspace, typeDependency), true);
-			writeFileSync(typeDependency, formatSpecification("export type Signal = number\n", revision), "utf8");
+			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");
@@ -2127,7 +2388,7 @@ var Probe = class {
 				context: { stage: "runtime" }
 			});
 			resolveWorkspaceFile(this.#workspace, relative(this.#workspace, runtimeDependency), true);
-			writeFileSync(runtimeDependency, formatSpecification("export const SIGNAL = 'after'\n", revision), "utf8");
+			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")}`, {
@@ -2156,20 +2417,44 @@ var Probe = class {
 		for (const pending of admitted) pending.catch(() => {});
 		return Promise.all(admitted);
 	}
+	async #inspectType(inspection) {
+		const release = await this.#admitType();
+		try {
+			const stage = this.#type;
+			return await this.#inspectStage(stage, stage.progress, stage.inspect(inspection.subject, inspection.claim.project), inspection.claim);
+		} finally {
+			release();
+		}
+	}
+	#inspectLint(inspection) {
+		return this.#inspectStage(this.#lint, this.#lint.progress, this.#lint.inspect(inspection.subject), inspection.claim);
+	}
+	#inspectRuntime(inspection) {
+		return this.#inspectStage(this.#runtime, this.#runtime.progress, this.#runtime.inspect(inspection.subject), inspection.claim);
+	}
 	async #inspectStage(stage, progress, operation, claim) {
+		try {
+			return await this.#bound(operation, `The ${stage.stage} stage exceeded ${this.#deadline} ms`, stage, progress);
+		} catch (error) {
+			this.#emitExpiry(stage, claim);
+			throw error;
+		}
+	}
+	async #bound(operation, message, stage, progress) {
 		const timeout = createTimeout({ ms: this.#deadline });
 		timeout.start();
 		try {
-			return await Promise.race([operation, this.#expiry(timeout, `The ${stage.stage} stage exceeded ${this.#deadline} ms`, stage, progress)]);
+			return await Promise.race([operation, this.#expiry(timeout, message, stage, progress)]);
 		} catch (error) {
 			if (!timeout.expired) throw error;
-			if (await this.#recycle(stage)) this.#emitter.emit("expire", claim);
+			await this.#recycle(stage);
 			throw error;
 		} finally {
 			timeout.clear();
 		}
 	}
 	async #recycle(stage) {
+		if (this.#destroyed) return false;
 		const timeout = createTimeout({ ms: this.#deadline });
 		timeout.start();
 		try {
@@ -2192,16 +2477,45 @@ var Probe = class {
 		}
 		return false;
 	}
+	async #admitType() {
+		const previous = this.#typeTail;
+		const turn = Promise.withResolvers();
+		this.#typeTail = turn.promise;
+		await previous;
+		return turn.resolve;
+	}
+	async #resolve(claim) {
+		const release = await this.#admitType();
+		try {
+			const stage = this.#type;
+			try {
+				return await this.#bound(stage.resolve(claim.project), `The type stage project resolution exceeded ${this.#deadline} ms`, stage, stage.progress);
+			} catch (error) {
+				this.#emitExpiry(stage, claim);
+				throw error;
+			}
+		} finally {
+			release();
+		}
+	}
+	#emitExpiry(stage, claim) {
+		if (stage === this.#type || stage === this.#lint || stage === this.#runtime) return;
+		this.#emitter.emit("expire", claim);
+	}
 	#expiry(timeout, message, stage, progress) {
 		return new Promise((_resolve, reject) => {
-			timeout.signal.addEventListener("abort", () => reject(new ProbeError(message, {
-				origin: stage.progress > progress ? "claimant" : "instrument",
-				code: "deadline",
-				context: {
-					stage: stage.stage,
-					deadline: this.#deadline
-				}
-			})), { once: true });
+			timeout.signal.addEventListener("abort", () => {
+				const error = new ProbeError(message, {
+					origin: stage.progress > progress ? "claimant" : "instrument",
+					code: "deadline",
+					context: {
+						stage: stage.stage,
+						deadline: this.#deadline
+					}
+				});
+				this.#deadlines.add(error);
+				reject(error);
+			}, { once: true });
 		});
 	}
 	async #destroy() {
@@ -2209,11 +2523,18 @@ var Probe = class {
 			await this.#arming;
 		} catch {}
 		await Promise.all([
-			this.#type.destroy(),
-			this.#lint.destroy(),
-			this.#runtime.destroy()
+			this.#destroyStage(this.#type),
+			this.#destroyStage(this.#lint),
+			this.#destroyStage(this.#runtime)
 		]);
 	}
+	async #destroyStage(stage) {
+		try {
+			await this.#bound(stage.destroy(), `The ${stage.stage} stage teardown exceeded ${this.#deadline} ms`, stage, stage.progress);
+		} catch (error) {
+			if (!(error instanceof ProbeError) || !this.#deadlines.has(error)) throw error;
+		}
+	}
 	#version(name) {
 		const version = readWorkspaceManifest(this.#workspace, name).contents.version;
 		if (typeof version !== "string") throw new ProbeError(`${name} publishes no readable version`, {
@@ -2223,6 +2544,21 @@ var Probe = class {
 		});
 		return version;
 	}
+	#admit(claim) {
+		const subject = claim.case;
+		const control = claim.control;
+		if (subject.test.path !== control.test.path) return;
+		if (subject.test.text !== control.test.text) return;
+		if (subject.files.length !== control.files.length) return;
+		if (!subject.files.every((draft, index) => {
+			const other = control.files[index];
+			return other !== void 0 && other.path === draft.path && other.text === draft.text;
+		})) return;
+		throw new ProbeError("The control must differ from the case; it carries the same candidate drafts and the same test", {
+			origin: "claimant",
+			code: "refused"
+		});
+	}
 	#support() {
 		const version = this.#toolchain.typescript;
 		const range = peerDependencies.typescript;
@@ -2342,17 +2678,7 @@ var ProbeServer = class {
 			name: "prove",
 			description: "Answers whether a TypeScript edit compiles, lints, and passes its test in this workspace — call it before relying on such a claim, instead of reasoning or writing a throwaway probe. Supply the edit you believe is correct and an edit that must break with the stage it breaks at; the closing line is a receipt only when the case ran clean and the control broke exactly at its declared stage, and no receipt otherwise. For a performance claim, measure before proving: write a guarded bench block — if (import.meta.env.MODE === 'benchmark') — beside the probe test, run the workspace bench script, and record only magnitudes; a settled ratio then proves here as an ordinary runtime claim.",
 			parameters,
-			execute: async (input) => {
-				if (!isClaim(input)) {
-					const refused = findRefusedPaths(input);
-					throw new ProbeError(refused.length === 0 ? "The prove tool requires a claim matching the advertised schema" : `The prove tool refuses ${refused.join(", ")}: a draft path must stay inside the workspace, which the advertised schema does not constrain`, {
-						origin: "claimant",
-						code: "refused",
-						context: { value: input }
-					});
-				}
-				return this.#probe.prove(input);
-			}
+			execute: this.#prove.bind(this)
 		}));
 		return createMCPServer({
 			identity: {
@@ -2360,26 +2686,38 @@ var ProbeServer = class {
 				version
 			},
 			tools,
-			execution: async ({ call }) => {
-				const result = await tools.execute(call);
-				if (!result.success) return result;
-				if (!isVerdict(result.value)) throw new ProbeError("The prove tool returned an invalid verdict", {
-					origin: "instrument",
-					code: "malformed",
-					context: { value: result.value }
-				});
-				return {
-					resultType: "complete",
-					content: [{
-						type: "text",
-						text: formatVerdict(result.value)
-					}]
-				};
-			}
+			execution: this.#execute.bind(this)
 		});
 	}
+	async #prove(input) {
+		if (!isClaim(input)) {
+			const refused = findRefusedPaths(input);
+			throw new ProbeError(refused.length === 0 ? "The prove tool requires a claim matching the advertised schema" : `The prove tool refuses ${refused.join(", ")}: a draft path must stay inside the workspace, which the advertised schema does not constrain`, {
+				origin: "claimant",
+				code: "refused",
+				context: { value: input }
+			});
+		}
+		return this.#probe.prove(input);
+	}
+	async #execute(context) {
+		const result = await context.tools.execute(context.call);
+		if (!result.success) return result;
+		if (!isVerdict(result.value)) throw new ProbeError("The prove tool returned an invalid verdict", {
+			origin: "instrument",
+			code: "malformed",
+			context: { value: result.value }
+		});
+		return {
+			resultType: "complete",
+			content: [{
+				type: "text",
+				text: formatVerdict(result.value)
+			}]
+		};
+	}
 };
 //#endregion
-export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, captureListeners, computeDigest, createRevisionFile, describeUnknown, findRefusedPaths, inferDocumentLanguage, inferTestProject, inferTypeProject, isRefusedName, loadWorkspaceModule, matchesWorkspaceModule, normalizePath, normalizeValue, parseContentLength, readWorkspaceManifest, relativeWorkspaceFile, releaseListeners, resolveWorkspaceBinary, resolveWorkspaceFile, resolveWorkspaceModule };
+export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, captureListeners, computeDigest, createRevisionFile, describeUnknown, findRefusedPaths, guardStage, inferDocumentLanguage, inferTestProject, inferTypeProject, isRefusedName, loadWorkspaceModule, matchesWorkspaceModule, normalizePath, normalizeValue, overwriteFile, parseContentLength, readWorkspaceManifest, relativeWorkspaceFile, relativeWorkspaceMessage, releaseListeners, resolveWorkspaceBinary, resolveWorkspaceFile, resolveWorkspaceModule };
 
 //# sourceMappingURL=index.js.map