@moritzwilksch/diffle 0.2.6 → 0.2.7

package/dist/server/main.js

@@ -2,8 +2,8 @@
 import { createRequire } from "node:module";
 import { EventEmitter } from "node:events";
 import childProcess, { execFile, spawn } from "node:child_process";
-import path, { delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import fs, { accessSync, constants, existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path, { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import fs, { accessSync, constants, existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import process$1 from "node:process";
 import { stripVTControlCharacters } from "node:util";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
@@ -3952,7 +3952,7 @@ function generateCompletion(program, { shell, executable = program.name() }) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.2.6";
+var version$1 = "0.2.7";
 //#endregion
 //#region src/server/comments/anchor.ts
 function splitLines(contents) {
@@ -11401,7 +11401,7 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 		return array(this);
 	},
 	or(arg) {
-		return union([this, arg]);
+		return union$1([this, arg]);
 	},
 	and(arg) {
 		return intersection(this, arg);
@@ -11950,7 +11950,7 @@ const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
 	inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
 	inst.options = def.options;
 });
-function union(options, params) {
+function union$1(options, params) {
 	return new ZodUnion({
 		type: "union",
 		options,
@@ -12238,10 +12238,14 @@ function superRefine(fn, params) {
 * server is told in `didOpen`, so it must be the spec's spelling, not ours.
 */
 const LanguageIdSchema = _enum([
+	"astro",
 	"c",
 	"cpp",
+	"csharp",
+	"css",
 	"go",
 	"haskell",
+	"html",
 	"java",
 	"javascript",
 	"javascriptreact",
@@ -12260,6 +12264,7 @@ const LanguageIdSchema = _enum([
 	"toml",
 	"typescript",
 	"typescriptreact",
+	"vue",
 	"yaml",
 	"zig"
 ]);
@@ -12713,8 +12718,8 @@ const LspLocationSchema = LspPositionSchema.extend({
 	*/
 	external: literal(true).optional()
 });
-/** A process plus the languages the pool routes to it. */
-const LspServerStatusSchema = object({
+/** One language server process, as its bridge sees it. */
+const LspProcessStatusSchema = object({
 	/** Program name, for messages: the basename of the command's first word, e.g. `pyrefly`. */
 	name: string(),
 	/** The command line it was started from. */
@@ -12728,19 +12733,83 @@ const LspServerStatusSchema = object({
 	message: string().optional(),
 	/** Active work reported through LSP work-done progress; absent when none is reported. */
 	activity: string().array().optional(),
-	/** Last warning or error reported by the server, not a process failure. */
+	/**
+	* What the server last said to the reader through `window/showMessage`, when it was a
+	* warning or an error. Its log never stands here: that is `log`.
+	*/
 	notice: object({
 		severity: _enum(["warning", "error"]),
 		message: string()
 	}).optional(),
-	/** Bounded stderr tail for servers that report failures only through their process output. */
-	stderr: string().optional()
-}).extend({ languages: LanguageIdSchema.array() });
+	/** The server's output channel in brief; `GET /api/lsp/log` lists the lines. */
+	log: object({
+		/** Changes whenever a line is added or repeated, so a reader showing the log knows to fetch again. */
+		seq: number().int().nonnegative(),
+		/** Error and warning lines since the server started, kept or not. */
+		errors: number().int().nonnegative(),
+		warnings: number().int().nonnegative()
+	})
+});
+/** Where a log line came from: `window/showMessage`, `window/logMessage`, or the process's stderr. */
+const LspLogSourceSchema = _enum([
+	"message",
+	"log",
+	"stderr"
+]);
+const LspLogLevelSchema = _enum([
+	"error",
+	"warning",
+	"info",
+	"log"
+]);
+/** One line of a server's output channel. The bridge keeps a bounded number of recent ones. */
+const LspLogEntrySchema = object({
+	/** Stable identity of the line within the run. */
+	id: number().int().positive(),
+	/** Milliseconds since the epoch, of its latest repeat. */
+	time: number(),
+	source: LspLogSourceSchema,
+	level: LspLogLevelSchema,
+	message: string(),
+	/** How many times in a row the server said exactly this. */
+	count: number().int().positive()
+});
+/** `GET /api/lsp/log?server=<command>`: the retained lines of one server, oldest first. */
+const LspLogQuerySchema = object({ server: string().min(1) });
+object({ entries: LspLogEntrySchema.array() });
+/**
+* A request the bridge sends a server only once it advertised the capability, in its
+* `initialize` result or by registering it later, as an editor does. Document highlights
+* are advisory: without them the answer is empty, never an error.
+*/
+const LspFeatureSchema = _enum([
+	"definition",
+	"typeDefinition",
+	"hover",
+	"references",
+	"documentSymbol",
+	"workspaceSymbol",
+	"documentHighlight"
+]);
+/** A process plus the languages the pool routes to it. */
+const LspServerStatusSchema = LspProcessStatusSchema.extend({
+	/** Languages it owns: asked first, and alone for highlights, token kinds and outlines. */
+	languages: LanguageIdSchema.array(),
+	/** Languages it answers for beside their owner, such as Tailwind's class hovers in markup. */
+	joins: LanguageIdSchema.array(),
+	/** What its `initialize` result advertised; empty while starting. */
+	supports: LspFeatureSchema.array()
+});
 /** A language in the diff with no server behind it. */
 const LspMissingSchema = object({
 	language: LanguageIdSchema,
 	/** Programs looked for on PATH, so the UI can name what to install. Empty when config turned the language off. */
-	tried: string().array()
+	tried: string().array(),
+	/**
+	* A program that is on PATH but lacks what the server loads from beside it, such as a
+	* `vue-language-server` without its tsserver plugin: installing more is not the answer.
+	*/
+	why: string().optional()
 });
 const LspStatusSchema = object({
 	/** False with `--no-lsp`: no server will start for this run. */
@@ -12749,7 +12818,16 @@ const LspStatusSchema = object({
 	servers: LspServerStatusSchema.array(),
 	missing: LspMissingSchema.array()
 });
-object({ locations: LspLocationSchema.array() });
+/**
+* Why an empty answer may be incomplete: the server reported background work (indexing, loading
+* the workspace) while answering, or a server that would also have answered was unavailable.
+* Never set beside a non-empty answer.
+*/
+const inconclusive$1 = string().optional();
+object({
+	locations: LspLocationSchema.array(),
+	inconclusive: inconclusive$1
+});
 object({
 	/** Markdown; null when the server has nothing for the position. */
 	contents: string().nullable(),
@@ -12759,11 +12837,9 @@ object({
 		col: number(),
 		endLine: number(),
 		endCol: number()
-	}).optional()
+	}).optional(),
+	inconclusive: inconclusive$1
 });
-object({ 
-/** Null when the position is not inside a token or the server does not classify tokens. */
-kind: string().nullable() });
 object({ occurrences: object({
 	line: number().int().positive(),
 	col: number().int().nonnegative(),
@@ -12777,16 +12853,19 @@ object({ occurrences: object({
 	])
 }).array() });
 object({
-	name: string(),
-	/** LSP SymbolKind number; the client maps it to a label. */
-	kind: number(),
-	/** Enclosing class or function, when any. */
-	container: string().optional(),
-	path: string(),
-	line: number(),
-	/** Last line of the declaration's full range. */
-	endLine: number(),
-	col: number()
+	symbols: object({
+		name: string(),
+		/** LSP SymbolKind number; the client maps it to a label. */
+		kind: number(),
+		/** Enclosing class or function, when any. */
+		container: string().optional(),
+		path: string(),
+		line: number(),
+		/** Last line of the declaration's full range. */
+		endLine: number(),
+		col: number()
+	}).array(),
+	inconclusive: inconclusive$1
 });
 _enum([
 	"unviewed",
@@ -12816,11 +12895,14 @@ function followsCheckout(snap) {
 }
 /** Extension (no dot, lowercase) → language. `.h` goes to c because clangd serves both. */
 const LANGUAGE_BY_EXT = {
+	astro: "astro",
 	bash: "shellscript",
 	c: "c",
 	cc: "cpp",
 	cjs: "javascript",
 	cpp: "cpp",
+	cs: "csharp",
+	css: "css",
 	cts: "typescript",
 	cxx: "cpp",
 	go: "go",
@@ -12828,6 +12910,8 @@ const LANGUAGE_BY_EXT = {
 	hh: "cpp",
 	hpp: "cpp",
 	hs: "haskell",
+	htm: "html",
+	html: "html",
 	hxx: "cpp",
 	java: "java",
 	js: "javascript",
@@ -12852,6 +12936,7 @@ const LANGUAGE_BY_EXT = {
 	toml: "toml",
 	ts: "typescript",
 	tsx: "typescriptreact",
+	vue: "vue",
 	yaml: "yaml",
 	yml: "yaml",
 	zig: "zig"
@@ -12863,35 +12948,6 @@ function languageOf(path) {
 	const ext = /\.([^./\\]+)$/.exec(path)?.[1]?.toLowerCase();
 	return ext && LANGUAGE_BY_EXT[ext] || null;
 }
-/**
-* Why the language server cannot answer for `path` — or, with no path, for a
-* repository-wide request — and null when it can. Shared so the client's flash and the
-* API's 409 say the same thing. The caller checks `followsCheckout` itself.
-*/
-function lspBlocker(lsp, path) {
-	if (!lsp.enabled) return "Language servers are off for this run (--no-lsp)";
-	if (path == null) {
-		if (!lsp.servers.length) return noServer(lsp);
-		return lsp.servers.some((s) => s.state === "ready") ? null : notReady(lsp.servers[0]);
-	}
-	const language = languageOf(path);
-	if (!language) return `No language server for ${/(\.[^./\\]+)$/.exec(path)?.[1] ?? "these"} files`;
-	const server = lsp.servers.find((s) => s.languages.includes(language));
-	if (!server) return noServer(lsp, language);
-	return server.state === "ready" ? null : notReady(server);
-}
-function notReady(s) {
-	return s.state === "starting" ? `${s.name} is starting…` : `${s.name} is unavailable: ${s.message ?? "unknown error"}`;
-}
-/** No server serves `language` (or nothing runs at all): say what the reader can do about it. */
-function noServer(lsp, language) {
-	const missing = language == null ? lsp.missing : lsp.missing.filter((m) => m.language === language);
-	const absent = missing.filter((m) => m.tried.length > 0);
-	const off = missing.filter((m) => m.tried.length === 0).map((m) => m.language);
-	if (absent.length) return `No language server for ${[...new Set(absent.map((m) => m.language))].join(", ")} on PATH: install one of ${[...new Set(absent.flatMap((m) => m.tried))].join(", ")}`;
-	if (off.length) return `The language server for ${off.join(", ")} is off in your diffle config`;
-	return language == null ? "No language server runs for this diff" : `No language server runs for ${language}`;
-}
 /** Writable HTTP config fields; unknown keys, including CLI-only lspCommands, are stripped. */
 const ConfigUpdateSchema = object({
 	autoViewed: string().array().optional(),
@@ -13013,46 +13069,158 @@ function fuzzyRank(items, query, key) {
 	return [...matched, ...items.filter((item) => !kept.has(item))];
 }
 //#endregion
-//#region src/server/lsp/hover.ts
+//#region src/shared/lsp.ts
+/** How messages name a feature: "pyrefly offers no go to definition". */
+const LSP_FEATURE_LABELS = {
+	definition: "go to definition",
+	typeDefinition: "go to type definition",
+	hover: "hover",
+	references: "references",
+	documentSymbol: "document symbols",
+	workspaceSymbol: "workspace symbols",
+	documentHighlight: "document highlights"
+};
 /**
-* One markdown document for the tooltip, or null when the server sent nothing
-* worth showing. Plaintext and `{language, value}` parts become fenced blocks,
-* so their text is never re-read as markdown.
+* Why no language server can answer the query right now, and null when one can. The one
+* place that reasons about the run, the snapshot and the servers together, so the
+* client's flash and the API's 409 say the same thing. A null `snap` is one not loaded yet.
 */
-function hoverMarkdown(contents) {
-	if (contents == null) return null;
-	const parts = (Array.isArray(contents) ? contents : [contents]).map(partMarkdown).filter((p) => p.trim() !== "");
-	return parts.length ? parts.join("\n\n") : null;
+function lspBlocker(lsp, snap, { path, feature, patient = false } = {}) {
+	if (!lsp.enabled) return "Language servers are off for this run (--no-lsp)";
+	if (!snap || !followsCheckout(snap)) return "Symbol navigation needs the new side to be the worktree or the checked-out commit";
+	let servers = lsp.servers;
+	let language;
+	if (path != null) {
+		language = languageOf(path) ?? void 0;
+		if (!language) return `No language server for ${/(\.[^./\\]+)$/.exec(path)?.[1] ?? "these"} files`;
+		servers = serversFor(lsp, language);
+	}
+	if (!servers.length) return noServer(lsp, language);
+	const able = feature ? servers.filter((s) => s.state === "starting" || s.supports.includes(feature)) : servers;
+	if (!able.length) return `${servers.map((s) => s.name).join(", ")} offers no ${LSP_FEATURE_LABELS[feature]}`;
+	return able.some((s) => s.state === "ready" || patient && s.state === "starting") ? null : notReady(able[0]);
+}
+/** The servers answering for `language`, its owners before the ones joining it. */
+function serversFor(lsp, language) {
+	return [...lsp.servers.filter((s) => s.languages.includes(language)), ...lsp.servers.filter((s) => s.joins.includes(language))];
+}
+/** A server's languages for a status line: the ones it owns, then the ones it joins marked `+`. */
+function languagesLabel(server) {
+	return [...server.languages, ...server.joins.map((l) => `+${l}`)].join(", ");
 }
-function partMarkdown(part) {
-	if (typeof part === "string") return part;
-	if ("kind" in part) return part.kind === "markdown" ? part.value : fence(part.value, "");
-	return fence(part.value, part.language);
+function notReady(s) {
+	return s.state === "starting" ? `${s.name} is starting…` : `${s.name} is unavailable: ${s.message ?? "unknown error"}`;
 }
-/** A fence long enough that a backtick run inside the code cannot close it early. */
-function fence(code, lang) {
-	const longest = Math.max(2, ...[...code.matchAll(/`+/g)].map((m) => m[0].length));
-	const ticks = "`".repeat(longest + 1);
-	return `${ticks}${lang}\n${code.replace(/\n$/, "")}\n${ticks}`;
+/** No server serves `language` (or nothing runs at all): say what the reader can do about it. */
+function noServer(lsp, language) {
+	const missing = language == null ? lsp.missing : lsp.missing.filter((m) => m.language === language);
+	const broken = missing.find((m) => m.why);
+	if (broken) return `No language server for ${broken.language}: ${broken.why}`;
+	const absent = missing.filter((m) => m.tried.length > 0);
+	const off = missing.filter((m) => m.tried.length === 0).map((m) => m.language);
+	if (absent.length) return `No language server for ${[...new Set(absent.map((m) => m.language))].join(", ")} on PATH: install one of ${[...new Set(absent.flatMap((m) => m.tried))].join(", ")}`;
+	if (off.length) return `The language server for ${off.join(", ")} is off in your diffle config`;
+	return language == null ? "No language server runs for this diff" : `No language server runs for ${language}`;
 }
-/** An inline markdown link whose target is a `file:` URI, as pyright and pyrefly write "Go to X". */
-const fileLink = () => /\[([^\]]*)\]\(\s*<?(file:[^\s)>]+)>?\s*\)/g;
-/** The `file:` URIs the hover text links to, each once. */
-function fileLinkUris(md) {
-	return [...new Set([...md.matchAll(fileLink())].map((m) => m[2]))];
+//#endregion
+//#region src/server/persist.ts
+/** A holder older than this is presumed hung, even when its pid is alive. */
+const LOCK_STALE_MS = 3e4;
+const LOCK_TIMEOUT_MS = 1e4;
+let seq = 0;
+/**
+* Writes `text` to `file` atomically: unique temp file in the same directory,
+* then rename. Creates the directory owner-only; the file gets `mode`. A failed
+* write leaves no temp file behind.
+*/
+async function writeFileAtomic(file, text, mode = 384) {
+	await mkdir(dirname(file), {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = `${file}.${process.pid}.${++seq}.${randomBytes(4).toString("hex")}.tmp`;
+	try {
+		await writeFile(tmp, text, {
+			encoding: "utf8",
+			mode
+		});
+		await rename(tmp, file);
+	} catch (e) {
+		await unlink(tmp).catch(() => {});
+		throw e;
+	}
 }
+const inProcess = /* @__PURE__ */ new Map();
 /**
-* Rewrites the hover text's `file:` links to `diffle:<path>#L<line>`, which the client follows as an
-* in-app jump. `resolved` maps each URI to its repo-relative path and line; a URI it omits lies
-* outside the repository and becomes plain text, since opening a browser tab on a source file is
-* never what the reader wants.
+* Runs `fn` while holding `<file>.lock`, exclusive across processes on this
+* machine and serialized within this one. A lock whose pid is dead, or older
+* than 30s, is taken over; waiting longer than 10s throws. The lock is
+* released whether `fn` resolves or rejects.
 */
-function localizeFileLinks(md, resolved) {
-	return md.replace(fileLink(), (_m, label, uri) => {
-		const loc = resolved.get(uri);
-		if (!loc) return label;
-		return `[${label}](diffle:${encodeURI(loc.path)}${loc.line != null ? `#L${loc.line}` : ""})`;
+async function withFileLock(file, fn) {
+	const prev = inProcess.get(file) ?? Promise.resolve();
+	let release;
+	const chain = prev.then(() => new Promise((r) => release = r));
+	inProcess.set(file, chain);
+	await prev;
+	const lock = `${file}.lock`;
+	try {
+		await acquire(lock);
+		try {
+			return await fn();
+		} finally {
+			await unlink(lock).catch(() => {});
+		}
+	} finally {
+		release();
+		if (inProcess.get(file) === chain) inProcess.delete(file);
+	}
+}
+async function acquire(lock) {
+	await mkdir(dirname(lock), {
+		recursive: true,
+		mode: 448
 	});
+	const deadline = Date.now() + LOCK_TIMEOUT_MS;
+	for (;;) {
+		try {
+			const fh = await open(lock, "wx", 384);
+			try {
+				await fh.writeFile(`${process.pid}\n`);
+			} finally {
+				await fh.close();
+			}
+			return;
+		} catch (e) {
+			if (e.code !== "EEXIST") throw e;
+		}
+		if (await isStale(lock)) {
+			await unlink(lock).catch(() => {});
+			continue;
+		}
+		if (Date.now() > deadline) throw new Error(`timed out waiting for ${lock}`);
+		await new Promise((r) => setTimeout(r, 10 + Math.random() * 20));
+	}
+}
+/** True when the holder is gone: dead pid, or too old to trust. A lock with no pid yet is being taken. */
+async function isStale(lock) {
+	let st;
+	let text;
+	try {
+		[st, text] = await Promise.all([stat$1(lock), readFile(lock, "utf8")]);
+	} catch (e) {
+		if (e.code === "ENOENT") return false;
+		throw e;
+	}
+	if (Date.now() - st.mtimeMs > LOCK_STALE_MS) return true;
+	const pid = Number.parseInt(text, 10);
+	if (!Number.isFinite(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return false;
+	} catch (e) {
+		return e.code === "ESRCH";
+	}
 }
 //#endregion
 //#region src/server/lsp/JsonRpc.ts
@@ -13110,8 +13278,8 @@ var JsonRpcConnection = class {
 			params
 		});
 	}
-	/** Observes server messages, including requests. */
-	onNotification(handler) {
+	/** Observes every message the server sends: notifications and requests alike. */
+	onMessage(handler) {
 		this.handlers.add(handler);
 	}
 	/** Handles a server request and returns its result, including asynchronous results. */
@@ -13150,10 +13318,10 @@ var JsonRpcConnection = class {
 			if (this.buffer.length < start + length) return;
 			const body = this.buffer.subarray(start, start + length).toString("utf8");
 			this.buffer = this.buffer.subarray(start + length);
-			this.onMessage(body);
+			this.receive(body);
 		}
 	}
-	onMessage(body) {
+	receive(body) {
 		let msg;
 		try {
 			msg = JSON.parse(body);
@@ -13190,552 +13358,497 @@ var JsonRpcConnection = class {
 	}
 };
 //#endregion
-//#region src/server/lsp/which.ts
-/**
-* The program a shell command line runs: its first word, unquoted. Only ever asked
-* about the built-in candidates, which are plain `prog arg…` lines; a command with a
-* leading assignment or a pipeline has no single program and is never probed (see
-* `resolveServers`).
-*/
-function argv0(command) {
-	const s = command.trim();
-	const quote = s[0];
-	if (quote === "\"" || quote === "'") {
-		const end = s.indexOf(quote, 1);
-		return end === -1 ? s.slice(1) : s.slice(1, end);
-	}
-	return s.split(/\s/, 1)[0] ?? "";
+//#region src/server/lsp/configuration.ts
+const SCHEMA_CATALOG = "https://www.schemastore.org/api/json/catalog.json";
+const MAX_AGE = 864e5;
+const AssociationSchema = object({
+	url: url({ protocol: /^https?$/ }),
+	fileMatch: array(string()).nonempty()
+});
+const SchemaCatalogSchema = object({ schemas: array(unknown()) });
+const ConfigurationParamsSchema = object({ items: array(object({ section: string().optional() })) });
+/** Valid catalog entries, in the association format understood by the JSON server. */
+function schemaAssociations(value) {
+	const catalog = SchemaCatalogSchema.safeParse(value);
+	if (!catalog.success) return [];
+	return catalog.data.schemas.flatMap((entry) => {
+		const association = AssociationSchema.safeParse(entry);
+		return association.success ? [association.data] : [];
+	});
 }
-/**
-* Where `command`'s program lives, or null when it is not an executable on PATH.
-* A name with a separator is resolved against `cwd` instead of searched, like a shell.
-*/
-function findOnPath(command, env = process.env, cwd = process.cwd()) {
-	const prog = argv0(command);
-	if (!prog) return null;
-	if (prog.includes("/") || process.platform === "win32" && prog.includes("\\")) return executable(isAbsolute(prog) ? prog : resolve(cwd, prog));
-	for (const dir of (env.PATH ?? "").split(delimiter)) {
-		if (!dir) continue;
-		const hit = executable(join(dir, prog));
-		if (hit) return hit;
+/** Caches catalog discovery for a day and uses the last good copy when offline. */
+async function loadSchemaCatalog(cacheFile = join(process.env.XDG_CACHE_HOME || join(homedir(), ".cache"), "diffle", "schemastore.json"), request = fetch) {
+	let cached = [];
+	try {
+		cached = schemaAssociations(JSON.parse(await readFile(cacheFile, "utf8")));
+		if (cached.length && Date.now() - (await stat$1(cacheFile)).mtimeMs < MAX_AGE) return cached;
+	} catch {}
+	try {
+		const response = await request(SCHEMA_CATALOG, { signal: AbortSignal.timeout(5e3) });
+		if (!response.ok) return cached;
+		const schemas = schemaAssociations(await response.json());
+		if (!schemas.length) return cached;
+		await writeFileAtomic(cacheFile, JSON.stringify({ schemas }) + "\n").catch(() => {});
+		return schemas;
+	} catch {
+		return cached;
 	}
-	return null;
 }
 /**
-* `file` itself when it is a runnable file, else the first `file` + PATHEXT match on
-* Windows, where the execute bit means nothing and programs are `.exe`/`.cmd`.
+* Answers a language server's `workspace/configuration` request from `settings`:
+* each requested section in order, null for unknown sections, and the whole tree
+* for an omitted section. Params are untrusted JSON from the server; malformed
+* requests throw JSON-RPC Invalid Params before any settings are returned.
 */
-function executable(file) {
-	if (runnable(file)) return file;
-	if (process.platform !== "win32") return null;
-	for (const ext of (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")) if (ext && runnable(file + ext)) return file + ext;
-	return null;
-}
-function runnable(file) {
-	try {
-		if (!statSync(file).isFile()) return false;
-		if (process.platform === "win32") return true;
-		accessSync(file, constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
+function configurationItems(settings, params) {
+	const request = ConfigurationParamsSchema.safeParse(params);
+	if (!request.success) throw new JsonRpcError(-32602, "Invalid workspace/configuration parameters");
+	return request.data.items.map((item) => {
+		if (!item.section) return settings;
+		let value = settings;
+		for (const part of item.section.split(".")) {
+			if (!value || typeof value !== "object" || !Object.hasOwn(value, part)) return null;
+			value = value[part];
+		}
+		return value ?? null;
+	});
 }
 //#endregion
-//#region src/server/persist.ts
-/** A holder older than this is presumed hung, even when its pid is alive. */
-const LOCK_STALE_MS = 3e4;
-const LOCK_TIMEOUT_MS = 1e4;
-let seq = 0;
+//#region src/server/lsp/ServerOutput.ts
+/** Log lines kept per server; older ones are dropped. */
+const LOG_CAPACITY = 200;
+/** LSP `MessageType` numbers; anything else, such as the newer Debug, reads as a plain log line. */
+const MESSAGE_LEVELS = {
+	1: "error",
+	2: "warning",
+	3: "info",
+	4: "log"
+};
 /**
-* Writes `text` to `file` atomically: unique temp file in the same directory,
-* then rename. Creates the directory owner-only; the file gets `mode`. A failed
-* write leaves no temp file behind.
+* What one server reports while it runs: its output channel (what it showed, what it
+* logged, what it wrote to stderr), the notice it shows the reader, and the progress it
+* runs. Each change goes to `onChange` as the status fields it moves. Only the log's
+* summary travels with the status: the lines are fetched by whoever shows them.
 */
-async function writeFileAtomic(file, text, mode = 384) {
-	await mkdir(dirname(file), {
-		recursive: true,
-		mode: 448
-	});
-	const tmp = `${file}.${process.pid}.${++seq}.${randomBytes(4).toString("hex")}.tmp`;
-	try {
-		await writeFile(tmp, text, {
-			encoding: "utf8",
-			mode
+var ServerOutput = class {
+	onChange;
+	/** Oldest first. */
+	log = [];
+	nextLogId = 1;
+	logSummary = {
+		seq: 0,
+		errors: 0,
+		warnings: 0
+	};
+	/** stderr bytes since the last newline. */
+	stderrTail = "";
+	notice;
+	progress = /* @__PURE__ */ new Map();
+	constructor(onChange) {
+		this.onChange = onChange;
+	}
+	/** The retained log lines, oldest first. */
+	entries() {
+		return this.log.map((e) => ({ ...e }));
+	}
+	summary() {
+		return this.logSummary;
+	}
+	/** Whole stderr lines go to the log; a trailing partial line waits for its newline. */
+	stderr(chunk) {
+		const lines = (this.stderrTail + chunk).split("\n");
+		this.stderrTail = lines.pop() ?? "";
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			this.record("stderr", "log", line);
+		}
+	}
+	/** A server-to-client message: `window/*Message*` lands in the log, `$/progress` in the activity. */
+	message(method, params) {
+		if (!params || typeof params !== "object") return;
+		const p = params;
+		if (method === "window/showMessage" || method === "window/logMessage" || method === "window/showMessageRequest") {
+			if (typeof p.message !== "string" || !p.message.trim()) return;
+			const level = MESSAGE_LEVELS[p.type] ?? "log";
+			this.record(method === "window/logMessage" ? "log" : "message", level, p.message);
+			if (method === "window/logMessage" || level !== "error" && level !== "warning") return;
+			const notice = {
+				severity: level,
+				message: p.message.trim()
+			};
+			if (notice.severity === this.notice?.severity && notice.message === this.notice.message) return;
+			this.notice = notice;
+			this.onChange({ notice });
+			return;
+		}
+		if (method === "$/progress") this.noteProgress(p);
+	}
+	/**
+	* Appends to the log, folding a line the server repeats into the previous entry's
+	* count, and reports that the log moved.
+	*/
+	record(source, level, message) {
+		const text = message.trim();
+		if (!text) return;
+		const last = this.log[this.log.length - 1];
+		if (last && last.source === source && last.level === level && last.message === text) {
+			last.count += 1;
+			last.time = Date.now();
+		} else {
+			this.log.push({
+				id: this.nextLogId++,
+				time: Date.now(),
+				source,
+				level,
+				message: text,
+				count: 1
+			});
+			if (this.log.length > LOG_CAPACITY) this.log.shift();
+		}
+		this.logSummary = {
+			seq: this.logSummary.seq + 1,
+			errors: this.logSummary.errors + (level === "error" ? 1 : 0),
+			warnings: this.logSummary.warnings + (level === "warning" ? 1 : 0)
+		};
+		this.onChange({ log: this.logSummary });
+	}
+	/** Work-done progress by token; the activity lists every piece still running. */
+	noteProgress(p) {
+		if (typeof p.token !== "string" && typeof p.token !== "number") return;
+		if (!p.value || typeof p.value !== "object") return;
+		const { kind, title, message, percentage } = p.value;
+		const percent = typeof percentage === "number" && percentage >= 0 && percentage <= 100 ? percentage : void 0;
+		if (kind === "begin" && typeof title === "string") this.progress.set(p.token, {
+			title,
+			message: typeof message === "string" ? message : void 0,
+			percentage: percent
 		});
-		await rename(tmp, file);
-	} catch (e) {
-		await unlink(tmp).catch(() => {});
-		throw e;
+		else if (kind === "report" && this.progress.has(p.token)) {
+			if (typeof message === "string") this.progress.get(p.token).message = message;
+			if (percent !== void 0) this.progress.get(p.token).percentage = percent;
+		} else if (kind === "end") {
+			if (!this.progress.delete(p.token)) return;
+		} else return;
+		this.onChange({ activity: [...this.progress.values()].map((p) => `${p.title}${p.percentage == null ? "" : ` (${p.percentage}%)`}${p.message ? `: ${p.message}` : ""}`) });
 	}
+};
+//#endregion
+//#region src/server/lsp/shapes.ts
+/**
+* How a server advertises each feature: the `initialize` capability (a boolean or an
+* options object) and the method a later `client/registerCapability` names.
+*/
+const FEATURES = {
+	definition: {
+		provider: "definitionProvider",
+		method: "textDocument/definition"
+	},
+	typeDefinition: {
+		provider: "typeDefinitionProvider",
+		method: "textDocument/typeDefinition"
+	},
+	hover: {
+		provider: "hoverProvider",
+		method: "textDocument/hover"
+	},
+	references: {
+		provider: "referencesProvider",
+		method: "textDocument/references"
+	},
+	documentSymbol: {
+		provider: "documentSymbolProvider",
+		method: "textDocument/documentSymbol"
+	},
+	workspaceSymbol: {
+		provider: "workspaceSymbolProvider",
+		method: "workspace/symbol"
+	},
+	documentHighlight: {
+		provider: "documentHighlightProvider",
+		method: "textDocument/documentHighlight"
+	}
+};
+/** The feature a registration's method names, or null for one diffle never asks for. */
+function featureOf(method) {
+	for (const [feature, { method: m }] of Object.entries(FEATURES)) if (m === method) return feature;
+	return null;
 }
-const inProcess = /* @__PURE__ */ new Map();
 /**
-* Runs `fn` while holding `<file>.lock`, exclusive across processes on this
-* machine and serialized within this one. A lock whose pid is dead, or older
-* than 30s, is taken over; waiting longer than 10s throws. The lock is
-* released whether `fn` resolves or rejects.
+* What diffle tells a server it can do. Every feature allows dynamic registration, so a
+* server that advertises after `initialize` is still asked.
 */
-async function withFileLock(file, fn) {
-	const prev = inProcess.get(file) ?? Promise.resolve();
-	let release;
-	const chain = prev.then(() => new Promise((r) => release = r));
-	inProcess.set(file, chain);
-	await prev;
-	const lock = `${file}.lock`;
-	try {
-		await acquire(lock);
-		try {
-			return await fn();
-		} finally {
-			await unlink(lock).catch(() => {});
+const CLIENT_CAPABILITIES = {
+	window: { workDoneProgress: true },
+	textDocument: {
+		synchronization: { didSave: false },
+		definition: {
+			dynamicRegistration: true,
+			linkSupport: true
+		},
+		typeDefinition: {
+			dynamicRegistration: true,
+			linkSupport: true
+		},
+		references: { dynamicRegistration: true },
+		documentHighlight: { dynamicRegistration: true },
+		hover: {
+			dynamicRegistration: true,
+			contentFormat: ["markdown", "plaintext"]
+		},
+		documentSymbol: {
+			dynamicRegistration: true,
+			hierarchicalDocumentSymbolSupport: true
 		}
-	} finally {
-		release();
-		if (inProcess.get(file) === chain) inProcess.delete(file);
+	},
+	workspace: {
+		symbol: { dynamicRegistration: true },
+		workspaceFolders: true,
+		configuration: true
 	}
+};
+/** `answer` as is, or with why it may be incomplete when it is `empty` and the server was `busy`. */
+function inconclusive(answer, empty, busy) {
+	return busy && empty ? {
+		...answer,
+		inconclusive: busy
+	} : answer;
 }
-async function acquire(lock) {
-	await mkdir(dirname(lock), {
-		recursive: true,
-		mode: 448
-	});
-	const deadline = Date.now() + LOCK_TIMEOUT_MS;
-	for (;;) {
-		try {
-			const fh = await open(lock, "wx", 384);
-			try {
-				await fh.writeFile(`${process.pid}\n`);
-			} finally {
-				await fh.close();
+function toLsp(pos) {
+	return {
+		line: Math.max(0, pos.line - 1),
+		character: Math.max(0, pos.col)
+	};
+}
+/** An LSP range as diffle spans it: 1-based lines, 0-based columns. */
+function fromLsp({ start, end }) {
+	return {
+		line: start.line + 1,
+		col: start.character,
+		endLine: end.line + 1,
+		endCol: end.character
+	};
+}
+function normalizeLocations(r) {
+	if (!r) return [];
+	return (Array.isArray(r) ? r : [r]).map((x) => "targetUri" in x ? {
+		uri: x.targetUri,
+		range: x.targetSelectionRange ?? x.targetRange
+	} : x);
+}
+/** Either symbol shape a server may answer `documentSymbol` with, flattened in document order. */
+function flattenSymbols(result, path) {
+	const out = [];
+	if (isDocumentSymbols(result)) {
+		const walk = (syms, container) => {
+			for (const s of syms) {
+				const start = (s.selectionRange ?? s.range).start;
+				const endLine = Math.max(start.line, (s.range ?? s.selectionRange).end.line) + 1;
+				out.push({
+					name: s.name,
+					kind: s.kind,
+					container,
+					path,
+					line: start.line + 1,
+					endLine,
+					col: start.character
+				});
+				if (s.children?.length) walk(s.children, s.name);
 			}
-			return;
-		} catch (e) {
-			if (e.code !== "EEXIST") throw e;
-		}
-		if (await isStale(lock)) {
-			await unlink(lock).catch(() => {});
-			continue;
-		}
-		if (Date.now() > deadline) throw new Error(`timed out waiting for ${lock}`);
-		await new Promise((r) => setTimeout(r, 10 + Math.random() * 20));
+		};
+		walk(result);
+		return out;
 	}
+	return result.map((s) => symbolInformation(s, path));
 }
-/** True when the holder is gone: dead pid, or too old to trust. A lock with no pid yet is being taken. */
-async function isStale(lock) {
-	let st;
-	let text;
-	try {
-		[st, text] = await Promise.all([stat$1(lock), readFile(lock, "utf8")]);
-	} catch (e) {
-		if (e.code === "ENOENT") return false;
-		throw e;
+function symbolInformation(s, path) {
+	const start = "range" in s.location ? s.location.range.start : {
+		line: 0,
+		character: 0
+	};
+	const end = "range" in s.location ? s.location.range.end : start;
+	return {
+		name: s.name,
+		kind: s.kind,
+		container: s.containerName || void 0,
+		path,
+		line: start.line + 1,
+		endLine: Math.max(start.line, end.line) + 1,
+		col: start.character
+	};
+}
+function isDocumentSymbols(r) {
+	return r.length > 0 && !("location" in r[0]);
+}
+//#endregion
+//#region src/server/lsp/which.ts
+/**
+* The program a shell command line runs: its first word, unquoted. Only ever asked
+* about the built-in candidates, which are plain `prog arg…` lines; a command with a
+* leading assignment or a pipeline has no single program and is never probed (see
+* `resolveServers`).
+*/
+function argv0(command) {
+	const s = command.trim();
+	const quote = s[0];
+	if (quote === "\"" || quote === "'") {
+		const end = s.indexOf(quote, 1);
+		return end === -1 ? s.slice(1) : s.slice(1, end);
 	}
-	if (Date.now() - st.mtimeMs > LOCK_STALE_MS) return true;
-	const pid = Number.parseInt(text, 10);
-	if (!Number.isFinite(pid) || pid <= 0) return false;
-	try {
-		process.kill(pid, 0);
-		return false;
-	} catch (e) {
-		return e.code === "ESRCH";
+	return s.split(/\s/, 1)[0] ?? "";
+}
+/**
+* The program a command line runs, as status lines and the registry name it: the basename
+* of its first word without a Windows extension. `"C:\\tools\\taplo.exe" lsp stdio` → `taplo`.
+*/
+function programOf(command) {
+	const prog = argv0(command);
+	return (prog.split(/[\\/]/).pop() || prog).replace(/\.(exe|cmd|bat)$/i, "");
+}
+/**
+* Where `command`'s program lives, or null when it is not an executable on PATH.
+* A name with a separator is resolved against `cwd` instead of searched, like a shell.
+*/
+function findOnPath(command, env = process.env, cwd = process.cwd()) {
+	const prog = argv0(command);
+	if (!prog) return null;
+	if (prog.includes("/") || process.platform === "win32" && prog.includes("\\")) return executable(isAbsolute(prog) ? prog : resolve(cwd, prog));
+	for (const dir of (env.PATH ?? "").split(delimiter)) {
+		if (!dir) continue;
+		const hit = executable(join(dir, prog));
+		if (hit) return hit;
 	}
+	return null;
 }
-//#endregion
-//#region src/server/lsp/configuration.ts
-const SCHEMA_CATALOG = "https://www.schemastore.org/api/json/catalog.json";
-const MAX_AGE = 864e5;
-const AssociationSchema = object({
-	url: url({ protocol: /^https?$/ }),
-	fileMatch: array(string()).nonempty()
-});
-const SchemaCatalogSchema = object({ schemas: array(unknown()) });
-const ConfigurationParamsSchema = object({ items: array(object({ section: string().optional() })) });
-/** Valid catalog entries, in the association format understood by the JSON server. */
-function schemaAssociations(value) {
-	const catalog = SchemaCatalogSchema.safeParse(value);
-	if (!catalog.success) return [];
-	return catalog.data.schemas.flatMap((entry) => {
-		const association = AssociationSchema.safeParse(entry);
-		return association.success ? [association.data] : [];
-	});
+/**
+* `file` itself when it is a runnable file, else the first `file` + PATHEXT match on
+* Windows, where the execute bit means nothing and programs are `.exe`/`.cmd`.
+*/
+function executable(file) {
+	if (runnable(file)) return file;
+	if (process.platform !== "win32") return null;
+	for (const ext of (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")) if (ext && runnable(file + ext)) return file + ext;
+	return null;
 }
-/** Caches catalog discovery for a day and uses the last good copy when offline. */
-async function loadSchemaCatalog(cacheFile = join(process.env.XDG_CACHE_HOME || join(homedir(), ".cache"), "diffle", "schemastore.json"), request = fetch) {
-	let cached = [];
-	try {
-		cached = schemaAssociations(JSON.parse(await readFile(cacheFile, "utf8")));
-		if (cached.length && Date.now() - (await stat$1(cacheFile)).mtimeMs < MAX_AGE) return cached;
-	} catch {}
+function runnable(file) {
 	try {
-		const response = await request(SCHEMA_CATALOG, { signal: AbortSignal.timeout(5e3) });
-		if (!response.ok) return cached;
-		const schemas = schemaAssociations(await response.json());
-		if (!schemas.length) return cached;
-		await writeFileAtomic(cacheFile, JSON.stringify({ schemas }) + "\n").catch(() => {});
-		return schemas;
+		if (!statSync(file).isFile()) return false;
+		if (process.platform === "win32") return true;
+		accessSync(file, constants.X_OK);
+		return true;
 	} catch {
-		return cached;
+		return false;
 	}
 }
-/** Default schema settings for the languages routed to a process. */
-async function settingsFor(languages, command) {
-	const settings = {};
-	if (languages.includes("yaml")) settings.yaml = {
-		hover: true,
-		schemaStore: {
-			enable: true,
-			url: SCHEMA_CATALOG
-		}
-	};
-	const program = argv0(command).split(/[\\/]/).pop()?.replace(/\.(exe|cmd|bat)$/i, "");
-	if (languages.includes("toml") && program === "taplo") settings.evenBetterToml = { schema: {
-		enabled: true,
-		catalogs: [SCHEMA_CATALOG]
-	} };
-	if (languages.some((l) => l === "json" || l === "jsonc")) settings.json = { schemas: await loadSchemaCatalog() };
-	return settings;
-}
 /**
-* Used by LspBridge to answer language servers' `workspace/configuration` requests.
-* Returns settings for each requested section in order, or null for unknown sections;
-* an omitted section requests all settings. Params are untrusted JSON from the server.
-* Malformed requests throw JSON-RPC Invalid Params before any settings are returned.
+* The file `executable` finally runs, as far as the filesystem tells: a pixi global
+* trampoline is replaced by the program its configuration names (the binary on PATH
+* is a launcher, with `trampoline_configuration/<name>.json` beside it pointing into
+* the environment), then symlinks are resolved. A path that leads nowhere is returned
+* as is.
 */
-function configurationItems(settings, params) {
-	const request = ConfigurationParamsSchema.safeParse(params);
-	if (!request.success) throw new JsonRpcError(-32602, "Invalid workspace/configuration parameters");
-	return request.data.items.map((item) => {
-		if (!item.section) return settings;
-		let value = settings;
-		for (const part of item.section.split(".")) {
-			if (!value || typeof value !== "object" || !Object.hasOwn(value, part)) return null;
-			value = value[part];
-		}
-		return value ?? null;
-	});
+function realExecutable(executable) {
+	let target = executable;
+	try {
+		const config = join(dirname(executable), "trampoline_configuration", `${basename(executable)}.json`);
+		const { exe } = JSON.parse(readFileSync(config, "utf8"));
+		if (typeof exe === "string" && exe) target = exe;
+	} catch {}
+	try {
+		return realpathSync(target);
+	} catch {
+		return target;
+	}
 }
 //#endregion
-//#region src/server/lsp/LspBridge.ts
-/** The server is off, still starting, or gone. Routes answer 409. */
+//#region src/server/lsp/LspProcess.ts
+/** The server is off, still starting, gone, or does not offer what was asked. Routes answer 409. */
 var LspUnavailableError = class extends Error {};
-/**
-* Token types by index when the server publishes no legend. The LSP spec's own
-* enumeration; pyrefly answers semantic token requests without advertising the
-* provider and numbers its tokens this way.
-*/
-const DEFAULT_TOKEN_TYPES = [
-	"namespace",
-	"type",
-	"class",
-	"enum",
-	"interface",
-	"struct",
-	"typeParameter",
-	"parameter",
-	"variable",
-	"property",
-	"enumMember",
-	"event",
-	"function",
-	"method",
-	"macro",
-	"keyword",
-	"modifier",
-	"comment",
-	"string",
-	"number",
-	"regexp",
-	"operator",
-	"decorator"
-];
+/** The server never advertised the feature, in `initialize` or since. Advisory requests answer nothing instead. */
+var LspUnsupportedError = class extends LspUnavailableError {};
+const RegistrationsSchema = object({ registrations: array(object({
+	id: string(),
+	method: string()
+})) });
+const UnregistrationsSchema = object({ unregisterations: array(object({ id: string() })) });
 const INIT_TIMEOUT_MS = 6e4;
-/**
-* Navigation opens whatever file a query lands in. Without a cap every path
-* visited in a long review stays open in the server, growing its memory and
-* per-save recheck cost.
-*/
-const MAX_UNTRACKED_OPEN = 64;
-/** Concurrent snapshot reads while mapping a result set back to paths. */
-const READ_CONCURRENCY = 8;
-/** Files outside the snapshot remembered for `readExternal`; the least recently named is forgotten first. */
-const MAX_EXTERNAL = 1024;
 /** Graceful shutdown budget. Both together stay under the CLI's hard exit deadline (main.ts). */
 const SHUTDOWN_RPC_MS = 500;
 const SIGKILL_AFTER_MS = 500;
-/** LSP `ContentModified`: the document moved under the request, so the answer would be stale. */
-const CONTENT_MODIFIED = -32801;
-/** Waits before re-asking a request the server refused as stale, one per attempt. */
-const CONTENT_MODIFIED_BACKOFF_MS = [40, 120];
 /**
-* Owns one language server process: the only module that spawns one. Speaks
-* JSON-RPC to it, keeps the queried document in sync from `read` before each
-* request, and maps results back to snapshot paths. Never throws from `start`;
-* failures become a status the UI can show.
+* `shell: true` runs the command under `sh -c`, so a plain kill would stop the
+* shell and orphan the language server. On POSIX the child leads its own process
+* group (`detached`), and shutdown signals the whole group.
+*/
+const DETACH = process.platform !== "win32";
+/**
+* One language server process: the only module that spawns one. Runs the
+* `initialize` handshake, keeps the status (with what `ServerOutput` reports), and
+* shuts it down. Speaks no document or query protocol: that is `Documents` and
+* `LspBridge`. Never throws from the constructor; failures become a status the UI
+* can show.
 */
-var LspBridge = class LspBridge {
+var LspProcess = class {
 	opts;
 	child = null;
 	rpc = null;
 	current;
 	ready;
-	stderr = "";
-	progress = /* @__PURE__ */ new Map();
-	/** Open documents, least recently synced first. */
-	open = /* @__PURE__ */ new Map();
-	/** Syncs in flight by path, so a track pass and a query racing on one file send a single didOpen. */
-	syncing = /* @__PURE__ */ new Map();
-	/** Paths `track` opened on the snapshot's behalf; closed again when they leave the snapshot. */
-	tracked = /* @__PURE__ */ new Set();
-	tracking = Promise.resolve();
 	closing = false;
-	ownsGroup = false;
-	/** Symlink-free root; servers often canonicalize, so URIs may not share the root's spelling. */
-	realRoot;
-	/** Semantic token legend from the server's capabilities, else the spec's default numbering. */
-	tokenTypes = DEFAULT_TOKEN_TYPES;
-	/** Absolute paths of files outside the snapshot that results named, least recently first. */
-	external = /* @__PURE__ */ new Set();
-	constructor(opts) {
-		this.opts = opts;
-		this.realRoot = safeRealpathSync(opts.root);
-		this.current = {
-			name: programName(opts.command),
-			command: opts.command,
-			state: "starting"
-		};
-		this.ready = this.launch();
-		this.ready.catch(() => {});
-	}
-	static start(opts) {
-		return new LspBridge(opts);
-	}
-	status() {
-		return this.current;
-	}
-	async definition(pos) {
-		const result = await this.query("textDocument/definition", {
-			textDocument: { uri: this.uri(pos.path) },
-			position: toLsp(pos)
-		}, pos.path);
-		return this.toLocations(normalizeLocations(result));
-	}
-	async typeDefinition(pos) {
-		const result = await this.query("textDocument/typeDefinition", {
-			textDocument: { uri: this.uri(pos.path) },
-			position: toLsp(pos)
-		}, pos.path);
-		return this.toLocations(normalizeLocations(result));
-	}
-	async hover(pos) {
-		const result = await this.query("textDocument/hover", {
-			textDocument: { uri: this.uri(pos.path) },
-			position: toLsp(pos)
-		}, pos.path);
-		const md = result ? hoverMarkdown(result.contents) : null;
-		const res = { contents: md == null ? null : localizeFileLinks(md, await this.resolveLinks(md)) };
-		if (result?.range) {
-			const { start, end } = result.range;
-			res.range = {
-				line: start.line + 1,
-				col: start.character,
-				endLine: end.line + 1,
-				endCol: end.character
-			};
-		}
-		return res;
-	}
-	/**
-	* The semantic token class at a position, via `textDocument/semanticTokens/range`
-	* on that one line. A server without semantic tokens, or a position between
-	* tokens, yields null, so callers treat null as "no opinion".
-	*/
-	async tokenKind(pos) {
-		const line = Math.max(0, pos.line - 1);
-		let data;
-		try {
-			data = (await this.query("textDocument/semanticTokens/range", {
-				textDocument: { uri: this.uri(pos.path) },
-				range: {
-					start: {
-						line,
-						character: 0
-					},
-					end: {
-						line: line + 1,
-						character: 0
-					}
-				}
-			}, pos.path))?.data ?? [];
-		} catch (e) {
-			if (e instanceof LspUnavailableError) throw e;
-			return { kind: null };
-		}
-		let tokLine = 0;
-		let tokStart = 0;
-		for (let i = 0; i + 4 < data.length; i += 5) {
-			const deltaLine = data[i];
-			tokLine += deltaLine;
-			tokStart = deltaLine === 0 ? tokStart + data[i + 1] : data[i + 1];
-			if (tokLine !== line || pos.col < tokStart || pos.col >= tokStart + data[i + 2]) continue;
-			return { kind: this.tokenTypes[data[i + 3]] ?? null };
-		}
-		return { kind: null };
-	}
-	/**
-	* Where else the symbol at `pos` occurs in its file, via `textDocument/documentHighlight`,
-	* so scope and shadowing are the server's call. A server without the method, or a
-	* position holding no symbol, yields no occurrences: the answer is advisory.
-	*/
-	async occurrences(pos) {
-		let result;
-		try {
-			result = await this.query("textDocument/documentHighlight", {
-				textDocument: { uri: this.uri(pos.path) },
-				position: toLsp(pos)
-			}, pos.path);
-		} catch (e) {
-			if (e instanceof LspUnavailableError) throw e;
-			return { occurrences: [] };
-		}
-		return { occurrences: (result ?? []).map(({ range: { start, end }, kind }) => ({
-			line: start.line + 1,
-			col: start.character,
-			endLine: end.line + 1,
-			endCol: end.character,
-			kind: kind === 3 ? "write" : kind === 2 ? "read" : "text"
-		})) };
+	ownsGroup = false;
+	/** What the server reports; each change lands on the status unless the process is done. */
+	output = new ServerOutput((change) => {
+		if (!this.closing && this.current.state !== "unavailable") this.set({
+			...this.current,
+			...change
+		});
+	});
+	/** Features the server offers, from `initialize` and from registrations since. */
+	advertised = /* @__PURE__ */ new Set();
+	/** Dynamic registrations by their id, so an unregistration knows which feature it ends. */
+	registrations = /* @__PURE__ */ new Map();
+	constructor(opts) {
+		this.opts = opts;
+		this.current = {
+			name: programOf(opts.command),
+			command: opts.command,
+			state: "starting",
+			log: this.output.summary()
+		};
+		this.ready = this.launch();
+		this.ready.catch(() => {});
 	}
-	async references(pos, opts = {}) {
-		const result = await this.query("textDocument/references", {
-			textDocument: { uri: this.uri(pos.path) },
-			position: toLsp(pos),
-			context: { includeDeclaration: opts.includeDeclaration ?? true }
-		}, pos.path);
-		return this.toLocations(normalizeLocations(result));
+	/** How messages name the server: `basedpyright-langserver --stdio` → `basedpyright-langserver`. */
+	get name() {
+		return this.current.name;
 	}
-	/**
-	* Keeps the diff's own files open in the server with their snapshot text.
-	* Servers index the workspace lazily and cap how much of it they index
-	* (pyrefly: in the background from the first open, 2000 files), so a
-	* reference in a changed file that nobody queried yet is otherwise only found
-	* once its file happens to be indexed, and from the text on disk. Opening
-	* everything at start also warms the index before the first query. Calls are
-	* serialized; the last set wins. Never throws: a path the snapshot cannot read
-	* is skipped.
-	*/
-	track(paths) {
-		const run = this.tracking.then(() => this.trackNow(paths)).catch(() => {});
-		this.tracking = run;
-		return run;
+	status() {
+		return this.current;
 	}
-	async trackNow(paths) {
-		const rpc = await this.ensureReady();
-		const next = new Set(paths);
-		for (const path of this.tracked) {
-			if (next.has(path)) continue;
-			this.tracked.delete(path);
-			if (this.open.delete(path)) rpc.notify("textDocument/didClose", { textDocument: { uri: this.uri(path) } });
-		}
-		for (const path of next) try {
-			await this.sync(path);
-			this.tracked.add(path);
-		} catch (e) {
-			if (e instanceof LspUnavailableError) return;
-		}
+	/** The retained log lines, oldest first. */
+	entries() {
+		return this.output.entries();
 	}
-	async documentSymbols(path) {
-		const result = await this.query("textDocument/documentSymbol", { textDocument: { uri: this.uri(path) } }, path);
-		if (!result) return [];
-		const out = [];
-		if (isDocumentSymbols(result)) {
-			const walk = (syms, container) => {
-				for (const s of syms) {
-					const start = (s.selectionRange ?? s.range).start;
-					const endLine = Math.max(start.line, (s.range ?? s.selectionRange).end.line) + 1;
-					out.push({
-						name: s.name,
-						kind: s.kind,
-						container,
-						path,
-						line: start.line + 1,
-						endLine,
-						col: start.character
-					});
-					if (s.children?.length) walk(s.children, s.name);
-				}
-			};
-			walk(result);
-			return out;
-		}
-		for (const s of result) {
-			const start = "range" in s.location ? s.location.range.start : {
-				line: 0,
-				character: 0
-			};
-			const end = "range" in s.location ? s.location.range.end : start;
-			out.push({
-				name: s.name,
-				kind: s.kind,
-				container: s.containerName || void 0,
-				path,
-				line: start.line + 1,
-				endLine: Math.max(start.line, end.line) + 1,
-				col: start.character
-			});
-		}
-		return out;
+	/** Whether the server advertised `feature`, at `initialize` or by registering it since. False until initialized. */
+	supports(feature) {
+		return this.advertised.has(feature);
 	}
-	/**
-	* Symbols the server knows for `query`, limited to paths the snapshot
-	* exposes, best `fuzzyRank` match first. Membership comes from `has`, never from reading the file: a
-	* per-keystroke search must not read every hit's text.
-	*/
-	async workspaceSymbols(query, limit = 200) {
-		const result = await this.query("workspace/symbol", { query });
-		if (!result) return [];
-		const paths = await Promise.all(result.map((s) => this.pathOf(s.location.uri)));
-		const inside = await this.membership(paths);
-		const out = [];
-		const seen = /* @__PURE__ */ new Set();
-		result.forEach((s, i) => {
-			const path = paths[i];
-			if (path == null || !inside.get(path)) return;
-			const start = "range" in s.location ? s.location.range.start : {
-				line: 0,
-				character: 0
-			};
-			const key = `${path}:${start.line}:${start.character}:${s.name}`;
-			if (seen.has(key)) return;
-			seen.add(key);
-			const end = "range" in s.location ? s.location.range.end : start;
-			out.push({
-				name: s.name,
-				kind: s.kind,
-				container: s.containerName || void 0,
-				path,
-				line: start.line + 1,
-				endLine: Math.max(start.line, end.line) + 1,
-				col: start.character
-			});
-		});
-		return fuzzyRank(out, query, (s) => s.name).slice(0, limit);
+	features() {
+		return [...this.advertised];
 	}
-	/**
-	* Contents of a file outside the snapshot that a recent result named as
-	* `external`, read from disk; null for every other path. This is the only
-	* read the bridge does on a client's behalf, so a path the language server
-	* never returned stays behind the snapshot allowlist.
-	*/
-	async readExternal(path) {
-		if (!this.external.has(path)) return null;
-		return readFile(path).catch(() => null);
+	/** The background work the server reports, as a reason an empty answer may be incomplete; null when idle. */
+	busy() {
+		const work = this.current.activity?.length ? this.current.activity.join("; ") : null;
+		return work ? `${this.name} is busy: ${work}; try again when it finishes` : null;
 	}
-	/** `has` for each distinct path, in parallel. */
-	async membership(paths) {
-		const distinct = [...new Set(paths.filter((p) => p != null))];
-		const flags = await mapLimit(distinct, READ_CONCURRENCY, (p) => this.opts.has(p));
-		return new Map(distinct.map((p, i) => [p, flags[i]]));
+	/** The connection once initialized; throws LspUnavailableError when the server is gone. */
+	async connection() {
+		try {
+			await this.ready;
+		} catch {
+			throw new LspUnavailableError(this.current.message ?? "language server unavailable");
+		}
+		if (this.current.state !== "ready" || !this.rpc) throw new LspUnavailableError(this.current.message ?? "language server unavailable");
+		return this.rpc;
 	}
 	async close() {
 		this.closing = true;
@@ -13794,18 +13907,12 @@ var LspBridge = class LspBridge {
 			throw e;
 		}
 		this.child = child;
-		child.stderr?.on("data", (d) => {
-			const chunk = d.toString("utf8");
-			this.stderr = (this.stderr + chunk).slice(-2e3);
-			if (!this.closing && this.current.state !== "unavailable") this.set({
-				...this.current,
-				stderr: this.stderr.trim()
-			});
-		});
+		child.stderr?.on("data", (d) => this.output.stderr(d.toString("utf8")));
 		child.on("error", (e) => this.fail(`cannot start "${this.opts.command}": ${e.message}`));
 		child.on("exit", (code, signal) => {
 			if (this.closing) return;
-			this.fail(`"${this.opts.command}" exited (${signal ?? code})${this.stderr.trim() ? `: ${lastLine(this.stderr)}` : ""}`);
+			this.output.stderr("\n");
+			this.fail(`"${this.opts.command}" exited (${signal ?? code})`);
 		});
 		if (!child.stdin || !child.stdout) {
 			this.fail(`cannot start "${this.opts.command}": no stdio`);
@@ -13813,11 +13920,15 @@ var LspBridge = class LspBridge {
 		}
 		const rpc = new JsonRpcConnection(child.stdout, child.stdin);
 		this.rpc = rpc;
-		rpc.onNotification((method, params) => this.noteWorkspace(method, params));
+		rpc.onMessage((method, params) => {
+			if (!this.closing && this.current.state !== "unavailable") this.output.message(method, params);
+		});
 		rpc.onRequest("workspace/configuration", async (params) => configurationItems(await this.opts.settings ?? {}, params));
+		rpc.onRequest("client/registerCapability", (params) => this.register(params));
+		rpc.onRequest("client/unregisterCapability", (params) => this.unregister(params));
 		const rootUri = pathToFileURL(this.opts.root).href;
 		try {
-			const legend = (await rpc.request("initialize", {
+			const capabilities = (await rpc.request("initialize", {
 				processId: process.pid,
 				clientInfo: { name: "diffle" },
 				rootUri,
@@ -13826,31 +13937,10 @@ var LspBridge = class LspBridge {
 					uri: rootUri,
 					name: "workspace"
 				}],
-				capabilities: {
-					window: { workDoneProgress: true },
-					textDocument: {
-						synchronization: { didSave: false },
-						definition: { linkSupport: true },
-						typeDefinition: { linkSupport: true },
-						references: {},
-						documentHighlight: {},
-						hover: { contentFormat: ["markdown", "plaintext"] },
-						documentSymbol: { hierarchicalDocumentSymbolSupport: true },
-						semanticTokens: {
-							requests: { range: true },
-							tokenTypes: DEFAULT_TOKEN_TYPES,
-							tokenModifiers: [],
-							formats: ["relative"]
-						}
-					},
-					workspace: {
-						symbol: {},
-						workspaceFolders: true,
-						configuration: true
-					}
-				}
-			}, INIT_TIMEOUT_MS))?.capabilities?.semanticTokensProvider?.legend?.tokenTypes;
-			if (legend?.length) this.tokenTypes = legend;
+				initializationOptions: this.opts.initializationOptions,
+				capabilities: CLIENT_CAPABILITIES
+			}, INIT_TIMEOUT_MS))?.capabilities ?? {};
+			for (const [feature, { provider }] of Object.entries(FEATURES)) if (capabilities[provider]) this.advertised.add(feature);
 			rpc.notify("initialized", {});
 			if (this.opts.settings) {
 				const settings = await this.opts.settings;
@@ -13865,40 +13955,30 @@ var LspBridge = class LspBridge {
 			state: "ready"
 		});
 	}
-	noteWorkspace(method, params) {
-		if (!params || typeof params !== "object" || this.closing || this.current.state === "unavailable") return;
-		const p = params;
-		if (method === "window/showMessage" || method === "window/logMessage" || method === "window/showMessageRequest") {
-			if (p.type !== 1 && p.type !== 2 || typeof p.message !== "string" || !p.message.trim()) return;
-			const notice = {
-				severity: p.type === 1 ? "error" : "warning",
-				message: p.message
-			};
-			if (notice.severity !== this.current.notice?.severity || notice.message !== this.current.notice?.message) this.set({
-				...this.current,
-				notice
-			});
-			return;
+	/** A feature the server offers from now on, as an editor takes it: counted like one advertised at `initialize`. */
+	register(params) {
+		const request = RegistrationsSchema.safeParse(params);
+		if (!request.success) throw new JsonRpcError(-32602, "Invalid client/registerCapability parameters");
+		for (const { id, method } of request.data.registrations) {
+			const feature = featureOf(method);
+			if (!feature) continue;
+			this.registrations.set(id, feature);
+			this.advertised.add(feature);
+		}
+		this.opts.onStatus(this.current);
+		return null;
+	}
+	unregister(params) {
+		const request = UnregistrationsSchema.safeParse(params);
+		if (!request.success) throw new JsonRpcError(-32602, "Invalid client/unregisterCapability parameters");
+		for (const { id } of request.data.unregisterations) {
+			const feature = this.registrations.get(id);
+			if (!feature) continue;
+			this.registrations.delete(id);
+			this.advertised.delete(feature);
 		}
-		if (method !== "$/progress" || typeof p.token !== "string" && typeof p.token !== "number") return;
-		if (!p.value || typeof p.value !== "object") return;
-		const { kind, title, message, percentage } = p.value;
-		const percent = typeof percentage === "number" && percentage >= 0 && percentage <= 100 ? percentage : void 0;
-		if (kind === "begin" && typeof title === "string") this.progress.set(p.token, {
-			title,
-			message: typeof message === "string" ? message : void 0,
-			percentage: percent
-		});
-		else if (kind === "report" && this.progress.has(p.token)) {
-			if (typeof message === "string") this.progress.get(p.token).message = message;
-			if (percent !== void 0) this.progress.get(p.token).percentage = percent;
-		} else if (kind === "end") {
-			if (!this.progress.delete(p.token)) return;
-		} else return;
-		this.set({
-			...this.current,
-			activity: [...this.progress.values()].map((p) => `${p.title}${p.percentage == null ? "" : ` (${p.percentage}%)`}${p.message ? `: ${p.message}` : ""}`)
-		});
+		this.opts.onStatus(this.current);
+		return null;
 	}
 	fail(message) {
 		if (this.current.state === "unavailable") return;
@@ -13906,75 +13986,94 @@ var LspBridge = class LspBridge {
 			name: this.current.name,
 			command: this.opts.command,
 			state: "unavailable",
-			message
+			message,
+			log: this.output.summary()
 		});
 		this.rpc?.dispose(new LspUnavailableError(message));
 	}
 	set(status) {
-		if (JSON.stringify(status) === JSON.stringify(this.current)) return;
 		this.current = status;
 		this.opts.onStatus(status);
 	}
-	/** Waits for initialize; throws LspUnavailableError when the server is gone. */
-	async ensureReady() {
-		try {
-			await this.ready;
-		} catch {
-			throw new LspUnavailableError(this.current.message ?? "language server unavailable");
-		}
-		if (this.current.state !== "ready" || !this.rpc) throw new LspUnavailableError(this.current.message ?? "language server unavailable");
-		return this.rpc;
+};
+//#endregion
+//#region src/server/lsp/Documents.ts
+/**
+* Navigation opens whatever file a query lands in. Without a cap every path
+* visited in a long review stays open in the server, growing its memory and
+* per-save recheck cost.
+*/
+const MAX_UNTRACKED_OPEN = 64;
+/**
+* The documents one server has open, kept in step with the snapshot: the diff's own files
+* for as long as they are in it, and the files queries land in until they fall off the
+* least-recently-used end. Sends `didOpen`, `didChange` and `didClose`; nothing else.
+*/
+var Documents = class {
+	opts;
+	/** Open documents, least recently synced first. */
+	open = /* @__PURE__ */ new Map();
+	/** Syncs in flight by path, so a track pass and a query racing on one file send a single didOpen. */
+	syncing = /* @__PURE__ */ new Map();
+	/** Paths `track` opened on the snapshot's behalf; closed again when they leave the snapshot. */
+	tracked = /* @__PURE__ */ new Set();
+	tracking = Promise.resolve();
+	constructor(opts) {
+		this.opts = opts;
 	}
-	/**
-	* One request against a synced document, re-asked while the server answers
-	* `ContentModified`: something moved the document under it — a watcher refresh, or a
-	* `track` pass opening the diff — so it refuses to answer from text it no longer holds.
-	* Re-syncing and asking again is what an editor does. Giving up reads as an outage, the
-	* one thing the reader can act on, rather than as a failed route.
-	*/
-	async query(method, params, path) {
-		for (let attempt = 0;; attempt++) {
-			const rpc = path == null ? await this.ensureReady() : await this.sync(path);
-			try {
-				const pending = busyReason(this.current);
-				const result = await rpc.request(method, params);
-				if (result == null || Array.isArray(result) && !result.length) {
-					const busy = busyReason(this.current) ?? pending;
-					if (busy) throw new LspUnavailableError(busy);
-					if (this.current.notice) {
-						const { severity, message } = this.current.notice;
-						throw new LspUnavailableError(`${this.current.name} returned no result; last server ${severity}: ${message}`);
-					}
-				}
-				return result;
-			} catch (e) {
-				if (!(e instanceof JsonRpcError) || e.code !== CONTENT_MODIFIED) throw e;
-				const backoff = CONTENT_MODIFIED_BACKOFF_MS[attempt];
-				if (backoff == null) throw new LspUnavailableError(`${this.current.name} could not answer while ${path ?? "the repository"} kept changing; try again`);
-				await new Promise((r) => setTimeout(r, backoff));
-			}
-		}
+	/** The text the server holds for an open path. */
+	textOf(path) {
+		return this.open.get(path)?.text;
 	}
 	/**
-	* Opens or updates the document so the server sees the snapshot's text before
-	* each request. Concurrent syncs of one path share a single read and
-	* notification. Untracked documents beyond `maxOpen` are closed, least
-	* recently used first; tracked ones stay open for the snapshot's lifetime.
+	* Opens or updates the document so the server sees the snapshot's text before a
+	* request. Concurrent syncs of one path share a single read and notification.
+	* Untracked documents beyond `maxOpen` are closed, least recently used first;
+	* tracked ones stay open for the snapshot's lifetime.
 	*/
-	async sync(path) {
-		const rpc = await this.ensureReady();
+	sync(path) {
 		let pending = this.syncing.get(path);
 		if (!pending) {
-			pending = this.syncNow(rpc, path).finally(() => this.syncing.delete(path));
+			pending = this.syncNow(path).finally(() => this.syncing.delete(path));
 			this.syncing.set(path, pending);
 		}
-		await pending;
-		return rpc;
+		return pending;
+	}
+	/**
+	* Keeps the diff's own files open in the server with their snapshot text.
+	* Servers index the workspace lazily and cap how much of it they index
+	* (pyrefly: in the background from the first open, 2000 files), so a
+	* reference in a changed file that nobody queried yet is otherwise only found
+	* once its file happens to be indexed, and from the text on disk. Opening
+	* everything at start also warms the index before the first query. Calls are
+	* serialized; the last set wins. Never throws: a path the snapshot cannot read
+	* is skipped.
+	*/
+	track(paths) {
+		const run = this.tracking.then(() => this.trackNow(paths)).catch(() => {});
+		this.tracking = run;
+		return run;
+	}
+	async trackNow(paths) {
+		const rpc = await this.opts.connection();
+		const next = new Set(paths);
+		for (const path of this.tracked) {
+			if (next.has(path)) continue;
+			this.tracked.delete(path);
+			if (this.open.delete(path)) rpc.notify("textDocument/didClose", { textDocument: { uri: this.opts.uri(path) } });
+		}
+		for (const path of next) try {
+			await this.sync(path);
+			this.tracked.add(path);
+		} catch (e) {
+			if (e instanceof LspUnavailableError) return;
+		}
 	}
-	async syncNow(rpc, path) {
+	async syncNow(path) {
+		const rpc = await this.opts.connection();
 		const text = await this.opts.read(path);
 		if (text == null) throw new Error(`${path} is not in the snapshot`);
-		const uri = this.uri(path);
+		const uri = this.opts.uri(path);
 		const doc = this.open.get(path);
 		if (!doc) {
 			this.open.set(path, {
@@ -14014,31 +14113,72 @@ var LspBridge = class LspBridge {
 			if (this.tracked.has(path) || this.syncing.has(path)) continue;
 			this.open.delete(path);
 			untracked--;
-			rpc.notify("textDocument/didClose", { textDocument: { uri: this.uri(path) } });
+			rpc.notify("textDocument/didClose", { textDocument: { uri: this.opts.uri(path) } });
 		}
 	}
-	uri(path) {
-		return pathToFileURL(join(this.opts.root, path)).href;
-	}
-	/**
-	* Where each `file:` link in hover text points inside the repository: the repo-relative path and,
-	* from the URI's `#line` or `#line,col` fragment, the 1-based line. Links outside the root are
-	* left out, so the client never offers a jump it cannot make.
-	*/
-	async resolveLinks(md) {
-		const uris = fileLinkUris(md);
-		const out = /* @__PURE__ */ new Map();
-		await Promise.all(uris.map(async (uri) => {
-			const hash = uri.indexOf("#");
-			const path = await this.pathOf(hash === -1 ? uri : uri.slice(0, hash));
-			if (path == null) return;
-			const line = hash === -1 ? null : /^L?(\d+)/.exec(uri.slice(hash + 1))?.[1];
-			out.set(uri, line == null ? { path } : {
-				path,
-				line: Number(line)
-			});
-		}));
-		return out;
+};
+//#endregion
+//#region src/server/lsp/hover.ts
+/**
+* One markdown document for the tooltip, or null when the server sent nothing
+* worth showing. Plaintext and `{language, value}` parts become fenced blocks,
+* so their text is never re-read as markdown.
+*/
+function hoverMarkdown(contents) {
+	if (contents == null) return null;
+	const parts = (Array.isArray(contents) ? contents : [contents]).map(partMarkdown).filter((p) => p.trim() !== "");
+	return parts.length ? parts.join("\n\n") : null;
+}
+function partMarkdown(part) {
+	if (typeof part === "string") return part;
+	if ("kind" in part) return part.kind === "markdown" ? part.value : fence(part.value, "");
+	return fence(part.value, part.language);
+}
+/** A fence long enough that a backtick run inside the code cannot close it early. */
+function fence(code, lang) {
+	const longest = Math.max(2, ...[...code.matchAll(/`+/g)].map((m) => m[0].length));
+	const ticks = "`".repeat(longest + 1);
+	return `${ticks}${lang}\n${code.replace(/\n$/, "")}\n${ticks}`;
+}
+/** An inline markdown link whose target is a `file:` URI, as pyright and pyrefly write "Go to X". */
+const fileLink = () => /\[([^\]]*)\]\(\s*<?(file:[^\s)>]+)>?\s*\)/g;
+/** The `file:` URIs the hover text links to, each once. */
+function fileLinkUris(md) {
+	return [...new Set([...md.matchAll(fileLink())].map((m) => m[2]))];
+}
+/**
+* Rewrites the hover text's `file:` links to `diffle:<path>#L<line>`, which the client follows as an
+* in-app jump. `resolved` maps each URI to its repo-relative path and line; a URI it omits lies
+* outside the repository and becomes plain text, since opening a browser tab on a source file is
+* never what the reader wants.
+*/
+function localizeFileLinks(md, resolved) {
+	return md.replace(fileLink(), (_m, label, uri) => {
+		const loc = resolved.get(uri);
+		if (!loc) return label;
+		return `[${label}](diffle:${encodeURI(loc.path)}${loc.line != null ? `#L${loc.line}` : ""})`;
+	});
+}
+//#endregion
+//#region src/server/lsp/Locator.ts
+/** Concurrent snapshot reads while mapping a result set back to paths. */
+const READ_CONCURRENCY = 8;
+/** Files outside the snapshot remembered for `readExternal`; the least recently named is forgotten first. */
+const MAX_EXTERNAL = 1024;
+/**
+* Maps the URIs a language server answers with back to snapshot paths, and remembers
+* the files outside the snapshot it named, so `/api/file` may serve those and nothing
+* else beyond the allowlist.
+*/
+var Locator = class {
+	opts;
+	/** Symlink-free root; servers often canonicalize, so URIs may not share the root's spelling. */
+	realRoot;
+	/** Absolute paths of files outside the snapshot that results named, least recently first. */
+	external = /* @__PURE__ */ new Set();
+	constructor(opts) {
+		this.opts = opts;
+		this.realRoot = safeRealpathSync(opts.root);
 	}
 	/**
 	* Repo-relative path for a file URI inside the root; null otherwise. Compares
@@ -14059,13 +14199,13 @@ var LspBridge = class LspBridge {
 		return relativeInside(this.realRoot, real);
 	}
 	/**
-	* Maps server locations to paths with the text of each line: a snapshot path,
-	* or, for a file the snapshot lacks (stdlib, site-packages, an ignored venv),
-	* the file itself read from disk and marked external. Each distinct URI is
-	* read once, in parallel with a limit, so a large reference set costs a
-	* bounded number of reads. A file readable neither way is dropped.
+	* Server locations as paths with the text of each line: a snapshot path, or, for a
+	* file the snapshot lacks (stdlib, site-packages, an ignored venv), the file itself
+	* read from disk and marked external. Each distinct URI is read once, in parallel
+	* with a limit, so a large reference set costs a bounded number of reads. A file
+	* readable neither way is dropped.
 	*/
-	async toLocations(locs) {
+	async locations(locs) {
 		const uris = [...new Set(locs.map((l) => l.uri))];
 		const found = await mapLimit(uris, READ_CONCURRENCY, (uri) => this.locate(uri));
 		const byUri = new Map(uris.map((uri, i) => [uri, found[i]]));
@@ -14083,12 +14223,48 @@ var LspBridge = class LspBridge {
 			if (f.external) loc.external = true;
 			out.push(loc);
 		}
-		return { locations: out };
+		return out;
+	}
+	/**
+	* Where each `file:` link in hover text points inside the repository: the repo-relative path and,
+	* from the URI's `#line` or `#line,col` fragment, the 1-based line. Links outside the root are
+	* left out, so the client never offers a jump it cannot make.
+	*/
+	async links(md) {
+		const uris = fileLinkUris(md);
+		const out = /* @__PURE__ */ new Map();
+		await Promise.all(uris.map(async (uri) => {
+			const hash = uri.indexOf("#");
+			const path = await this.pathOf(hash === -1 ? uri : uri.slice(0, hash));
+			if (path == null) return;
+			const line = hash === -1 ? null : /^L?(\d+)/.exec(uri.slice(hash + 1))?.[1];
+			out.set(uri, line == null ? { path } : {
+				path,
+				line: Number(line)
+			});
+		}));
+		return out;
+	}
+	/** `has` for each distinct path, in parallel. */
+	async membership(paths) {
+		const distinct = [...new Set(paths.filter((p) => p != null))];
+		const flags = await mapLimit(distinct, READ_CONCURRENCY, (p) => this.opts.has(p));
+		return new Map(distinct.map((p, i) => [p, flags[i]]));
+	}
+	/**
+	* Contents of a file outside the snapshot that a recent result named as
+	* `external`, read from disk; null for every other path. This is the only
+	* read done on a client's behalf, so a path the language server never
+	* returned stays behind the snapshot allowlist.
+	*/
+	async readExternal(path) {
+		if (!this.external.has(path)) return null;
+		return readFile(path).catch(() => null);
 	}
 	async locate(uri) {
 		const path = await this.pathOf(uri);
 		if (path != null) {
-			const text = this.open.get(path)?.text ?? await this.opts.read(path);
+			const text = this.opts.textOf(path) ?? await this.opts.read(path);
 			if (text != null) return {
 				path,
 				text,
@@ -14125,11 +14301,6 @@ function relativeInside(root, abs) {
 	if (!rel || rel.startsWith("..") || isAbsolute(rel)) return null;
 	return rel.split("\\").join("/");
 }
-/** How status messages name a server: `basedpyright-langserver --stdio` → `basedpyright-langserver`. */
-function programName(command) {
-	const prog = argv0(command);
-	return prog.split(/[\\/]/).pop() || prog;
-}
 /**
 * Canonical `p`, or `p` itself when it cannot be resolved. Uses libuv's
 * realpath, the same one the async `realpath` in `pathOf` uses: the JS
@@ -14143,28 +14314,6 @@ function safeRealpathSync(p) {
 		return p;
 	}
 }
-function toLsp(pos) {
-	return {
-		line: Math.max(0, pos.line - 1),
-		character: Math.max(0, pos.col)
-	};
-}
-function normalizeLocations(r) {
-	if (!r) return [];
-	return (Array.isArray(r) ? r : [r]).map((x) => "targetUri" in x ? {
-		uri: x.targetUri,
-		range: x.targetSelectionRange ?? x.targetRange
-	} : x);
-}
-function isDocumentSymbols(r) {
-	return r.length > 0 && !("location" in r[0]);
-}
-/**
-* `shell: true` runs the command under `sh -c`, so a plain kill would stop the
-* shell and orphan the language server. On POSIX the child leads its own process
-* group (`detached`), and shutdown signals the whole group.
-*/
-const DETACH = process.platform !== "win32";
 function lineAt(text, line) {
 	let start = 0;
 	for (let i = 1; i < line; i++) {
@@ -14175,17 +14324,338 @@ function lineAt(text, line) {
 	const end = text.indexOf("\n", start);
 	return (end === -1 ? text.slice(start) : text.slice(start, end)).replace(/\r$/, "");
 }
-function lastLine(s) {
-	const lines = s.trim().split("\n");
-	return lines[lines.length - 1] ?? "";
+//#endregion
+//#region src/server/lsp/LspBridge.ts
+/** LSP `ContentModified`: the document moved under the request, so the answer would be stale. */
+const CONTENT_MODIFIED = -32801;
+/** Waits before re-asking a request the server refused as stale, one per attempt. */
+const CONTENT_MODIFIED_BACKOFF_MS = [40, 120];
+/**
+* One language server as diffle asks it: each LSP request against a document synced
+* from the snapshot, with the answer mapped back to snapshot paths. The process, the
+* open documents and the path mapping are `LspProcess`, `Documents` and `Locator`;
+* this is where the requests and their result shapes live.
+*/
+var LspBridge = class {
+	opts;
+	process;
+	documents;
+	locator;
+	constructor(opts) {
+		this.opts = opts;
+		this.process = new LspProcess(opts);
+		this.documents = new Documents({
+			connection: () => this.process.connection(),
+			read: opts.read,
+			uri: (path) => this.uri(path),
+			maxOpen: opts.maxOpen
+		});
+		this.locator = new Locator({
+			root: opts.root,
+			read: opts.read,
+			has: opts.has,
+			textOf: (path) => this.documents.textOf(path)
+		});
+	}
+	status() {
+		return this.process.status();
+	}
+	/** The retained log lines, oldest first. */
+	entries() {
+		return this.process.entries();
+	}
+	/** What the server's `initialize` result advertised; empty while starting. */
+	features() {
+		return this.process.features();
+	}
+	async definition(pos) {
+		return this.locations("definition", "textDocument/definition", pos);
+	}
+	async typeDefinition(pos) {
+		return this.locations("typeDefinition", "textDocument/typeDefinition", pos);
+	}
+	async references(pos) {
+		return this.locations("references", "textDocument/references", pos, { context: { includeDeclaration: true } });
+	}
+	async hover(pos) {
+		const { result, busy } = await this.query("textDocument/hover", {
+			textDocument: { uri: this.uri(pos.path) },
+			position: toLsp(pos)
+		}, pos.path, "hover");
+		const md = result ? hoverMarkdown(result.contents) : null;
+		if (md == null) return inconclusive({ contents: null }, true, busy);
+		const res = { contents: localizeFileLinks(md, await this.locator.links(md)) };
+		if (result?.range) res.range = fromLsp(result.range);
+		return res;
+	}
+	/**
+	* Where else the symbol at `pos` occurs in its file, via `textDocument/documentHighlight`,
+	* so scope and shadowing are the server's call. A server not offering the request, or a
+	* position holding no symbol, yields no occurrences: the answer is advisory.
+	*/
+	async occurrences(pos) {
+		const { result } = await this.query("textDocument/documentHighlight", {
+			textDocument: { uri: this.uri(pos.path) },
+			position: toLsp(pos)
+		}, pos.path, "documentHighlight").catch(unsupported(null));
+		return { occurrences: (result ?? []).map(({ range, kind }) => ({
+			...fromLsp(range),
+			kind: kind === 3 ? "write" : kind === 2 ? "read" : "text"
+		})) };
+	}
+	/** Keeps the diff's own files open in the server (see `Documents.track`). Never throws. */
+	track(paths) {
+		return this.documents.track(paths);
+	}
+	async documentSymbols(path) {
+		const { result, busy } = await this.query("textDocument/documentSymbol", { textDocument: { uri: this.uri(path) } }, path, "documentSymbol");
+		const symbols = result ? flattenSymbols(result, path) : [];
+		return inconclusive({ symbols }, !symbols.length, busy);
+	}
+	/**
+	* Symbols the server knows for `query`, limited to paths the snapshot exposes, in the
+	* server's order: the pool ranks the union. Membership comes from `has`, never from
+	* reading the file: a per-keystroke search must not read every hit's text.
+	*/
+	async workspaceSymbols(query) {
+		const { result, busy } = await this.query("workspace/symbol", { query }, void 0, "workspaceSymbol");
+		if (!result) return inconclusive({ symbols: [] }, true, busy);
+		const paths = await Promise.all(result.map((s) => this.locator.pathOf(s.location.uri)));
+		const inside = await this.locator.membership(paths);
+		const out = [];
+		const seen = /* @__PURE__ */ new Set();
+		result.forEach((s, i) => {
+			const path = paths[i];
+			if (path == null || !inside.get(path)) return;
+			const symbol = symbolInformation(s, path);
+			const key = `${path}:${symbol.line}:${symbol.col}:${symbol.name}`;
+			if (seen.has(key)) return;
+			seen.add(key);
+			out.push(symbol);
+		});
+		return inconclusive({ symbols: out }, !out.length, busy);
+	}
+	/** Reads a file outside the snapshot only if a result named it (see `Locator.readExternal`). */
+	readExternal(path) {
+		return this.locator.readExternal(path);
+	}
+	close() {
+		return this.process.close();
+	}
+	async locations(feature, method, pos, extra = {}) {
+		const { result, busy } = await this.query(method, {
+			textDocument: { uri: this.uri(pos.path) },
+			position: toLsp(pos),
+			...extra
+		}, pos.path, feature);
+		const locations = await this.locator.locations(normalizeLocations(result));
+		return inconclusive({ locations }, !locations.length, busy);
+	}
+	/**
+	* One request against a synced document, re-asked while the server answers
+	* `ContentModified`: something moved the document under it — a watcher refresh, or a
+	* `track` pass opening the diff — so it refuses to answer from text it no longer holds.
+	* Re-syncing and asking again is what an editor does. Giving up reads as an outage, the
+	* one thing the reader can act on, rather than as a failed route. A `feature` the
+	* server never advertised is not asked for. `busy` is why an empty `result` may be
+	* incomplete: background work the server reported before or during the request.
+	*/
+	async query(method, params, path, feature) {
+		for (let attempt = 0;; attempt++) {
+			if (path != null) await this.documents.sync(path);
+			const rpc = await this.process.connection();
+			if (feature && !this.process.supports(feature)) throw new LspUnsupportedError(`${this.process.name} offers no ${LSP_FEATURE_LABELS[feature]}`);
+			try {
+				const pending = this.process.busy();
+				return {
+					result: await rpc.request(method, params),
+					busy: this.process.busy() ?? pending
+				};
+			} catch (e) {
+				if (!(e instanceof JsonRpcError) || e.code !== CONTENT_MODIFIED) throw e;
+				const backoff = CONTENT_MODIFIED_BACKOFF_MS[attempt];
+				if (backoff == null) throw new LspUnavailableError(`${this.process.name} could not answer while ${path ?? "the repository"} kept changing; try again`);
+				await new Promise((r) => setTimeout(r, backoff));
+			}
+		}
+	}
+	uri(path) {
+		return pathToFileURL(join(this.opts.root, path)).href;
+	}
+};
+/** A catch handler answering `result` for a request the server does not offer; anything else propagates. */
+function unsupported(result) {
+	return (e) => {
+		if (e instanceof LspUnsupportedError) return {
+			result,
+			busy: null
+		};
+		throw e;
+	};
+}
+//#endregion
+//#region src/server/lsp/merge.ts
+/**
+* The union of what several servers answered. A server that fails drops its share;
+* every one failing is the first failure. When the union is `empty`, the first reason it
+* may be incomplete stands: a server's own, else a failed server's message, so an
+* owner still starting reads as such rather than as silence.
+*/
+async function union(asked, merge, empty) {
+	const results = await Promise.allSettled(asked);
+	const answers = results.flatMap((r) => r.status === "fulfilled" ? [r.value] : []);
+	const failed = results.find((r) => r.status === "rejected");
+	if (!answers.length && failed) throw failed.reason;
+	const merged = merge(answers);
+	if (empty(merged)) {
+		const reason = answers.find((a) => a.inconclusive)?.inconclusive ?? (failed ? messageOf(failed.reason) : void 0);
+		if (reason) merged.inconclusive = reason;
+	}
+	return merged;
+}
+function messageOf(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+/** Every server's hover, owner first, as one tooltip; the span is the first one offered. */
+function mergeHovers(answers) {
+	const said = answers.filter((a) => a.contents != null);
+	if (!said.length) return { contents: null };
+	const range = said.find((a) => a.range)?.range;
+	return {
+		contents: said.map((a) => a.contents).join("\n\n---\n\n"),
+		...range ? { range } : {}
+	};
+}
+/** The union of every server's locations, owner first, each place once. */
+function mergeLocations(answers) {
+	const seen = /* @__PURE__ */ new Set();
+	return { locations: answers.flatMap((a) => a.locations.filter((l) => {
+		const key = `${l.path}\0${l.line}\0${l.col}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	})) };
+}
+//#endregion
+//#region src/server/lsp/tsdk.ts
+/**
+* The TypeScript `lib` directory a Volar server such as astro-ls loads as its
+* `typescript.tsdk`, or null when none is found. The repository's own `typescript`
+* wins, so the server reads code with the project's version; after it, the one
+* installed beside the first of `executables` that has one. Node's resolution from an
+* executable's real location reaches the package in the layouts of npm (hoisted under
+* `lib/node_modules`), a Windows `.cmd` shim (beside `node_modules`) and nixpkgs (the
+* pnpm store the symlink's target sits in). A conda or pixi environment runs a launcher
+* in `bin`, so each package under its `lib/node_modules` is tried as well, where the
+* TypeScript is nested or hoisted. TypeScript 7 ships no `typescript.js`, so it is
+* passed over: Volar cannot load the Go port.
+*/
+function tsdkLocation(root, executables) {
+	const bases = [root];
+	for (const executable of executables) {
+		if (executable == null) continue;
+		const bin = dirname(realExecutable(executable));
+		bases.push(bin, ...globalPackages(resolve(bin, "..", "lib", "node_modules")));
+	}
+	for (const base of bases) {
+		const lib = typescriptLib(base);
+		if (lib) return lib;
+	}
+	return null;
+}
+/** The package directories under a global `node_modules`, scoped ones included; none when it is not there. */
+function globalPackages(modules) {
+	const entries = (dir) => {
+		try {
+			return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
+		} catch {
+			return [];
+		}
+	};
+	return entries(modules).flatMap((name) => name.startsWith("@") ? entries(join(modules, name)).map((sub) => join(modules, name, sub)) : [join(modules, name)]);
+}
+/** `typescript/lib` as resolved from `base`, when it holds a loadable TypeScript. */
+function typescriptLib(base) {
+	try {
+		const lib = join(dirname(createRequire(join(base, "package.json")).resolve("typescript/package.json")), "lib");
+		return ["typescript.js", "tsserverlibrary.js"].some((file) => existsSync(join(lib, file))) ? lib : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/server/lsp/vue.ts
+/** The tsserver plugin that turns .vue files into TypeScript documents. */
+const VUE_PLUGIN = "@vue/typescript-plugin";
+/**
+* Where tsserver loads the Vue plugin from, given the `vue-language-server` executable,
+* or null when no package holding the plugin is found beside it. Vue language tools 3
+* serve .vue files through this plugin inside tsserver; the standalone server only
+* relays to a tsserver the editor must bridge, so diffle never runs it. The package is
+* reached through the layouts of npm (a symlink into the package, or a `.cmd` shim
+* beside `node_modules` on Windows), conda and pixi (a launcher in `bin` beside
+* `lib/node_modules`, behind a pixi global trampoline), and nixpkgs (a wrapper beside
+* `lib/language-tools`).
+*/
+function vuePluginLocation(executable) {
+	const real = realExecutable(executable);
+	const candidates = [
+		resolve(dirname(real), ".."),
+		join(dirname(executable), "node_modules", "@vue", "language-server"),
+		resolve(dirname(real), "..", "lib", "node_modules", "@vue", "language-server"),
+		resolve(dirname(real), "..", "lib", "language-tools", "packages", "language-server")
+	];
+	for (const dir of candidates) try {
+		createRequire(join(dir, "package.json")).resolve(VUE_PLUGIN);
+		return dir;
+	} catch {}
+	return null;
 }
-/** Why an empty result may be incomplete while the server reports background work. */
-function busyReason(s) {
-	const work = s.activity?.length ? s.activity.join("; ") : null;
-	return work ? `${s.name} is busy: ${work}; try again when it finishes` : null;
+/**
+* The tsserver plugin entry for .vue files when `vue-language-server` is on PATH, else
+* null. Loaded whenever a TypeScript server starts, not only when the diff holds a .vue
+* file: a process serving .ts files first and .vue files after a refresh cannot load it
+* later, and .ts files importing components resolve them. `lookup` is the PATH probe.
+*/
+function vuePlugin(lookup) {
+	const executable = lookup("vue-language-server");
+	const location = executable == null ? null : vuePluginLocation(executable);
+	return location == null ? null : {
+		name: VUE_PLUGIN,
+		location,
+		languages: ["vue"]
+	};
 }
 //#endregion
 //#region src/server/lsp/registry.ts
+const TYPESCRIPT = [
+	"typescript",
+	"typescriptreact",
+	"javascript",
+	"javascriptreact"
+];
+const TSSERVER = {
+	command: "typescript-language-server --stdio",
+	initializationOptions: ({ lookup }) => {
+		const plugin = vuePlugin(lookup);
+		return plugin ? { plugins: [plugin] } : void 0;
+	}
+};
+const VTSLS = {
+	command: "vtsls --stdio",
+	settings: ({ lookup }) => {
+		const plugin = vuePlugin(lookup);
+		return plugin ? { vtsls: { tsserver: { globalPlugins: [{
+			...plugin,
+			configNamespace: "typescript"
+		}] } } } : {};
+	}
+};
+const VUE = {
+	program: "vue-language-server",
+	what: VUE_PLUGIN,
+	locate: vuePluginLocation
+};
 /**
 * Built-in servers, in preference order per language: the first one whose program is
 * on PATH is used. Entries serving several languages become one process, which is how
@@ -14217,22 +14687,34 @@ const CANDIDATES = [
 		command: "jedi-language-server"
 	},
 	{
-		languages: [
-			"typescript",
-			"typescriptreact",
-			"javascript",
-			"javascriptreact"
-		],
-		command: "typescript-language-server --stdio"
+		languages: TYPESCRIPT,
+		...TSSERVER
 	},
 	{
-		languages: [
-			"typescript",
-			"typescriptreact",
-			"javascript",
-			"javascriptreact"
-		],
-		command: "vtsls --stdio"
+		languages: TYPESCRIPT,
+		...VTSLS
+	},
+	{
+		languages: ["vue"],
+		...TSSERVER,
+		requires: VUE
+	},
+	{
+		languages: ["vue"],
+		...VTSLS,
+		requires: VUE
+	},
+	{
+		languages: ["astro"],
+		command: "astro-ls --stdio",
+		initializationOptions: ({ root, lookup }) => {
+			const tsdk = tsdkLocation(root, [
+				"astro-ls",
+				"typescript-language-server",
+				"vtsls"
+			].map((c) => lookup(c)));
+			return tsdk ? { typescript: { tsdk } } : void 0;
+		}
 	},
 	{
 		languages: ["rust"],
@@ -14258,6 +14740,18 @@ const CANDIDATES = [
 		languages: ["java"],
 		command: "jdtls"
 	},
+	{
+		languages: ["csharp"],
+		command: "roslyn-language-server --stdio --autoLoadProjects"
+	},
+	{
+		languages: ["csharp"],
+		command: "Microsoft.CodeAnalysis.LanguageServer --stdio --autoLoadProjects"
+	},
+	{
+		languages: ["csharp"],
+		command: "csharp-ls"
+	},
 	{
 		languages: ["lua"],
 		command: "lua-language-server"
@@ -14304,15 +14798,24 @@ const CANDIDATES = [
 	},
 	{
 		languages: ["json", "jsonc"],
-		command: "vscode-json-language-server --stdio"
+		command: "vscode-json-language-server --stdio",
+		settings: async () => ({ json: { schemas: await loadSchemaCatalog() } })
 	},
 	{
 		languages: ["json", "jsonc"],
-		command: "vscode-json-languageserver --stdio"
+		command: "vscode-json-languageserver --stdio",
+		settings: async () => ({ json: { schemas: await loadSchemaCatalog() } })
 	},
 	{
 		languages: ["yaml"],
-		command: "yaml-language-server --stdio"
+		command: "yaml-language-server --stdio",
+		settings: () => ({ yaml: {
+			hover: true,
+			schemaStore: {
+				enable: true,
+				url: SCHEMA_CATALOG
+			}
+		} })
 	},
 	{
 		languages: ["toml"],
@@ -14320,35 +14823,117 @@ const CANDIDATES = [
 	},
 	{
 		languages: ["toml"],
-		command: "taplo lsp stdio"
+		command: "taplo lsp stdio",
+		settings: () => ({ evenBetterToml: { schema: {
+			enabled: true,
+			catalogs: [SCHEMA_CATALOG]
+		} } })
+	},
+	{
+		languages: ["css"],
+		command: "vscode-css-language-server --stdio",
+		settings: () => ({
+			css: { validate: false },
+			less: { validate: false },
+			scss: { validate: false }
+		})
+	},
+	{
+		languages: ["html"],
+		command: "vscode-html-language-server --stdio"
+	},
+	{
+		languages: [],
+		joins: [
+			"astro",
+			"css",
+			"html",
+			"javascript",
+			"javascriptreact",
+			"typescript",
+			"typescriptreact",
+			"vue"
+		],
+		command: "tailwindcss-language-server --stdio"
 	}
 ];
-/** The candidate commands for a language, in the order they are tried. */
-function candidatesFor(language) {
-	return CANDIDATES.filter((c) => c.languages.includes(language)).map((c) => c.command);
+/**
+* How a command line's program is configured, by the built-in definition for that program:
+* an override naming a known server with other flags or a full path still gets its
+* settings. A program diffle does not know takes none.
+*/
+function definitionOf(command) {
+	const program = programOf(command);
+	const known = CANDIDATES.find((c) => programOf(c.command) === program);
+	return {
+		command,
+		settings: known?.settings,
+		initializationOptions: known?.initializationOptions
+	};
 }
 /**
 * Which servers to start for `languages`. A config override replaces the candidate
 * list for its language and is never probed: the user named a command, so a typo
 * should surface as the server failing to start, not as silence. An override of `''`
 * turns the language off. Languages resolving to the same command line share one
-* process. `lookup` is a test seam for the PATH probe.
+* process. A missing language's `tried` names the programs that were not on PATH, so
+* a candidate needing two programs lists only the absent one; a program on PATH that
+* lacks what the candidate loads from beside it is as good as absent, and the first
+* such finding is the language's `why`. A candidate joining a requested language
+* starts too, when on PATH, whatever owns it, and joins only the requested ones,
+* growing like an owner does as later snapshots ask for more; its absence is no one's
+* missing server. `lookup` is a test seam for the PATH probe.
 */
 function resolveServers(languages, overrides = {}, lookup = (c) => findOnPath(c)) {
-	const probe = /* @__PURE__ */ new Map();
-	const found = (command) => {
-		let hit = probe.get(command);
-		if (hit == null) probe.set(command, hit = lookup(command) != null);
+	const probed = /* @__PURE__ */ new Map();
+	const where = (command) => {
+		let hit = probed.get(command);
+		if (hit === void 0) probed.set(command, hit = lookup(command));
 		return hit;
 	};
+	/** What keeps a candidate from starting: programs not on PATH, or one on PATH without what it loads from beside it. */
+	const probe = (candidate) => {
+		const absent = [];
+		if (where(candidate.command) == null) absent.push(argv0(candidate.command));
+		const { requires } = candidate;
+		if (!requires) return { absent };
+		const executable = where(requires.program);
+		if (executable == null) absent.push(requires.program);
+		else if (requires.locate(executable) == null) return {
+			absent,
+			why: `${requires.program} is on PATH but ${requires.what} was not found beside it`
+		};
+		return { absent };
+	};
+	const startable = (candidate) => {
+		const { absent, why } = probe(candidate);
+		return !absent.length && !why;
+	};
 	const servers = /* @__PURE__ */ new Map();
 	const missing = [];
-	for (const language of [...new Set(languages)].sort()) {
-		const command = overrides[language]?.trim() ?? candidatesFor(language).find(found);
+	const asked = [...new Set(languages)].sort();
+	for (const language of asked) {
+		let command = overrides[language]?.trim();
+		const tried = [];
+		let why;
+		if (command == null) for (const candidate of CANDIDATES) {
+			if (!candidate.languages.includes(language)) continue;
+			const { absent, why: broken } = probe(candidate);
+			if (!absent.length && !broken) {
+				command = candidate.command;
+				break;
+			}
+			why ??= broken;
+			for (const program of absent) if (!tried.includes(program)) tried.push(program);
+		}
 		if (command == null || command === "") {
-			missing.push({
+			missing.push(why ? {
 				language,
-				tried: command === "" ? [] : candidatesFor(language).map(argv0)
+				tried,
+				why
+			} : {
+				language,
+				tried
 			});
 			continue;
 		}
@@ -14356,9 +14941,21 @@ function resolveServers(languages, overrides = {}, lookup = (c) => findOnPath(c)
 		if (server) server.languages.push(language);
 		else servers.set(command, {
 			command,
-			languages: [language]
+			languages: [language],
+			joins: []
 		});
 	}
+	for (const candidate of CANDIDATES) {
+		const joins = (candidate.joins ?? []).filter((l) => asked.includes(l));
+		if (!joins.length || !startable(candidate)) continue;
+		const server = servers.get(candidate.command) ?? {
+			command: candidate.command,
+			languages: [],
+			joins: []
+		};
+		servers.set(candidate.command, server);
+		for (const l of joins) if (!server.languages.includes(l) && !server.joins.includes(l)) server.joins.push(l);
+	}
 	return {
 		servers: [...servers.values()],
 		missing
@@ -14367,21 +14964,31 @@ function resolveServers(languages, overrides = {}, lookup = (c) => findOnPath(c)
 //#endregion
 //#region src/server/lsp/LspPool.ts
 /**
-* One language server per language in the diff, started the first time a snapshot
-* names that language and kept for the run. Routes every request by the path's
-* language, fans repository-wide queries out to all of them, and reports them as one
-* status. Owns no protocol logic: each server is an `LspBridge`.
+* A status change goes out at once when the pool has been quiet, and later ones within
+* this window ride on one trailing publish: a server logging a hundred stderr lines
+* while indexing is a few broadcasts, not a hundred.
+*/
+const PUBLISH_MS = 20;
+/**
+* The language servers of one run, started the first time a snapshot names a language
+* they serve and kept for the run. Routes like an editor: every server for a file's
+* language is asked at once and their hovers, definitions and references are merged,
+* owner first; highlights and outlines come from the owner alone, as two
+* servers' highlight sets would only clash. Repository-wide queries fan out to all
+* servers, and all of them report as one status. Owns no protocol logic: each server
+* is an `LspBridge`.
 */
 var LspPool = class {
 	opts;
 	/** Servers by command line: languages that resolve to the same command share one process. */
 	entries = /* @__PURE__ */ new Map();
-	byLanguage = /* @__PURE__ */ new Map();
 	missing = [];
 	/** Languages already resolved, served or not, so the PATH probe runs once each. */
 	resolved = /* @__PURE__ */ new Set();
 	closing = false;
 	closed;
+	publishTimer = null;
+	publishDue = false;
 	constructor(opts) {
 		this.opts = opts;
 		this.ensure(opts.preload ?? []);
@@ -14391,11 +14998,17 @@ var LspPool = class {
 			enabled: true,
 			servers: [...this.entries.values()].map((e) => ({
 				...e.bridge.status(),
-				languages: [...e.languages]
+				languages: [...e.languages],
+				joins: [...e.joins],
+				supports: e.bridge.features()
 			})),
 			missing: this.missing
 		};
 	}
+	/** The retained log lines of the server started by `command`, or null when none was. */
+	log(command) {
+		return this.entries.get(command)?.bridge.entries() ?? null;
+	}
 	/** Reads an external file only if a running server named it. */
 	async readExternal(path) {
 		for (const { bridge } of this.entries.values()) {
@@ -14404,47 +15017,44 @@ var LspPool = class {
 		}
 		return null;
 	}
-	async definition(pos) {
-		return this.bridgeFor(pos.path).definition(pos);
-	}
-	async typeDefinition(pos) {
-		return this.bridgeFor(pos.path).typeDefinition(pos);
+	definition(pos) {
+		return this.locations(pos, (b) => b.definition(pos));
 	}
-	async hover(pos) {
-		return this.bridgeFor(pos.path).hover(pos);
+	typeDefinition(pos) {
+		return this.locations(pos, (b) => b.typeDefinition(pos));
 	}
-	async tokenKind(pos) {
-		return this.bridgeFor(pos.path).tokenKind(pos);
+	references(pos) {
+		return this.locations(pos, (b) => b.references(pos));
 	}
-	async references(pos) {
-		return this.bridgeFor(pos.path).references(pos);
+	hover(pos) {
+		return this.fanOut(pos.path, (b) => b.hover(pos), mergeHovers, (r) => r.contents == null);
 	}
 	async occurrences(pos) {
-		return this.bridgeFor(pos.path).occurrences(pos);
+		return this.ownerFor(pos.path).occurrences(pos);
 	}
 	async documentSymbols(path) {
-		return this.bridgeFor(path).documentSymbols(path);
+		return this.ownerFor(path).documentSymbols(path);
 	}
 	/**
-	* Symbols matching `query` from every running server, best `fuzzyRank` match first. One server
-	* failing drops its share; only an outage everywhere is an error.
+	* Symbols matching `query` from every running server, best `fuzzyRank` match first.
+	* Ranked before the cap: servers list loose matches in their own order.
 	*/
 	async workspaceSymbols(query, limit = 200) {
+		if (this.closing) throw new LspUnavailableError("the language servers are shutting down");
 		const bridges = [...this.entries.values()].map((e) => e.bridge);
-		if (!bridges.length) throw new LspUnavailableError(this.why());
-		const results = await Promise.allSettled(bridges.map((b) => b.workspaceSymbols(query, limit)));
-		const out = results.flatMap((r) => r.status === "fulfilled" ? r.value : []);
-		const failed = results.find((r) => r.status === "rejected");
-		if (!out.length && failed) throw failed.reason;
-		return fuzzyRank(out, query, (s) => s.name).slice(0, limit);
+		if (!bridges.length) throw new LspUnavailableError("no language server is running");
+		return union(bridges.map((b) => b.workspaceSymbols(query)), (answers) => ({ symbols: fuzzyRank(answers.flatMap((a) => a.symbols), query, (s) => s.name).slice(0, limit) }), (r) => !r.symbols.length);
 	}
 	/**
-	* Keeps the diff's files open in the server for their language, starting one for each
+	* Keeps the diff's files open in every server for their language, starting one for each
 	* language the diff has newly grown. A server whose language left the diff stays up
-	* with nothing tracked, so its index is warm if the reader switches back.
+	* with nothing tracked, so its index is warm if the reader switches back. Nothing is
+	* tracked when the new side is not the checkout: a server would see text that
+	* contradicts the disk it indexes, and `lspBlocker` refuses queries there anyway.
 	*/
-	track(paths) {
+	track(snap) {
 		if (this.closing) return Promise.resolve();
+		const paths = followsCheckout(snap) ? snap.changed.filter((f) => f.status !== "D" && !f.binary).map((f) => f.path) : [];
 		const byLanguage = /* @__PURE__ */ new Map();
 		for (const path of paths) {
 			const language = languageOf(path);
@@ -14455,23 +15065,38 @@ var LspPool = class {
 		}
 		this.ensure(byLanguage.keys());
 		const entries = [...this.entries.values()];
-		return Promise.all(entries.map((e) => e.bridge.track(e.languages.flatMap((l) => byLanguage.get(l) ?? [])))).then(() => {});
+		return Promise.all(entries.map((e) => e.bridge.track([...e.languages, ...e.joins].flatMap((l) => byLanguage.get(l) ?? [])))).then(() => {});
 	}
 	/** Idempotent: the CLI's dispose can run beside a signal handler's. */
 	close() {
 		this.closing = true;
+		if (this.publishTimer) clearTimeout(this.publishTimer);
+		this.publishTimer = null;
 		return this.closed ??= Promise.all([...this.entries.values()].map((e) => e.bridge.close())).then(() => {});
 	}
-	/** The server for `path`, or an unavailable error naming what is missing. */
-	bridgeFor(path) {
+	/**
+	* Every server for `path`, owner first. A language nothing owns is still served by the
+	* servers joining it. The route has already asked `lspBlocker` why none would answer,
+	* so an empty list here is a race with a snapshot or a shutdown, not a message to word.
+	*/
+	bridgesFor(path) {
 		if (this.closing) throw new LspUnavailableError("the language servers are shutting down");
 		const language = languageOf(path);
-		const bridge = language ? this.byLanguage.get(language) : void 0;
-		if (!bridge) throw new LspUnavailableError(this.why(path));
-		return bridge;
+		const entries = [...this.entries.values()];
+		const bridges = language ? [...entries.filter((e) => e.languages.includes(language)), ...entries.filter((e) => e.joins.includes(language))].map((e) => e.bridge) : [];
+		if (!bridges.length) throw new LspUnavailableError(`no language server for ${path}`);
+		return bridges;
+	}
+	ownerFor(path) {
+		return this.bridgesFor(path)[0];
+	}
+	/** Every server's locations for `pos`, owner first, each place once. */
+	locations(pos, ask) {
+		return this.fanOut(pos.path, ask, mergeLocations, (r) => !r.locations.length);
 	}
-	why(path) {
-		return lspBlocker(this.status(), path) ?? "no language server available";
+	/** Asks every server for `path` at once and merges what they answered (see `union`). */
+	async fanOut(path, ask, merge, empty) {
+		return union(this.bridgesFor(path).map(ask), merge, empty);
 	}
 	/** Resolves and starts servers for languages not seen before. Cheap and idempotent per language. */
 	ensure(languages) {
@@ -14482,19 +15107,24 @@ var LspPool = class {
 		const { servers, missing } = resolveServers(fresh, this.opts.overrides, this.opts.lookup);
 		this.missing.push(...missing);
 		for (const server of servers) {
-			const entry = this.entries.get(server.command) ?? this.spawn(server.command, server.languages);
-			for (const l of server.languages) {
-				if (!entry.languages.includes(l)) entry.languages.push(l);
-				this.byLanguage.set(l, entry.bridge);
-			}
+			const entry = this.entries.get(server.command) ?? this.spawn(server.command);
+			for (const l of server.languages) if (!entry.languages.includes(l)) entry.languages.push(l);
+			for (const l of server.joins) if (!entry.joins.includes(l)) entry.joins.push(l);
 		}
 		if (servers.length || missing.length) this.publish();
 	}
-	spawn(command, languages) {
+	spawn(command) {
+		const definition = definitionOf(command);
+		const ctx = {
+			root: this.opts.root,
+			lookup: this.opts.lookup ?? findOnPath
+		};
 		const entry = {
-			bridge: LspBridge.start({
+			command,
+			bridge: new LspBridge({
 				command,
-				settings: settingsFor(languages, command),
+				settings: definition.settings ? Promise.resolve(definition.settings(ctx)) : void 0,
+				initializationOptions: definition.initializationOptions?.(ctx),
 				root: this.opts.root,
 				read: this.opts.read,
 				has: this.opts.has,
@@ -14502,17 +15132,30 @@ var LspPool = class {
 				spawnProcess: this.opts.spawnProcess,
 				maxOpen: this.opts.maxOpen
 			}),
-			languages: []
+			languages: [],
+			joins: []
 		};
 		this.entries.set(command, entry);
 		return entry;
 	}
 	publish() {
-		if (!this.closing) this.opts.onStatus(this.status());
+		if (this.closing) return;
+		if (this.publishTimer) {
+			this.publishDue = true;
+			return;
+		}
+		this.opts.onStatus(this.status());
+		this.publishTimer = setTimeout(() => {
+			this.publishTimer = null;
+			if (!this.publishDue || this.closing) return;
+			this.publishDue = false;
+			this.publish();
+		}, PUBLISH_MS);
+		this.publishTimer.unref();
 	}
 };
 //#endregion
-//#region src/server/revspec.ts
+//#region src/server/mode/revspec.ts
 /** The uncommitted tree, accepted on either side of a comparison. */
 const WORKTREE = "worktree";
 /**
@@ -17926,7 +18569,7 @@ function imageType(buf) {
 	return null;
 }
 //#endregion
-//#region src/server/routes.ts
+//#region src/server/routes/body.ts
 /** Invalid JSON is a request error; failures after parsing still propagate. */
 async function readJson(c) {
 	try {
@@ -17935,110 +18578,10 @@ async function readJson(c) {
 		throw new HTTPException(400, { message: "invalid JSON body" });
 	}
 }
-function createApi(deps) {
-	const { session, hub } = deps;
-	const app = new Hono();
-	app.onError((err, c) => {
-		if (err instanceof HTTPException) return c.json({ error: err.message }, err.status);
-		if (err instanceof ZodError) return c.json({ error: prettifyError(err) }, 400);
-		if (err instanceof NotFoundError) return c.json({ error: "not found" }, 404);
-		if (err instanceof RevspecError || err instanceof GitError) return c.json({ error: err.message }, 400);
-		if (err instanceof ImportError || err instanceof UnquotableError) return c.json({ error: err.message }, 400);
-		if (err instanceof LspUnavailableError) return c.json({ error: err.message }, 409);
-		if (err instanceof GithubError) return c.json({ error: err.message }, err.status);
-		console.error(err);
-		return c.json({ error: err.message }, 500);
-	});
-	app.use("/api/*", async (c, next) => {
-		if (c.req.path !== "/api/config") await session.ready();
-		await next();
-	});
-	app.get("/api/snapshot", async (c) => c.json(await session.snapshotter.current()));
-	app.get("/api/moved", (c) => c.json(session.moved));
-	app.post("/api/reload", async (c) => c.json(await session.reload()));
-	app.delete("/api/iterations", async (c) => c.json(await session.clearIterations()));
-	app.delete("/api/iterations/:n", async (c) => {
-		const n = Number(c.req.param("n"));
-		if (!Number.isInteger(n) || n < 1) throw new RevspecError(`not an iteration number: ${c.req.param("n")}`);
-		return c.json(await session.deleteIteration(n));
-	});
-	app.post("/api/mode", async (c) => {
-		const req = ModeRequestSchema.parse(await readJson(c));
-		return c.json(await session.switchMode(req));
-	});
-	app.get("/api/github", async (c) => {
-		const snap = await session.snapshotter.current();
-		return c.json(await session.github(snap));
-	});
-	app.get("/api/refs", async (c) => c.json(await session.repo.refs()));
-	app.get("/api/last-commits-preview", async (c) => {
-		const { oldOffset, newOffset } = LastCommitsQuerySchema.parse(c.req.query());
-		return c.json(await session.repo.lastCommitsPreview(oldOffset, newOffset));
-	});
-	app.get("/api/patch", async (c) => {
-		const { path } = PatchQuerySchema.parse(c.req.query());
-		if (!path) return c.text(await session.snapshotter.patchAll());
-		const patch = await session.snapshotter.patch(path);
-		if (patch == null) return c.json({ error: "not a changed file" }, 404);
-		return c.text(patch);
-	});
-	app.post("/api/patch", async (c) => {
-		const { paths } = PatchRequestSchema.parse(await readJson(c));
-		return c.text(await session.snapshotter.patchMany(paths));
-	});
-	app.get("/api/file", async (c) => {
-		const { path, rev } = FileQuerySchema.parse(c.req.query());
-		const snap = await session.snapshotter.current();
-		const buf = await session.readSide(snap, path, rev) ?? (rev === "new" ? await deps.lsp?.readExternal(path) : null);
-		if (buf == null) return c.json({ error: "absent on that side" }, 404);
-		const binary = isBinary(buf);
-		const body = {
-			path,
-			contents: binary ? "" : buf.toString("utf8"),
-			binary
-		};
-		return c.json(body);
-	});
-	app.get("/api/image", async (c) => {
-		const { path, rev, key } = ImageQuerySchema.parse(c.req.query());
-		const buf = await session.readImage(await session.snapshotter.current(), path, rev, key);
-		const type = buf && imageType(buf);
-		if (!type) return c.json({ error: "no image under that key" }, 404);
-		return c.body(new Uint8Array(buf), 200, {
-			"content-type": type,
-			"cache-control": "private, max-age=31536000, immutable",
-			"x-content-type-options": "nosniff",
-			"cross-origin-resource-policy": "same-origin"
-		});
-	});
-	app.get("/api/search", async (c) => {
-		const query = SearchQuerySchema.parse(c.req.query());
-		const { q, scope } = query;
-		const snap = await session.snapshotter.current();
-		let paths = scope === "repo" ? void 0 : scope === "file" ? snap.tree.filter((p) => p === query.path) : snap.changed.filter((f) => f.status !== "D").map((f) => f.path);
-		let ranges;
-		if (query.content === "diff") {
-			const entries = await mapLimit(snap.changed.filter((f) => f.status !== "D" && !f.binary && (!paths || paths.includes(f.path))), 8, async (file) => {
-				const patch = await session.repo.patch(snap.oldSha, snap.newSha, file, snap.context);
-				return [file.path, shownRanges(patch, "new")];
-			});
-			ranges = new Map(entries);
-			paths = entries.filter(([, spans]) => spans.length > 0).map(([path]) => path);
-		}
-		const { matches, truncated } = await session.repo.grep(q, snap.newSha, 500, {
-			word: query.word,
-			ignoreCase: query.i,
-			regex: query.re,
-			paths,
-			ranges
-		});
-		const body = {
-			query: q,
-			matches,
-			truncated
-		};
-		return c.json(body);
-	});
+//#endregion
+//#region src/server/routes/comments.ts
+/** Comment threads, their export to a pending GitHub review, and viewed marks. Each write broadcasts its invalidation. */
+function commentRoutes(app, { session, hub }) {
 	app.get("/api/threads", (c) => {
 		const q = ThreadQuerySchema.parse(c.req.query());
 		q.state ??= "all";
@@ -18118,57 +18661,202 @@ function createApi(deps) {
 		hub.broadcast({ type: "viewed" });
 		return c.json(list);
 	});
+}
+//#endregion
+//#region src/server/routes/lsp.ts
+/** Symbol navigation, answered only while the new side is the checkout the language servers read. */
+function lspRoutes(app, deps) {
+	const { session } = deps;
 	app.get("/api/lsp/status", (c) => c.json(lspStatus(deps)));
-	/** The pool, or a 409 reason: the language server reads the checkout, so the new side must be it. */
-	const lspFor = async (path) => {
-		if (!deps.lsp) return { error: lspBlocker(lspStatus(deps)) ?? "language servers are off" };
+	app.get("/api/lsp/log", (c) => {
+		const { server } = LspLogQuerySchema.parse(c.req.query());
+		const entries = deps.lsp?.log(server);
+		if (entries == null) return c.json({ error: "no such language server" }, 404);
+		return c.json({ entries });
+	});
+	/**
+	* The pool, or the 409 reason `lspBlocker` gives: off, the wrong side, no server, or
+	* not that feature. An advisory query names no feature: a server not offering it
+	* answers nothing, which is no reason to refuse.
+	*/
+	const lspFor = async ({ path, feature }) => {
 		const snap = await session.snapshotter.current();
-		if (!followsCheckout(snap)) return { error: "Symbol navigation needs the new side to be the worktree or the checked-out commit" };
+		const error = lspBlocker(lspStatus(deps), snap, {
+			path,
+			feature,
+			patient: true
+		});
+		if (error != null || !deps.lsp) return { error: error ?? "language servers are off" };
 		if (path != null && !snap.tree.includes(path)) return { error: `${path} is not in the snapshot` };
 		return { lsp: deps.lsp };
 	};
 	app.post("/api/lsp/definition", async (c) => {
 		const pos = LspPositionSchema.parse(await readJson(c));
-		const r = await lspFor(pos.path);
+		const r = await lspFor({
+			path: pos.path,
+			feature: "definition"
+		});
 		if ("error" in r) return c.json({ error: r.error }, 409);
 		return c.json(await r.lsp.definition(pos));
 	});
 	app.post("/api/lsp/type-definition", async (c) => {
 		const pos = LspPositionSchema.parse(await readJson(c));
-		const r = await lspFor(pos.path);
+		const r = await lspFor({
+			path: pos.path,
+			feature: "typeDefinition"
+		});
 		if ("error" in r) return c.json({ error: r.error }, 409);
 		return c.json(await r.lsp.typeDefinition(pos));
 	});
 	app.post("/api/lsp/hover", async (c) => {
 		const pos = LspPositionSchema.parse(await readJson(c));
-		const r = await lspFor(pos.path);
+		const r = await lspFor({
+			path: pos.path,
+			feature: "hover"
+		});
 		if ("error" in r) return c.json({ error: r.error }, 409);
 		return c.json(await r.lsp.hover(pos));
 	});
-	app.post("/api/lsp/token-kind", async (c) => {
-		const pos = LspPositionSchema.parse(await readJson(c));
-		const r = await lspFor(pos.path);
-		if ("error" in r) return c.json({ error: r.error }, 409);
-		return c.json(await r.lsp.tokenKind(pos));
-	});
 	app.post("/api/lsp/references", async (c) => {
 		const pos = LspPositionSchema.parse(await readJson(c));
-		const r = await lspFor(pos.path);
+		const r = await lspFor({
+			path: pos.path,
+			feature: "references"
+		});
 		if ("error" in r) return c.json({ error: r.error }, 409);
 		return c.json(await r.lsp.references(pos));
 	});
 	app.post("/api/lsp/occurrences", async (c) => {
 		const pos = LspPositionSchema.parse(await readJson(c));
-		const r = await lspFor(pos.path);
+		const r = await lspFor({ path: pos.path });
 		if ("error" in r) return c.json({ error: r.error }, 409);
 		return c.json(await r.lsp.occurrences(pos));
 	});
 	app.get("/api/lsp/symbols", async (c) => {
 		const { path, q: query } = SymbolsQuerySchema.parse(c.req.query());
-		const r = await lspFor(path);
+		const r = await lspFor({
+			path,
+			feature: path != null ? "documentSymbol" : "workspaceSymbol"
+		});
 		if ("error" in r) return c.json({ error: r.error }, 409);
 		return c.json(path != null ? await r.lsp.documentSymbols(path) : await r.lsp.workspaceSymbols(query ?? ""));
 	});
+}
+function lspStatus(deps) {
+	return deps.lsp?.status() ?? {
+		enabled: false,
+		servers: [],
+		missing: []
+	};
+}
+//#endregion
+//#region src/server/routes/api.ts
+function createApi(deps) {
+	const { session, hub } = deps;
+	const app = new Hono();
+	app.onError((err, c) => {
+		if (err instanceof HTTPException) return c.json({ error: err.message }, err.status);
+		if (err instanceof ZodError) return c.json({ error: prettifyError(err) }, 400);
+		if (err instanceof NotFoundError) return c.json({ error: "not found" }, 404);
+		if (err instanceof RevspecError || err instanceof GitError) return c.json({ error: err.message }, 400);
+		if (err instanceof ImportError || err instanceof UnquotableError) return c.json({ error: err.message }, 400);
+		if (err instanceof LspUnavailableError) return c.json({ error: err.message }, 409);
+		if (err instanceof GithubError) return c.json({ error: err.message }, err.status);
+		console.error(err);
+		return c.json({ error: err.message }, 500);
+	});
+	app.use("/api/*", async (c, next) => {
+		if (c.req.path !== "/api/config") await session.ready();
+		await next();
+	});
+	app.get("/api/snapshot", async (c) => c.json(await session.snapshotter.current()));
+	app.get("/api/moved", (c) => c.json(session.moved));
+	app.post("/api/reload", async (c) => c.json(await session.reload()));
+	app.delete("/api/iterations", async (c) => c.json(await session.clearIterations()));
+	app.delete("/api/iterations/:n", async (c) => {
+		const n = Number(c.req.param("n"));
+		if (!Number.isInteger(n) || n < 1) throw new RevspecError(`not an iteration number: ${c.req.param("n")}`);
+		return c.json(await session.deleteIteration(n));
+	});
+	app.post("/api/mode", async (c) => {
+		const req = ModeRequestSchema.parse(await readJson(c));
+		return c.json(await session.switchMode(req));
+	});
+	app.get("/api/github", async (c) => {
+		const snap = await session.snapshotter.current();
+		return c.json(await session.github(snap));
+	});
+	app.get("/api/refs", async (c) => c.json(await session.repo.refs()));
+	app.get("/api/last-commits-preview", async (c) => {
+		const { oldOffset, newOffset } = LastCommitsQuerySchema.parse(c.req.query());
+		return c.json(await session.repo.lastCommitsPreview(oldOffset, newOffset));
+	});
+	app.get("/api/patch", async (c) => {
+		const { path } = PatchQuerySchema.parse(c.req.query());
+		if (!path) return c.text(await session.snapshotter.patchAll());
+		const patch = await session.snapshotter.patch(path);
+		if (patch == null) return c.json({ error: "not a changed file" }, 404);
+		return c.text(patch);
+	});
+	app.post("/api/patch", async (c) => {
+		const { paths } = PatchRequestSchema.parse(await readJson(c));
+		return c.text(await session.snapshotter.patchMany(paths));
+	});
+	app.get("/api/file", async (c) => {
+		const { path, rev } = FileQuerySchema.parse(c.req.query());
+		const snap = await session.snapshotter.current();
+		const buf = await session.readSide(snap, path, rev) ?? (rev === "new" ? await deps.lsp?.readExternal(path) : null);
+		if (buf == null) return c.json({ error: "absent on that side" }, 404);
+		const binary = isBinary(buf);
+		const body = {
+			path,
+			contents: binary ? "" : buf.toString("utf8"),
+			binary
+		};
+		return c.json(body);
+	});
+	app.get("/api/image", async (c) => {
+		const { path, rev, key } = ImageQuerySchema.parse(c.req.query());
+		const buf = await session.readImage(await session.snapshotter.current(), path, rev, key);
+		const type = buf && imageType(buf);
+		if (!type) return c.json({ error: "no image under that key" }, 404);
+		return c.body(new Uint8Array(buf), 200, {
+			"content-type": type,
+			"cache-control": "private, max-age=31536000, immutable",
+			"x-content-type-options": "nosniff",
+			"cross-origin-resource-policy": "same-origin"
+		});
+	});
+	app.get("/api/search", async (c) => {
+		const query = SearchQuerySchema.parse(c.req.query());
+		const { q, scope } = query;
+		const snap = await session.snapshotter.current();
+		let paths = scope === "repo" ? void 0 : scope === "file" ? snap.tree.filter((p) => p === query.path) : snap.changed.filter((f) => f.status !== "D").map((f) => f.path);
+		let ranges;
+		if (query.content === "diff") {
+			const entries = await mapLimit(snap.changed.filter((f) => f.status !== "D" && !f.binary && (!paths || paths.includes(f.path))), 8, async (file) => {
+				const patch = await session.repo.patch(snap.oldSha, snap.newSha, file, snap.context);
+				return [file.path, shownRanges(patch, "new")];
+			});
+			ranges = new Map(entries);
+			paths = entries.filter(([, spans]) => spans.length > 0).map(([path]) => path);
+		}
+		const { matches, truncated } = await session.repo.grep(q, snap.newSha, 500, {
+			word: query.word,
+			ignoreCase: query.i,
+			regex: query.re,
+			paths,
+			ranges
+		});
+		const body = {
+			query: q,
+			matches,
+			truncated
+		};
+		return c.json(body);
+	});
+	commentRoutes(app, deps);
+	lspRoutes(app, deps);
 	app.get("/api/config", (c) => c.json(effectiveConfig(deps)));
 	app.put("/api/config", async (c) => {
 		const body = ConfigUpdateSchema.parse(await readJson(c));
@@ -18186,14 +18874,7 @@ function effectiveConfig(deps) {
 	return {
 		...c,
 		autoViewed: [.../* @__PURE__ */ new Set([...c.autoViewed, ...deps.extraAutoViewed])],
-		contextLines: deps.session.context
-	};
-}
-function lspStatus(deps) {
-	return deps.lsp?.status() ?? {
-		enabled: false,
-		servers: [],
-		missing: []
+		contextLines: deps.session.context
 	};
 }
 //#endregion
@@ -18496,7 +19177,7 @@ function parsePullRequest(value) {
 	};
 }
 //#endregion
-//#region src/server/GithubMetadata.ts
+//#region src/server/github/metadata.ts
 const LOOKUP_TIMEOUT_MS = 5e3;
 /**
 * Enriches a comparison without fetching commits, changing its endpoints, or changing comment
@@ -18562,10 +19243,142 @@ async function discoverGithub(repo, snap, { github, prUrl } = {}) {
 	}
 }
 //#endregion
-//#region src/server/github/review.ts
+//#region src/server/github/pendingReview.ts
 function isFileComment(c) {
 	return "subjectType" in c;
 }
+/** The anchor must still match before we rewrite an exported thread. */
+function anchorKey(c) {
+	if (isFileComment(c)) return [c.path, "FILE"].join("\0");
+	return [
+		c.path,
+		c.side,
+		c.startLine ?? c.line,
+		c.line
+	].join("\0");
+}
+const PENDING_QUERY = `query($owner:String!,$repo:String!,$number:Int!){
+  viewer{login}
+  repository(owner:$owner,name:$repo){pullRequest(number:$number){id reviews(last:20,states:[PENDING]){nodes{id author{login}}}}}
+}`;
+/**
+* The PR's node id and the viewer's own pending review on it, or null. GitHub hides other
+* people's pending reviews, and the login check makes sure of it: appending to someone
+* else's draft would put our comments in their review.
+*/
+async function findPendingReview(github, pr) {
+	const { owner, repo } = repoOfPrUrl(pr.url);
+	const data = await github.graphql(PENDING_QUERY, {
+		owner,
+		repo,
+		number: pr.number
+	});
+	const pullRequestId = data.repository?.pullRequest?.id;
+	if (typeof pullRequestId !== "string") throw new GithubError(`cannot read pull request ${pr.url} from GitHub`, 502);
+	const login = data.viewer?.login;
+	for (const node of data.repository?.pullRequest?.reviews?.nodes ?? []) if (node?.id && node.author?.login === login) return {
+		pullRequestId,
+		pending: { id: node.id }
+	};
+	return {
+		pullRequestId,
+		pending: null
+	};
+}
+const THREADS_QUERY = `query($owner:String!,$repo:String!,$number:Int!,$after:String){
+  repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewThreads(first:100,after:$after){
+    pageInfo{hasNextPage endCursor}
+    nodes{path line startLine diffSide subjectType comments(first:1){nodes{id body pullRequestReview{id}}}}
+  }}}
+}`;
+/**
+* The pending review's own comments, by anchor. It has to be `reviewThreads`: it is the only view
+* that reports a *pending* comment's real position — REST's review-comment list leaves `line`,
+* `side` and `start_line` null for one, and the GraphQL comment type has no side field at all.
+* A failed or incomplete lookup aborts the export: absence is safe to infer only from a complete read.
+*/
+async function pendingComments(github, pr, reviewId) {
+	const by = /* @__PURE__ */ new Map();
+	const { owner, repo } = repoOfPrUrl(pr.url);
+	let after = null;
+	for (let page = 0; page < 10; page++) {
+		const threads = (await github.graphql(THREADS_QUERY, {
+			owner,
+			repo,
+			number: pr.number,
+			after
+		})).repository?.pullRequest?.reviewThreads;
+		if (!threads?.nodes || typeof threads.pageInfo?.hasNextPage !== "boolean") throw new GithubError("cannot read the complete pending review", 502);
+		for (const t of threads.nodes) {
+			const c = t?.comments?.nodes?.[0];
+			if (!t?.path || !c?.id || c.pullRequestReview?.id !== reviewId) continue;
+			const key = pendingKey(t);
+			if (key == null) continue;
+			const at = by.get(key);
+			if (at) at.push({
+				nodeId: c.id,
+				body: c.body ?? ""
+			});
+			else by.set(key, [{
+				nodeId: c.id,
+				body: c.body ?? ""
+			}]);
+		}
+		if (!threads.pageInfo.hasNextPage) return by;
+		if (!threads.pageInfo.endCursor || threads.pageInfo.endCursor === after) throw new GithubError("cannot read the next page of the pending review", 502);
+		after = threads.pageInfo.endCursor;
+	}
+	throw new GithubError("pending review exceeds the 1000-thread lookup limit; export stopped without changes", 502);
+}
+/** The anchor key of a thread already in the review, or null for one GitHub reports without a position. */
+function pendingKey(t) {
+	const path = t.path;
+	if (t.subjectType === "FILE") return anchorKey({
+		path,
+		subjectType: "FILE",
+		body: ""
+	});
+	if (t.line == null) return null;
+	return anchorKey({
+		path,
+		side: t.diffSide === "LEFT" ? "LEFT" : "RIGHT",
+		line: t.line,
+		startLine: t.startLine ?? void 0,
+		body: ""
+	});
+}
+const UPDATE_COMMENT = `mutation($input:UpdatePullRequestReviewCommentInput!){updatePullRequestReviewComment(input:$input){pullRequestReviewComment{id}}}`;
+/** Rewrites one comment where it already sits in the pending review. */
+async function updateComment(github, nodeId, body) {
+	await github.graphql(UPDATE_COMMENT, { input: {
+		pullRequestReviewCommentId: nodeId,
+		body
+	} });
+}
+const CREATE_REVIEW = `mutation($input:AddPullRequestReviewInput!){addPullRequestReview(input:$input){pullRequestReview{id}}}`;
+/**
+* No `event` in the input, so GitHub keeps the new review pending with all of its threads.
+* Resolves the review's node id, for the comments a new review cannot carry.
+*/
+async function createPendingReview(github, pullRequestId, commitOID, threads) {
+	const id = (await github.graphql(CREATE_REVIEW, { input: {
+		pullRequestId,
+		commitOID,
+		threads
+	} })).addPullRequestReview?.pullRequestReview?.id;
+	if (typeof id !== "string") throw new GithubError("GitHub did not return the created review", 502);
+	return { id };
+}
+const ADD_THREAD = `mutation($input:AddPullRequestReviewThreadInput!){addPullRequestReviewThread(input:$input){thread{id}}}`;
+/** Appends one thread to the pending review; the only way to extend one, or to place a file comment. */
+async function addToPendingReview(github, reviewId, c) {
+	await github.graphql(ADD_THREAD, { input: {
+		pullRequestReviewId: reviewId,
+		...c
+	} });
+}
+//#endregion
+//#region src/server/github/review.ts
 /**
 * Threads → the comments of one pending GitHub review, one per thread. Stale threads are skipped:
 * their lines no longer sit in the diff, and GitHub would refuse them anyway. With
@@ -18701,10 +19514,7 @@ async function exportToGithub({ snap, pullRequest: pr, threads, threadIds, githu
 				});
 				continue;
 			}
-			await github.graphql(UPDATE_COMMENT, { input: {
-				pullRequestReviewCommentId: hit.nodeId,
-				body: c.body
-			} });
+			await updateComment(github, hit.nodeId, c.body);
 			updated++;
 		}
 		for (const c of add) {
@@ -18727,129 +19537,6 @@ async function exportToGithub({ snap, pullRequest: pr, threads, threadIds, githu
 function threadMarker(id) {
 	return `<!-- diffle-thread:${encodeURIComponent(id)} -->`;
 }
-/** The anchor must still match before we rewrite an exported thread. */
-function anchorKey(c) {
-	if (isFileComment(c)) return [c.path, "FILE"].join("\0");
-	return [
-		c.path,
-		c.side,
-		c.startLine ?? c.line,
-		c.line
-	].join("\0");
-}
-const PENDING_QUERY = `query($owner:String!,$repo:String!,$number:Int!){
-  viewer{login}
-  repository(owner:$owner,name:$repo){pullRequest(number:$number){id reviews(last:20,states:[PENDING]){nodes{id author{login}}}}}
-}`;
-/**
-* The PR's node id and the viewer's own pending review on it, or null. GitHub hides other
-* people's pending reviews, and the login check makes sure of it: appending to someone
-* else's draft would put our comments in their review.
-*/
-async function findPendingReview(github, pr) {
-	const { owner, repo } = repoOfPrUrl(pr.url);
-	const data = await github.graphql(PENDING_QUERY, {
-		owner,
-		repo,
-		number: pr.number
-	});
-	const pullRequestId = data.repository?.pullRequest?.id;
-	if (typeof pullRequestId !== "string") throw new GithubError(`cannot read pull request ${pr.url} from GitHub`, 502);
-	const login = data.viewer?.login;
-	for (const node of data.repository?.pullRequest?.reviews?.nodes ?? []) if (node?.id && node.author?.login === login) return {
-		pullRequestId,
-		pending: { id: node.id }
-	};
-	return {
-		pullRequestId,
-		pending: null
-	};
-}
-const THREADS_QUERY = `query($owner:String!,$repo:String!,$number:Int!,$after:String){
-  repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewThreads(first:100,after:$after){
-    pageInfo{hasNextPage endCursor}
-    nodes{path line startLine diffSide subjectType comments(first:1){nodes{id body pullRequestReview{id}}}}
-  }}}
-}`;
-/**
-* The pending review's own comments, by anchor. It has to be `reviewThreads`: it is the only view
-* that reports a *pending* comment's real position — REST's review-comment list leaves `line`,
-* `side` and `start_line` null for one, and the GraphQL comment type has no side field at all.
-* A failed or incomplete lookup aborts the export: absence is safe to infer only from a complete read.
-*/
-async function pendingComments(github, pr, reviewId) {
-	const by = /* @__PURE__ */ new Map();
-	const { owner, repo } = repoOfPrUrl(pr.url);
-	let after = null;
-	for (let page = 0; page < 10; page++) {
-		const threads = (await github.graphql(THREADS_QUERY, {
-			owner,
-			repo,
-			number: pr.number,
-			after
-		})).repository?.pullRequest?.reviewThreads;
-		if (!threads?.nodes || typeof threads.pageInfo?.hasNextPage !== "boolean") throw new GithubError("cannot read the complete pending review", 502);
-		for (const t of threads.nodes) {
-			const c = t?.comments?.nodes?.[0];
-			if (!t?.path || !c?.id || c.pullRequestReview?.id !== reviewId) continue;
-			const key = pendingKey(t);
-			if (key == null) continue;
-			const at = by.get(key);
-			if (at) at.push({
-				nodeId: c.id,
-				body: c.body ?? ""
-			});
-			else by.set(key, [{
-				nodeId: c.id,
-				body: c.body ?? ""
-			}]);
-		}
-		if (!threads.pageInfo.hasNextPage) return by;
-		if (!threads.pageInfo.endCursor || threads.pageInfo.endCursor === after) throw new GithubError("cannot read the next page of the pending review", 502);
-		after = threads.pageInfo.endCursor;
-	}
-	throw new GithubError("pending review exceeds the 1000-thread lookup limit; export stopped without changes", 502);
-}
-/** The anchor key of a thread already in the review, or null for one GitHub reports without a position. */
-function pendingKey(t) {
-	const path = t.path;
-	if (t.subjectType === "FILE") return anchorKey({
-		path,
-		subjectType: "FILE",
-		body: ""
-	});
-	if (t.line == null) return null;
-	return anchorKey({
-		path,
-		side: t.diffSide === "LEFT" ? "LEFT" : "RIGHT",
-		line: t.line,
-		startLine: t.startLine ?? void 0,
-		body: ""
-	});
-}
-const UPDATE_COMMENT = `mutation($input:UpdatePullRequestReviewCommentInput!){updatePullRequestReviewComment(input:$input){pullRequestReviewComment{id}}}`;
-const CREATE_REVIEW = `mutation($input:AddPullRequestReviewInput!){addPullRequestReview(input:$input){pullRequestReview{id}}}`;
-/**
-* No `event` in the input, so GitHub keeps the new review pending with all of its threads.
-* Resolves the review's node id, for the comments a new review cannot carry.
-*/
-async function createPendingReview(github, pullRequestId, commitOID, threads) {
-	const id = (await github.graphql(CREATE_REVIEW, { input: {
-		pullRequestId,
-		commitOID,
-		threads
-	} })).addPullRequestReview?.pullRequestReview?.id;
-	if (typeof id !== "string") throw new GithubError("GitHub did not return the created review", 502);
-	return { id };
-}
-const ADD_THREAD = `mutation($input:AddPullRequestReviewThreadInput!){addPullRequestReviewThread(input:$input){thread{id}}}`;
-/** Appends one thread to the pending review; the only way to extend one, or to place a file comment. */
-async function addToPendingReview(github, reviewId, c) {
-	await github.graphql(ADD_THREAD, { input: {
-		pullRequestReviewId: reviewId,
-		...c
-	} });
-}
 function describe(skipped) {
 	const counts = /* @__PURE__ */ new Map();
 	for (const s of skipped) counts.set(s.reason, (counts.get(s.reason) ?? 0) + 1);
@@ -18952,7 +19639,7 @@ async function read(file) {
 	}
 }
 //#endregion
-//#region src/server/rangediff.ts
+//#region src/server/mode/rangediff.ts
 /**
 * The mode that compares `older` with `newer`: `older`'s head replayed onto `newer`'s base against
 * `newer`'s head, so only what the series itself changed in between shows, with the two ranges'
@@ -19013,7 +19700,7 @@ async function pairRanges(repo, older, newer) {
 	}));
 }
 //#endregion
-//#region src/server/mode.ts
+//#region src/server/mode/resolve.ts
 /**
 * Resolves a comparison to Git endpoints for initial mode setup, PR setup after
 * fetching, and snapshot refreshes. Revisions become full hashes; "worktree"
@@ -24064,7 +24751,8 @@ program.command("lsp").description("show the language server each language would
 	const { servers, missing } = resolveServers(LANGUAGE_IDS, lspCommands);
 	const answer = /* @__PURE__ */ new Map();
 	for (const s of servers) for (const language of s.languages) answer.set(language, `${s.command}${lspCommands[language] == null ? "" : c.dim(" (config)")}`);
-	for (const m of missing) answer.set(m.language, c.dim(m.tried.length ? `not on PATH (tried ${m.tried.join(", ")})` : "off in config"));
+	for (const m of missing) answer.set(m.language, c.dim(m.why ?? (m.tried.length ? `not on PATH (tried ${m.tried.join(", ")})` : "off in config")));
+	for (const s of servers) for (const language of s.joins) answer.set(language, `${answer.get(language) ?? ""} ${c.dim("+")} ${s.command}`);
 	const width = Math.max(...LANGUAGE_IDS.map((l) => l.length));
 	for (const language of LANGUAGE_IDS) console.log(`${language.padEnd(width)}  ${answer.get(language) ?? ""}`);
 });
@@ -24181,7 +24869,7 @@ async function serve(req, opts, repo, closeRepo, config, github, timing) {
 		if (snap.mode.live !== "none") console.error(`👀 ${c.dim(snap.mode.live === "worktree" ? "watching the worktree" : session.follows ? "watching refs" : "watching refs; moved refs show a Reload button")}${opts.watch ? "" : c.dim(" (disabled with --no-watch)")}`);
 		if (lsp) {
 			const { servers, missing } = lsp.status();
-			const names = servers.map((s) => `${s.name} ${c.dim(`(${s.languages.join(", ")})`)}`).join(", ");
+			const names = servers.map((s) => `${s.name} ${c.dim(`(${languagesLabel(s)})`)}`).join(", ");
 			if (!followsCheckout(snap)) console.error(`🧭 ${c.dim("no language server: symbol navigation needs the new side to be the checkout")}`);
 			else console.error(`🧭 ${c.dim("lsp")} ${names || c.dim("no language server for this diff")}`);
 			for (const m of missing.filter((m) => m.tried.length)) console.error(`${c.yellow("!")} no ${m.language} language server ${c.dim(`(tried ${m.tried.join(", ")})`)}`);
@@ -24207,17 +24895,11 @@ async function connectGithub() {
 }
 /**
 * The pool reads new-side text through the session, so the snapshot allowlist applies to
-* every LSP path. Each snapshot decides which languages run: it re-opens the diff's files
-* in the server for their language, so references in them are found from the reviewed text
-* (see LspPool.track). Nothing starts when the new side is not the checkout: the client
-* refuses symbol navigation there, and a server would otherwise see text that contradicts
-* the disk it indexes.
+* every LSP path. Each snapshot decides which languages run and which files the servers
+* hold open (see LspPool.track).
 */
 function startLsp(repo, session, hub, overrides, preload) {
-	session.onSnapshot((snap) => {
-		const paths = followsCheckout(snap) ? snap.changed.filter((f) => f.status !== "D" && !f.binary).map((f) => f.path) : [];
-		lsp.track(paths);
-	});
+	session.onSnapshot((snap) => void lsp.track(snap));
 	const reported = /* @__PURE__ */ new Map();
 	const lsp = new LspPool({
 		root: repo.root,