@orkestrel/probe 0.0.6 → 0.0.9

package/dist/src/server/index.cjs

@@ -9,7 +9,8 @@ let _src_core = require("../core/index.cjs");
 let _orkestrel_emitter = require("@orkestrel/emitter");
 let _orkestrel_queue = require("@orkestrel/queue");
 let _orkestrel_timeout = require("@orkestrel/timeout");
-let node_child_process = require("node:child_process");
+let _orkestrel_lsp = require("@orkestrel/lsp");
+let _orkestrel_lsp_server = require("@orkestrel/lsp/server");
 let node_stream = require("node:stream");
 let node_timers_promises = require("node:timers/promises");
 let _orkestrel_mcp = require("@orkestrel/mcp");
@@ -114,12 +115,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.
@@ -139,8 +146,9 @@ function resolveWorkspaceFile(workspace, target, mutate = false) {
 * ```
 */
 function overwriteFile(file, text) {
-	const descriptor = (0, node_fs.openSync)(file, node_fs.constants.O_WRONLY | node_fs.constants.O_TRUNC | node_fs.constants.O_NOFOLLOW);
+	const descriptor = (0, node_fs.openSync)(file, node_fs.constants.O_WRONLY | node_fs.constants.O_NOFOLLOW);
 	try {
+		(0, node_fs.ftruncateSync)(descriptor, 0);
 		(0, node_fs.writeFileSync)(descriptor, text, "utf8");
 	} finally {
 		(0, node_fs.closeSync)(descriptor);
@@ -515,24 +523,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
@@ -742,6 +732,15 @@ 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.
+*
 * @example
 * ```ts
 * const overlay = new Overlay()
@@ -752,22 +751,36 @@ function releaseListeners(emitter, capture) {
 */
 var Overlay = class {
 	#revision = (0, node_crypto.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.keys()];
+		return [...this.#candidates.values()].map(([path]) => path);
 	}
 	/**
 	* 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.
+	*
 	* @param path - The absolute path the candidate replaces
 	* @param text - The candidate's full contents
 	* @returns Nothing
 	*/
 	set(path, text) {
-		this.#candidates.set(normalizePath(path), text);
+		const recorded = normalizePath(path);
+		this.#candidates.set(this.#key(recorded), [recorded, text]);
 	}
 	/**
 	* Reads the candidate text recorded for one absolute path.
@@ -776,7 +789,7 @@ var Overlay = class {
 	* @returns The recorded text, or `undefined` when this overlay holds no candidate there
 	*/
 	text(path) {
-		return this.#candidates.get(normalizePath(path));
+		return this.#candidates.get(this.#key(normalizePath(path)))?.[1];
 	}
 	/**
 	* Checks whether a candidate sits beneath one directory.
@@ -785,14 +798,16 @@ 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.
+	* 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.
 	*
 	* @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.keys()) if (path.startsWith(base)) return true;
+		for (const [path] of this.#candidates.values()) if (path.startsWith(base)) return true;
 		return false;
 	}
 	/**
@@ -803,10 +818,13 @@ var Overlay = class {
 	clear() {
 		this.#candidates.clear();
 	}
+	#key(path) {
+		return this.#sensitive ? path : path.toLowerCase();
+	}
 };
 //#endregion
 //#region package.json
-var version = "0.0.6";
+var version = "0.0.8";
 var peerDependencies = {
 	"oxlint": "^1.77.0",
 	"typescript": "^6.0.0",
@@ -818,13 +836,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,
@@ -837,24 +864,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.
@@ -872,8 +895,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;
@@ -881,13 +904,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 (0, _src_core.createDestroyedError)("lint stage");
+		if (options === void 0) throw new _src_core.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 (0, _src_core.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),
@@ -895,118 +923,86 @@ var LintStage = class {
 		};
 	}
 	async #destroy() {
-		const child = await this.#warmed();
-		this.#fail((0, _src_core.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 = (0, _orkestrel_lsp.createLSPClient)({
+			transport: (0, _orkestrel_lsp_server.createStdioTransport)({
+				server: {
+					command: [
+						process.execPath,
+						binary,
+						"--lsp"
+					],
+					directory: this.#workspace
+				},
+				grace: this.#deadline / 2
+			}),
+			workspace: (0, node_url.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 = (0, _orkestrel_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 = (0, _orkestrel_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 _src_core.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 = (0, node_child_process.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: (0, node_url.pathToFileURL)(this.#workspace).href,
-			capabilities: {},
-			workspaceFolders: [{
-				uri: (0, node_url.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 = (0, node_url.pathToFileURL)(resolveWorkspaceFile(this.#workspace, draft.path)).href;
-		if (this.#publishes.has(uri)) return Promise.reject(new _src_core.ProbeError(`The lint stage is already inspecting ${draft.path}`, {
+		if (this.#documents.has(uri)) throw new _src_core.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 _src_core.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 (0, _src_core.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 _src_core.ProbeError(message, {
@@ -1019,153 +1015,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
@@ -1796,11 +1661,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 {
@@ -1925,7 +1798,7 @@ var TypeStage = class {
 			this.#configure(this.#service(typescript, selection.project), selection.project);
 			await this.#unblock();
 		}
-		const overlay = new Overlay();
+		const overlay = new Overlay({ sensitive: this.#caseSensitive(typescript) });
 		this.#overlay = overlay;
 		try {
 			this.#record(subject.test, overlay);
@@ -2142,7 +2015,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))
+			}
 		};
 	}
 };
@@ -2435,16 +2311,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 {
@@ -2457,12 +2335,14 @@ var Probe = class {
 	async #bound(operation, message, stage, progress) {
 		const timeout = (0, _orkestrel_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();
 		}
@@ -2503,7 +2383,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;
@@ -2544,7 +2424,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 _src_core.ProbeError) || !this.#deadlines.has(error)) throw error;
 		}
@@ -2753,7 +2633,6 @@ exports.matchesWorkspaceModule = matchesWorkspaceModule;
 exports.normalizePath = normalizePath;
 exports.normalizeValue = normalizeValue;
 exports.overwriteFile = overwriteFile;
-exports.parseContentLength = parseContentLength;
 exports.readWorkspaceManifest = readWorkspaceManifest;
 exports.relativeWorkspaceFile = relativeWorkspaceFile;
 exports.relativeWorkspaceMessage = relativeWorkspaceMessage;