@orkestrel/probe 0.0.5 → 0.0.8

package/dist/src/server/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, constants, existsSync, ftruncateSync, 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";
@@ -8,7 +8,8 @@ import { CLAIM_SHAPE, ProbeError, computeReceipt, createDestroyedError, formatCh
 import { Emitter } from "@orkestrel/emitter";
 import { createQueue } from "@orkestrel/queue";
 import { createTimeout } from "@orkestrel/timeout";
-import { spawn } from "node:child_process";
+import { createLSPClient } from "@orkestrel/lsp";
+import { createStdioTransport } from "@orkestrel/lsp/server";
 import { PassThrough } from "node:stream";
 import { setTimeout } from "node:timers/promises";
 import { createMCPLegacy, createMCPServer } from "@orkestrel/mcp";
@@ -113,12 +114,18 @@ function resolveWorkspaceFile(workspace, target, mutate = false) {
 * 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
+* so the walk's reading does not bind the write. Opening `O_WRONLY | 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.
 *
+* Truncation runs through the held descriptor rather than through an `O_TRUNC` flag, so it reaches
+* the file the open bound. A Windows host refuses the numeric `O_TRUNC` without `O_CREAT` outright:
+* measured on 2026-08-26 on Windows 11 with Node v24.19.0 over NTFS, `openSync` reported `EINVAL`
+* for `O_WRONLY | O_TRUNC` and for `O_RDWR | O_TRUNC` while `O_WRONLY` alone opened, and adding
+* `O_CREAT` would trade that refusal for the create this function must never perform.
+*
 * 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.
@@ -138,8 +145,9 @@ function resolveWorkspaceFile(workspace, target, mutate = false) {
 * ```
 */
 function overwriteFile(file, text) {
-	const descriptor = openSync(file, constants.O_WRONLY | constants.O_TRUNC | constants.O_NOFOLLOW);
+	const descriptor = openSync(file, constants.O_WRONLY | constants.O_NOFOLLOW);
 	try {
+		ftruncateSync(descriptor, 0);
 		writeFileSync(descriptor, text, "utf8");
 	} finally {
 		closeSync(descriptor);
@@ -514,24 +522,6 @@ function matchesWorkspaceModule(path) {
 	return /\.(?:[cm]?[jt]sx?|vue|json)$/.test(path);
 }
 /**
-* Reads a JSON-RPC frame's declared byte length.
-*
-* @param header - The frame header text without its terminating empty line
-* @returns The non-negative content length, or `undefined` for an invalid header
-*
-* @example
-* ```ts
-* parseContentLength('Content-Length: 128') // 128
-* parseContentLength('Content-Type: application/json') // undefined
-* ```
-*/
-function parseContentLength(header) {
-	const text = /(?:^|\r\n)Content-Length:\s*(\d+)(?:\r\n|$)/i.exec(header)?.[1];
-	if (text === void 0) return void 0;
-	const length = Number.parseInt(text, 10);
-	return Number.isSafeInteger(length) && length >= 0 ? length : void 0;
-}
-/**
 * Normalizes a caught or foreign error into readable text.
 *
 * @param value - The value to describe
@@ -805,7 +795,7 @@ var Overlay = class {
 };
 //#endregion
 //#region package.json
-var version = "0.0.5";
+var version = "0.0.8";
 var peerDependencies = {
 	"oxlint": "^1.77.0",
 	"typescript": "^6.0.0",
@@ -817,13 +807,22 @@ var peerDependencies = {
 * Inspects virtual documents through one resident Oxlint language server.
 *
 * @remarks
-* Construction starts the target workspace's Oxlint binary with its Language Server Protocol
-* mode. Each inspection opens the supplied text by URI, waits for published diagnostics, and
-* closes the document without writing it to disk.
+* Construction starts the target workspace's Oxlint binary with its Language Server Protocol mode
+* and hands the conversation to `@orkestrel/lsp`: `createStdioTransport` owns the child process and
+* its bytes, and `createLSPClient` owns the framing, the request correlation, the capabilities this
+* stage advertises, and the choice between pulled and pushed diagnostics. This stage owns the
+* workspace, the candidate identity, and the projection from a diagnostic to an `Issue`.
+*
+* Each inspection opens the supplied text by URI, waits for the client's diagnostics, and closes the
+* document without writing it to disk. The caller's own signal is what bounds that wait, so a server
+* that admits a document and publishes nothing refuses the inspection when the caller's bound
+* expires rather than holding it for the life of the process. This stage mints no bound of its own
+* for the wait: a second one would race the caller's, and the answer would depend on scheduling.
 *
 * Teardown is bounded at both ends. Warming waits for the server's `initialize` response and the
-* ending waits for its `shutdown` reply, and the protocol leaves both answers to the server, so
-* `destroy` bounds each exchange and takes the ending back with a signal when the bound passes.
+* ending waits for its `shutdown` reply, and the protocol leaves both answers to the server, so the
+* client's deadline bounds each exchange and the transport's cooperative window takes the ending
+* back with a signal when that window passes.
 *
 * The URI is the path the candidate declared, so the candidate receives exactly the rule set the
 * workspace's own lint gate applies to that path, including an override anchored to one directory,
@@ -836,24 +835,20 @@ var peerDependencies = {
 * @example
 * ```ts
 * const stage = new LintStage('/srv/checkout')
-* const check = await stage.inspect(subject)
+* const check = await stage.inspect(subject, { signal: AbortSignal.timeout(30_000) })
 * await stage.destroy()
 * ```
 */
 var LintStage = class {
 	#workspace;
 	#deadline = 2e3;
+	#documents = /* @__PURE__ */ new Set();
 	#warmth;
-	#responses = /* @__PURE__ */ new Map();
-	#failures = /* @__PURE__ */ new Map();
-	#documents = /* @__PURE__ */ new Map();
-	#publishes = /* @__PURE__ */ new Map();
-	#refusals = /* @__PURE__ */ new Map();
-	#child;
-	#buffer = Buffer.alloc(0);
-	#sequence = 0;
+	#client;
+	#ending;
 	#closing;
 	#progress = 0;
+	#revision = 0;
 	#destroyed = false;
 	/**
 	* Starts warming the target workspace's Oxlint language server.
@@ -871,8 +866,8 @@ var LintStage = class {
 	get progress() {
 		return this.#progress;
 	}
-	inspect(subject) {
-		return guardStage(this.stage, this.#inspect(subject));
+	inspect(subject, options) {
+		return guardStage(this.stage, this.#inspect(subject, options));
 	}
 	destroy() {
 		if (this.#closing !== void 0) return this.#closing;
@@ -880,13 +875,18 @@ var LintStage = class {
 		this.#closing = guardStage(this.stage, this.#destroy());
 		return this.#closing;
 	}
-	async #inspect(subject) {
+	async #inspect(subject, options) {
 		if (this.#destroyed) throw createDestroyedError("lint stage");
+		if (options === void 0) throw new ProbeError("The lint stage inspects only under a bound its caller supplies", {
+			origin: "claimant",
+			code: "refused",
+			context: { stage: this.stage }
+		});
 		const started = performance.now();
-		await this.#warmth;
+		const client = await this.#warmed();
 		if (this.#destroyed) throw createDestroyedError("lint stage");
 		const issues = [];
-		for (const draft of [...subject.files, subject.test]) issues.push(...await this.#document(draft));
+		for (const draft of [...subject.files, subject.test]) issues.push(...await this.#document(client, draft, options.signal));
 		return {
 			stage: this.stage,
 			elapsed: Math.round(performance.now() - started),
@@ -894,118 +894,86 @@ var LintStage = class {
 		};
 	}
 	async #destroy() {
-		const child = await this.#warmed();
-		this.#fail(createDestroyedError("lint stage"));
-		if (child === void 0 || this.#ending !== void 0) return;
-		const released = new Promise((resolve) => {
-			child.once("exit", () => resolve());
-			child.once("close", () => resolve());
+		await this.#client?.destroy();
+	}
+	async #warm() {
+		const binary = resolveWorkspaceBinary(this.#workspace, "oxlint");
+		const client = createLSPClient({
+			transport: createStdioTransport({
+				server: {
+					command: [
+						process.execPath,
+						binary,
+						"--lsp"
+					],
+					directory: this.#workspace
+				},
+				grace: this.#deadline / 2
+			}),
+			workspace: pathToFileURL(this.#workspace).href,
+			timeout: this.#deadline
 		});
-		await this.#release(child, released);
+		this.#client = client;
+		client.emitter.on("exit", (exit) => this.#retire(exit));
+		await client.start();
+		return client;
 	}
 	async #warmed() {
-		const timeout = createTimeout({ ms: this.#deadline });
-		timeout.start();
-		try {
-			return await Promise.race([this.#warmth, this.#expiry(timeout)]);
-		} catch {
-			return this.#child;
-		} finally {
-			timeout.clear();
-		}
-	}
-	async #release(child, released) {
-		const timeout = createTimeout({ ms: this.#deadline });
-		timeout.start();
-		try {
-			await Promise.race([this.#retire(child).then(() => released), this.#expiry(timeout)]);
-		} catch {
-			child.kill("SIGKILL");
-			await released;
-		} finally {
-			timeout.clear();
-		}
-	}
-	async #retire(child) {
 		try {
-			await this.#request("shutdown", void 0);
-			this.#notify("exit", void 0);
-		} catch {
-			child.kill("SIGKILL");
+			return await this.#warmth;
+		} catch (error) {
+			throw this.#translate(error);
 		}
 	}
-	#expiry(timeout) {
-		return new Promise((_resolve, reject) => {
-			timeout.signal.addEventListener("abort", () => reject(new ProbeError(`The Oxlint language server did not exit within ${timeout.ms} ms`, {
-				origin: "instrument",
-				code: "deadline",
-				context: {
-					stage: this.stage,
-					deadline: timeout.ms
-				}
-			})), { once: true });
-		});
-	}
-	async #warm() {
-		const binary = resolveWorkspaceBinary(this.#workspace, "oxlint");
-		const child = spawn(process.execPath, [binary, "--lsp"], {
-			cwd: this.#workspace,
-			stdio: "pipe"
-		});
-		this.#child = child;
-		child.stderr.resume();
-		child.stdout.on("data", (chunk) => this.#read(chunk));
-		child.stdin.on("error", (error) => this.#fail(error));
-		child.on("error", (error) => this.#fail(error));
-		child.on("exit", (code, signal) => this.#exit(code, signal));
-		await this.#request("initialize", {
-			processId: process.pid,
-			rootUri: pathToFileURL(this.#workspace).href,
-			capabilities: {},
-			workspaceFolders: [{
-				uri: pathToFileURL(this.#workspace).href,
-				name: "workspace"
-			}]
-		});
-		this.#notify("initialized", {});
-		return child;
+	#retire(exit) {
+		this.#ending = exit.signal === null ? `code ${exit.code}` : `signal ${exit.signal}`;
 	}
-	#document(draft) {
+	async #document(client, draft, signal) {
 		const uri = pathToFileURL(resolveWorkspaceFile(this.#workspace, draft.path)).href;
-		if (this.#publishes.has(uri)) return Promise.reject(new ProbeError(`The lint stage is already inspecting ${draft.path}`, {
+		if (this.#documents.has(uri)) throw new ProbeError(`The lint stage is already inspecting ${draft.path}`, {
 			origin: "claimant",
 			code: "refused",
 			context: {
 				stage: this.stage,
 				path: draft.path
 			}
-		}));
-		const inspected = new Promise((resolve, reject) => {
-			this.#documents.set(uri, normalizePath(draft.path));
-			this.#publishes.set(uri, resolve);
-			this.#refusals.set(uri, reject);
-		}).finally(() => this.#close(uri));
+		});
+		this.#documents.add(uri);
+		this.#progress += 1;
+		this.#revision += 1;
 		try {
-			this.#notify("textDocument/didOpen", { textDocument: {
+			const diagnostics = await client.open({
 				uri,
 				languageId: inferDocumentLanguage(draft.path),
-				version: this.#sequence,
+				version: this.#revision,
 				text: draft.text
-			} });
-			this.#progress += 1;
+			}, { signal });
+			return this.#issues(normalizePath(draft.path), diagnostics);
 		} catch (error) {
-			this.#refusals.get(uri)?.(this.#fault(describeUnknown(error), error, draft.path));
+			if (signal.aborted) throw this.#abandoned(draft.path);
+			throw this.#translate(error, draft.path);
+		} finally {
+			this.#progress -= 1;
+			this.#documents.delete(uri);
+			await client.close(uri).catch(() => void 0);
 		}
-		return inspected;
 	}
-	get #ending() {
-		const child = this.#child;
-		if (child === void 0) return void 0;
-		if (child.exitCode === null && child.signalCode === null) return void 0;
-		return this.#describe(child.exitCode, child.signalCode);
+	#abandoned(path) {
+		return new ProbeError("The lint stage inspection stopped at the bound its caller supplied", {
+			origin: "claimant",
+			code: "deadline",
+			context: {
+				stage: this.stage,
+				path
+			}
+		});
 	}
-	#describe(code, signal) {
-		return signal === null ? `code ${code}` : `signal ${signal}`;
+	#translate(error, path) {
+		if (this.#destroyed) return createDestroyedError("lint stage");
+		const ending = this.#ending;
+		if (ending !== void 0) return this.#fault(`The Oxlint language server exited with ${ending}`, error, path);
+		if (error instanceof Error) return error;
+		return this.#fault(describeUnknown(error), error, path);
 	}
 	#fault(message, cause, path) {
 		return new ProbeError(message, {
@@ -1018,153 +986,22 @@ var LintStage = class {
 			...cause === void 0 ? {} : { cause }
 		});
 	}
-	get #reachable() {
-		return this.#ending === void 0 && this.#child?.stdin.writable === true;
-	}
-	#close(uri) {
-		this.#documents.delete(uri);
-		this.#publishes.delete(uri);
-		this.#refusals.delete(uri);
-		if (this.#destroyed || !this.#reachable) return;
-		this.#notify("textDocument/didClose", { textDocument: { uri } });
-	}
-	#request(method, params) {
-		this.#sequence += 1;
-		const id = this.#sequence;
-		const response = new Promise((resolve, reject) => {
-			this.#responses.set(id, resolve);
-			this.#failures.set(id, reject);
-		});
-		try {
-			this.#send({
-				jsonrpc: "2.0",
-				id,
-				method,
-				params
-			});
-		} catch (error) {
-			const reject = this.#failures.get(id);
-			this.#responses.delete(id);
-			this.#failures.delete(id);
-			reject?.(this.#fault(describeUnknown(error), error));
-		}
-		return response;
-	}
-	#notify(method, params) {
-		this.#sequence += 1;
-		this.#send({
-			jsonrpc: "2.0",
-			method,
-			params
-		});
-	}
-	#send(message) {
-		const child = this.#child;
-		if (this.#ending !== void 0) throw this.#fault(`The Oxlint language server exited with ${this.#ending}`);
-		if (child === void 0) throw this.#fault("The Oxlint language server is not running");
-		if (!child.stdin.writable) throw this.#fault("The Oxlint language server closed its input");
-		const content = JSON.stringify(message);
-		const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
-		child.stdin.write(header + content);
-	}
-	#read(chunk) {
-		this.#buffer = Buffer.concat([this.#buffer, chunk]);
-		while (this.#frame());
-	}
-	#frame() {
-		const boundary = this.#buffer.indexOf("\r\n\r\n");
-		if (boundary < 0) return false;
-		const length = parseContentLength(this.#buffer.subarray(0, boundary).toString("ascii"));
-		if (length === void 0) {
-			this.#fail(this.#fault("Oxlint sent an invalid JSON-RPC frame header"));
-			return false;
-		}
-		const start = boundary + 4;
-		const end = start + length;
-		if (this.#buffer.length < end) return false;
-		const content = this.#buffer.subarray(start, end).toString("utf8");
-		this.#buffer = this.#buffer.subarray(end);
-		try {
-			const message = JSON.parse(content);
-			this.#receive(message);
-		} catch (error) {
-			this.#fail(this.#fault(`Oxlint sent invalid JSON: ${describeUnknown(error)}`, error));
-		}
-		return true;
-	}
-	#receive(message) {
-		if (typeof message !== "object" || message === null) return;
-		if ("id" in message && typeof message.id === "number") {
-			const id = message.id;
-			const resolve = this.#responses.get(id);
-			const reject = this.#failures.get(id);
-			this.#responses.delete(id);
-			this.#failures.delete(id);
-			if ("error" in message && message.error !== void 0) reject?.(this.#fault(describeUnknown(message.error)));
-			else resolve?.("result" in message ? message.result : void 0);
-			return;
-		}
-		if (!("method" in message) || message.method !== "textDocument/publishDiagnostics") return;
-		if (!("params" in message) || typeof message.params !== "object" || message.params === null) return;
-		const params = message.params;
-		if (!("uri" in params) || typeof params.uri !== "string") return;
-		if (!("diagnostics" in params) || !Array.isArray(params.diagnostics)) return;
-		const publish = this.#publishes.get(params.uri);
-		if (publish === void 0) return;
-		publish(this.#issues(params.uri, params.diagnostics));
-	}
-	#issues(uri, diagnostics) {
-		const path = this.#documents.get(uri);
-		if (path === void 0) return [];
-		const issues = [];
-		for (const diagnostic of diagnostics) {
-			if (typeof diagnostic !== "object" || diagnostic === null) continue;
-			if (!("message" in diagnostic) || typeof diagnostic.message !== "string") continue;
-			if (!("range" in diagnostic) || typeof diagnostic.range !== "object" || diagnostic.range === null) {
-				issues.push({
-					origin: "claimant",
-					path,
-					message: diagnostic.message
-				});
-				continue;
-			}
-			const range = diagnostic.range;
-			if (!("start" in range) || typeof range.start !== "object" || range.start === null) {
-				issues.push({
-					origin: "claimant",
-					path,
-					message: diagnostic.message
-				});
-				continue;
-			}
-			const start = range.start;
-			if (!("line" in start) || typeof start.line !== "number") {
-				issues.push({
-					origin: "claimant",
-					path,
-					message: diagnostic.message
-				});
-				continue;
+	#issues(path, diagnostics) {
+		return diagnostics.map((diagnostic) => ({
+			origin: "claimant",
+			path,
+			message: diagnostic.message,
+			range: {
+				start: {
+					line: diagnostic.range.start.line,
+					character: diagnostic.range.start.character
+				},
+				end: {
+					line: diagnostic.range.end.line,
+					character: diagnostic.range.end.character
+				}
 			}
-			issues.push({
-				origin: "claimant",
-				path,
-				message: diagnostic.message,
-				line: start.line + 1
-			});
-		}
-		return issues;
-	}
-	#fail(error) {
-		for (const reject of this.#failures.values()) reject(error);
-		for (const reject of this.#refusals.values()) reject(error);
-		this.#responses.clear();
-		this.#failures.clear();
-		this.#publishes.clear();
-		this.#refusals.clear();
-	}
-	#exit(code, signal) {
-		this.#fail(this.#fault(`The Oxlint language server exited with ${this.#describe(code, signal)}`));
+		}));
 	}
 };
 //#endregion
@@ -1795,11 +1632,19 @@ var RuntimeStage = class {
 				path,
 				message
 			};
+			const character = "column" in stack && typeof stack.column === "number" ? stack.column - 1 : 0;
+			const position = {
+				line: stack.line - 1,
+				character
+			};
 			return {
 				origin: "claimant",
 				path,
 				message,
-				line: stack.line
+				range: {
+					start: position,
+					end: position
+				}
 			};
 		}
 		return {
@@ -2141,7 +1986,10 @@ var TypeStage = class {
 			origin: "claimant",
 			path,
 			message,
-			line: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start).line + 1
+			range: {
+				start: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start),
+				end: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start + (diagnostic.length ?? 0))
+			}
 		};
 	}
 };
@@ -2179,6 +2027,7 @@ var Probe = class {
 	#lintQueue;
 	#runtimeQueue;
 	#deadlines = /* @__PURE__ */ new WeakSet();
+	#surfaced = /* @__PURE__ */ new WeakSet();
 	#typeTail = Promise.resolve();
 	#arming;
 	#closing;
@@ -2260,7 +2109,7 @@ var Probe = class {
 			this.#emitter.emit("prove", verdict);
 			return verdict;
 		} catch (error) {
-			this.#emitter.emit("error", error);
+			if (!(error instanceof ProbeError) || !this.#surfaced.has(error)) this.#emitter.emit("error", error);
 			throw error;
 		}
 	}
@@ -2285,18 +2134,30 @@ var Probe = class {
 		await this.#arming;
 	}
 	async #arm() {
-		const created = this.#workbench();
+		let created;
+		try {
+			created = this.#workbench();
+		} catch (error) {
+			this.#surface(error);
+			throw error;
+		}
 		try {
 			await this.#boot(created);
 		} catch (error) {
-			throw new ProbeError(`The probe could not arm: ${describeUnknown(error)}`, {
+			const failure = new ProbeError(`The probe could not arm: ${describeUnknown(error)}`, {
 				origin: "instrument",
 				code: "malformed",
 				cause: error
 			});
+			this.#surface(failure);
+			throw failure;
 		}
 		this.#emitter.emit("arm", this.#toolchain);
 	}
+	#surface(error) {
+		if (error instanceof ProbeError) this.#surfaced.add(error);
+		this.#emitter.emit("error", error);
+	}
 	#workbench() {
 		const path = "tmp/probe";
 		const directory = resolveWorkspaceFile(this.#workspace, path);
@@ -2421,16 +2282,18 @@ var Probe = class {
 		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);
+			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);
+		const stage = this.#lint;
+		return this.#inspectStage(stage, stage.progress, (signal) => stage.inspect(inspection.subject, { signal }), inspection.claim);
 	}
 	#inspectRuntime(inspection) {
-		return this.#inspectStage(this.#runtime, this.#runtime.progress, this.#runtime.inspect(inspection.subject), inspection.claim);
+		const stage = this.#runtime;
+		return this.#inspectStage(stage, stage.progress, () => stage.inspect(inspection.subject), inspection.claim);
 	}
 	async #inspectStage(stage, progress, operation, claim) {
 		try {
@@ -2443,12 +2306,14 @@ var Probe = class {
 	async #bound(operation, message, stage, progress) {
 		const timeout = createTimeout({ ms: this.#deadline });
 		timeout.start();
+		const expiry = this.#expiry(timeout, message, stage, progress);
+		const refusal = expiry.catch((error) => error);
 		try {
-			return await Promise.race([operation, this.#expiry(timeout, message, stage, progress)]);
+			return await Promise.race([operation(timeout.signal), expiry]);
 		} catch (error) {
 			if (!timeout.expired) throw error;
 			await this.#recycle(stage);
-			throw error;
+			throw await refusal;
 		} finally {
 			timeout.clear();
 		}
@@ -2489,7 +2354,7 @@ var Probe = class {
 		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);
+				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;
@@ -2530,7 +2395,7 @@ var Probe = class {
 	}
 	async #destroyStage(stage) {
 		try {
-			await this.#bound(stage.destroy(), `The ${stage.stage} stage teardown exceeded ${this.#deadline} ms`, stage, stage.progress);
+			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;
 		}
@@ -2718,6 +2583,6 @@ var ProbeServer = class {
 	}
 };
 //#endregion
-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 };
+export { LintStage, Overlay, Probe, ProbeServer, RuntimeStage, TypeStage, captureListeners, computeDigest, createRevisionFile, describeUnknown, findRefusedPaths, guardStage, inferDocumentLanguage, inferTestProject, inferTypeProject, isRefusedName, loadWorkspaceModule, matchesWorkspaceModule, normalizePath, normalizeValue, overwriteFile, readWorkspaceManifest, relativeWorkspaceFile, relativeWorkspaceMessage, releaseListeners, resolveWorkspaceBinary, resolveWorkspaceFile, resolveWorkspaceModule };
 
 //# sourceMappingURL=index.js.map