@sackville-mcp/lsp 0.0.1-alpha.0

package/dist/index.mjs

@@ -0,0 +1,2604 @@
+import { spawn } from "node:child_process";
+import { ResponseError, StreamMessageReader, StreamMessageWriter, createMessageConnection } from "vscode-jsonrpc/node.js";
+import { ApplyWorkspaceEditRequest, CallHierarchyIncomingCallsRequest, CallHierarchyOutgoingCallsRequest, CallHierarchyPrepareRequest, ConfigurationRequest, DefinitionRequest, DidChangeTextDocumentNotification, DidChangeWorkspaceFoldersNotification, DidCloseTextDocumentNotification, DidOpenTextDocumentNotification, DocumentDiagnosticRequest, DocumentSymbolRequest, ExitNotification, HoverRequest, InitializeRequest, InitializedNotification, PrepareRenameRequest, PublishDiagnosticsNotification, ReferencesRequest, RegistrationRequest, RenameRequest, ShutdownRequest, TypeDefinitionRequest, UnregistrationRequest, WorkDoneProgressCreateRequest, WorkspaceSymbolRequest } from "vscode-languageserver-protocol";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+//#region src/encoding.ts
+const SUPPORTED = [
+	"utf-8",
+	"utf-16",
+	"utf-32"
+];
+/**
+* The encodings we advertise to the server, in preference order. UTF-16 is first
+* deliberately: it is the JS-native, best-tested path (a server honouring our preference
+* picks the one we exercise most). We still implement all three for servers that only
+* speak UTF-8 (e.g. clangd).
+*/
+const PREFERRED_ENCODINGS = ["utf-16", "utf-8"];
+/**
+* Resolve the encoding to use from the server's reported `positionEncoding`. Absent ⇒ the
+* spec default, UTF-16. **Present but unsupported ⇒ throw** — never silently default, or
+* we would do offset math in the wrong unit and return wrong locations.
+*/
+function resolvePositionEncoding(reported) {
+	if (reported === void 0) return "utf-16";
+	if (SUPPORTED.includes(reported)) return reported;
+	throw new Error(`server negotiated an unsupported position encoding: ${reported} (expected one of ${SUPPORTED.join(", ")})`);
+}
+/** Length of a string in the code units of `encoding`. */
+function codeUnits(s, encoding) {
+	switch (encoding) {
+		case "utf-16": return s.length;
+		case "utf-8": return Buffer.byteLength(s, "utf8");
+		case "utf-32": return [...s].length;
+	}
+}
+/** Strip a single leading BOM (U+FEFF) — it must not shift line-1 column math. */
+function stripBom(text) {
+	return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+/**
+* Convert a 1-based human column (counting code points) on `lineText` to a 0-based LSP
+* `character` offset in `encoding`. A column past the line end clamps to the line length.
+*/
+function toLspCharacter(lineText, humanColumn, encoding) {
+	const cps = [...lineText];
+	const take = Math.max(0, Math.min(humanColumn - 1, cps.length));
+	return codeUnits(cps.slice(0, take).join(""), encoding);
+}
+/**
+* Inverse of {@link toLspCharacter}: map a 0-based LSP `character` offset back to a 1-based
+* human code-point column. An offset landing inside a multi-unit code point clamps to that
+* code point's start; an offset past the line end clamps to one past the last column.
+*/
+function fromLspCharacter(lineText, lspCharacter, encoding) {
+	if (lspCharacter <= 0) return 1;
+	const cps = [...lineText];
+	let units = 0;
+	for (let k = 0; k < cps.length; k++) {
+		const u = codeUnits(cps[k], encoding);
+		if (units + u > lspCharacter) return k + 1;
+		units += u;
+	}
+	return cps.length + 1;
+}
+/** Split text into line contents on LF / CR / CRLF, excluding the terminators (LSP's model). */
+function splitLines(text) {
+	return text.split(/\r\n|\r|\n/);
+}
+/**
+* Convert a human 1-based line:column over the full source `text` to a 0-based LSP
+* `Position` in `encoding`. Lines are split on LF/CR/CRLF WITHOUT normalizing the document
+* (the text we send the server is its source of truth); a leading BOM is stripped before
+* line-1 column math.
+*/
+function toLspPosition(text, humanLine, humanColumn, encoding) {
+	const lineText = splitLines(stripBom(text))[humanLine - 1] ?? "";
+	return {
+		line: humanLine - 1,
+		character: toLspCharacter(lineText, humanColumn, encoding)
+	};
+}
+/** Inverse of {@link toLspPosition}: map an LSP `Position` back to human 1-based line:column. */
+function fromLspPosition(text, position, encoding) {
+	const lineText = splitLines(stripBom(text))[position.line] ?? "";
+	return {
+		line: position.line + 1,
+		column: fromLspCharacter(lineText, position.character, encoding)
+	};
+}
+/** JS-string (UTF-16) offset WITHIN `lineText` for a 0-based LSP `character` in `encoding`. */
+function lspCharacterToJsOffset(lineText, character, encoding) {
+	if (character <= 0) return 0;
+	let units = 0;
+	let js = 0;
+	for (const cp of lineText) {
+		if (units >= character) break;
+		const u = codeUnits(cp, encoding);
+		if (units + u > character) break;
+		units += u;
+		js += cp.length;
+	}
+	return js;
+}
+/**
+* Convert an LSP `Position` to an ABSOLUTE JS-string (UTF-16 `.length`) index into `text`, for
+* splicing edits (the write-mode core). Unlike {@link toLspPosition} this does NOT use
+* `splitLines` — that splitter discards terminator identity and would shift the offset by one
+* JS code unit per CRLF line above the position. We raw-scan terminators (counting their actual
+* length) and count negotiated code units only WITHIN the target line, returning the cumulative
+* JS index. A leading BOM is stripped for line/character math (matching `toLspPosition`) but its
+* length is added back, so the returned offset indexes into the real, BOM-bearing `text`.
+*/
+function lspPositionToOffset(text, position, encoding) {
+	const bom = text.charCodeAt(0) === 65279 ? 1 : 0;
+	const body = bom ? text.slice(1) : text;
+	const n = body.length;
+	let i = 0;
+	let line = 0;
+	while (line < position.line && i < n) {
+		const ch = body.charCodeAt(i);
+		if (ch === 13) {
+			i += body.charCodeAt(i + 1) === 10 ? 2 : 1;
+			line++;
+		} else if (ch === 10) {
+			i += 1;
+			line++;
+		} else i += 1;
+	}
+	let lineEnd = i;
+	while (lineEnd < n) {
+		const ch = body.charCodeAt(lineEnd);
+		if (ch === 13 || ch === 10) break;
+		lineEnd++;
+	}
+	const within = lspCharacterToJsOffset(body.slice(i, lineEnd), position.character, encoding);
+	return bom + i + within;
+}
+//#endregion
+//#region src/normalize.ts
+function isLocationLink(item) {
+	return item.targetUri !== void 0;
+}
+/** Normalize any definition/references/typeDefinition result shape to a flat location list. */
+function normalizeLocations(result) {
+	if (result == null) return [];
+	return (Array.isArray(result) ? result : [result]).map((item) => {
+		if (isLocationLink(item)) return {
+			uri: item.targetUri,
+			range: item.targetSelectionRange,
+			fullRange: item.targetRange
+		};
+		return {
+			uri: item.uri,
+			range: item.range
+		};
+	});
+}
+function markedToString(m) {
+	if (typeof m === "string") return m;
+	return `\`\`\`${m.language}\n${m.value}\n\`\`\``;
+}
+/** Normalize hover contents (MarkupContent | MarkedString | MarkedString[]) to one string. */
+function normalizeHover(hover) {
+	if (hover == null) return null;
+	const c = hover.contents;
+	let value;
+	if (Array.isArray(c)) value = c.map(markedToString).join("\n\n");
+	else if (typeof c === "string") value = c;
+	else if ("kind" in c) value = c.value;
+	else value = markedToString(c);
+	return hover.range ? {
+		value,
+		range: hover.range
+	} : { value };
+}
+const SYMBOL_KIND_NAMES = [
+	"File",
+	"Module",
+	"Namespace",
+	"Package",
+	"Class",
+	"Method",
+	"Property",
+	"Field",
+	"Constructor",
+	"Enum",
+	"Interface",
+	"Function",
+	"Variable",
+	"Constant",
+	"String",
+	"Number",
+	"Boolean",
+	"Array",
+	"Object",
+	"Key",
+	"Null",
+	"EnumMember",
+	"Struct",
+	"Event",
+	"Operator",
+	"TypeParameter"
+];
+function symbolKindName(kind) {
+	return SYMBOL_KIND_NAMES[kind - 1] ?? "Unknown";
+}
+function isSymbolInformation(s) {
+	return s.location !== void 0;
+}
+function normalizeDocumentSymbol(s) {
+	const out = {
+		name: s.name,
+		kind: s.kind,
+		kindName: symbolKindName(s.kind),
+		range: s.range
+	};
+	if (s.detail !== void 0) out.detail = s.detail;
+	if (s.children && s.children.length > 0) out.children = s.children.map(normalizeDocumentSymbol);
+	return out;
+}
+/** Normalize documentSymbol's dual shape (hierarchical DocumentSymbol[] or flat SymbolInformation[]). */
+function normalizeDocumentSymbols(result) {
+	if (result == null || result.length === 0) return [];
+	const first = result[0];
+	if (isSymbolInformation(first)) return result.map((s) => {
+		const out = {
+			name: s.name,
+			kind: s.kind,
+			kindName: symbolKindName(s.kind),
+			range: s.location.range
+		};
+		if (s.containerName !== void 0) out.container = s.containerName;
+		return out;
+	});
+	return result.map(normalizeDocumentSymbol);
+}
+function hasRange(loc) {
+	return loc.range !== void 0;
+}
+/** Normalize a `workspace/symbol` result (flat `SymbolInformation[]`/`WorkspaceSymbol[]`). */
+function normalizeWorkspaceSymbols(result) {
+	if (result == null) return [];
+	return result.map((s) => {
+		const out = {
+			name: s.name,
+			kind: s.kind,
+			kindName: symbolKindName(s.kind),
+			uri: s.location.uri
+		};
+		if (hasRange(s.location)) out.range = s.location.range;
+		if (s.containerName !== void 0) out.container = s.containerName;
+		return out;
+	});
+}
+const SEVERITY_NAMES = [
+	"Error",
+	"Warning",
+	"Information",
+	"Hint"
+];
+const TAG_NAMES = {
+	1: "Unnecessary",
+	2: "Deprecated"
+};
+function diagnosticSeverityName(severity) {
+	return SEVERITY_NAMES[severity - 1] ?? "Unknown";
+}
+/** Normalize a `publishDiagnostics` `diagnostics[]` (push model) — severity/tag names, related info. */
+function normalizeDiagnostics(items) {
+	if (items == null) return [];
+	return items.map((d) => {
+		const out = {
+			range: d.range,
+			message: d.message
+		};
+		if (d.severity !== void 0) {
+			out.severity = d.severity;
+			out.severityName = diagnosticSeverityName(d.severity);
+		}
+		if (d.code !== void 0) out.code = d.code;
+		if (d.source !== void 0) out.source = d.source;
+		if (d.tags && d.tags.length > 0) out.tags = d.tags.map((t) => TAG_NAMES[t] ?? `Tag(${t})`);
+		if (d.relatedInformation && d.relatedInformation.length > 0) out.related = d.relatedInformation.map((r) => ({
+			uri: r.location.uri,
+			range: r.location.range,
+			message: r.message
+		}));
+		return out;
+	});
+}
+/**
+* Diagnostics from a PULL-model `textDocument/diagnostic` report. A `full` report carries `items`;
+* an `unchanged` report means "identical to the previousResultId" — Sackville's single-shot reads
+* send no previousResultId, so a server should always answer `full`; we treat `unchanged`/absent
+* defensively as no items. The items themselves are normalized by the shared `normalizeDiagnostics`
+* (the report is just the pull envelope around the same `Diagnostic[]` the push model publishes).
+*/
+function diagnosticsFromReport(report) {
+	return report?.kind === "full" ? normalizeDiagnostics(report.items) : [];
+}
+function normalizeCallHierarchyItem(item) {
+	const out = {
+		name: item.name,
+		kind: item.kind,
+		kindName: symbolKindName(item.kind),
+		uri: item.uri,
+		range: item.range,
+		selectionRange: item.selectionRange
+	};
+	if (item.detail !== void 0 && item.detail !== "") out.detail = item.detail;
+	return out;
+}
+function normalizeCallHierarchyItems(result) {
+	if (result == null) return [];
+	return result.map(normalizeCallHierarchyItem);
+}
+/** `callHierarchy/incomingCalls` → `{from, fromRanges}[]`; the edge item is the CALLER. */
+function normalizeIncomingCalls(result) {
+	if (result == null) return [];
+	return result.map((c) => ({
+		item: normalizeCallHierarchyItem(c.from),
+		fromRanges: c.fromRanges ?? []
+	}));
+}
+/** `callHierarchy/outgoingCalls` → `{to, fromRanges}[]`; the edge item is the CALLEE. */
+function normalizeOutgoingCalls(result) {
+	if (result == null) return [];
+	return result.map((c) => ({
+		item: normalizeCallHierarchyItem(c.to),
+		fromRanges: c.fromRanges ?? []
+	}));
+}
+function decideStatus(isEmpty, ready) {
+	if (!isEmpty) return "ok";
+	return ready ? "no_result" : "not_ready";
+}
+function isResourceOp(member) {
+	const kind = member.kind;
+	return kind === "create" || kind === "rename" || kind === "delete";
+}
+/**
+* Normalize a `WorkspaceEdit` to a uniform `files → edits` list plus a separate, flagged list of
+* resource operations. Handles both shapes (ADR 0011 addendum §2.5):
+* - `documentChanges` takes PRECEDENCE over `changes` when both are present (never merged).
+* - Per-file and per-edit order is preserved.
+* - `CreateFile`/`RenameFile`/`DeleteFile` members are surfaced under `resourceOps`, never
+*   translated into a TextEdit (v1 refuses to apply them).
+* - An `AnnotatedTextEdit` is normalized to `{range,newText}`; if its annotation is
+*   `needsConfirmation` the edit carries `needsConfirmation: true` + the label (a preview-only
+*   signal, excluded from apply) so the server's safety signal is never silently dropped.
+*
+* NOTE: real `typescript-language-server` 5.3.0 returns the legacy `changes` map for an ordinary
+* rename even when the client advertises `documentChanges` (see `test/fixtures/README.md`); the
+* `documentChanges` branch is exercised by a synthesized fixture.
+*/
+function normalizeWorkspaceEdit(raw) {
+	if (raw == null) return {
+		files: [],
+		resourceOps: [],
+		operations: []
+	};
+	const annotations = raw.changeAnnotations ?? {};
+	const mapEdit = (e) => {
+		const out = {
+			range: e.range,
+			newText: e.newText
+		};
+		if (e.annotationId !== void 0) {
+			const ann = annotations[e.annotationId];
+			if (ann?.needsConfirmation) out.needsConfirmation = true;
+			if (ann?.label !== void 0) out.annotationLabel = ann.label;
+		}
+		return out;
+	};
+	if (raw.documentChanges !== void 0) {
+		const files = [];
+		const resourceOps = [];
+		const operations = [];
+		for (const member of raw.documentChanges) if (isResourceOp(member)) {
+			const uris = member.kind === "rename" ? [member.oldUri, member.newUri].filter((u) => u !== void 0) : member.uri !== void 0 ? [member.uri] : [];
+			resourceOps.push({
+				kind: member.kind,
+				uris
+			});
+			if (member.kind === "rename") operations.push({
+				type: "rename",
+				oldUri: member.oldUri ?? "",
+				newUri: member.newUri ?? "",
+				...member.options ? { options: member.options } : {}
+			});
+			else operations.push({
+				type: member.kind,
+				uri: member.uri ?? "",
+				...member.options ? { options: member.options } : {}
+			});
+		} else {
+			const edits = member.edits.map(mapEdit);
+			files.push({
+				uri: member.textDocument.uri,
+				edits
+			});
+			operations.push({
+				type: "edit",
+				uri: member.textDocument.uri,
+				edits
+			});
+		}
+		return {
+			files,
+			resourceOps,
+			operations
+		};
+	}
+	if (raw.changes !== void 0) {
+		const files = Object.entries(raw.changes).map(([uri, edits]) => ({
+			uri,
+			edits: edits.map(mapEdit)
+		}));
+		return {
+			files,
+			resourceOps: [],
+			operations: files.map((f) => ({
+				type: "edit",
+				uri: f.uri,
+				edits: f.edits
+			}))
+		};
+	}
+	return {
+		files: [],
+		resourceOps: [],
+		operations: []
+	};
+}
+/**
+* Normalize a `prepareRename` result. `null` ⇒ the position is NOT renameable (the engine maps
+* this to a structured refusal, distinct from a tri-state `no_result`). A bare `Range`,
+* `{range, placeholder}`, and `{defaultBehavior}` all mean renameable — the real
+* `typescript-language-server` 5.3.0 returns a bare `Range` (see `test/fixtures/README.md`).
+*/
+function normalizePrepareRename(raw) {
+	if (raw == null) return null;
+	if ("start" in raw && "end" in raw) return { range: raw };
+	if ("range" in raw) {
+		const out = { range: raw.range };
+		if (raw.placeholder !== void 0) out.placeholder = raw.placeholder;
+		return out;
+	}
+	if ("defaultBehavior" in raw) return { defaultBehavior: raw.defaultBehavior };
+	return {};
+}
+//#endregion
+//#region src/client.ts
+/**
+* The LSP JSON-RPC client (ADR 0011, slice 2) — one live, stateful, bidirectional session
+* with a language-server subprocess, the documented exception to ARCHITECTURE §1's
+* no-live-RPC rule. It leans on Microsoft's reference transport (`vscode-jsonrpc` for
+* Content-Length framing + id correlation, `vscode-languageserver-protocol` for method
+* constants) — the playwright-core pattern, NOT a hand-rolled framing layer.
+*
+* The five corners the adversarial pass flagged as load-bearing, all handled here:
+*
+* 1. **Encoding negotiation.** Advertise `positionEncodings: ["utf-16","utf-8"]`, read back
+*    `ServerCapabilities.positionEncoding`, and do ALL offset math in that unit (via
+*    `encoding.ts`). Absent ⇒ spec-default UTF-16; present-but-unsupported ⇒ fail loud.
+* 2. **Tri-state readiness.** An empty result is `no_result` only when the server is READY;
+*    while an indexing `$/progress` work-done token is active it is `not_ready` — never
+*    collapsed into "no definition". One authoritative deadline (the operator timeout) with
+*    the bounded retry/backoff living INSIDE it; the first call returns `not_ready` fast.
+* 3. **Deadlock-safe inbound replies.** The client MUST answer every id-bearing server
+*    request (`workspace/configuration`, `window/workDoneProgress/create`,
+*    `client/registerCapability`) or it deadlocks — in particular it must answer
+*    `workDoneProgress/create` before the `$/progress` that drives readiness arrives.
+* 4. **Document lifecycle.** `didOpen` full-text once, reference-counted, NO `didClose` by
+*    default (the per-(server,uri) mutex that serializes the open+query critical section
+*    lives in the manager — slice 3).
+* 5. **Capability gating + provenance.** Every request is gated on its `*Provider`
+*    capability; `serverInfo.{name,version}` rides on every result (turns "silently wrong"
+*    into "wrong-but-attributed").
+*
+* All time-based code goes through the injected clock (`now`/`delay`) — the production code
+* never calls `setTimeout`/`setInterval` directly except inside the default `delay` seam, so
+* the gate drives retry/backoff deterministically with a fake clock.
+*/
+/** Default live spawn: a child process over stdio, framed by the reference transport. */
+const defaultServerSpawn = (spec) => {
+	const child = spawn(spec.command, spec.args, { stdio: [
+		"pipe",
+		"pipe",
+		"pipe"
+	] });
+	const connection = createMessageConnection(new StreamMessageReader(child.stdout), new StreamMessageWriter(child.stdin));
+	return {
+		connection,
+		dispose() {
+			connection.dispose();
+			child.kill("SIGKILL");
+		}
+	};
+};
+/** Thrown when a navigation is requested against a capability the server did not advertise. */
+var LspUnsupportedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LspUnsupportedError";
+	}
+};
+const defaultDelay$1 = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+* `ResponseError` codes a server uses to signal "not ready / nothing to answer here" rather than
+* returning an empty result. Some servers (rust-analyzer) ERROR where tsserver returns empty —
+* `withRetry` routes these through the SAME tri-state path as an empty result (indexing ⇒ not_ready
+* and retry within the deadline; settled ⇒ no_result), instead of letting them throw as a hard
+* failure. Any OTHER error (a genuine protocol/internal failure) propagates unchanged.
+* -32801 ContentModified / -32802 ServerCancelled / -32800 RequestCancelled — the spec's
+* retry/cancel codes; -32602 InvalidParams — rust-analyzer's "No references found at position".
+*/
+const SOFT_NOT_READY_CODES = new Set([
+	-32801,
+	-32802,
+	-32800,
+	-32602
+]);
+var LspClient = class {
+	conn;
+	timeoutMs;
+	noRetry;
+	now;
+	delay;
+	baseBackoffMs;
+	maxBackoffMs;
+	listening = false;
+	_encoding = "utf-16";
+	_serverInfo;
+	_capabilities = {};
+	/** Active indexing work-done-progress tokens — non-empty ⇒ the server is still indexing. */
+	activeProgress = /* @__PURE__ */ new Set();
+	/** Resolvers waiting for indexing to DRAIN (the active set to empty); fired on the final `end`. */
+	drainWaiters = [];
+	/**
+	* Open documents (open-once, no `didClose` by default). `version` is the per-uri monotonic
+	* document version: seeded at 1 by `didOpen`, pre-incremented by each `applyEdited` `didChange`
+	* — versions MUST strictly increase or the server ignores the change and keeps stale text.
+	*/
+	open = /* @__PURE__ */ new Map();
+	/**
+	* Pushed diagnostics per uri (the PUSH model — `textDocument/publishDiagnostics` is a server
+	* notification, not a request; tsserver advertises no `diagnosticProvider`, so pull diagnostics
+	* are unavailable). An entry's absence ⇒ the server hasn't published for that uri yet.
+	*/
+	diagnostics = /* @__PURE__ */ new Map();
+	/** Uris freshly `didOpen`ed whose first post-open publish hasn't arrived yet. */
+	awaitingDiagnostics = /* @__PURE__ */ new Set();
+	/** Resolvers waiting for the NEXT publish on a uri (keyed); fired by the publish handler. */
+	diagnosticsWaiters = /* @__PURE__ */ new Map();
+	constructor(connection, options) {
+		this.conn = connection;
+		this.timeoutMs = options.timeoutMs;
+		this.noRetry = options.noRetry ?? false;
+		this.now = options.now ?? Date.now;
+		this.delay = options.delay ?? defaultDelay$1;
+		this.baseBackoffMs = options.baseBackoffMs ?? 50;
+		this.maxBackoffMs = options.maxBackoffMs ?? 1e3;
+	}
+	get encoding() {
+		return this._encoding;
+	}
+	get serverInfo() {
+		return this._serverInfo;
+	}
+	get capabilities() {
+		return this._capabilities;
+	}
+	/** Indexing is active when at least one `$/progress` work-done token is open. */
+	get indexing() {
+		return this.activeProgress.size > 0;
+	}
+	/** Any non-`false`, non-absent `*Provider` value counts as enabled (LSP convention). */
+	supports(provider) {
+		const v = this._capabilities[provider];
+		return v !== void 0 && v !== false;
+	}
+	/**
+	* `prepareRename` is advertised only by the OBJECT form `renameProvider: {prepareProvider:true}`
+	* — the boolean `supports()` helper cannot detect it, so the engine must check this before
+	* calling `prepareRename` (bare `renameProvider: true` supports rename but not prepare).
+	*/
+	get supportsPrepareRename() {
+		const rp = this._capabilities.renameProvider;
+		return typeof rp === "object" && rp !== null && rp.prepareProvider === true;
+	}
+	/**
+	* Whether the server accepts `workspace/didChangeWorkspaceFolders` — the gate for the manager's
+	* grow-only warm-server reuse. Advertised by `ServerCapabilities.workspace.workspaceFolders`:
+	* `supported !== false` AND `changeNotifications` truthy (the spec allows `true` OR a string
+	* registration id). rust-analyzer advertises it; the captured tsserver 5.3.0 does NOT, so the
+	* manager falls back to spawning a fresh per-group server there.
+	*/
+	get supportsWorkspaceFolderChange() {
+		const wf = this._capabilities.workspace?.workspaceFolders;
+		if (wf === void 0 || wf.supported === false) return false;
+		return wf.changeNotifications === true || typeof wf.changeNotifications === "string";
+	}
+	/**
+	* Handshake. Registers the deadlock-safe inbound handlers + the `$/progress` listener
+	* BEFORE `listen()`, advertises the preferred encodings, then reads back the negotiated
+	* encoding + capabilities + provenance and sends `initialized`.
+	*/
+	async initialize(rootUri, opts = {}) {
+		this.installInboundHandlers();
+		if (!this.listening) {
+			this.conn.listen();
+			this.listening = true;
+		}
+		const result = await this.conn.sendRequest(InitializeRequest.method, {
+			processId: process.pid ?? null,
+			clientInfo: { name: "sackville-lsp" },
+			rootUri,
+			capabilities: {
+				general: { positionEncodings: PREFERRED_ENCODINGS },
+				textDocument: {
+					synchronization: { dynamicRegistration: false },
+					definition: { linkSupport: true },
+					typeDefinition: { linkSupport: true },
+					references: {},
+					hover: { contentFormat: ["markdown", "plaintext"] },
+					documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+					publishDiagnostics: {
+						relatedInformation: true,
+						tagSupport: { valueSet: [1, 2] },
+						versionSupport: true,
+						codeDescriptionSupport: true
+					},
+					diagnostic: {
+						dynamicRegistration: false,
+						relatedDocumentSupport: false
+					},
+					callHierarchy: { dynamicRegistration: false },
+					rename: {
+						dynamicRegistration: false,
+						prepareSupport: true,
+						prepareSupportDefaultBehavior: 1
+					}
+				},
+				window: { workDoneProgress: true },
+				workspace: {
+					configuration: true,
+					workspaceFolders: true,
+					symbol: { dynamicRegistration: false },
+					workspaceEdit: {
+						documentChanges: true,
+						resourceOperations: [
+							"create",
+							"rename",
+							"delete"
+						],
+						normalizesLineEndings: false
+					}
+				}
+			},
+			workspaceFolders: opts.workspaceFolders ?? [{
+				uri: rootUri,
+				name: "root"
+			}],
+			initializationOptions: opts.initializationOptions
+		});
+		this._capabilities = result.capabilities ?? {};
+		this._serverInfo = result.serverInfo;
+		this._encoding = resolvePositionEncoding(this._capabilities.positionEncoding);
+		this.conn.sendNotification(InitializedNotification.method, {});
+		return {
+			encoding: this._encoding,
+			serverInfo: this._serverInfo,
+			capabilities: this._capabilities
+		};
+	}
+	/** Register the id-bearing inbound replies (deadlock-safe) + the `$/progress` tracker. */
+	installInboundHandlers() {
+		this.conn.onRequest(ConfigurationRequest.method, (params) => (params?.items ?? []).map(() => null));
+		this.conn.onRequest(WorkDoneProgressCreateRequest.method, () => null);
+		this.conn.onRequest(RegistrationRequest.method, () => null);
+		this.conn.onRequest(UnregistrationRequest.method, () => null);
+		this.conn.onRequest(ApplyWorkspaceEditRequest.method, () => ({
+			applied: false,
+			failureReason: "sackville applies rename edits itself; server-initiated edits are declined"
+		}));
+		this.conn.onNotification(PublishDiagnosticsNotification.method, (p) => {
+			this.diagnostics.set(p.uri, { items: p.diagnostics ?? [] });
+			this.awaitingDiagnostics.delete(p.uri);
+			for (const w of this.diagnosticsWaiters.get(p.uri)?.splice(0) ?? []) w();
+		});
+		this.conn.onNotification("$/progress", (p) => {
+			const kind = p?.value?.kind;
+			if (kind === "begin") this.activeProgress.add(p.token);
+			else if (kind === "end") {
+				this.activeProgress.delete(p.token);
+				if (this.activeProgress.size === 0) for (const w of this.drainWaiters.splice(0)) w();
+			}
+		});
+	}
+	/** A promise that resolves the next time indexing drains to empty (an `end` clears the set). */
+	indexingDrain() {
+		return new Promise((resolve) => this.drainWaiters.push(resolve));
+	}
+	/**
+	* Wait until the server is NOT indexing, bounded by `deadline`. Returns true if it settled,
+	* false if the deadline elapsed while still indexing. Event-driven (resolves on the `$/progress`
+	* `end`), with the injected `delay` as the deadline backstop — so the gate drives it
+	* deterministically and a real session blocks no longer than the operator timeout.
+	*/
+	async awaitIndexingSettled(deadline) {
+		while (this.indexing) {
+			const remaining = deadline - this.now();
+			if (remaining <= 0) return false;
+			const drained = this.indexingDrain();
+			if (!this.indexing) return true;
+			await Promise.race([drained, this.delay(remaining)]);
+		}
+		return true;
+	}
+	/** Open a document full-text once (version 1); subsequent calls just bump the refcount. */
+	ensureOpen(uri, languageId, text) {
+		const entry = this.open.get(uri);
+		if (entry !== void 0) {
+			entry.refs += 1;
+			return;
+		}
+		this.open.set(uri, {
+			refs: 1,
+			version: 1,
+			languageId
+		});
+		this.awaitingDiagnostics.add(uri);
+		this.conn.sendNotification(DidOpenTextDocumentNotification.method, { textDocument: {
+			uri,
+			languageId,
+			version: 1,
+			text
+		} });
+	}
+	/** Decrement a document's refcount (keeps the entry + version). Does NOT `didClose`. */
+	releaseDoc(uri) {
+		const entry = this.open.get(uri);
+		if (entry === void 0) return;
+		entry.refs = Math.max(0, entry.refs - 1);
+	}
+	/**
+	* After Sackville writes `newText` to `uri` on disk (write-mode, ADR 0011 addendum), resync the
+	* server's in-memory buffer with a **full-text `didChange`** so a later navigation sees
+	* post-rename positions (we never `didClose`, so the server still holds the pre-rename text).
+	* The version is **pre-incremented** — it must be strictly greater than the last `didOpen`/
+	* `didChange` or the server ignores the change. No-op for a uri the server never opened (it
+	* re-reads fresh on the next `didOpen`). Full-text (no incremental ranges) — correctness over
+	* bytes, and it avoids re-introducing offset math on the server-bound path.
+	*/
+	applyEdited(uri, newText) {
+		const entry = this.open.get(uri);
+		if (entry === void 0) return;
+		entry.version += 1;
+		this.conn.sendNotification(DidChangeTextDocumentNotification.method, {
+			textDocument: {
+				uri,
+				version: entry.version
+			},
+			contentChanges: [{ text: newText }]
+		});
+	}
+	/**
+	* A file moved on disk (resource-op `RenameFile`). The open-once/no-`didClose` invariant keys the
+	* server buffer by `oldUri`, which now names a non-existent path — a later query would be silently
+	* wrong (the worst failure class). MIGRATE the open entry: `didClose(oldUri)` + `didOpen(newUri)`
+	* with the moved text, carrying the refcount and the languageId to the new key. NO-OP if `oldUri`
+	* was never opened (Sackville opens only the queried file, so the renamed file is usually closed).
+	* Run inside the held multi-URI lock so no concurrent query races the key migration.
+	*/
+	didFileRename(oldUri, newUri, newText) {
+		const entry = this.open.get(oldUri);
+		if (entry === void 0) return;
+		this.open.delete(oldUri);
+		this.diagnostics.delete(oldUri);
+		this.awaitingDiagnostics.delete(oldUri);
+		this.conn.sendNotification(DidCloseTextDocumentNotification.method, { textDocument: { uri: oldUri } });
+		this.open.set(newUri, {
+			refs: entry.refs,
+			version: 1,
+			languageId: entry.languageId
+		});
+		this.awaitingDiagnostics.add(newUri);
+		this.conn.sendNotification(DidOpenTextDocumentNotification.method, { textDocument: {
+			uri: newUri,
+			languageId: entry.languageId,
+			version: 1,
+			text: newText
+		} });
+	}
+	/**
+	* A file was deleted on disk (resource-op `DeleteFile`). `didClose` + evict the open entry so the
+	* server stops tracking a buffer for a path that no longer exists. NO-OP if it was never opened.
+	*/
+	didFileDelete(uri) {
+		if (this.open.get(uri) === void 0) return;
+		this.open.delete(uri);
+		this.diagnostics.delete(uri);
+		this.awaitingDiagnostics.delete(uri);
+		this.conn.sendNotification(DidCloseTextDocumentNotification.method, { textDocument: { uri } });
+	}
+	/**
+	* Notify the server that the workspace-folder set changed (`workspace/didChangeWorkspaceFolders`)
+	* — the wire primitive behind the manager's grow-only warm-server reuse. A fire-and-forget
+	* notification, so it is ordered on the single connection BEFORE any subsequent request: a query
+	* sent right after sees the new folder scope. Capability gating is the caller's job (the manager
+	* only calls this when {@link supportsWorkspaceFolderChange}); the folders are operator-allowlisted
+	* roots, never agent-supplied paths.
+	*/
+	changeWorkspaceFolders(added, removed) {
+		this.conn.sendNotification(DidChangeWorkspaceFoldersNotification.method, { event: {
+			added,
+			removed
+		} });
+	}
+	async definition(uri, position) {
+		if (!this.supports("definitionProvider")) throw new LspUnsupportedError("server does not advertise definition support");
+		return this.navigateLocations(DefinitionRequest.method, {
+			textDocument: { uri },
+			position
+		});
+	}
+	async typeDefinition(uri, position) {
+		if (!this.supports("typeDefinitionProvider")) throw new LspUnsupportedError("server does not advertise typeDefinition support");
+		return this.navigateLocations(TypeDefinitionRequest.method, {
+			textDocument: { uri },
+			position
+		});
+	}
+	async references(uri, position) {
+		if (!this.supports("referencesProvider")) throw new LspUnsupportedError("server does not advertise references support");
+		return this.navigateLocations(ReferencesRequest.method, {
+			textDocument: { uri },
+			position,
+			context: { includeDeclaration: true }
+		});
+	}
+	async hover(uri, position) {
+		if (!this.supports("hoverProvider")) throw new LspUnsupportedError("server does not advertise hover support");
+		return this.withRetry(() => this.conn.sendRequest(HoverRequest.method, {
+			textDocument: { uri },
+			position
+		}), (raw) => normalizeHover(raw), (h) => h === null);
+	}
+	/** Document symbols — the file outline. Position-less (whole document); tri-state like the rest. */
+	async documentSymbols(uri) {
+		if (!this.supports("documentSymbolProvider")) throw new LspUnsupportedError("server does not advertise documentSymbol support");
+		return this.withRetry(() => this.conn.sendRequest(DocumentSymbolRequest.method, { textDocument: { uri } }), (raw) => normalizeDocumentSymbols(raw), (syms) => syms.length === 0);
+	}
+	/** A promise that resolves on the next `publishDiagnostics` for `uri`. */
+	nextDiagnostics(uri) {
+		return new Promise((resolve) => {
+			const list = this.diagnosticsWaiters.get(uri) ?? [];
+			list.push(resolve);
+			this.diagnosticsWaiters.set(uri, list);
+		});
+	}
+	/**
+	* Diagnostics for an OPEN document (ADR 0011 staged tail; PUSH model). NOT capability-gated —
+	* `textDocument/publishDiagnostics` is a server notification every server may send, and tsserver
+	* advertises no `diagnosticProvider` (pull diagnostics are staged). The caller (manager.run) has
+	* already `didOpen`ed the file, which triggers the server's publish.
+	*
+	* Readiness (grounded in the captured timeline — `didOpen` → `$/progress` begin/end → publish
+	* ~60ms AFTER the project loads): wait out the project-load `$/progress`, then return the publish
+	* once the file's first post-open publish has arrived. An EMPTY publish is a legitimate `ok` (a
+	* clean file), never `no_result`. If the project never settles or no publish arrives within the
+	* deadline ⇒ `not_ready` (retry), the same honest-tri-state posture as the navigation reads.
+	*/
+	async documentDiagnostics(uri) {
+		if (this.supports("diagnosticProvider")) return this.pullDiagnostics(uri);
+		return this.pushDiagnostics(uri);
+	}
+	/** PUSH model — accumulate the server's `publishDiagnostics` for an open file (see {@link documentDiagnostics}). */
+	async pushDiagnostics(uri) {
+		const deadline = this.now() + this.timeoutMs;
+		while (true) {
+			await this.awaitIndexingSettled(deadline);
+			if (!this.indexing && !this.awaitingDiagnostics.has(uri)) {
+				const cached = this.diagnostics.get(uri);
+				return this.wrap("ok", normalizeDiagnostics(cached?.items));
+			}
+			const remaining = deadline - this.now();
+			if (remaining <= 0) {
+				const cached = this.diagnostics.get(uri);
+				return this.wrap("not_ready", normalizeDiagnostics(cached?.items));
+			}
+			await Promise.race([this.nextDiagnostics(uri), this.delay(remaining)]);
+		}
+	}
+	/**
+	* PULL model — `textDocument/diagnostic` (LSP 3.17), capability-gated on `diagnosticProvider`.
+	* A request/response (unlike push), so it is deterministic for a single-shot read. Echoes the
+	* provider's `identifier` when one was advertised (rust-analyzer requires it). Tri-state, with
+	* the diagnostics-specific twist that an EMPTY report is a legitimate `ok` (a clean file), NEVER
+	* `no_result` — so this does NOT reuse {@link withRetry} (whose empty ⇒ no_result is wrong here).
+	* Readiness: wait out the project-load `$/progress`; if the send (re)starts indexing, re-query the
+	* loaded project within the deadline; a soft "not ready" `ResponseError` backs off and retries
+	* inside the deadline. Still indexing at the deadline ⇒ `not_ready` (retry).
+	*/
+	async pullDiagnostics(uri) {
+		const provider = this._capabilities.diagnosticProvider;
+		const deadline = this.now() + this.timeoutMs;
+		let attempt = 0;
+		while (true) {
+			await this.awaitIndexingSettled(deadline);
+			if (this.indexing) return this.wrap("not_ready", []);
+			let report = null;
+			let softNotReady = false;
+			try {
+				report = await this.conn.sendRequest(DocumentDiagnosticRequest.method, {
+					textDocument: { uri },
+					...provider?.identifier ? { identifier: provider.identifier } : {}
+				});
+			} catch (err) {
+				if (!(err instanceof ResponseError) || !SOFT_NOT_READY_CODES.has(err.code)) throw err;
+				softNotReady = true;
+			}
+			if (this.indexing && this.now() < deadline) continue;
+			if (!softNotReady) return this.wrap(this.indexing ? "not_ready" : "ok", diagnosticsFromReport(report));
+			attempt += 1;
+			const backoff = Math.min(this.baseBackoffMs * 2 ** (attempt - 1), this.maxBackoffMs);
+			if (this.noRetry || this.now() + backoff > deadline) return this.wrap("not_ready", []);
+			await this.delay(backoff);
+		}
+	}
+	/**
+	* `workspace/symbol` — project-wide symbol search by name (ADR 0011 staged tail). Position-less
+	* and file-less: the query is just a name fragment matched against the whole indexed workspace,
+	* so it needs no open document (the project is loaded at `initialize`). Tri-state like the rest —
+	* an empty result while the project is still indexing is `not_ready`, never collapsed into
+	* "no such symbol" (the cold-load trap the rest of the client already guards). Handles both the
+	* flat `SymbolInformation[]` (range present) and the uri-only `WorkspaceSymbol[]` shapes.
+	*/
+	async workspaceSymbols(query) {
+		if (!this.supports("workspaceSymbolProvider")) throw new LspUnsupportedError("server does not advertise workspace symbol support");
+		return this.withRetry(() => this.conn.sendRequest(WorkspaceSymbolRequest.method, { query }), (raw) => normalizeWorkspaceSymbols(raw), (syms) => syms.length === 0);
+	}
+	/**
+	* `textDocument/prepareRename` — the cheap validate-first pre-flight (write-mode, ADR 0011
+	* addendum). Tri-state: `null` while indexing ⇒ `not_ready`; `null` while ready ⇒ `no_result`
+	* (the engine maps that to a structured "not renameable here" refusal); a non-null outcome ⇒
+	* `ok`. Only callable when {@link supportsPrepareRename} (the engine skips it otherwise).
+	*/
+	async prepareRename(uri, position) {
+		if (!this.supportsPrepareRename) throw new LspUnsupportedError("server does not advertise prepareRename support");
+		return this.withRetry(() => this.conn.sendRequest(PrepareRenameRequest.method, {
+			textDocument: { uri },
+			position
+		}), (raw) => normalizePrepareRename(raw), (outcome) => outcome === null);
+	}
+	/**
+	* `textDocument/rename` — compute the cross-file `WorkspaceEdit` for renaming the symbol at
+	* `position` to `newName`. Capability-gated on `renameProvider`; normalized to the uniform
+	* `files`/`resourceOps` shape; tri-state (empty/`null` while indexing ⇒ `not_ready`). This
+	* computes only — applying the edit to disk is the gated engine's job (Slice F), never here.
+	*/
+	async rename(uri, position, newName) {
+		if (!this.supports("renameProvider")) throw new LspUnsupportedError("server does not advertise rename support");
+		return this.withRetry(() => this.conn.sendRequest(RenameRequest.method, {
+			textDocument: { uri },
+			position,
+			newName
+		}), (raw) => normalizeWorkspaceEdit(raw), (we) => we.files.length === 0 && we.resourceOps.length === 0);
+	}
+	/**
+	* Call hierarchy — a TWO-round-trip protocol. `prepareCallHierarchy` resolves the symbol at
+	* `position` to one or more `CallHierarchyItem`s (null vs empty is distinct; overloads yield
+	* MANY — we keep them all, never silently the first); then per item we fetch incoming or
+	* outgoing calls. Tri-state lives on the PREPARE step (empty-while-indexing ⇒ not_ready). A
+	* prepared item with no callers/callees is a legitimate `ok` with empty `calls`. The RAW item
+	* is passed back to the calls request (it may carry an opaque `data` field the server needs).
+	*/
+	async callHierarchy(uri, position, direction) {
+		if (!this.supports("callHierarchyProvider")) throw new LspUnsupportedError("server does not advertise callHierarchy support");
+		const prepared = await this.withRetry(() => this.conn.sendRequest(CallHierarchyPrepareRequest.method, {
+			textDocument: { uri },
+			position
+		}), (raw) => raw ?? [], (items) => items.length === 0);
+		if (prepared.status !== "ok") return this.wrap(prepared.status, []);
+		const method = direction === "incoming" ? CallHierarchyIncomingCallsRequest.method : CallHierarchyOutgoingCallsRequest.method;
+		const groups = [];
+		for (const item of prepared.result) {
+			const raw = await this.conn.sendRequest(method, { item });
+			const calls = direction === "incoming" ? normalizeIncomingCalls(raw) : normalizeOutgoingCalls(raw);
+			groups.push({
+				source: normalizeCallHierarchyItem(item),
+				calls
+			});
+		}
+		return this.wrap("ok", groups);
+	}
+	navigateLocations(method, params) {
+		return this.withRetry(() => this.conn.sendRequest(method, params), (raw) => normalizeLocations(raw), (locs) => locs.length === 0);
+	}
+	/**
+	* The tri-state request loop: settle → send → decide, all inside one operator deadline.
+	*
+	* The load-bearing rule (ADR 0011 addendum — proven by a live `typescript-language-server`
+	* capture): **a result returned while the server is still indexing the project is NOT
+	* trustworthy** — tsserver answers an early request from a single-file *inferred* project
+	* (a non-empty BUT PARTIAL answer — e.g. a cross-file rename that sees only the opened file)
+	* and only *then* finishes loading the configured project. So:
+	*
+	* 1. Before sending, wait out any in-flight indexing (`awaitIndexingSettled`) so we hit the
+	*    loaded project.
+	* 2. After sending, if indexing is active (the send itself triggered the configured-project
+	*    load), the answer is from the unstable inferred project — loop to settle + re-query.
+	* 3. Once the server is settled: a non-empty result is `ok`; an empty result is `no_result`
+	*    (retried with bounded backoff) — or `not_ready` only if we hit the deadline still indexing.
+	*
+	* This trades the old "return `not_ready` fast" for "wait for the correct answer within the
+	* deadline" — correctness over latency, bounded by the operator timeout.
+	*/
+	async withRetry(send, normalize, isEmpty) {
+		const deadline = this.now() + this.timeoutMs;
+		let attempt = 0;
+		while (true) {
+			await this.awaitIndexingSettled(deadline);
+			let value;
+			let softError = false;
+			try {
+				value = normalize(await send());
+			} catch (err) {
+				if (!(err instanceof ResponseError) || !SOFT_NOT_READY_CODES.has(err.code)) throw err;
+				value = normalize(null);
+				softError = true;
+			}
+			if (this.indexing && this.now() < deadline) continue;
+			const status = decideStatus(isEmpty(value), !this.indexing);
+			if (status !== "no_result") return this.wrap(status, value);
+			if (softError) return this.wrap("no_result", value);
+			attempt += 1;
+			const backoff = Math.min(this.baseBackoffMs * 2 ** (attempt - 1), this.maxBackoffMs);
+			if (this.noRetry || this.now() + backoff > deadline) return this.wrap("no_result", value);
+			await this.delay(backoff);
+		}
+	}
+	wrap(status, result) {
+		return {
+			status,
+			result,
+			serverInfo: this._serverInfo,
+			encoding: this._encoding
+		};
+	}
+	/** Graceful teardown: LSP `shutdown` request then the `exit` notification. */
+	async shutdown() {
+		try {
+			await this.conn.sendRequest(ShutdownRequest.method);
+		} catch {}
+		try {
+			this.conn.sendNotification(ExitNotification.method);
+		} catch {}
+	}
+};
+//#endregion
+//#region src/registry.ts
+/** Thrown on a malformed operator registry or a request for an unbound language. */
+var LspRegistryError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LspRegistryError";
+	}
+};
+function isStringArray(v) {
+	return Array.isArray(v) && v.every((x) => typeof x === "string");
+}
+/**
+* Parse + validate the operator JSON registry. Fails loud on anything malformed — an
+* operator misconfiguration must be a clear error, never a silently-empty or
+* partially-parsed registry an agent then queries against.
+*/
+function parseServerRegistry(json) {
+	let raw;
+	try {
+		raw = JSON.parse(json);
+	} catch (e) {
+		throw new LspRegistryError(`registry is not valid JSON: ${e.message}`);
+	}
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new LspRegistryError("registry must be a JSON object keyed by language");
+	const out = {};
+	for (const [language, value] of Object.entries(raw)) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new LspRegistryError(`registry entry for "${language}" must be an object`);
+		const entry = value;
+		if (typeof entry.command !== "string" || entry.command.length === 0) throw new LspRegistryError(`registry entry for "${language}" needs a non-empty string command`);
+		if (entry.args !== void 0 && !isStringArray(entry.args)) throw new LspRegistryError(`registry entry for "${language}" args must be an array of strings`);
+		if (entry.languageId !== void 0 && typeof entry.languageId !== "string") throw new LspRegistryError(`registry entry for "${language}" languageId must be a string`);
+		out[language] = {
+			command: entry.command,
+			args: entry.args ?? [],
+			...entry.initializationOptions !== void 0 ? { initializationOptions: entry.initializationOptions } : {},
+			...entry.languageId !== void 0 ? { languageId: entry.languageId } : {}
+		};
+	}
+	if (Object.keys(out).length === 0) throw new LspRegistryError("registry is empty — bind at least one language→server");
+	return out;
+}
+/** Resolve a language to its registered server, or refuse it (never spawns an unbound server). */
+function resolveServer(registry, language) {
+	const entry = registry[language];
+	if (!entry) throw new LspRegistryError(`no server bound for language "${language}" (bound: ${Object.keys(registry).join(", ") || "(none)"})`);
+	return entry;
+}
+//#endregion
+//#region src/manager.ts
+/**
+* The `LanguageServerManager` (ADR 0011, slice 3) — owns the resident language-server
+* subprocesses. The right analogy is the browser pillar's `BrowserManager` (a resident,
+* code-executing subprocess), NOT the short-lived test-runner: lazy spawn, idle reaper,
+* caps, injected clock. Three deliberate divergences the browser analogy hides:
+*
+* - **Keyed by `(language, projectRoot)` and SHARED across MCP sessions** (not one ephemeral
+*   context per session). A server is expensive to spawn and *warm* (indexing takes
+*   seconds-to-minutes), so it is reused across calls with a longer idle TTL than browser's.
+* - **Per-`(server, uri)` async mutex.** JSON-RPC id-correlation makes concurrent *requests*
+*   safe, but the document lifecycle is shared mutable state: two concurrent queries each
+*   sending `didOpen(version 1)` on the same file is a protocol violation. The mutex
+*   serializes the open+query critical section per file (open-once + refcount lives in the
+*   client; the mutex is what makes that race-free under concurrency).
+* - **The reaper respects an in-flight counter** and resets the idle clock on request start:
+*   never reap a server with `inFlight > 0`; on reap send LSP `shutdown` → `exit` with a
+*   clock-driven grace before the hard `dispose()` (SIGKILL). Deterministic in tests via the
+*   injected clock + `sweepIdle(nowMs)`.
+*
+* Safety (re-derived from the browser pillar): `rootUri`/`workspaceFolders` are pinned to the
+* operator-allowlisted `projectRoot` — the agent never supplies a root, and a root outside
+* `allowedRoots` is refused before any spawn. The agent supplies only a `language`; an unbound
+* language is refused by the registry, never spawned. `allowRun` (the paired gate) lives one
+* layer up in `query.ts`.
+*/
+/** Thrown when the manager refuses a request (root outside the allowlist, server cap reached). */
+var LspManagerError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LspManagerError";
+	}
+};
+/** The LSP capabilities `lsp_languages` reports per active server (v1 + staged tools). */
+const REPORTED_CAPABILITIES = {
+	definition: "definitionProvider",
+	references: "referencesProvider",
+	hover: "hoverProvider",
+	typeDefinition: "typeDefinitionProvider",
+	documentSymbol: "documentSymbolProvider",
+	workspaceSymbol: "workspaceSymbolProvider",
+	callHierarchy: "callHierarchyProvider"
+};
+/** A server is keyed by `(language, sorted root group)`; parts are joined with `\x1f` (unit
+* separator) so a path with a space can never collide with the language separator — and, unlike
+* a raw NUL, it keeps this file as plain text for grep/find-replace tooling. */
+const serverKey = (language, roots) => `${language}\x1f${roots.join("")}`;
+const defaultDelay = (ms) => new Promise((r) => setTimeout(r, ms));
+var LanguageServerManager = class {
+	registry;
+	allowedRoots;
+	timeoutMs;
+	serverSpawn;
+	idleTtlMs;
+	maxServers;
+	shutdownGraceMs;
+	noRetry;
+	now;
+	delay;
+	servers = /* @__PURE__ */ new Map();
+	/** In-flight spawn+initialize, so concurrent first callers share one initialization. */
+	initing = /* @__PURE__ */ new Map();
+	reaper;
+	constructor(options) {
+		this.registry = options.registry;
+		this.allowedRoots = options.allowedRoots;
+		this.timeoutMs = options.timeoutMs;
+		this.serverSpawn = options.serverSpawn ?? defaultServerSpawn;
+		this.idleTtlMs = options.idleTtlMs ?? 15 * 6e4;
+		this.maxServers = options.maxServers ?? 8;
+		this.shutdownGraceMs = options.shutdownGraceMs ?? 2e3;
+		this.noRetry = options.noRetry ?? false;
+		this.now = options.now ?? Date.now;
+		this.delay = options.delay ?? defaultDelay;
+	}
+	get serverCount() {
+		return this.servers.size;
+	}
+	/**
+	* Run `fn` against the (shared, lazily-spawned) server for `(language, projectRoot)`, under
+	* the per-`(server, uri)` mutex. The document is opened once (refcounted in the client) and
+	* the server's idle clock is reset on entry and exit; `inFlight` is held for the duration so
+	* the reaper cannot tear the server down mid-request.
+	*/
+	async run(input, fn) {
+		const entry = await this.acquire(input.language, input.projectRoot, input.workspaceRoots);
+		return this.withUriLock(entry, input.uri, async () => {
+			entry.inFlight += 1;
+			entry.lastUsedAt = this.now();
+			try {
+				const languageId = this.registry[input.language]?.languageId ?? input.language;
+				entry.client.ensureOpen(input.uri, languageId, input.text);
+				const result = await fn(entry.client);
+				entry.lastUsedAt = this.now();
+				return result;
+			} finally {
+				entry.inFlight -= 1;
+			}
+		});
+	}
+	/**
+	* Like {@link run}, but holds the per-`(server, uri)` lock for MANY uris at once — the
+	* primitive a multi-file write needs (Slice F′). Locks are acquired in a deterministic SORTED
+	* order so two concurrent multi-file renames can never deadlock (no lock-ordering cycle), and
+	* are all held across the whole `fn` (the stage+commit+`didChange` window). Does NOT `didOpen`
+	* any document — the caller opened what it needs during the compute phase (open-once/refcount).
+	*/
+	async runWithUris(input, fn) {
+		const entry = await this.acquire(input.language, input.projectRoot, input.workspaceRoots);
+		return this.withUriLocks(entry, input.uris, async () => {
+			entry.inFlight += 1;
+			entry.lastUsedAt = this.now();
+			try {
+				const result = await fn(entry.client);
+				entry.lastUsedAt = this.now();
+				return result;
+			} finally {
+				entry.inFlight -= 1;
+			}
+		});
+	}
+	/**
+	* The resolved, sorted, de-duplicated root group for a query — the primary `projectRoot` plus any
+	* `workspaceRoots`. EVERY member is `assertRootAllowed`'d (refused before any spawn), so a
+	* multi-root group cannot smuggle in an un-allowlisted folder.
+	*/
+	resolveGroup(projectRoot, workspaceRoots) {
+		const all = [projectRoot, ...workspaceRoots].map((r) => resolve(r));
+		for (const r of all) this.assertRootAllowed(r);
+		return [...new Set(all)].sort();
+	}
+	/** Resolve (and lazily spawn+initialize) the shared server for `(language, root group)`. */
+	async acquire(language, projectRoot, workspaceRoots = []) {
+		const roots = this.resolveGroup(projectRoot, workspaceRoots);
+		const spec = resolveServer(this.registry, language);
+		const key = serverKey(language, roots);
+		const existing = this.servers.get(key);
+		if (existing) {
+			existing.lastUsedAt = this.now();
+			return existing;
+		}
+		const grown = this.tryGrowExisting(language, roots, key);
+		if (grown) return grown;
+		const pending = this.initing.get(key);
+		if (pending) return pending;
+		const p = this.spawnAndInit(language, roots, key, spec);
+		this.initing.set(key, p);
+		try {
+			return await p;
+		} finally {
+			this.initing.delete(key);
+		}
+	}
+	/**
+	* Find the UNIQUELY-largest warm server whose root group is a strict subset of `roots` (same
+	* language, and it must advertise workspace-folder change support), grow it to `roots` in place,
+	* and re-key it. Returns the grown entry, or `undefined` when there is no candidate or the largest
+	* subset is ambiguous (≥2 candidates tie for the most roots) — in which case we spawn fresh rather
+	* than guess which to mutate. Grow-only: a subset request of an existing LARGER server is NOT
+	* shrunk (it spawns its own server) — keeping keys, `describe()`, and confinement unambiguous.
+	*/
+	tryGrowExisting(language, roots, newKey) {
+		const group = new Set(roots);
+		const candidates = [...this.servers.values()].filter((e) => e.language === language && e.client.supportsWorkspaceFolderChange && e.roots.length < roots.length && e.roots.every((r) => group.has(r)));
+		if (candidates.length === 0) return void 0;
+		const maxSize = Math.max(...candidates.map((e) => e.roots.length));
+		const largest = candidates.filter((e) => e.roots.length === maxSize);
+		if (largest.length !== 1) return void 0;
+		const entry = largest[0];
+		const added = roots.filter((r) => !entry.roots.includes(r)).map((r) => ({
+			uri: pathToFileURL(r).toString(),
+			name: basename(r)
+		}));
+		entry.client.changeWorkspaceFolders(added, []);
+		this.servers.delete(entry.key);
+		entry.key = newKey;
+		entry.roots = roots;
+		entry.projectRoot = roots[0] ?? "";
+		entry.lastUsedAt = this.now();
+		this.servers.set(newKey, entry);
+		return entry;
+	}
+	async spawnAndInit(language, roots, key, spec) {
+		if (this.servers.size >= this.maxServers) throw new LspManagerError(`max servers reached (${this.maxServers}); reap or wait`);
+		const connection = this.serverSpawn({
+			command: spec.command,
+			args: spec.args,
+			initializationOptions: spec.initializationOptions
+		});
+		const client = new LspClient(connection.connection, {
+			timeoutMs: this.timeoutMs,
+			noRetry: this.noRetry,
+			now: this.now,
+			delay: this.delay
+		});
+		const folders = roots.map((r) => ({
+			uri: pathToFileURL(r).toString(),
+			name: basename(r)
+		}));
+		await client.initialize(folders[0]?.uri ?? "", {
+			initializationOptions: spec.initializationOptions,
+			workspaceFolders: folders
+		});
+		const entry = {
+			key,
+			language,
+			projectRoot: roots[0] ?? "",
+			roots,
+			client,
+			connection,
+			lastUsedAt: this.now(),
+			inFlight: 0,
+			locks: /* @__PURE__ */ new Map()
+		};
+		this.servers.set(key, entry);
+		return entry;
+	}
+	/** Provenance for every currently-live server (drives the always-on `lsp_languages` tool). */
+	describe() {
+		return [...this.servers.values()].map((entry) => {
+			const capabilities = {};
+			for (const [name, provider] of Object.entries(REPORTED_CAPABILITIES)) capabilities[name] = entry.client.supports(provider);
+			return {
+				language: entry.language,
+				projectRoot: entry.projectRoot,
+				...entry.roots.length > 1 ? { roots: entry.roots } : {},
+				...entry.client.serverInfo ? { serverInfo: entry.client.serverInfo } : {},
+				capabilities
+			};
+		});
+	}
+	assertRootAllowed(projectRoot) {
+		const root = resolve(projectRoot);
+		if (!this.allowedRoots.map((r) => resolve(r)).includes(root)) throw new LspManagerError(`project root ${projectRoot} is not in the operator allowlist`);
+	}
+	/** Serialize `fn` against all other callers holding the same `(server, uri)` lock. */
+	async withUriLock(entry, uri, fn) {
+		const prev = entry.locks.get(uri) ?? Promise.resolve();
+		let release;
+		const current = new Promise((r) => {
+			release = r;
+		});
+		entry.locks.set(uri, prev.then(() => current));
+		await prev;
+		try {
+			return await fn();
+		} finally {
+			release();
+		}
+	}
+	/**
+	* Acquire the per-uri locks for EVERY uri (deduped, SORTED — deadlock-free ordering) and hold
+	* them all across `fn`, releasing in reverse on exit. Each lock chains on the same per-uri
+	* promise the single-uri `withUriLock` uses, so a multi-file write serializes correctly against
+	* any concurrent single-file query on one of its files.
+	*/
+	async withUriLocks(entry, uris, fn) {
+		const sorted = [...new Set(uris)].sort();
+		const releases = [];
+		for (const uri of sorted) {
+			const prev = entry.locks.get(uri) ?? Promise.resolve();
+			let release;
+			const current = new Promise((r) => {
+				release = r;
+			});
+			entry.locks.set(uri, prev.then(() => current));
+			await prev;
+			releases.push(release);
+		}
+		try {
+			return await fn();
+		} finally {
+			for (const release of releases.reverse()) release();
+		}
+	}
+	/**
+	* Reap every server idle for at least `idleTtlMs` that has NO in-flight request. Returns the
+	* reaped keys. Drives the deterministic reaper logic; `nowMs` defaults to the injected clock.
+	*/
+	async sweepIdle(nowMs = this.now()) {
+		const reaped = [];
+		for (const [key, entry] of this.servers) {
+			if (entry.inFlight > 0) continue;
+			if (nowMs - entry.lastUsedAt >= this.idleTtlMs) reaped.push(key);
+		}
+		await Promise.all(reaped.map((key) => this.reap(key)));
+		return reaped;
+	}
+	async reap(key) {
+		const entry = this.servers.get(key);
+		if (!entry) return;
+		this.servers.delete(key);
+		await this.gracefulStop(entry);
+	}
+	/** LSP `shutdown` → `exit` (graceful), then a clock-driven grace, then the hard `dispose()`. */
+	async gracefulStop(entry) {
+		try {
+			await entry.client.shutdown();
+		} catch {}
+		await this.delay(this.shutdownGraceMs);
+		entry.connection.dispose();
+	}
+	/** Start the production idle reaper (a `setInterval` driving the injected-clock `sweepIdle`). */
+	startReaper(intervalMs) {
+		this.stopReaper();
+		this.reaper = setInterval(() => {
+			this.sweepIdle();
+		}, intervalMs);
+		this.reaper.unref?.();
+	}
+	stopReaper() {
+		if (this.reaper) {
+			clearInterval(this.reaper);
+			this.reaper = void 0;
+		}
+	}
+	/** Gracefully stop and dispose every server; the manager can be reused afterward. */
+	async shutdown() {
+		this.stopReaper();
+		const entries = [...this.servers.values()];
+		this.servers.clear();
+		this.initing.clear();
+		await Promise.all(entries.map((entry) => this.gracefulStop(entry)));
+	}
+};
+//#endregion
+//#region src/confine.ts
+/**
+* The shared paired-gate + path-confinement guards for the LSP engines (ADR 0011). Factored
+* out of `query.ts` so the read engine (`LspQueryEngine`) and the write engine
+* (`LspRenameEngine`, Slice F) share one implementation — with a `resolveSymlinks` mode that
+* the WRITE path always sets.
+*
+* The read path confines the single queried file lexically (lower stakes). The write path must
+* confine EVERY file a `WorkspaceEdit` would touch, and lexically is not enough: `resolve()`
+* does not canonicalize symlinks, so a symlink INSIDE the root pointing OUTSIDE it passes a
+* prefix check and a write would clobber the out-of-root target. The write path therefore
+* `realpath`-canonicalizes the root and each target's nearest existing ancestor and re-asserts
+* containment, and refuses any non-`file://` scheme. Confinement is pure path/metadata work —
+* it runs BEFORE any target file content is read.
+*/
+/** Thrown when the paired operator gate denies a query/edit (allowRun off, out-of-bounds, bad scheme). */
+var LspGateError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LspGateError";
+	}
+};
+/** The paired deny-by-default gate: `allowRun` + the operator root allowlist. */
+function assertAllowed(allowRun, allowedRoots, projectRoot) {
+	if (!allowRun) throw new LspGateError("LSP navigation is not enabled (the operator must set allowRun)");
+	const root = resolve(projectRoot);
+	if (!allowedRoots.map((r) => resolve(r)).includes(root)) throw new LspGateError(`project root ${projectRoot} is not in the operator allowlist`);
+}
+/** Lexical containment: `child` must equal `root` or sit beneath it. */
+function assertInside(root, child, message) {
+	if (child !== root && !child.startsWith(root + sep)) throw new LspGateError(message);
+}
+/** Canonicalize `abs` by realpath-ing its deepest existing ancestor and re-appending the tail. */
+function realpathNearest(abs) {
+	let existing = abs;
+	const tail = [];
+	while (!existsSync(existing)) {
+		const parent = dirname(existing);
+		if (parent === existing) break;
+		tail.unshift(basename(existing));
+		existing = parent;
+	}
+	const real = realpathSync(existing);
+	return tail.length > 0 ? resolve(real, ...tail) : real;
+}
+/**
+* Confine a project-relative-or-absolute `file` to `projectRoot`, returning the absolute path.
+* Read path: lexical (default). Write path (`resolveSymlinks: true`): additionally
+* realpath-canonicalizes the root + the target's nearest existing ancestor and re-asserts
+* containment, closing the symlink-escape hole a lexical `resolve()` misses.
+*/
+function confineFile(projectRoot, file, opts = {}) {
+	const root = resolve(projectRoot);
+	const abs = resolve(root, file);
+	assertInside(root, abs, `file ${file} escapes the project root ${projectRoot}`);
+	if (opts.resolveSymlinks) {
+		let realRoot;
+		try {
+			realRoot = realpathSync(root);
+		} catch {
+			throw new LspGateError(`project root ${projectRoot} does not exist`);
+		}
+		assertInside(realRoot, realpathNearest(abs), `file ${file} escapes the project root ${projectRoot} after symlink resolution`);
+	}
+	return abs;
+}
+/**
+* Like {@link confineEditedUri}, but confines to a GROUP of allowlisted roots (the multi-root
+* write path): a `WorkspaceEdit` for a monorepo legitimately edits files in any bound workspace
+* folder, so the edited URI is accepted when it realpath-confines to ANY root in the group, and
+* refused only when it escapes EVERY root. Refuses a non-`file://` scheme once, up front (it can
+* never confine to any root). Returns the absolute filesystem path.
+*/
+function confineEditedUriToRoots(roots, uri) {
+	let abs;
+	try {
+		abs = fileURLToPath(uri);
+	} catch {
+		throw new LspGateError(`edited document ${uri} is not a file:// URI (refused for write)`);
+	}
+	for (const root of roots) try {
+		return confineFile(root, abs, { resolveSymlinks: true });
+	} catch {}
+	throw new LspGateError(`edited document ${uri} escapes every allowlisted root (refused for write)`);
+}
+//#endregion
+//#region src/query.ts
+/**
+* The gated LSP query engine (ADR 0011, slice 4) — the agent-facing entry that ties the
+* operator gate, the `LanguageServerManager`, and the encoding core together. Mirrors
+* coverage's `runScoped`: a **paired deny-by-default operator gate** (`allowRun` +
+* `allowedRoots` + the manager's per-request deadline), because every navigation answer
+* requires a live, code-executing, indexing daemon to exist. There is **no "free read" tier**
+* here — unlike `search_docs`/`list_requests`.
+*
+* The engine owns the I/O the protocol-level client must not: it **confines the queried file
+* to the project root** (no traversal), reads its text, converts the human 1-based line:col to
+* a 0-based LSP `Position` in the server's **negotiated encoding**, drives `manager.run`, and
+* maps the result ranges back to human 1-based line:col (reading each target file's text for an
+* encoding-faithful inverse; best-effort `+1` fallback when a target — e.g. a dep's `.d.ts` —
+* is unreadable). Tri-state status passes through untouched (never collapse `not_ready` into
+* "no result"). `serverInfo` provenance rides on every result; its absence is surfaced as a
+* `versionWarning` (an answer that cannot be attributed to a server version). The richer
+* warn-on-toolchain-mismatch heuristic (reusing `core.detectInstalledVersion`) is staged to the
+* surface, which can pass detected `toolchain` provenance to echo here.
+*/
+const defaultReadFile$1 = (p) => {
+	try {
+		return readFileSync(p, "utf8");
+	} catch {
+		return;
+	}
+};
+/** The position-based kinds — those that require a `line`/`column`. */
+const POSITION_KINDS = new Set([
+	"definition",
+	"typeDefinition",
+	"references",
+	"hover",
+	"callHierarchy"
+]);
+var LspQueryEngine = class {
+	manager;
+	allowRun;
+	allowedRoots;
+	readFile;
+	constructor(options) {
+		this.manager = options.manager;
+		this.allowRun = options.allowRun;
+		this.allowedRoots = options.allowedRoots;
+		this.readFile = options.readFile ?? defaultReadFile$1;
+	}
+	async query(input) {
+		assertAllowed(this.allowRun, this.allowedRoots, input.projectRoot);
+		for (const root of input.workspaceRoots ?? []) assertAllowed(this.allowRun, this.allowedRoots, root);
+		if (input.kind === "workspaceSymbol") return this.queryWorkspaceSymbol(input);
+		if (input.file === void 0) throw new LspGateError(`the ${input.kind} query requires a file`);
+		const absFile = confineFile(input.projectRoot, input.file);
+		const text = this.readFile(absFile);
+		if (text === void 0) throw new LspGateError(`cannot read file ${input.file} in ${input.projectRoot}`);
+		const uri = pathToFileURL(absFile).toString();
+		if (POSITION_KINDS.has(input.kind) && (input.line === void 0 || input.column === void 0)) throw new LspGateError(`the ${input.kind} query requires a line and column`);
+		const nav = await this.manager.run({
+			language: input.language,
+			projectRoot: input.projectRoot,
+			uri,
+			text,
+			...input.workspaceRoots ? { workspaceRoots: input.workspaceRoots } : {}
+		}, (client) => {
+			switch (input.kind) {
+				case "documentSymbols": return client.documentSymbols(uri);
+				case "diagnostics": return client.documentDiagnostics(uri);
+				default: {
+					const pos = toLspPosition(text, input.line, input.column, client.encoding);
+					switch (input.kind) {
+						case "definition": return client.definition(uri, pos);
+						case "typeDefinition": return client.typeDefinition(uri, pos);
+						case "references": return client.references(uri, pos);
+						case "hover": return client.hover(uri, pos);
+						case "callHierarchy": return client.callHierarchy(uri, pos, input.direction ?? "incoming");
+						default: throw new LspGateError(`unsupported position-based query kind: ${input.kind}`);
+					}
+				}
+			}
+		});
+		return this.shape(input, nav, uri, text);
+	}
+	/**
+	* Run the project-wide `workspace/symbol` search and shape its cross-file result.
+	*
+	* `workspace/symbol` takes no position, but a real server still needs a *project* to search.
+	* Some servers — notably `typescript-language-server` — only build a project once a document is
+	* open, and answer `workspace/symbol` with a "No Project" error otherwise (caught running the
+	* greeter example live, the cold-load lesson again). So the agent may pass an OPTIONAL anchor
+	* `file`: when present we open it (establishing the project) before searching; when absent we
+	* search with no document open, which works for eager indexers (gopls, rust-analyzer) that load
+	* the project at `initialize`.
+	*/
+	async queryWorkspaceSymbol(input) {
+		if (input.query === void 0) throw new LspGateError("the workspaceSymbol query requires a `query` string");
+		const query = input.query;
+		let nav;
+		if (input.file !== void 0) {
+			const absFile = confineFile(input.projectRoot, input.file);
+			const text = this.readFile(absFile);
+			if (text === void 0) throw new LspGateError(`cannot read anchor file ${input.file} in ${input.projectRoot}`);
+			const uri = pathToFileURL(absFile).toString();
+			nav = await this.manager.run({
+				language: input.language,
+				projectRoot: input.projectRoot,
+				uri,
+				text
+			}, (client) => client.workspaceSymbols(query));
+		} else nav = await this.manager.runWithUris({
+			language: input.language,
+			projectRoot: input.projectRoot,
+			uris: [],
+			...input.workspaceRoots ? { workspaceRoots: input.workspaceRoots } : {}
+		}, (client) => client.workspaceSymbols(query));
+		const base = this.baseResult(input, nav);
+		const cache = /* @__PURE__ */ new Map();
+		return {
+			...base,
+			workspaceSymbols: nav.result.map((s) => this.mapWorkspaceSymbol(s, nav.encoding, cache))
+		};
+	}
+	/** The shared provenance/status envelope every result carries (status + encoding + provenance). */
+	baseResult(input, nav) {
+		const { encoding, serverInfo } = nav;
+		const versionWarning = serverInfo === void 0 ? "the language server did not report its version (serverInfo); the answer cannot be attributed to a specific server version" : void 0;
+		return {
+			status: nav.status,
+			kind: input.kind,
+			encoding,
+			...serverInfo ? { serverInfo } : {},
+			...input.toolchain ? { toolchain: input.toolchain } : {},
+			...versionWarning ? { versionWarning } : {}
+		};
+	}
+	shape(input, nav, queriedUri, queriedText) {
+		const { encoding } = nav;
+		const base = this.baseResult(input, nav);
+		if (input.kind === "diagnostics") {
+			const diags = nav.result;
+			const cache = new Map([[queriedUri, queriedText]]);
+			return {
+				...base,
+				diagnostics: diags.map((d) => this.mapDiagnostic(d, queriedText, encoding, cache))
+			};
+		}
+		if (input.kind === "hover") {
+			const hover = nav.result;
+			if (!hover) return base;
+			return {
+				...base,
+				hover: {
+					value: hover.value,
+					...hover.range ? { range: this.mapRange(queriedText, hover.range, encoding) } : {}
+				}
+			};
+		}
+		if (input.kind === "documentSymbols") {
+			const symbols = nav.result;
+			return {
+				...base,
+				symbols: symbols.map((s) => this.mapSymbol(s, queriedText, encoding))
+			};
+		}
+		if (input.kind === "callHierarchy") {
+			const direction = input.direction ?? "incoming";
+			const groups = nav.result;
+			const cache = new Map([[queriedUri, queriedText]]);
+			return {
+				...base,
+				callHierarchy: groups.map((g) => this.mapCallGroup(g, direction, encoding, queriedUri, cache))
+			};
+		}
+		const locations = nav.result;
+		const cache = /* @__PURE__ */ new Map();
+		return {
+			...base,
+			locations: locations.map((loc) => this.mapLocation(loc, encoding, queriedUri, queriedText, cache))
+		};
+	}
+	mapLocation(loc, encoding, queriedUri, queriedText, cache) {
+		const text = loc.uri === queriedUri ? queriedText : this.textForUri(loc.uri, cache);
+		return {
+			uri: loc.uri,
+			range: this.mapRange(text, loc.range, encoding),
+			...loc.fullRange ? { fullRange: this.mapRange(text, loc.fullRange, encoding) } : {},
+			mapped: text !== void 0
+		};
+	}
+	/** Map a normalized document symbol (and its children) to human coords in the queried file. */
+	mapSymbol(s, text, encoding) {
+		const out = {
+			name: s.name,
+			kind: s.kind,
+			kindName: s.kindName,
+			range: this.mapRange(text, s.range, encoding)
+		};
+		if (s.detail !== void 0) out.detail = s.detail;
+		if (s.container !== void 0) out.container = s.container;
+		if (s.children && s.children.length > 0) out.children = s.children.map((c) => this.mapSymbol(c, text, encoding));
+		return out;
+	}
+	/** Map a diagnostic's range (queried file) + any relatedInformation ranges (their own files). */
+	mapDiagnostic(d, queriedText, encoding, cache) {
+		const out = {
+			range: this.mapRange(queriedText, d.range, encoding),
+			message: d.message
+		};
+		if (d.severity !== void 0) out.severity = d.severity;
+		if (d.severityName !== void 0) out.severityName = d.severityName;
+		if (d.code !== void 0) out.code = d.code;
+		if (d.source !== void 0) out.source = d.source;
+		if (d.tags !== void 0) out.tags = d.tags;
+		if (d.related !== void 0) out.related = d.related.map((r) => ({
+			uri: r.uri,
+			range: this.mapRange(this.textForUri(r.uri, cache), r.range, encoding),
+			message: r.message
+		}));
+		return out;
+	}
+	/** Map a workspace symbol to human coords, reading its OWN target file (cross-file, read-only). */
+	mapWorkspaceSymbol(s, encoding, cache) {
+		const out = {
+			name: s.name,
+			kind: s.kind,
+			kindName: s.kindName,
+			uri: s.uri,
+			mapped: false
+		};
+		if (s.container !== void 0) out.container = s.container;
+		if (s.range !== void 0) {
+			const text = this.textForUri(s.uri, cache);
+			out.range = this.mapRange(text, s.range, encoding);
+			out.mapped = text !== void 0;
+		}
+		return out;
+	}
+	mapCallItem(item, encoding, cache) {
+		const text = this.textForUri(item.uri, cache);
+		return {
+			name: item.name,
+			kind: item.kind,
+			kindName: item.kindName,
+			...item.detail !== void 0 ? { detail: item.detail } : {},
+			uri: item.uri,
+			range: this.mapRange(text, item.range, encoding),
+			selectionRange: this.mapRange(text, item.selectionRange, encoding)
+		};
+	}
+	mapCallGroup(g, direction, encoding, queriedUri, cache) {
+		return {
+			source: this.mapCallItem(g.source, encoding, cache),
+			direction,
+			calls: g.calls.map((c) => {
+				const fromText = this.textForUri(direction === "incoming" ? c.item.uri : queriedUri, cache);
+				return {
+					item: this.mapCallItem(c.item, encoding, cache),
+					fromRanges: c.fromRanges.map((r) => this.mapRange(fromText, r, encoding))
+				};
+			})
+		};
+	}
+	textForUri(uri, cache) {
+		if (cache.has(uri)) return cache.get(uri);
+		let text;
+		try {
+			text = this.readFile(fileURLToPath(uri));
+		} catch {
+			text = void 0;
+		}
+		cache.set(uri, text);
+		return text;
+	}
+	/** Map an LSP 0-based range to a human 1-based range, encoding-faithfully when text is known. */
+	mapRange(text, range, encoding) {
+		if (text === void 0) return {
+			start: {
+				line: range.start.line + 1,
+				column: range.start.character + 1
+			},
+			end: {
+				line: range.end.line + 1,
+				column: range.end.character + 1
+			}
+		};
+		return {
+			start: fromLspPosition(text, range.start, encoding),
+			end: fromLspPosition(text, range.end, encoding)
+		};
+	}
+};
+//#endregion
+//#region src/apply.ts
+/**
+* The pure write-mode apply core (ADR 0011 write-mode addendum, Slice A). No I/O, no spawn —
+* the most defensible TDD entry for write-mode, pinning down the corruption-class vectors
+* (encoding-wrong offsets, overlapping edits, edit-ordering) before any disk write exists.
+*
+* The silent-wrong trap mirrors the read path: a TextEdit `range.character` is in the
+* NEGOTIATED encoding's code units, so applying it must resolve each position to an absolute
+* JS index via `lspPositionToOffset` (which is CRLF/BOM/non-BMP faithful) and never via a
+* naive line:column arithmetic.
+*/
+/** Thrown when two edits in one document overlap or share a start offset. */
+var OverlappingEditError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OverlappingEditError";
+	}
+};
+/**
+* Apply a set of LSP TextEdits to one document's `text`, encoding-faithfully. Each edit's
+* positions are resolved to absolute JS offsets, validated, then spliced in DESCENDING start
+* order so an earlier edit never invalidates a later one's offsets.
+*
+* Enforced invariants (throw {@link OverlappingEditError}, never silently corrupt):
+* - Two edits sharing a start offset are refused (subsumes a zero-length double insertion);
+*   with distinct starts the splice order is total and JS sort stability is never relied on.
+* - A true overlap (`prev.end > next.start`) is refused. Adjacency (`prev.end == next.start`)
+*   is allowed.
+*/
+function applyTextEdits(text, edits, encoding) {
+	const sorted = [...edits.map((e) => {
+		const start = lspPositionToOffset(text, e.range.start, encoding);
+		const end = lspPositionToOffset(text, e.range.end, encoding);
+		if (end < start) throw new OverlappingEditError(`edit range end (${end}) precedes its start (${start}) — malformed range`);
+		return {
+			start,
+			end,
+			newText: e.newText
+		};
+	})].sort((a, b) => a.start - b.start);
+	for (let k = 1; k < sorted.length; k++) {
+		const prev = sorted[k - 1];
+		const cur = sorted[k];
+		if (cur.start === prev.start) throw new OverlappingEditError(`two edits share start offset ${cur.start}`);
+		if (prev.end > cur.start) throw new OverlappingEditError(`edits overlap: [${prev.start},${prev.end}) and [${cur.start},${cur.end})`);
+	}
+	let out = text;
+	for (let k = sorted.length - 1; k >= 0; k--) {
+		const s = sorted[k];
+		out = out.slice(0, s.start) + s.newText + out.slice(s.end);
+	}
+	return out;
+}
+const MAX_RENAME_NAME_LENGTH = 255;
+/**
+* A coarse injection guard for a rename target. `newName` is sent verbatim to the server and
+* then written verbatim into EVERY edited site, so a newline or path separator in it is a
+* corruption/injection vector. This is a defensive bound, NOT a per-language identifier
+* validator: it rejects empty / over-length / multi-line / path-separator / control-character
+* names and accepts everything else (incl. non-ASCII letters). Validated before the rename
+* request is sent to the server.
+*/
+function isPlausibleRenameName(newName) {
+	if (typeof newName !== "string") return false;
+	if (newName.length === 0 || newName.length > MAX_RENAME_NAME_LENGTH) return false;
+	if (newName.includes("/") || newName.includes("\\")) return false;
+	if (/[\u0000-\u001f\u007f]/.test(newName)) return false;
+	return true;
+}
+//#endregion
+//#region src/rename.ts
+/**
+* The gated LSP rename engine (ADR 0011 write-mode addendum, Slices F + F′). The first WRITE
+* surface of the pillar. It mirrors `LspQueryEngine` but layers a SECOND operator gate —
+* `allowWrite` — on top of the read gate (`allowRun` + `allowedRoots`): rename is **dry-run by
+* default** (compute + preview, ZERO disk writes) and applies to disk only when `allowWrite` is
+* set AND every safety condition holds.
+*
+* Apply is a separate phase from compute (it may need more locks than the compute phase held).
+* Single- AND multi-file edits apply, the latter under the manager's multi-URI lock (sorted,
+* deadlock-free) held across the whole stage→commit→`didChange` window. Every touched file is
+* confined to the root group (realpath, all-or-nothing) BEFORE any I/O. Resource operations
+* (CreateFile/RenameFile/DeleteFile) APPLY in `documentChanges` order interleaved with text edits;
+* the replay runs over a per-file `Fate` VFS keyed by ORIGINAL uri, so content flows through a
+* rename (an edit to a renamed file's new path composes onto the carried content) and net-no-op
+* batches (create-then-delete) drop out. `ignoreIfExists`/`ignoreIfNotExists` are conditional
+* no-ops. `overwrite` (Create/Rename truncate-and-replace of an EXISTING regular file) APPLIES only
+* behind the separate operator `allowDestructiveResourceOps` gate, auditing the clobbered bytes and
+* surfacing `overwritten[]`; a symlink/directory target, recursive/directory delete, `overwrite` on
+* a delete, and genuinely ambiguous batches (a rename cycle, two renames into one target, editing a
+* renamed-away path, deleting a path that is also a rename/create target) all stay refused. A
+* mid-commit fault is terminal (`partial`).
+*
+* The adversarial corrections baked in here: oldText is sliced with absolute offsets (never
+* reconstructed from line:col); apply is staleness-guarded (the queried file vs its compute hash;
+* each on-disk edit site vs the old identifier — a not-yet-on-disk rename target is skipped, so an
+* import fix-up in a moved file never trips it) then stage-then-commit (the injected writer);
+* out-of-root edits never have their bytes read/surfaced; the post-commit `didChange`/`didFileRename`
+* doc-sync runs inside the held lock(s) and carries the bytes that ACTUALLY landed (pristine on a
+* partial commit, never the projected edit); secrets are redacted in every surfaced hunk.
+*/
+const defaultReadFile = (p) => {
+	try {
+		return readFileSync(p, "utf8");
+	} catch {
+		return;
+	}
+};
+const SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	".hg",
+	".svn",
+	"__pycache__",
+	".venv",
+	"venv",
+	"env",
+	".env",
+	".tox",
+	".nox",
+	".mypy_cache",
+	".pytest_cache",
+	".ruff_cache",
+	"dist",
+	"build",
+	"target",
+	".idea",
+	".vscode"
+]);
+const MAX_SCAN_FILES = 5e3;
+/** Default lister: a bounded, symlink-safe recursive walk collecting `extension` files, skipping
+* dependency/VCS/cache/build dirs and any dotdir. Stops (`truncated`) at {@link MAX_SCAN_FILES}.
+* The partial-rename guard is OFF until a lister is wired (like `redact`, the surfaces wire this). */
+const defaultListFiles = (roots, { extension }) => {
+	const files = [];
+	const seenDirs = /* @__PURE__ */ new Set();
+	let truncated = false;
+	const walk = (dir) => {
+		if (truncated) return;
+		let real;
+		try {
+			real = realpathSync(dir);
+		} catch {
+			return;
+		}
+		if (seenDirs.has(real)) return;
+		seenDirs.add(real);
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			if (truncated) return;
+			const full = join(dir, e.name);
+			if (e.isDirectory()) {
+				if (SKIP_DIRS.has(e.name) || e.name.startsWith(".")) continue;
+				walk(full);
+			} else if (e.isFile() && extname(e.name) === extension) {
+				if (files.length >= MAX_SCAN_FILES) {
+					truncated = true;
+					return;
+				}
+				files.push(full);
+			}
+		}
+	};
+	for (const r of roots) walk(r);
+	return {
+		files,
+		truncated
+	};
+};
+const realpathOrSelf = (p) => {
+	try {
+		return realpathSync(p);
+	} catch {
+		return p;
+	}
+};
+const ID_CHAR = /[\p{L}\p{N}_$]/u;
+/** The identifier token (code-point aware) spanning a 1-based human `line`/`column` in `text`. */
+function identifierAt(text, line, column) {
+	const ln = text.split(/\r\n|\r|\n/)[line - 1];
+	if (ln === void 0) return "";
+	const cps = [...ln];
+	let i = column - 1;
+	if ((i < 0 || i >= cps.length || !ID_CHAR.test(cps[i])) && i > 0 && ID_CHAR.test(cps[i - 1])) i -= 1;
+	if (i < 0 || i >= cps.length || !ID_CHAR.test(cps[i])) return "";
+	let s = i;
+	let e = i + 1;
+	while (s > 0 && ID_CHAR.test(cps[s - 1])) s -= 1;
+	while (e < cps.length && ID_CHAR.test(cps[e])) e += 1;
+	return cps.slice(s, e).join("");
+}
+/** A whole-word matcher for `name` (not flanked by identifier chars). `name` is regex-escaped. */
+function wholeWordRegex(name) {
+	const esc = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`(?<![\\p{L}\\p{N}_$])${esc}(?![\\p{L}\\p{N}_$])`, "u");
+}
+const MAX_SUSPECTS = 50;
+let tempCounter = 0;
+const defaultRenameWriter = { commit(ops) {
+	const temps = /* @__PURE__ */ new Map();
+	try {
+		for (const op of ops) {
+			if (op.kind !== "write") continue;
+			mkdirSync(dirname(op.absPath), { recursive: true });
+			tempCounter += 1;
+			const tmp = `${op.absPath}.sackville-rename-${process.pid}-${tempCounter}`;
+			writeFileSync(tmp, op.newText, "utf8");
+			const fd = openSync(tmp, "r+");
+			fsyncSync(fd);
+			closeSync(fd);
+			temps.set(op.absPath, tmp);
+		}
+	} catch (err) {
+		for (const tmp of temps.values()) try {
+			unlinkSync(tmp);
+		} catch {}
+		throw err;
+	}
+	const completed = [];
+	try {
+		for (const op of ops) {
+			if (op.kind === "write") renameSync(temps.get(op.absPath), op.absPath);
+			else if (op.kind === "rename") renameSync(op.fromAbs, op.toAbs);
+			else unlinkSync(op.absPath);
+			completed.push(op);
+		}
+	} catch (err) {
+		for (const [abs, tmp] of temps) if (!completed.some((c) => c.kind === "write" && c.absPath === abs)) try {
+			unlinkSync(tmp);
+		} catch {}
+		return {
+			completed,
+			partial: true,
+			error: err.message
+		};
+	}
+	return {
+		completed,
+		partial: false
+	};
+} };
+function isRegularFile(abs) {
+	try {
+		return statSync(abs).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* A symlink-AWARE regular-file check for an OVERWRITE target. Refuses a symlink (no clobber THROUGH a
+* link — the digest would read the link target's bytes while `renameSync`/atomic-write replaces the
+* link itself, a silent audit lie + the real file survives) and refuses a directory. `lstatSync` does
+* NOT follow the link, so a symlink ⇒ `isFile()` is false ⇒ refused. Used only on an overwrite target.
+*/
+function isOverwritableRegularFile(abs) {
+	try {
+		return lstatSync(abs).isFile();
+	} catch {
+		return false;
+	}
+}
+/** True if a path exists on disk (any kind), WITHOUT following a symlink. Used to detect an overwrite
+* destination that `liveOccupied` (content-read-based) misses — notably a DIRECTORY, whose content
+* read returns undefined so it would otherwise look unoccupied. */
+function existsLstat(abs) {
+	try {
+		lstatSync(abs);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const sha256 = (s) => createHash("sha256").update(s, "utf8").digest("hex");
+var LspRenameEngine = class {
+	manager;
+	allowRun;
+	allowedRoots;
+	allowWrite;
+	allowPartialRename;
+	allowDestructiveResourceOps;
+	readFile;
+	/** When unset the partial-rename guard is inactive (the bin/CLI/MCP wire `defaultListFiles`). */
+	listFiles;
+	writer;
+	redact;
+	constructor(options) {
+		this.manager = options.manager;
+		this.allowRun = options.allowRun;
+		this.allowedRoots = options.allowedRoots;
+		this.allowWrite = options.allowWrite;
+		this.allowPartialRename = options.allowPartialRename ?? false;
+		this.allowDestructiveResourceOps = options.allowDestructiveResourceOps ?? false;
+		this.readFile = options.readFile ?? defaultReadFile;
+		this.listFiles = options.listFiles;
+		this.writer = options.writer ?? defaultRenameWriter;
+		this.redact = options.redact ?? ((t) => t);
+	}
+	async rename(input) {
+		assertAllowed(this.allowRun, this.allowedRoots, input.projectRoot);
+		for (const root of input.workspaceRoots ?? []) assertAllowed(this.allowRun, this.allowedRoots, root);
+		const queriedAbs = confineFile(input.projectRoot, input.file);
+		const text = this.readFile(queriedAbs);
+		if (text === void 0) throw new LspGateError(`cannot read file ${input.file} in ${input.projectRoot}`);
+		if (!isPlausibleRenameName(input.newName)) throw new LspGateError(`invalid rename target ${JSON.stringify(input.newName)}`);
+		const queriedUri = pathToFileURL(queriedAbs).toString();
+		const run = await this.manager.run({
+			language: input.language,
+			projectRoot: input.projectRoot,
+			uri: queriedUri,
+			text,
+			...input.workspaceRoots ? { workspaceRoots: input.workspaceRoots } : {}
+		}, async (client) => {
+			const pos = toLspPosition(text, input.line, input.column, client.encoding);
+			const empty = {
+				files: [],
+				resourceOps: [],
+				operations: []
+			};
+			if (client.supportsPrepareRename) {
+				const prep = await client.prepareRename(queriedUri, pos);
+				if (prep.status === "not_ready") return base(prep, empty, { applied: false });
+				if (prep.status === "no_result") return base(prep, empty, { applied: false }, "rename is not valid at this position");
+			}
+			const r = await client.rename(queriedUri, pos, input.newName);
+			return base(r, r.result, { applied: false });
+		});
+		const guard = run.status === "ok" && this.listFiles ? this.assessCompleteness(run.edit, input, queriedAbs, text) : void 0;
+		const destructiveBatch = run.status === "ok" && run.edit.operations.some((o) => o.type !== "edit" && o.options?.overwrite === true);
+		const blockedByGuard = (guard?.completeness === "suspect" || destructiveBatch && guard?.completeness === "unknown") && !this.allowPartialRename;
+		const apply = run.status === "ok" && this.allowWrite && !blockedByGuard ? await this.applyEdit(run.edit, input, queriedUri, text, run.encoding) : { applied: false };
+		const guardRefusal = !(this.allowWrite && blockedByGuard) ? void 0 : guard?.completeness === "suspect" ? `rename may be INCOMPLETE: the symbol ${JSON.stringify(guard?.oldName ?? "")} also appears in ${guard?.suspectFiles.length} same-language file(s) not in this edit (e.g. ${guard?.suspectFiles.slice(0, 3).join(", ")}). The language server may scope rename to open files; nothing was written. Re-run with allowPartialRename to apply anyway.` : `rename completeness could not be verified: the same-language scan for ${JSON.stringify(guard?.oldName ?? "")} was TRUNCATED, and this batch contains a DESTRUCTIVE overwrite — an unverifiable scan is treated as blocking; nothing was written. Re-run with allowPartialRename to apply anyway.`;
+		return this.shape(input, {
+			...run,
+			apply,
+			refused: guardRefusal ?? apply.refused ?? run.refused
+		}, queriedUri, text, guard);
+	}
+	/**
+	* Decide + execute the apply, consuming the ordered `operations` (text edits interleaved with
+	* CreateFile/RenameFile/DeleteFile). Confine EVERY touched URI (edit + create + rename old&new +
+	* delete) to the root group all-or-nothing BEFORE any I/O; refuse the v1 cuts early (non-default
+	* resource-op options; editing a file also renamed in the same batch). Then, under the multi-URI
+	* lock over ALL touched URIs, replay the ops over a virtual content map (no writes) with the
+	* staleness guards, build a physical plan, stage-then-commit it, and resync any open buffer
+	* (`didChange` for an edited file, `didClose`+`didOpen` migration for a renamed/deleted one).
+	*/
+	async applyEdit(edit, input, queriedUri, text, encoding) {
+		const ops = edit.operations;
+		if (ops.length === 0) return { applied: false };
+		const group = [input.projectRoot, ...input.workspaceRoots ?? []];
+		const abs = /* @__PURE__ */ new Map();
+		const rel = (uri) => relative(input.projectRoot, abs.get(uri));
+		for (const op of ops) {
+			const uris = op.type === "rename" ? [op.oldUri, op.newUri] : [op.uri];
+			for (const u of uris) {
+				if (abs.has(u)) continue;
+				try {
+					abs.set(u, confineEditedUriToRoots(group, u));
+				} catch {
+					return {
+						applied: false,
+						refused: "an edited file is outside the project root; previewed only"
+					};
+				}
+			}
+		}
+		const destructiveAllowed = this.allowWrite && this.allowDestructiveResourceOps;
+		for (const op of ops) {
+			if (op.type === "edit") continue;
+			if (op.type === "delete" && op.options?.recursive === true) return {
+				applied: false,
+				refused: "recursive/directory delete is unsupported (refused — not enabled by any gate)"
+			};
+			if (op.type === "delete" && op.options?.overwrite === true) return {
+				applied: false,
+				refused: "overwrite is not a valid option on a delete (malformed; refused)"
+			};
+			if ((op.type === "create" || op.type === "rename") && op.options?.overwrite === true && !destructiveAllowed) return {
+				applied: false,
+				refused: "resource-op overwrite requires the operator destructive-resource-ops gate (allowDestructiveResourceOps + allowWrite); previewed only"
+			};
+		}
+		return this.manager.runWithUris({
+			language: input.language,
+			projectRoot: input.projectRoot,
+			uris: [...abs.keys()],
+			...input.workspaceRoots ? { workspaceRoots: input.workspaceRoots } : {}
+		}, async (client) => {
+			const refuse = (msg) => ({
+				applied: false,
+				refused: msg
+			});
+			const vfs = /* @__PURE__ */ new Map();
+			const created = /* @__PURE__ */ new Set();
+			const order = [];
+			const ordered = /* @__PURE__ */ new Set();
+			const aliasMap = /* @__PURE__ */ new Map();
+			const diskBefore = /* @__PURE__ */ new Map();
+			const renamedOld = /* @__PURE__ */ new Set();
+			const overwroteExisting = /* @__PURE__ */ new Set();
+			const overwrites = /* @__PURE__ */ new Map();
+			const clobbered = /* @__PURE__ */ new Map();
+			const diskCache = /* @__PURE__ */ new Map();
+			const readDisk = (u) => {
+				if (!diskCache.has(u)) diskCache.set(u, this.readFile(abs.get(u)));
+				return diskCache.get(u);
+			};
+			const resolveOrig = (u) => aliasMap.get(u) ?? u;
+			const touch = (o) => {
+				if (!ordered.has(o)) {
+					ordered.add(o);
+					order.push(o);
+				}
+				if (!diskBefore.has(o)) diskBefore.set(o, readDisk(o) ?? "");
+			};
+			const contentOf = (u) => {
+				const f = vfs.get(resolveOrig(u));
+				if (f) return f.kind === "live" ? f.content : void 0;
+				return readDisk(u);
+			};
+			const liveOccupied = (u) => {
+				const f = vfs.get(resolveOrig(u));
+				return f ? f.kind === "live" : readDisk(u) !== void 0;
+			};
+			let expectedOld;
+			for (const op of ops) if (op.type === "create") {
+				if (resolveOrig(op.uri) !== op.uri) return refuse(`cannot create ${rel(op.uri)}: conflicts with another operation`);
+				if (liveOccupied(op.uri)) {
+					if (op.options?.overwrite === true) {
+						const a = abs.get(op.uri);
+						if (!isOverwritableRegularFile(a)) return refuse(`cannot overwrite ${rel(op.uri)}: not a regular file on disk (symlink/directory — refused)`);
+						if (op.uri === queriedUri && sha256(readDisk(op.uri) ?? "") !== sha256(text)) return refuse("the file changed on disk since the rename was computed; re-query and retry");
+						touch(op.uri);
+						vfs.set(op.uri, {
+							kind: "live",
+							finalUri: op.uri,
+							content: ""
+						});
+						overwroteExisting.add(op.uri);
+						overwrites.set(a, rel(op.uri));
+						continue;
+					}
+					if (op.options?.ignoreIfExists === true) continue;
+					return refuse(`cannot create ${rel(op.uri)}: it already exists`);
+				}
+				touch(op.uri);
+				vfs.set(op.uri, {
+					kind: "live",
+					finalUri: op.uri,
+					content: ""
+				});
+				created.add(op.uri);
+			} else if (op.type === "delete") {
+				if (contentOf(op.uri) === void 0) {
+					if (op.options?.ignoreIfNotExists === true) continue;
+					return refuse(`cannot delete ${rel(op.uri)}: it does not exist`);
+				}
+				const o = resolveOrig(op.uri);
+				if (!created.has(o) && !isRegularFile(abs.get(o))) return refuse(`cannot delete ${rel(op.uri)}: not a regular file (recursive/directory delete unsupported in v1)`);
+				touch(o);
+				vfs.set(o, { kind: "deleted" });
+			} else if (op.type === "rename") {
+				const src = contentOf(op.oldUri);
+				if (src === void 0) return refuse(`cannot rename ${rel(op.oldUri)}: it does not exist`);
+				const o = resolveOrig(op.oldUri);
+				if (renamedOld.has(op.newUri) || resolveOrig(op.newUri) === o) return refuse(`cannot rename ${rel(op.oldUri)} onto a same-batch source (rename cycle in this edit)`);
+				if (resolveOrig(op.newUri) !== op.newUri) return refuse(`cannot rename to ${rel(op.newUri)}: it is already a target in this edit`);
+				const newAbs = abs.get(op.newUri);
+				if (op.options?.overwrite === true && (liveOccupied(op.newUri) || existsLstat(newAbs))) {
+					if (vfs.get(op.newUri)?.kind === "live") return refuse(`cannot overwrite ${rel(op.newUri)}: it is created or edited in this same edit (refused)`);
+					if (!isOverwritableRegularFile(newAbs)) return refuse(`cannot overwrite ${rel(op.newUri)}: not a regular file on disk (symlink/directory — refused)`);
+					if (op.newUri === queriedUri && sha256(readDisk(op.newUri) ?? "") !== sha256(text)) return refuse("the file changed on disk since the rename was computed; re-query and retry");
+					clobbered.set(op.newUri, readDisk(op.newUri) ?? "");
+					overwrites.set(newAbs, rel(op.newUri));
+				} else if (liveOccupied(op.newUri)) {
+					if (op.options?.ignoreIfExists === true) continue;
+					return refuse(`cannot rename to ${rel(op.newUri)}: it already exists`);
+				}
+				touch(o);
+				vfs.set(o, {
+					kind: "live",
+					finalUri: op.newUri,
+					content: src
+				});
+				aliasMap.set(op.newUri, o);
+				renamedOld.add(op.oldUri);
+			} else {
+				if (renamedOld.has(op.uri)) return refuse(`cannot edit ${rel(op.uri)}: it was renamed in this edit; address the new path`);
+				const base = contentOf(op.uri);
+				if (base === void 0) return refuse(`cannot read edited file ${rel(op.uri)}`);
+				if (op.uri === queriedUri && sha256(base) !== sha256(text)) return refuse("the file changed on disk since the rename was computed; re-query and retry");
+				if (op.uri === queriedUri && op.edits[0]) expectedOld = sliceByOffsets(base, op.edits[0].range, encoding);
+				const o = resolveOrig(op.uri);
+				const f = vfs.get(o);
+				const finalUri = f?.kind === "live" ? f.finalUri : op.uri;
+				touch(o);
+				vfs.set(o, {
+					kind: "live",
+					finalUri,
+					content: applyTextEdits(base, op.edits, encoding)
+				});
+			}
+			if (expectedOld !== void 0) for (const op of ops) {
+				if (op.type !== "edit") continue;
+				const oo = resolveOrig(op.uri);
+				if (created.has(oo) || overwroteExisting.has(oo)) continue;
+				const cur = readDisk(op.uri);
+				if (cur === void 0) continue;
+				for (const e of op.edits) if (sliceByOffsets(cur, e.range, encoding) !== expectedOld) return refuse("an edit site no longer matches the renamed symbol; re-query and retry");
+			}
+			const liveFinalAbs = /* @__PURE__ */ new Set();
+			for (const o of order) {
+				const f = vfs.get(o);
+				if (f?.kind === "live") liveFinalAbs.add(abs.get(f.finalUri));
+			}
+			for (const o of order) {
+				if (vfs.get(o)?.kind !== "deleted" || created.has(o)) continue;
+				if (liveFinalAbs.has(abs.get(o))) return refuse(`cannot delete ${rel(o)}: its path is a rename or create target in this edit`);
+			}
+			const physical = [];
+			const digests = [];
+			const digestForPhysical = [];
+			const extraRowsForPhysical = [];
+			const push = (p, d, extra = []) => {
+				physical.push(p);
+				digestForPhysical.push(d);
+				extraRowsForPhysical.push(extra);
+			};
+			const clobberRow = (finalUri) => {
+				if (!clobbered.has(finalUri)) return [];
+				return [digests.push({
+					file: `${rel(finalUri)} (overwritten)`,
+					before: sha256(clobbered.get(finalUri)),
+					after: ""
+				}) - 1];
+			};
+			for (const o of order) {
+				const f = vfs.get(o);
+				if (f?.kind !== "live") continue;
+				const moved = f.finalUri !== o;
+				const before = sha256(diskBefore.get(o) ?? "");
+				const contentChanged = created.has(o) || overwroteExisting.has(o) || sha256(f.content) !== before;
+				if (!moved) {
+					if (contentChanged) {
+						const d = digests.push({
+							file: rel(o),
+							before,
+							after: sha256(f.content)
+						}) - 1;
+						push({
+							kind: "write",
+							absPath: abs.get(o),
+							newText: f.content
+						}, d);
+					}
+				} else if (created.has(o)) {
+					const d = digests.push({
+						file: rel(f.finalUri),
+						before,
+						after: sha256(f.content)
+					}) - 1;
+					push({
+						kind: "write",
+						absPath: abs.get(f.finalUri),
+						newText: f.content
+					}, d);
+				} else if (contentChanged) {
+					const d = digests.push({
+						file: `${rel(o)} → ${rel(f.finalUri)}`,
+						before,
+						after: sha256(f.content)
+					}) - 1;
+					push({
+						kind: "rename",
+						fromAbs: abs.get(o),
+						toAbs: abs.get(f.finalUri)
+					}, d, clobberRow(f.finalUri));
+					push({
+						kind: "write",
+						absPath: abs.get(f.finalUri),
+						newText: f.content
+					}, d);
+				} else {
+					const d = digests.push({
+						file: `${rel(o)} → ${rel(f.finalUri)}`,
+						before,
+						after: before
+					}) - 1;
+					push({
+						kind: "rename",
+						fromAbs: abs.get(o),
+						toAbs: abs.get(f.finalUri)
+					}, d, clobberRow(f.finalUri));
+				}
+			}
+			for (const o of order) {
+				if (vfs.get(o)?.kind !== "deleted" || created.has(o)) continue;
+				const d = digests.push({
+					file: `${rel(o)} (deleted)`,
+					before: sha256(diskBefore.get(o) ?? ""),
+					after: ""
+				}) - 1;
+				push({
+					kind: "delete",
+					absPath: abs.get(o)
+				}, d);
+			}
+			if (physical.length === 0) return { applied: false };
+			const res = this.writer.commit(physical);
+			const landed = new Set(res.completed);
+			const landedWrite = (a) => res.completed.some((p) => p.kind === "write" && p.absPath === a);
+			const landedRename = (a) => res.completed.some((p) => p.kind === "rename" && p.toAbs === a);
+			const landedDelete = (a) => res.completed.some((p) => p.kind === "delete" && p.absPath === a);
+			for (const o of order) {
+				const f = vfs.get(o);
+				if (f?.kind !== "live") continue;
+				const moved = f.finalUri !== o;
+				const toAbs = abs.get(f.finalUri);
+				if (created.has(o)) {
+					if (landedWrite(toAbs)) if (o === queriedUri && moved) client.didFileRename(o, f.finalUri, f.content);
+					else client.applyEdited(f.finalUri, f.content);
+				} else if (moved) {
+					if (landedRename(toAbs)) {
+						if (clobbered.has(f.finalUri)) client.didFileDelete(f.finalUri);
+						const wl = landedWrite(toAbs);
+						client.didFileRename(o, f.finalUri, wl ? f.content : diskBefore.get(o) ?? "");
+					}
+				} else if (landedWrite(abs.get(o))) client.applyEdited(o, f.content);
+			}
+			for (const o of order) {
+				if (vfs.get(o)?.kind !== "deleted" || created.has(o)) continue;
+				if (landedDelete(abs.get(o))) client.didFileDelete(o);
+			}
+			const outDigests = res.partial ? [...new Set(physical.flatMap((p, i) => landed.has(p) ? [digestForPhysical[i], ...extraRowsForPhysical[i]] : []))].map((i) => digests[i]) : digests;
+			const overwritten = [...overwrites].filter(([a]) => landedWrite(a) || landedRename(a)).map(([, r]) => r);
+			return {
+				applied: true,
+				digests: outDigests,
+				...overwritten.length ? { overwritten } : {},
+				...res.partial ? {
+					partial: true,
+					partialError: res.error
+				} : {}
+			};
+		});
+	}
+	/**
+	* The partial-rename completeness guard. Extracts the old identifier at the queried position,
+	* then scans the allowlisted root group for same-language files that mention it as a whole word
+	* but are NOT covered by the server's edit (text edits + resource-op endpoints). Any such file is
+	* a SUSPECT — the edit is likely partial (an open-files-scoped server). `unknown` ⇒ the scan was
+	* truncated (cap hit). Server-agnostic: a whole-project-rename server covers every use ⇒ `complete`.
+	*/
+	assessCompleteness(edit, input, queriedAbs, queriedText) {
+		const lister = this.listFiles;
+		const oldName = identifierAt(queriedText, input.line, input.column);
+		const group = [input.projectRoot, ...input.workspaceRoots ?? []];
+		if (!lister || !oldName) return {
+			completeness: "complete",
+			suspectFiles: [],
+			oldName
+		};
+		const covered = /* @__PURE__ */ new Set();
+		const cover = (uri) => {
+			try {
+				covered.add(confineEditedUriToRoots(group, uri));
+			} catch {}
+		};
+		for (const f of edit.files) cover(f.uri);
+		for (const op of edit.operations) if (op.type === "rename") {
+			cover(op.oldUri);
+			cover(op.newUri);
+		} else cover(op.uri);
+		const { files, truncated } = lister(group, { extension: extname(queriedAbs) });
+		const re = wholeWordRegex(oldName);
+		const suspectsAbs = [];
+		for (const f of files) {
+			const real = realpathOrSelf(f);
+			if (covered.has(real)) continue;
+			const t = this.readFile(real);
+			if (t === void 0) continue;
+			if (re.test(t)) {
+				suspectsAbs.push(real);
+				if (suspectsAbs.length >= MAX_SUSPECTS) break;
+			}
+		}
+		return {
+			completeness: suspectsAbs.length ? "suspect" : truncated ? "unknown" : "complete",
+			suspectFiles: suspectsAbs.map((p) => relative(input.projectRoot, p)),
+			oldName
+		};
+	}
+	shape(input, run, queriedUri, queriedText, guard) {
+		const { edit, encoding, serverInfo } = run;
+		const totalEditCount = edit.files.reduce((n, f) => n + f.edits.length, 0);
+		const group = [input.projectRoot, ...input.workspaceRoots ?? []];
+		const edits = edit.files.map((f) => this.previewFile(f, group, queriedUri, queriedText, encoding));
+		const versionWarning = serverInfo === void 0 ? "the language server did not report its version (serverInfo); the rename cannot be attributed to a specific server version" : void 0;
+		const relUri = (uri) => {
+			try {
+				return relative(input.projectRoot, confineEditedUriToRoots(group, uri));
+			} catch {
+				return "(out of project root)";
+			}
+		};
+		const resourceOps = edit.resourceOps.map((op) => ({
+			kind: op.kind,
+			uris: op.uris.map(relUri)
+		}));
+		return {
+			status: run.status,
+			kind: "rename",
+			applied: run.apply.applied,
+			...run.refused ? { refused: run.refused } : {},
+			newName: input.newName,
+			fileCount: edit.files.length,
+			totalEditCount,
+			edits,
+			...resourceOps.length > 0 ? { resourceOps } : {},
+			...run.apply.digests ? { digests: run.apply.digests } : {},
+			...run.apply.overwritten ? { overwritten: run.apply.overwritten } : {},
+			...run.apply.partial ? { partial: true } : {},
+			...run.apply.partialError ? { partialError: run.apply.partialError } : {},
+			...serverInfo ? { serverInfo } : {},
+			...input.toolchain ? { toolchain: input.toolchain } : {},
+			...guard ? { completeness: guard.completeness } : {},
+			...guard && guard.suspectFiles.length > 0 ? { suspectedMissedFiles: guard.suspectFiles } : {},
+			encoding,
+			...versionWarning ? { versionWarning } : {}
+		};
+	}
+	previewFile(f, group, queriedUri, queriedText, encoding) {
+		let abs;
+		try {
+			abs = confineEditedUriToRoots(group, f.uri);
+		} catch {
+			return {
+				uri: f.uri,
+				file: "(out of project root)",
+				editCount: f.edits.length,
+				outOfRoot: true
+			};
+		}
+		const text = f.uri === queriedUri ? queriedText : this.readFile(abs);
+		const out = {
+			uri: f.uri,
+			file: relative(group[0] ?? "", abs),
+			editCount: f.edits.length
+		};
+		if (text !== void 0) out.hunks = f.edits.map((e) => this.hunk(text, e, encoding));
+		return out;
+	}
+	hunk(text, e, encoding) {
+		const out = {
+			range: {
+				start: fromLspPosition(text, e.range.start, encoding),
+				end: fromLspPosition(text, e.range.end, encoding)
+			},
+			oldText: this.redact(sliceByOffsets(text, e.range, encoding)),
+			newText: this.redact(e.newText)
+		};
+		if (e.needsConfirmation) out.needsConfirmation = true;
+		if (e.annotationLabel !== void 0) out.annotationLabel = this.redact(e.annotationLabel);
+		return out;
+	}
+};
+/** The OLD text of an edit, sliced by absolute offsets — NEVER reconstructed from line:col. */
+function sliceByOffsets(text, range, encoding) {
+	return text.slice(lspPositionToOffset(text, range.start, encoding), lspPositionToOffset(text, range.end, encoding));
+}
+function base(nav, edit, apply, refused) {
+	return {
+		status: nav.status,
+		edit,
+		encoding: nav.encoding,
+		...nav.serverInfo ? { serverInfo: nav.serverInfo } : {},
+		...refused ? { refused } : {},
+		apply
+	};
+}
+//#endregion
+export { LanguageServerManager, LspClient, LspGateError, LspManagerError, LspQueryEngine, LspRegistryError, LspRenameEngine, LspUnsupportedError, PREFERRED_ENCODINGS, decideStatus, defaultListFiles, defaultRenameWriter, defaultServerSpawn, diagnosticSeverityName, fromLspCharacter, fromLspPosition, normalizeCallHierarchyItem, normalizeCallHierarchyItems, normalizeDiagnostics, normalizeDocumentSymbols, normalizeHover, normalizeIncomingCalls, normalizeLocations, normalizeOutgoingCalls, normalizePrepareRename, normalizeWorkspaceEdit, normalizeWorkspaceSymbols, parseServerRegistry, resolvePositionEncoding, resolveServer, symbolKindName, toLspCharacter, toLspPosition };
+
+//# sourceMappingURL=index.mjs.map