@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/lsp/server.js

@@ -0,0 +1,4301 @@
+import {
+  USAGE_COUNT_UNIT_LABEL,
+  USAGE_SITE_FILTER_LABEL,
+  countUnresolvedNameMatches,
+  isDeclarationRelationship,
+  isUsageSiteRow,
+  usageSites
+} from "../chunk-GBI7V7KY.js";
+import {
+  TypeInference
+} from "../chunk-7DRPNVIN.js";
+import {
+  UNRESOLVED_TYPE,
+  crossLanguageSection,
+  factsFromRows,
+  parseParameters,
+  renderSignature,
+  storedCrossLanguageRows
+} from "../chunk-RM3PY6TG.js";
+import {
+  classifyStoredRow,
+  orderTiers,
+  primaryTier
+} from "../chunk-RCMTFSEF.js";
+import {
+  ADDRESS_NOTES,
+  STORED_LINE_SELECT,
+  addressLine0,
+  deriveCallSiteAddress,
+  isExactAddress,
+  storedLineFromRow,
+  traverseGraph
+} from "../chunk-ENW4BTBA.js";
+import {
+  isCommentNodeType,
+  isIdentifierNodeType,
+  parseForSafety
+} from "../chunk-5BVAH26D.js";
+import {
+  getProjectId
+} from "../chunk-DIYAGQJL.js";
+import "../chunk-UUNHHX4M.js";
+import {
+  BACKBENCHER_BRAIN_VERSION
+} from "../chunk-WIG36E67.js";
+import {
+  checkFileFreshness,
+  hashFileContent
+} from "../chunk-QLK6ED4Q.js";
+import {
+  BrainDatabase
+} from "../chunk-QKTRECYS.js";
+import {
+  ASTEngine
+} from "../chunk-3ZTOHHSW.js";
+import "../chunk-BQ3OVQ3P.js";
+import "../chunk-SK6YVHFZ.js";
+import "../chunk-2BSKD7O3.js";
+import "../chunk-KAET47ZL.js";
+import "../chunk-KCDECRJY.js";
+import "../chunk-SM7RFQRO.js";
+import "../chunk-L5TDYKYK.js";
+import "../chunk-ROMM6KMC.js";
+import "../chunk-MLKGABMK.js";
+
+// src/lsp/server.ts
+import path2 from "path";
+import { realpathSync, appendFileSync } from "fs";
+
+// src/lsp/document_highlight.ts
+import { readFileSync as readFileSync5 } from "fs";
+
+// src/lsp/hover.ts
+import { readFileSync as readFileSync4 } from "fs";
+
+// src/lsp/positions.ts
+var PositionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PositionError";
+  }
+};
+function resolveRowByteColumns(sourceText, line, byte, linesIn) {
+  if (!Number.isInteger(line) || line < 1 || !Number.isInteger(byte) || byte < 0) return null;
+  const lines = linesIn ?? sourceText.split("\n");
+  if (line > lines.length) return null;
+  if (byte === 0) return line === 1 ? { line: 1, column: 1 } : null;
+  const line0 = line - 1;
+  const lineByteLen = Buffer.byteLength(lines[line0], "utf8");
+  if (byte <= lineByteLen + 1) return { line, column: byte };
+  let cumStart = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const len = Buffer.byteLength(lines[i], "utf8") + 1;
+    if (byte >= cumStart && byte < cumStart + len) {
+      const col = byte - cumStart + 1;
+      if (col <= Buffer.byteLength(lines[i], "utf8") + 1) return { line: i + 1, column: col };
+      return null;
+    }
+    cumStart += len;
+  }
+  return null;
+}
+var PositionMapper = class {
+  /** 0-based line -> UTF-16 code unit length of that line (excluding terminator) */
+  lineUtf16Lengths;
+  /** 0-based line -> byte length of that line (excluding terminator) */
+  lineByteLengths;
+  /** 0-based line -> the line's text (excluding terminator) */
+  lineTexts;
+  constructor(sourceText) {
+    this.lineTexts = sourceText.split(/\r\n|\r|\n/);
+    this.lineUtf16Lengths = this.lineTexts.map((line) => line.length);
+    this.lineByteLengths = this.lineTexts.map((line) => Buffer.byteLength(line, "utf8"));
+  }
+  assertLine(line0) {
+    if (!Number.isInteger(line0) || line0 < 0 || line0 >= this.lineTexts.length) {
+      throw new PositionError(`line ${line0} out of range (0..${this.lineTexts.length - 1})`);
+    }
+  }
+  /**
+   * Convert a byte offset within a line to a UTF-16 code unit offset.
+   * The byte offset must land on a code point boundary.
+   */
+  byteOffsetToUtf16Offset(line0, byteOffset) {
+    this.assertLine(line0);
+    const text = this.lineTexts[line0];
+    const byteLen = this.lineByteLengths[line0];
+    if (!Number.isInteger(byteOffset) || byteOffset < 0 || byteOffset > byteLen) {
+      throw new PositionError(`byte offset ${byteOffset} out of range (0..${byteLen}) on line ${line0 + 1}`);
+    }
+    if (byteOffset === 0) return 0;
+    if (byteOffset === byteLen) return text.length;
+    const buf = Buffer.from(text, "utf8");
+    if ((buf[byteOffset] & 192) === 128) {
+      throw new PositionError(`byte offset ${byteOffset} on line ${line0 + 1} lands mid-code-point`);
+    }
+    return buf.subarray(0, byteOffset).toString("utf8").length;
+  }
+  /**
+   * Convert a UTF-16 code unit offset within a line to a byte offset.
+   * A low-surrogate offset is not a character start — fail rather than guess.
+   */
+  utf16OffsetToByteOffset(line0, utf16Offset) {
+    this.assertLine(line0);
+    const text = this.lineTexts[line0];
+    const utf16Len = this.lineUtf16Lengths[line0];
+    if (!Number.isInteger(utf16Offset) || utf16Offset < 0 || utf16Offset > utf16Len) {
+      throw new PositionError(`utf16 offset ${utf16Offset} out of range (0..${utf16Len}) on line ${line0 + 1}`);
+    }
+    if (utf16Offset === 0) return 0;
+    if (utf16Offset === utf16Len) return this.lineByteLengths[line0];
+    const unit = text.charCodeAt(utf16Offset);
+    if (unit >= 56320 && unit <= 57343) {
+      throw new PositionError(`utf16 offset ${utf16Offset} on line ${line0 + 1} lands on a surrogate trailing half`);
+    }
+    return Buffer.byteLength(text.slice(0, utf16Offset), "utf8");
+  }
+  indexToLsp(pos) {
+    if (!Number.isInteger(pos.line) || pos.line < 1) {
+      throw new PositionError(`index line must be >= 1, got ${pos.line}`);
+    }
+    if (!Number.isInteger(pos.column) || pos.column < 1) {
+      throw new PositionError(`index column must be >= 1, got ${pos.column}`);
+    }
+    const line0 = pos.line - 1;
+    const character = this.byteOffsetToUtf16Offset(line0, pos.column - 1);
+    return { line: line0, character };
+  }
+  lspToIndex(pos) {
+    if (!Number.isInteger(pos.line) || pos.line < 0) {
+      throw new PositionError(`LSP line must be >= 0, got ${pos.line}`);
+    }
+    if (!Number.isInteger(pos.character) || pos.character < 0) {
+      throw new PositionError(`LSP character must be >= 0, got ${pos.character}`);
+    }
+    const line0 = pos.line;
+    const byteOffset = this.utf16OffsetToByteOffset(line0, pos.character);
+    return { line: line0 + 1, column: byteOffset + 1 };
+  }
+  indexRangeToLsp(range) {
+    return {
+      start: this.indexToLsp(range.start),
+      end: this.indexToLsp(range.end)
+    };
+  }
+  lspRangeToIndex(range) {
+    return {
+      start: this.lspToIndex(range.start),
+      end: this.lspToIndex(range.end)
+    };
+  }
+};
+function createPositionMapper(sourceText) {
+  const mapper = new PositionMapper(sourceText);
+  return Object.assign(mapper, { get lineCount() {
+    return mapper.lineTexts.length;
+  } });
+}
+
+// src/lsp/annotation_ui.ts
+function escapeAnnotationText(text) {
+  return text.replace(/[\r\n\u2028\u2029]+/g, " ").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function formatAnnotationTime(epochMs) {
+  return new Date(epochMs).toISOString().slice(0, 10);
+}
+function annotationHoverSection(rows) {
+  if (!Array.isArray(rows) || rows.length === 0) return "";
+  const lines = ["**notes** (agent/human annotations \u2014 provenance recorded, not index-derived):"];
+  for (const row of rows) {
+    const who = `${escapeAnnotationText(row.author_class)} note by ${escapeAnnotationText(row.tool_identity)}`;
+    const when = formatAnnotationTime(row.time_updated);
+    const scope = row.symbol_path === null || row.symbol_path === void 0 ? "name-level" : "this file";
+    lines.push(`- [${who}, ${when}, ${scope}]: ${escapeAnnotationText(row.body)}`);
+  }
+  return lines.join("\n");
+}
+
+// src/lsp/doc_comment.ts
+function stripCommentMarkup(raw) {
+  const lines = raw.split("\n");
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    let l = lines[i].replace(/\r$/, "");
+    if (i === 0) l = l.replace(/^\s*\/\*+\s?/, "").replace(/^\s*#+\s?/, "").replace(/^\s*--+\s?/, "");
+    if (i === lines.length - 1) l = l.replace(/\s?\*+\/\s*$/, "");
+    l = l.replace(/^\s*\*\s?/, "");
+    l = l.replace(/^\s*\/\/\/\s?/, "");
+    l = l.replace(/^\s*#\s?/, "");
+    out.push(l.replace(/\s+$/, ""));
+  }
+  while (out.length > 0 && out[0].trim() === "") out.shift();
+  while (out.length > 0 && out[out.length - 1].trim() === "") out.pop();
+  return out.join("\n").trim();
+}
+
+// src/lsp/hover_cache.ts
+var CACHE_BYTE_CEILING = 4 * 1024 * 1024;
+var CACHE_ENTRY_CEILING = 8;
+var EXCLUDED_LANGUAGES = {
+  lua: "ASTEngine.parseRaw gives lua a private parser and grammar per parse so external-scanner state cannot leak between files (engine.ts parseRaw); a retained lua tree would carry that state into the next request"
+};
+var entries = /* @__PURE__ */ new Map();
+var retainedBytes = 0;
+var tick = 0;
+var hits = 0;
+var misses = 0;
+var bypasses = 0;
+var evictionsBytes = 0;
+var evictionsEntries = 0;
+function cacheStats() {
+  return {
+    entries: entries.size,
+    retainedBytes,
+    byteCeiling: CACHE_BYTE_CEILING,
+    entryCeiling: CACHE_ENTRY_CEILING,
+    hits,
+    misses,
+    bypasses,
+    evictionsBytes,
+    evictionsEntries,
+    excludedLanguages: { ...EXCLUDED_LANGUAGES }
+  };
+}
+function evict() {
+  while (entries.size > CACHE_ENTRY_CEILING || retainedBytes > CACHE_BYTE_CEILING) {
+    let oldestKey = null;
+    let oldest = Number.POSITIVE_INFINITY;
+    for (const [k, v] of entries) {
+      if (v.lastUsed < oldest) {
+        oldest = v.lastUsed;
+        oldestKey = k;
+      }
+    }
+    if (oldestKey === null) break;
+    const dropped = entries.get(oldestKey);
+    try {
+      if (dropped.tree && typeof dropped.tree.delete === "function") dropped.tree.delete();
+    } catch {
+    }
+    entries.delete(oldestKey);
+    retainedBytes -= dropped.bytes;
+    if (retainedBytes < 0) retainedBytes = 0;
+    if (entries.size > CACHE_ENTRY_CEILING) evictionsEntries++;
+    else evictionsBytes++;
+  }
+}
+async function parseForCursor(filePath, content) {
+  const contentHash = hashFileContent(content);
+  const bytes = Buffer.byteLength(content, "utf8");
+  const detected = languageFor(filePath, content);
+  if (detected !== null && EXCLUDED_LANGUAGES[detected] !== void 0) {
+    bypasses++;
+    return guardedParse(filePath, content, contentHash, bytes, "cache-bypass");
+  }
+  const entry = entries.get(contentHash);
+  if (entry !== void 0) {
+    hits++;
+    tick++;
+    entry.lastUsed = tick;
+    return { tree: entry.tree, language: entry.language, source: "cache-hit", contentHash, bytes, cache: cacheStats() };
+  }
+  misses++;
+  return guardedParse(filePath, content, contentHash, bytes, "fresh");
+}
+var ParseUnavailable = class extends Error {
+  /** Why the file could not be parsed, verbatim from the engine. */
+  reason;
+  constructor(reason) {
+    super(`the file could not be parsed: ${reason}`);
+    this.name = "ParseUnavailable";
+    this.reason = reason;
+  }
+};
+async function guardedParse(filePath, content, contentHash, bytes, source) {
+  let parsed;
+  try {
+    parsed = await ASTEngine.parseTree(filePath, content);
+  } catch (error) {
+    throw new ParseUnavailable(error instanceof Error ? error.message : String(error));
+  }
+  const { language, tree } = parsed;
+  if (source === "fresh") {
+    entries.set(contentHash, { hash: contentHash, language, bytes, tree, lastUsed: ++tick });
+    retainedBytes += bytes;
+    evict();
+  }
+  return { tree, language, source, contentHash, bytes, cache: cacheStats() };
+}
+function languageFor(filePath, content) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  if (ext === ".lua") return "lua";
+  if (content.startsWith("#!")) return "lua";
+  return null;
+}
+function occurrenceAtPoint(tree, line, byteColumn) {
+  if (!Number.isInteger(line) || line < 1 || !Number.isInteger(byteColumn) || byteColumn < 1) return null;
+  let node = tree.rootNode.descendantForPosition({ row: line - 1, column: byteColumn - 1 });
+  while (node !== null && node !== void 0) {
+    const type = node.type;
+    if (!isCommentNodeType(type) && node.isNamed && isIdentifierNodeType(type) && node.namedChildCount === 0) {
+      const text = String(node.text ?? "");
+      if (text.length > 0) {
+        return {
+          text,
+          startLine: node.startPosition.row + 1,
+          startColumn: node.startPosition.column + 1,
+          endColumn: node.endPosition.column + 1
+        };
+      }
+    }
+    node = node.parent;
+  }
+  return null;
+}
+function docCommentAt(tree, declarationLine) {
+  if (!tree || declarationLine === null || declarationLine === void 0) return "";
+  const targetRow = declarationLine - 2;
+  if (targetRow < 0) return "";
+  let found = null;
+  const visit = (n) => {
+    if (found !== null || n === null || n === void 0) return;
+    const startRow = Number(n.startPosition?.row ?? 0);
+    const endRow = Number(n.endPosition?.row ?? 0);
+    if (startRow > targetRow || endRow < targetRow) return;
+    if (isCommentNodeType(String(n.type))) {
+      if (endRow === targetRow) found = stripCommentMarkup(String(n.text ?? ""));
+      return;
+    }
+    const kids = n.children ?? [];
+    for (let i = 0; i < kids.length; i++) visit(kids[i]);
+  };
+  visit(tree.rootNode);
+  return found ?? "";
+}
+
+// src/lsp/type_inference_surface.ts
+import { readFileSync } from "fs";
+var ENGINE_CONFIDENCE_FLOOR = 0.9;
+var MAX_WITNESS_BYTES = 48 * 1024;
+var STRING_NODES = /* @__PURE__ */ new Set([
+  "string",
+  "string_literal",
+  "template_string",
+  "string_fragment",
+  "raw_string",
+  "verbatim_string_literal",
+  "interpolated_string_expression",
+  "char_literal"
+]);
+var NUMBER_NODES = /* @__PURE__ */ new Set([
+  "number",
+  "integer_literal",
+  "float_literal",
+  "decimal_integer_literal",
+  "decimal_floating_point_literal",
+  "hex_integer_literal",
+  "int_literal",
+  "float_literal_node",
+  "integer"
+]);
+var BOOLEAN_NODES = /* @__PURE__ */ new Set(["true", "false", "boolean", "bool_literal", "true_literal", "false_literal"]);
+var RETURN_NODES = /* @__PURE__ */ new Set(["return_statement", "return_expression", "return_token", "yield_statement"]);
+var CALLABLE_NODES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function_definition",
+  "function_item",
+  "method_declaration",
+  "method_definition",
+  "method",
+  "constructor_declaration",
+  "singleton_method",
+  "arrow_function",
+  "function_expression",
+  "function",
+  "def",
+  "defn",
+  "fn",
+  "func",
+  "local_function_statement",
+  "function_signature",
+  "subroutine"
+]);
+var ENGINE_DECL_TYPES = [
+  "variable_declaration",
+  "let_declaration",
+  "const_declaration",
+  "var_declaration",
+  "local_variable_declaration",
+  "assignment_statement"
+];
+var ENGINE_FUNC_TYPES = [
+  "function_declaration",
+  "function_definition",
+  "method_declaration",
+  "def",
+  "defn",
+  "fn",
+  "func"
+];
+function literalKindOf(node) {
+  if (node === null || node === void 0) return "valueless";
+  const t = node.type;
+  if (STRING_NODES.has(t)) return "string";
+  if (NUMBER_NODES.has(t)) return "number";
+  if (BOOLEAN_NODES.has(t)) return "boolean";
+  return null;
+}
+function kindForCandidate(candidate) {
+  const c = candidate.trim();
+  const table = {
+    string: "string",
+    String: "string",
+    number: "number",
+    int: "number",
+    long: "number",
+    double: "number",
+    float: "number",
+    i32: "number",
+    i64: "number",
+    f32: "number",
+    f64: "number",
+    decimal: "number",
+    boolean: "boolean",
+    bool: "boolean"
+  };
+  return Object.prototype.hasOwnProperty.call(table, c) ? table[c] : null;
+}
+function collectFacts(root) {
+  const nodeTypes = /* @__PURE__ */ new Set();
+  const callables = [];
+  const returns = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    nodeTypes.add(n.type);
+    if (CALLABLE_NODES.has(n.type)) callables.push(n);
+    if (RETURN_NODES.has(n.type)) {
+      const value = n.childForFieldName?.("expression") ?? n.childForFieldName?.("value") ?? n.childForFieldName?.("result") ?? n.namedChildren?.find((c) => c !== null && c.type !== "return" && c.type !== "yield") ?? null;
+      returns.push({ kind: literalKindOf(value), node: n });
+    }
+    const children = n.children ?? [];
+    for (let i = children.length - 1; i >= 0; i--) if (children[i]) stack.push(children[i]);
+  }
+  return { nodeTypes, callables, returns };
+}
+function locateByStoredRange(callables, lineStart, lineEnd) {
+  let best = null;
+  let bestWidth = Number.MAX_SAFE_INTEGER;
+  for (const n of callables) {
+    const s = n.startPosition.row + 1;
+    const e = n.endPosition.row + 1;
+    if (s > lineStart || e < lineEnd) continue;
+    const width = e - s;
+    if (width < bestWidth) {
+      bestWidth = width;
+      best = n;
+    }
+  }
+  return best;
+}
+function storedReturnType(raw) {
+  const t = (raw ?? "").trim();
+  return t === "" ? null : t;
+}
+function unknownLine(reason, withheld, engine, witness = null) {
+  return {
+    provenance: "unknown",
+    text: UNRESOLVED_TYPE,
+    confidence: null,
+    reason,
+    withheld,
+    withheldText: engine === null ? null : engine.name,
+    storedProvenanceUnknown: false,
+    stale: false,
+    witness
+  };
+}
+function renderTypeLine(line) {
+  const staleMark = line.stale && line.provenance !== "unknown" ? " \u26A0\uFE0F stale" : "";
+  if (line.provenance === "inferred") {
+    const conf = line.confidence === null ? "n/a" : String(line.confidence);
+    return `type: ${line.text} _(inferred \xB7 engine confidence ${conf} \xB7 ${line.reason})_${staleMark}`;
+  }
+  if (line.provenance === "stored") {
+    const origin = line.storedProvenanceUnknown ? "its explicit-vs-inferred origin is not recorded" : "origin recorded";
+    return `type: ${line.text} _(stored in the bb index \xB7 ${origin})_${staleMark}`;
+  }
+  return `type: ${line.text} _(not resolved \u2014 ${line.reason})_`;
+}
+async function resolveTypeLine(filePath, content, symbol, raw) {
+  const stored = storedReturnType(raw);
+  const language = symbol.language ?? null;
+  if (!CALLABLE_SYMBOL_TYPES.has((symbol.symbol_type ?? "").toLowerCase())) {
+    return {
+      line: unknownLine("not a callable symbol; no return type exists to report", "not-a-function-symbol", null),
+      engine: null,
+      engineCoverage: { language: language ?? "unknown", covered: false, matchedNodeTypes: [] }
+    };
+  }
+  if (symbol.line_start === null || symbol.line_end === null) {
+    return {
+      line: unknownLine("the index stored no line range for this symbol, so nothing can be witnessed", "symbol-not-locatable-in-tree", null),
+      engine: null,
+      engineCoverage: { language: language ?? "unknown", covered: false, matchedNodeTypes: [] }
+    };
+  }
+  if (stored !== null) {
+    return {
+      line: {
+        provenance: "stored",
+        text: stored,
+        confidence: null,
+        reason: "type as stored in the index; the index records no marker of whether the analyzer read it from an explicit annotation or inferred it, so its own provenance is unstated",
+        withheld: null,
+        withheldText: null,
+        // Declared, measured: the column mixes explicit and inferred values
+        // indistinguishably. Reported on the wire, never resolved by guessing.
+        storedProvenanceUnknown: true,
+        stale: false,
+        witness: null
+      },
+      engine: null,
+      engineCoverage: { language: language ?? "unknown", covered: false, matchedNodeTypes: [] }
+    };
+  }
+  return await inferWithWitness(filePath, content, symbol, language, symbol.line_start, symbol.line_end);
+}
+var CALLABLE_SYMBOL_TYPES = /* @__PURE__ */ new Set([
+  "function",
+  "method",
+  "constructor",
+  "procedure",
+  "subroutine",
+  "getter",
+  "setter"
+]);
+async function inferWithWitness(filePath, content, symbol, language, symStart, symEnd) {
+  let facts = null;
+  let engineTypes = null;
+  let tree = null;
+  if (Buffer.byteLength(content, "utf8") > MAX_WITNESS_BYTES) {
+    const kib = (Buffer.byteLength(content, "utf8") / 1024).toFixed(0);
+    return {
+      line: unknownLine(
+        `the file is ${kib} KiB, over the declared ${MAX_WITNESS_BYTES / 1024} KiB ceiling for witnessing (measured: p95 rises past the 50 ms hover budget above that size), so no type was inferred`,
+        "file-too-large-for-witness",
+        null
+      ),
+      engine: null,
+      engineCoverage: { language: language ?? "unknown", covered: false, matchedNodeTypes: [] }
+    };
+  }
+  try {
+    const parsed = await ASTEngine.parseTree(filePath, content);
+    tree = parsed.tree;
+    facts = collectFacts(tree.rootNode);
+    const engine = new TypeInference.TypeInferenceEngine();
+    engineTypes = engine.inferTypesForFile(tree.rootNode, content, filePath, language ?? "unknown");
+  } catch {
+    tree?.delete?.();
+    return {
+      line: unknownLine("the file could not be parsed, so no type was witnessed", "parse-failed", null),
+      engine: null,
+      engineCoverage: { language: language ?? "unknown", covered: false, matchedNodeTypes: [] }
+    };
+  }
+  try {
+    const matched = [...facts.nodeTypes].filter(
+      (t) => ENGINE_FUNC_TYPES.includes(t) || ENGINE_DECL_TYPES.includes(t)
+    );
+    const coverage = { language: language ?? "unknown", covered: matched.length > 0, matchedNodeTypes: matched.sort() };
+    const candidate = engineTypes.get(`${symbol.name}:return`);
+    const answer = candidate === void 0 ? null : { name: candidate.name, confidence: candidate.confidence, kind: candidate.kind, inferredAtCount: candidate.inferredAt.length };
+    if (!coverage.covered) {
+      return {
+        line: unknownLine(
+          `the inference engine has no node-type coverage for ${coverage.language}; it returned nothing rather than a type`,
+          "language-not-covered",
+          answer
+        ),
+        engine: answer,
+        engineCoverage: coverage
+      };
+    }
+    if (answer === null) {
+      return {
+        line: unknownLine("the engine returned no entry for this function; no type is asserted", "no-engine-answer", null),
+        engine: null,
+        engineCoverage: coverage
+      };
+    }
+    const node = locateByStoredRange(facts.callables, symStart, symEnd);
+    if (node === null) {
+      return {
+        line: unknownLine("no callable node in the tree contains this symbol's stored line range", "symbol-not-locatable-in-tree", answer),
+        engine: answer,
+        engineCoverage: coverage
+      };
+    }
+    const own = facts.returns.filter((r) => {
+      const s = r.node.startPosition.row + 1;
+      const e = r.node.endPosition.row + 1;
+      return s >= node.startPosition.row + 1 && e <= node.endPosition.row + 1;
+    });
+    const kinds = [...new Set(own.map((r) => r.kind).filter((k) => k !== null))].sort();
+    const witness = {
+      nodeType: node.type,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      returnExpressionsSeen: own.length,
+      returnKinds: kinds,
+      corroborated: false
+    };
+    const isVoidCandidate = answer.name === "void" || answer.kind === TypeInference.TypeKind.Void;
+    const hasValuelessReturn = own.length > 0 && own.every((r) => r.kind === "valueless");
+    const annotatesVoid = /(^|[^A-Za-z0-9_])(void|Unit)($|[^A-Za-z0-9_])/.test(stripDeclarationHead(node.text));
+    if (isVoidCandidate && !(hasValuelessReturn || annotatesVoid)) {
+      return {
+        line: unknownLine(
+          "the engine answered `void` at high confidence, but the tree shows no valueless return and no explicit void annotation \u2014 that answer means the grammar's return form was not recognized, so it is withheld",
+          "engine-reported-void-without-valueless-return",
+          answer,
+          witness
+        ),
+        engine: answer,
+        engineCoverage: coverage
+      };
+    }
+    if (isVoidCandidate && (hasValuelessReturn || annotatesVoid)) {
+      witness.corroborated = true;
+      return {
+        line: {
+          provenance: "inferred",
+          text: answer.name,
+          confidence: answer.confidence,
+          reason: `witnessed in the tree: ${witness.returnExpressionsSeen} valueless return expression(s) at ${witness.nodeType}`,
+          withheld: null,
+          withheldText: null,
+          storedProvenanceUnknown: false,
+          stale: false,
+          witness
+        },
+        engine: answer,
+        engineCoverage: coverage
+      };
+    }
+    const wanted = kindForCandidate(answer.name);
+    if (wanted === null) {
+      return {
+        line: unknownLine(
+          `the engine proposed \`${answer.name}\`, which is outside the narrow proven subset (a bare primitive literal type only)`,
+          "no-witness-in-tree",
+          answer,
+          witness
+        ),
+        engine: answer,
+        engineCoverage: coverage
+      };
+    }
+    if (kinds.length !== 1 || kinds[0] !== wanted) {
+      return {
+        line: unknownLine(
+          `the engine proposed \`${answer.name}\` but the tree's return expressions read ${kinds.length === 0 ? "no recognizable literal" : kinds.join(" | ")}`,
+          "witness-disagrees-with-engine",
+          answer,
+          witness
+        ),
+        engine: answer,
+        engineCoverage: coverage
+      };
+    }
+    witness.corroborated = true;
+    if (answer.confidence < ENGINE_CONFIDENCE_FLOOR) {
+      return {
+        line: {
+          ...unknownLine(
+            `witnessed in the tree, but the engine's own confidence ${answer.confidence} is below the declared floor ${ENGINE_CONFIDENCE_FLOOR}`,
+            "engine-confidence-below-floor",
+            answer,
+            witness
+          ),
+          witness
+        },
+        engine: answer,
+        engineCoverage: coverage
+      };
+    }
+    return {
+      line: {
+        provenance: "inferred",
+        text: answer.name,
+        confidence: answer.confidence,
+        reason: `witnessed in the tree: ${witness.returnExpressionsSeen} return expression(s) of kind ${kinds[0]} at ${witness.nodeType}`,
+        withheld: null,
+        withheldText: null,
+        storedProvenanceUnknown: false,
+        stale: false,
+        witness
+      },
+      engine: answer,
+      engineCoverage: coverage
+    };
+  } finally {
+    tree?.delete?.();
+  }
+}
+function stripDeclarationHead(text) {
+  const i = text.indexOf("{");
+  return i === -1 ? text : text.slice(0, i);
+}
+
+// src/lsp/rich_hover.ts
+import { readFileSync as readFileSync3, statSync } from "fs";
+
+// src/lsp/navigation.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/lsp/launch_languages.ts
+import path from "path";
+var LAUNCH_LANGUAGES = [
+  "java",
+  "groovy",
+  "kotlin",
+  "scala",
+  "typescript",
+  "javascript",
+  "python",
+  "zig",
+  "go",
+  "rust",
+  "c",
+  "cpp",
+  "vue",
+  "svelte",
+  // M29 wave 3 (owner-approved 2026-11-08): the remaining analyzers. Each
+  // language joins the launch set only through the wave protocol; the wave
+  // execution gate reports which of them can actually serve hover/definition/
+  // references today and which are blocked on an analyzer gap.
+  "tsx",
+  "html",
+  "css",
+  "scss",
+  "sass",
+  "json",
+  "yaml",
+  "toml",
+  "markdown",
+  "xml",
+  "graphql",
+  "protobuf",
+  "sql",
+  "perl",
+  "ruby",
+  "php",
+  "lua",
+  "elixir",
+  "erlang",
+  "haskell",
+  "clojure",
+  "julia",
+  "r",
+  "bash",
+  "powershell",
+  "make",
+  "swift",
+  "dart",
+  "csharp",
+  "fsharp",
+  "nim",
+  "vb",
+  "vba",
+  "matlab",
+  "clean",
+  "solidity",
+  "hcl",
+  "terraform"
+];
+function isLaunchLanguage(language) {
+  return language !== null && LAUNCH_LANGUAGES.includes(language);
+}
+function languageForPath(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const map = {
+    ".java": "java",
+    ".groovy": "groovy",
+    ".gradle": "groovy",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".scala": "scala",
+    ".sc": "scala",
+    ".ts": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".zig": "zig",
+    ".go": "go",
+    ".rs": "rust",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".vue": "vue",
+    ".svelte": "svelte",
+    // M29 wave 3 — extension-level identity for the onboarded languages.
+    // Deliberately ABSENT: ".m" (objc and matlab share it, so it resolves to
+    // neither until content sniffing lands — a declared absence, not a guess).
+    ".tsx": "tsx",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".md": "markdown",
+    ".markdown": "markdown",
+    ".mdx": "markdown",
+    ".xml": "xml",
+    ".graphql": "graphql",
+    ".gql": "graphql",
+    ".proto": "protobuf",
+    ".sql": "sql",
+    ".pl": "perl",
+    ".pm": "perl",
+    ".rb": "ruby",
+    ".php": "php",
+    ".lua": "lua",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".erl": "erlang",
+    ".hrl": "erlang",
+    ".hs": "haskell",
+    ".clj": "clojure",
+    ".cljs": "clojure",
+    ".cljc": "clojure",
+    ".jl": "julia",
+    ".r": "r",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".ps1": "powershell",
+    ".psm1": "powershell",
+    ".mk": "make",
+    ".swift": "swift",
+    ".dart": "dart",
+    ".cs": "csharp",
+    ".fs": "fsharp",
+    ".fsi": "fsharp",
+    ".fsx": "fsharp",
+    ".nim": "nim",
+    ".vb": "vb",
+    ".bas": "vba",
+    ".vba": "vba",
+    ".icl": "clean",
+    ".dcl": "clean",
+    ".sol": "solidity",
+    ".hcl": "hcl",
+    ".tf": "terraform",
+    ".tfvars": "terraform"
+  };
+  return map[ext] ?? null;
+}
+
+// src/lsp/navigation.ts
+var MAX_LOCATIONS = 200;
+var DECLARATION_ENTRY_NOTE = "this is the symbol's own declaration, served because the client asked for it (not a usage)";
+function languageAbsence(filePath) {
+  const language = languageForPath(filePath);
+  if (isLaunchLanguage(language)) return null;
+  return {
+    reason: "language_not_launched",
+    language,
+    detail: language === null ? `file type not in the launch language set (launch: ${LAUNCH_LANGUAGES.join(", ")})` : `${language} is not a launch language (launch: ${LAUNCH_LANGUAGES.join(", ")})`,
+    searchedIndex: false
+  };
+}
+function notIndexedAbsence(filePath) {
+  return {
+    reason: "not_indexed",
+    language: languageForPath(filePath),
+    detail: "no indexed symbol at this position",
+    searchedIndex: true
+  };
+}
+function findIndexedSymbol(raw, filePath, line, character) {
+  let sourceText;
+  try {
+    sourceText = readFileSync2(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const mapper = createPositionMapper(sourceText);
+  let indexPos;
+  try {
+    indexPos = mapper.lspToIndex({ line, character });
+  } catch (err) {
+    if (err instanceof PositionError) return null;
+    throw err;
+  }
+  const rows = raw.prepare(
+    `SELECT s.id, s.name, s.qualified_name, s.symbol_type, s.file_id,
+              s.byte_start, s.byte_end, s.line_start, s.line_end,
+              f.path, f.language
+       FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+       WHERE f.path = ? AND s.line_start IS NOT NULL AND s.line_end IS NOT NULL
+         AND s.line_start <= ? AND s.line_end >= ?`
+  ).all(filePath, indexPos.line, indexPos.line);
+  let best = null;
+  let bestSpan = Number.MAX_SAFE_INTEGER;
+  for (const row of rows) {
+    if (row.byte_start !== null && row.byte_end !== null && row.line_start === indexPos.line && indexPos.column >= row.byte_start && indexPos.column < row.byte_end) {
+      return row;
+    }
+    const span = (row.line_end ?? 0) - (row.line_start ?? 0);
+    if (best === null || span < bestSpan) {
+      best = row;
+      bestSpan = span;
+    }
+  }
+  return best;
+}
+function findNamedSymbolAtPosition(raw, filePath, line, character) {
+  let sourceText;
+  try {
+    sourceText = readFileSync2(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const mapper = createPositionMapper(sourceText);
+  let indexPos;
+  try {
+    indexPos = mapper.lspToIndex({ line, character });
+  } catch (err) {
+    if (err instanceof PositionError) return null;
+    throw err;
+  }
+  let jsCol;
+  try {
+    jsCol = mapper.indexToLsp({ line: indexPos.line, column: indexPos.column }).character;
+  } catch (err) {
+    if (err instanceof PositionError) return null;
+    throw err;
+  }
+  const lineText = mapper.lineTexts[indexPos.line - 1] ?? "";
+  if (jsCol > lineText.length) return null;
+  const isWordChar3 = (ch) => /[A-Za-z0-9_$]/.test(ch);
+  if (jsCol < lineText.length && !isWordChar3(lineText[jsCol])) {
+    if (jsCol === 0 || !isWordChar3(lineText[jsCol - 1])) return null;
+    jsCol--;
+  }
+  let start = jsCol;
+  let end = jsCol;
+  while (start > 0 && isWordChar3(lineText[start - 1])) start--;
+  while (end < lineText.length && isWordChar3(lineText[end])) end++;
+  const identifier = lineText.slice(start, end);
+  if (!identifier) return null;
+  const sameFile = raw.prepare(
+    `SELECT s.id, s.name, s.qualified_name, s.symbol_type, s.file_id,
+              s.byte_start, s.byte_end, s.line_start, s.line_end,
+              f.path, f.language
+       FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+       WHERE f.path = ? AND s.name = ?`
+  ).all(filePath, identifier);
+  if (sameFile.length === 1) return sameFile[0];
+  if (sameFile.length > 1) {
+    const hit = sameFile.find(
+      (r) => r.line_start !== null && r.line_end !== null && r.line_start <= indexPos.line && r.line_end >= indexPos.line
+    );
+    if (hit) return hit;
+  }
+  const rows = raw.prepare(
+    `SELECT s.id, s.name, s.qualified_name, s.symbol_type, s.file_id,
+              s.byte_start, s.byte_end, s.line_start, s.line_end,
+              f.path, f.language
+       FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+       WHERE s.name = ?`
+  ).all(identifier);
+  if (rows.length === 1) return rows[0];
+  return null;
+}
+function resolveDefinition(raw, request) {
+  const languageGate = languageAbsence(request.filePath);
+  if (languageGate !== null) {
+    return {
+      found: false,
+      location: null,
+      symbol: null,
+      evidenceTier: "not_indexed",
+      absence: languageGate
+    };
+  }
+  const named = findNamedSymbolAtPosition(raw, request.filePath, request.line, request.character);
+  const symbol = named ?? findIndexedSymbol(raw, request.filePath, request.line, request.character);
+  if (symbol === null) {
+    return {
+      found: false,
+      location: null,
+      symbol: null,
+      evidenceTier: "not_indexed",
+      absence: notIndexedAbsence(request.filePath)
+    };
+  }
+  const location = symbolLocation(symbol);
+  if (location === null) {
+    return {
+      found: false,
+      location: null,
+      symbol: {
+        id: symbol.id,
+        name: symbol.name,
+        qualifiedName: symbol.qualified_name,
+        symbolType: symbol.symbol_type
+      },
+      evidenceTier: "indexed",
+      absence: {
+        reason: "unresolvable_location",
+        language: symbol.language ?? languageForPath(request.filePath),
+        detail: `symbol ${symbol.name} is indexed at lines ${symbol.line_start}..${symbol.line_end} but its stored byte columns do not convert against the source on disk`,
+        searchedIndex: true
+      }
+    };
+  }
+  return {
+    found: true,
+    location,
+    symbol: {
+      id: symbol.id,
+      name: symbol.name,
+      qualifiedName: symbol.qualified_name,
+      symbolType: symbol.symbol_type
+    },
+    evidenceTier: "indexed",
+    absence: null
+  };
+}
+function symbolLocation(symbol) {
+  if (symbol.byte_start === null || symbol.byte_end === null || symbol.line_start === null || symbol.line_end === null || symbol.path === null) {
+    return null;
+  }
+  let sourceText;
+  try {
+    sourceText = readFileSync2(symbol.path, "utf8");
+  } catch {
+    return null;
+  }
+  const startCol = resolveRowByteColumns(sourceText, symbol.line_start, symbol.byte_start);
+  const endCol = resolveRowByteColumns(sourceText, symbol.line_end, symbol.byte_end);
+  if (startCol === null || endCol === null) return null;
+  const mapper = createPositionMapper(sourceText);
+  const range = mapper.indexRangeToLsp({
+    start: { line: startCol.line, column: startCol.column },
+    end: { line: endCol.line, column: endCol.column }
+  });
+  return {
+    path: symbol.path,
+    line: range.start.line,
+    character: range.start.character,
+    endLine: range.end.line,
+    endCharacter: range.end.character
+  };
+}
+function edgeLocation(path3, byteStart, byteEnd, lineStart, lineEnd, sourceCache) {
+  if (path3 === null || byteStart === null || byteEnd === null || lineStart === null || lineEnd === null) {
+    return null;
+  }
+  return edgeLocationDetailed(path3, byteStart, byteEnd, lineStart, lineEnd, sourceCache).location;
+}
+function edgeLocationDetailed(path3, byteStart, byteEnd, lineStart, lineEnd, sourceCache) {
+  if (path3 === null || byteStart === null || byteEnd === null || lineStart === null || lineEnd === null) {
+    return {
+      location: null,
+      absence: {
+        reason: "unresolvable_location",
+        language: null,
+        detail: "stored relationship endpoint carries no complete range (path, line, or byte columns are null)",
+        searchedIndex: true
+      }
+    };
+  }
+  let sourceText;
+  let cachedMapper;
+  let cachedLines;
+  const cached = sourceCache?.get(path3);
+  if (cached !== void 0 && "readError" in cached) {
+    return {
+      location: null,
+      absence: {
+        reason: "unresolvable_location",
+        language: languageForPath(path3),
+        detail: `source file could not be read (${cached.readError}); the stored line is omitted rather than emitted unverified`,
+        searchedIndex: true
+      }
+    };
+  } else if (cached !== void 0) {
+    sourceText = cached.text;
+    cachedLines = cached.lines;
+    cachedMapper = cached.mapper;
+  } else {
+    try {
+      sourceText = readFileSync2(path3, "utf8");
+      const lines2 = sourceText.split("\n");
+      sourceCache?.set(path3, { text: sourceText, lines: lines2 });
+    } catch (error) {
+      sourceCache?.set(path3, { readError: error.message });
+      return {
+        location: null,
+        absence: {
+          reason: "unresolvable_location",
+          language: languageForPath(path3),
+          detail: `source file could not be read (${error.message}); the stored line is omitted rather than emitted unverified`,
+          searchedIndex: true
+        }
+      };
+    }
+  }
+  const lines = cachedLines ?? sourceText.split("\n");
+  const startCol = resolveRowByteColumns(sourceText, lineStart, byteStart, lines);
+  const endCol = resolveRowByteColumns(sourceText, lineEnd, byteEnd, lines);
+  if (startCol === null || endCol === null) {
+    return {
+      location: null,
+      absence: {
+        reason: "unresolvable_location",
+        language: languageForPath(path3),
+        detail: `stored byte columns (${byteStart}..${byteEnd} on lines ${lineStart}..${lineEnd}) do not convert against this source text`,
+        searchedIndex: true
+      }
+    };
+  }
+  const mapper = cachedMapper ?? createPositionMapper(sourceText);
+  if (cachedMapper === void 0 && cached !== void 0 && sourceCache !== void 0) {
+    sourceCache.set(path3, { text: sourceText, lines, mapper });
+  }
+  let range;
+  try {
+    range = mapper.indexRangeToLsp({
+      start: { line: startCol.line, column: startCol.column },
+      end: { line: endCol.line, column: endCol.column }
+    });
+  } catch (error) {
+    return {
+      location: null,
+      absence: {
+        reason: "unresolvable_location",
+        language: languageForPath(path3),
+        detail: `stored range does not convert to an LSP range (${error.message})`,
+        searchedIndex: true
+      }
+    };
+  }
+  return {
+    location: {
+      path: path3,
+      line: range.start.line,
+      character: range.start.character,
+      endLine: range.end.line,
+      endCharacter: range.end.character
+    },
+    absence: null
+  };
+}
+function resolveReferences(raw, request) {
+  const limit = Math.max(1, Math.min(request.limit ?? MAX_LOCATIONS, MAX_LOCATIONS));
+  const languageGate = languageAbsence(request.filePath);
+  if (languageGate !== null) {
+    return referencesAbsent(languageGate, limit);
+  }
+  const symbol = findIndexedSymbol(raw, request.filePath, request.line, request.character);
+  if (symbol === null) {
+    return referencesAbsent({ ...notIndexedAbsence(request.filePath), totalCount: 0 }, limit);
+  }
+  const edges = raw.prepare(
+    // M62 §2: the stored call-site line is now SELECTED — the surface has to
+    // reach the call site, and the store's line is the only place a call site
+    // is recorded. It arrives under one alias (`stored_call_line`) and its
+    // ONLY use is the hand-off to the address owner below; nothing in this
+    // module reads it for display. The source-side join is UNCHANGED: it is
+    // still the calling symbol's own indexed range, which is what the
+    // `declaration` substitute uses and what the caller declaration line
+    // comes from.
+    `SELECT r.id, r.source_symbol_id, r.target_symbol_id,
+              r.confidence, r.relationship_type,
+              ${STORED_LINE_SELECT},
+              sf.path AS source_path, ss.byte_start AS source_byte_start,
+              ss.byte_end AS source_byte_end, ss.line_start AS source_line_start,
+              ss.line_end AS source_line_end,
+              tf.path AS target_path, ts.byte_start AS target_byte_start,
+              ts.byte_end AS target_byte_end, ts.line_start AS target_line_start,
+              ts.line_end AS target_line_end
+       FROM brain_relationship r
+       LEFT JOIN brain_symbol ss ON ss.id = r.source_symbol_id
+       LEFT JOIN brain_file sf ON sf.id = ss.file_id
+       LEFT JOIN brain_symbol ts ON ts.id = r.target_symbol_id
+       LEFT JOIN brain_file tf ON tf.id = ts.file_id
+       WHERE r.target_symbol_id = ?
+       ORDER BY r.confidence DESC, r.id`
+  ).all(symbol.id);
+  const locations = [];
+  const seen = /* @__PURE__ */ new Set();
+  let omittedUnresolvable = 0;
+  let omittedUnpositionable = 0;
+  let coalescedRows = 0;
+  const sourceCache = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (!isUsageSiteRow(
+      {
+        source_symbol_id: edge.source_symbol_id,
+        target_symbol_id: edge.target_symbol_id,
+        relationship_type: edge.relationship_type
+      },
+      symbol.id
+    )) {
+      continue;
+    }
+    const address = deriveCallSiteAddress({
+      storedLine: storedLineFromRow(edge),
+      // The address owner's `file` is documented as the calling symbol's
+      // RELATIVE path, for the renderings the graph/hub/MCP surfaces produce.
+      // This surface hands the editor absolute paths (brain_file.path), and it
+      // holds no project root to relativise against, so the field carries the
+      // same absolute string as `NavigationLocation.path`. DECLARED divergence,
+      // not a silent substitution: a renderer printing this address gets an
+      // absolute path, which is correct here and differs from the graph/hub
+      // renderings. Reported as a gap in the owner's field contract.
+      file: edge.source_path ?? "",
+      // The ONLY permitted substitute, and the caller's own declaration line.
+      callerDeclaration: { line: edge.source_line_start }
+    });
+    const placed = referenceLocation(edge, address, sourceCache);
+    if (placed.location === null) {
+      if (placed.omission === "unpositionable") omittedUnpositionable++;
+      else omittedUnresolvable++;
+      continue;
+    }
+    const loc = placed.location;
+    const key = `${loc.path}:${loc.line}:${loc.character}`;
+    if (seen.has(key)) {
+      coalescedRows++;
+      continue;
+    }
+    seen.add(key);
+    if (locations.length < limit) {
+      locations.push(loc);
+    }
+  }
+  if (request.includeDeclaration) {
+    const decl = symbolLocation(symbol);
+    if (decl !== null && symbol.line_start !== null && symbol.path !== null) {
+      const withAddress = {
+        ...decl,
+        callSite: {
+          kind: "declaration",
+          file: symbol.path,
+          line: symbol.line_start,
+          note: DECLARATION_ENTRY_NOTE,
+          rowId: `declaration:${symbol.id}`
+        }
+      };
+      const key = `${withAddress.path}:${withAddress.line}:declaration:${symbol.id}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        if (locations.length < limit) {
+          locations.push(withAddress);
+        }
+      }
+    }
+  }
+  const totalCount = seen.size;
+  return {
+    locations,
+    truncated: totalCount > locations.length,
+    totalCount,
+    limit,
+    evidenceTier: "indexed",
+    // Locations WERE served, so there is no absence — but the omission counts
+    // are not absence markers and must not be dropped: a caller showing 3 of 5
+    // rows needs to know the other two were dropped on purpose, and WHICH way.
+    absence: null,
+    omittedUnresolvable,
+    omittedUnpositionable,
+    coalescedRows
+  };
+}
+function referenceLocation(edge, address, sourceCache) {
+  if (address.kind === "unknown") return { location: null, omission: "unpositionable" };
+  if (edge.source_path === null) return { location: null, omission: "unresolvable" };
+  if (isExactAddress(address)) {
+    const line0 = addressLine0(address);
+    if (line0 === null) return { location: null, omission: "unpositionable" };
+    const sourceText = readSourceCached(edge.source_path, sourceCache);
+    if (sourceText === null) return { location: null, omission: "unresolvable" };
+    if (line0 >= createPositionMapper(sourceText).lineTexts.length) {
+      return { location: null, omission: "unresolvable" };
+    }
+    return {
+      location: {
+        path: edge.source_path,
+        line: line0,
+        character: 0,
+        endLine: line0,
+        endCharacter: 0,
+        callSite: { ...address, rowId: edge.id }
+      },
+      omission: "none"
+    };
+  }
+  const resolved = edgeLocationDetailed(
+    edge.source_path,
+    edge.source_byte_start,
+    edge.source_byte_end,
+    edge.source_line_start,
+    edge.source_line_end
+  );
+  if (resolved.location === null) return { location: null, omission: "unresolvable" };
+  return {
+    location: { ...resolved.location, callSite: { ...address, rowId: edge.id } },
+    omission: "none"
+  };
+}
+function readSourceCached(path3, cache) {
+  const hit = cache.get(path3);
+  if (hit !== void 0) return hit;
+  let text = null;
+  try {
+    text = readFileSync2(path3, "utf8");
+  } catch {
+    text = null;
+  }
+  cache.set(path3, text);
+  return text;
+}
+function referencesAbsent(absence, limit) {
+  return {
+    locations: [],
+    truncated: false,
+    totalCount: 0,
+    limit,
+    evidenceTier: "not_indexed",
+    // The count is restated INSIDE the absence, beside `searchedIndex`. A
+    // client that reads the absence must be able to see "0 matches, and the
+    // index was not searched for this language" as one fact; leaving the count
+    // only on the result invites a reader to treat it as a workspace-wide
+    // claim about a language this server never served.
+    absence: { ...absence, totalCount: 0 },
+    omittedUnresolvable: 0,
+    omittedUnpositionable: 0,
+    coalescedRows: 0
+  };
+}
+
+// src/lsp/enrichment.ts
+var ENRICHMENT_KEYS = /* @__PURE__ */ new Set([
+  "role",
+  "pattern",
+  "layerFlow",
+  "criticality",
+  "frequency",
+  "isTestCode",
+  "isGeneratedCode",
+  "isFrameworkContract",
+  "isDependencyInjection",
+  "inferredAt"
+]);
+function parseEnrichment(metadata) {
+  if (typeof metadata !== "string" || metadata.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(metadata);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  if (typeof parsed["inferredAt"] !== "number") return null;
+  const out = { inferredAt: parsed["inferredAt"] };
+  for (const key of ENRICHMENT_KEYS) {
+    if (key === "inferredAt") continue;
+    const v = parsed[key];
+    if (v === void 0 || v === null) continue;
+    if (key === "role" || key === "pattern" || key === "criticality") {
+      if (typeof v === "string") out[key] = v;
+    } else if (key === "layerFlow" || key === "frequency") {
+      if (typeof v === "string") out[key] = v;
+    } else if (typeof v === "boolean") {
+      ;
+      out[key] = v;
+    }
+  }
+  return out;
+}
+function enrichmentIsStale(enrichment, rowTimeUpdated) {
+  if (typeof enrichment.inferredAt !== "number") return false;
+  if (typeof rowTimeUpdated !== "number" || rowTimeUpdated <= 0) return false;
+  return enrichment.inferredAt < rowTimeUpdated;
+}
+function describeFrequency(frequency) {
+  const m = /^one_of_(\d+)$/.exec(frequency);
+  if (m) {
+    const n = Number(m[1]);
+    return n === 0 ? "no referring rows" : n === 1 ? "1 referring row" : `${n} referring rows`;
+  }
+  return frequency;
+}
+function describeEnrichment(e) {
+  const parts = [];
+  if (e.role) parts.push(`role ${e.role}`);
+  if (e.pattern) parts.push(`pattern ${e.pattern}`);
+  if (e.layerFlow) parts.push(`layer ${e.layerFlow}`);
+  if (e.frequency) parts.push(describeFrequency(e.frequency));
+  if (e.criticality) parts.push(`${e.criticality} criticality`);
+  const flags = [];
+  if (e.isTestCode) flags.push("test code");
+  if (e.isGeneratedCode) flags.push("generated");
+  if (e.isFrameworkContract) flags.push("framework contract");
+  if (e.isDependencyInjection) flags.push("dependency injection");
+  if (flags.length > 0) parts.push(flags.join("+"));
+  return parts.join(" \xB7 ");
+}
+function hasDisplayableEnrichment(e) {
+  if (!e) return false;
+  return describeEnrichment(e).length > 0;
+}
+
+// src/lsp/rich_hover.ts
+var MAX_USAGE_LINKS = 3;
+var LINE_COUNT_CACHE_MAX = 512;
+var lineCountCache = /* @__PURE__ */ new Map();
+function cachedLineCount(path3) {
+  let stat;
+  try {
+    const st = statSync(path3);
+    stat = { mtimeMs: st.mtimeMs, size: st.size };
+  } catch {
+    return null;
+  }
+  const entry = lineCountCache.get(path3);
+  if (entry === void 0) return null;
+  if (entry.mtimeMs !== stat.mtimeMs || entry.size !== stat.size) {
+    lineCountCache.delete(path3);
+    return null;
+  }
+  lineCountCache.delete(path3);
+  lineCountCache.set(path3, entry);
+  return entry.lineCount;
+}
+function rememberLineCount(path3, lineCount) {
+  let stat;
+  try {
+    const st = statSync(path3);
+    stat = { mtimeMs: st.mtimeMs, size: st.size };
+  } catch {
+    return;
+  }
+  lineCountCache.delete(path3);
+  lineCountCache.set(path3, { ...stat, lineCount });
+  while (lineCountCache.size > LINE_COUNT_CACHE_MAX) {
+    const oldest = lineCountCache.keys().next();
+    if (oldest.done === true) break;
+    lineCountCache.delete(oldest.value);
+  }
+}
+var CANONICAL_RELATIONSHIP_KINDS = [
+  "calls",
+  "extends",
+  "implements",
+  "uses",
+  "instantiates",
+  "overrides",
+  "contains",
+  "references",
+  "imports",
+  "exports",
+  "decorates",
+  "renders",
+  "mixes_in",
+  "part_of"
+];
+var RELATIONSHIP_KIND_ALIASES = {
+  call: "calls",
+  inherits: "extends",
+  import: "imports",
+  use: "uses",
+  usage: "uses",
+  reference: "references"
+};
+function canonicalKind(relationshipType) {
+  const t = relationshipType.trim().toLowerCase();
+  if (CANONICAL_RELATIONSHIP_KINDS.includes(t)) return t;
+  return RELATIONSHIP_KIND_ALIASES[t] ?? null;
+}
+var RELATIONSHIP_VERB = {
+  calls: { outgoing: "calls", incoming: "called by" },
+  extends: { outgoing: "extends", incoming: "extended by" },
+  implements: { outgoing: "implements", incoming: "implemented by" },
+  uses: { outgoing: "uses", incoming: "used by" },
+  instantiates: { outgoing: "instantiates", incoming: "instantiated by" },
+  overrides: { outgoing: "overrides", incoming: "overridden by" },
+  // §14 rule 4 + the owner's decision: `contains` reads as a CONTAINMENT verb,
+  // never as a usage or a connection. The words are chosen so that
+  // "Hub contains greet" and "greet — contained by Hub" are statements about
+  // DECLARATION from either end, and so that no reader can take either for
+  // "someone uses this". The negative test that proves it is in the gate.
+  contains: { outgoing: "contains", incoming: "contained by" },
+  references: { outgoing: "references", incoming: "referenced by" },
+  imports: { outgoing: "imports", incoming: "imported by" },
+  // `exports` is the other declaration containment (relations.ts). Same law.
+  exports: { outgoing: "exports", incoming: "exported by" },
+  // ── the four EXTENDED kinds (2026-10-18 vocabulary extension) ─────────────
+  // `decorates`: the EMITTED direction is decorated declaration -> decorator, so
+  // a card for the decorated declaration reads "carries decorator [X]" and a card
+  // for the decorator reads "decorates [Y]". Not "called by": nothing invokes a
+  // decorator at the source level (src/ast/types.ts says so in as many words).
+  decorates: { outgoing: "carries decorator", incoming: "decorates" },
+  // `renders`: rendering component -> rendered component (JSX element creation;
+  // NOT `instantiates` — nothing is `new`ed in the source).
+  renders: { outgoing: "renders", incoming: "rendered by" },
+  // `mixes_in`: class -> mixin composed into its supertype chain (Dart `with`).
+  // A supertype-composition relation, like `extends`/`implements`.
+  mixes_in: { outgoing: "mixes in", incoming: "mixed in by" },
+  // `part_of`: a `part`/`part of` DIRECTIVE. Its emitted direction is the
+  // directive's own and metadata.partRole names which end is the library, so the
+  // two direction words describe the DIRECTIVE, not a symbol-usage claim: a card
+  // reading "part-of directive" or "named by part-of directive" is true whichever
+  // role this row carries. The card never claims a part USES a library (§13.5:
+  // a module-level edge is a directive, not a symbol usage). Rows whose far end
+  // the index could not resolve as a symbol are declared in DECLARED_ABSENCE.
+  part_of: { outgoing: "part-of directive", incoming: "named by part-of directive" }
+};
+function verbFor(relationshipType, direction) {
+  const canonical = canonicalKind(relationshipType);
+  if (canonical === null) return null;
+  const entry = RELATIONSHIP_VERB[canonical];
+  return direction === "incoming" ? entry.incoming : entry.outgoing;
+}
+var CONTAINMENT_VERB_DECLARES = "declares";
+var CONTAINMENT_VERB_DECLARED_IN = "declared in";
+var USAGE_COMMAND = "bb.openUsage";
+var DEFINITION_COMMAND = "bb.openDefinition";
+var SHOW_ALL_USAGES_COMMAND = "bb.showAllUsages";
+var OPEN_GRAPH_COMMAND = "bb.openGraph";
+var OPEN_IMPACT_COMMAND = "bb.openImpact";
+var SHOW_CALL_HIERARCHY_COMMAND = "bb.showCallHierarchy";
+function encodeLocationArgs(path3, line, character) {
+  return encodeURIComponent(JSON.stringify([{ file: path3, line, character }]));
+}
+function openUsageUri(site) {
+  return `command:${USAGE_COMMAND}?${encodeLocationArgs(site.path, site.line, site.character)}`;
+}
+function openDefinitionUri(path3, line, character) {
+  return `command:${DEFINITION_COMMAND}?${encodeLocationArgs(path3, line, character)}`;
+}
+function encodeActionArgs(symbol, path3, line, character) {
+  return encodeURIComponent(JSON.stringify([{ symbol, file: path3, line, character }]));
+}
+function openGraphUri(a) {
+  return `command:${OPEN_GRAPH_COMMAND}?${encodeActionArgs(a.symbol, a.file, a.line, a.character)}`;
+}
+function openImpactUri(a) {
+  return `command:${OPEN_IMPACT_COMMAND}?${encodeActionArgs(a.symbol, a.file, a.line, a.character)}`;
+}
+function showCallHierarchyUri(a) {
+  return `command:${SHOW_CALL_HIERARCHY_COMMAND}?${encodeActionArgs(a.symbol, a.file, a.line, a.character)}`;
+}
+function actionsSection(symbol, filePath, line, character) {
+  if (symbol.length === 0 || filePath.length === 0 || line < 0 || character < 0) return "";
+  const a = { symbol, file: filePath, line, character };
+  return `**actions**: [Open in graph](${openGraphUri(a)}) \xB7 [Impact analysis](${openImpactUri(a)}) \xB7 [Call hierarchy](${showCallHierarchyUri(a)})`;
+}
+function showAllUsagesUri(a) {
+  return `command:${SHOW_ALL_USAGES_COMMAND}?${encodeURIComponent(JSON.stringify([{ file: a.file, line: a.line, character: a.character, symbol: a.symbol }]))}`;
+}
+function siteLabel(site) {
+  const base = site.path.split(/[\\/]/).pop() ?? site.path;
+  const label = `${site.name} \u2014 ${base}:${site.line + 1}`;
+  return addressNoteSuffix(site.callSite) === null ? label : `${label} ${addressNoteSuffix(site.callSite)}`;
+}
+function addressNoteSuffix(address) {
+  if (address === void 0 || address === null) return null;
+  if (isExactAddress(address)) return null;
+  return address.kind === "declaration" ? `_(${ADDRESS_NOTES.substitute})_` : `(${address.kind === "unknown" ? address.note : ""})`;
+}
+function richSitesForSymbol(raw, symbolId, omissions) {
+  const locationMemo = /* @__PURE__ */ new Map();
+  const edgeSourceCache = /* @__PURE__ */ new Map();
+  const locationOf = (p, bs, be, ls, le) => {
+    const key = `${p}:${bs}:${be}:${ls}:${le}`;
+    const hit = locationMemo.get(key);
+    if (hit !== void 0 || locationMemo.has(key)) return hit ?? null;
+    let loc;
+    try {
+      loc = edgeLocation(p, bs, be, ls, le, edgeSourceCache);
+    } catch (error) {
+      if (!(error instanceof PositionError)) throw error;
+      loc = null;
+    }
+    locationMemo.set(key, loc);
+    return loc;
+  };
+  const lineCountOf = (p) => {
+    const cached = edgeSourceCache.get(p);
+    if (cached !== void 0) {
+      if ("readError" in cached) return null;
+      if (cached.mapper === void 0) cached.mapper = createPositionMapper(cached.text);
+      const count = cached.mapper.lineTexts.length;
+      rememberLineCount(p, count);
+      return count;
+    }
+    const hit = cachedLineCount(p);
+    if (hit !== null) return hit;
+    try {
+      const text = readFileSync3(p, "utf8");
+      const lines = text.split("\n");
+      const mapper = createPositionMapper(text);
+      edgeSourceCache.set(p, { text, lines, mapper });
+      rememberLineCount(p, mapper.lineTexts.length);
+      return mapper.lineTexts.length;
+    } catch (error) {
+      edgeSourceCache.set(p, { readError: error.message });
+      return null;
+    }
+  };
+  const rows = raw.prepare(
+    `SELECT r.id, r.relationship_type, r.confidence, r.metadata, r.time_updated,
+              r.source_symbol_id, r.target_symbol_id, ${STORED_LINE_SELECT},
+              ss.name AS src_name, ss.symbol_type AS src_type,
+              ss.byte_start AS src_bs, ss.byte_end AS src_be,
+              ss.line_start AS src_ls, ss.line_end AS src_le, sf.path AS src_path,
+              ss.line_start AS src_decl, sf.relative_path AS src_rel,
+              ts.name AS tgt_name, ts.symbol_type AS tgt_type,
+              ts.byte_start AS tgt_bs, ts.byte_end AS tgt_be,
+              ts.line_start AS tgt_ls, ts.line_end AS tgt_le, tf.path AS tgt_path,
+              ts.line_start AS tgt_decl, tf.relative_path AS tgt_rel
+       FROM brain_relationship r
+       LEFT JOIN brain_symbol ss ON ss.id = r.source_symbol_id
+       LEFT JOIN brain_file sf ON sf.id = ss.file_id
+       LEFT JOIN brain_symbol ts ON ts.id = r.target_symbol_id
+       LEFT JOIN brain_file tf ON tf.id = ts.file_id
+       WHERE r.source_symbol_id = ? OR r.target_symbol_id = ?
+       ORDER BY r.confidence DESC, r.id`
+  ).all(symbolId, symbolId);
+  const sites = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (row.source_symbol_id === symbolId && row.target_symbol_id === symbolId) continue;
+    const incoming = row.target_symbol_id === symbolId && row.source_symbol_id !== symbolId;
+    const other = incoming ? { name: row.src_name, type: row.src_type, path: row.src_path, bs: row.src_bs, be: row.src_be, ls: row.src_ls, le: row.src_le, decl: row.src_decl, rel: row.src_rel } : { name: row.tgt_name, type: row.tgt_type, path: row.tgt_path, bs: row.tgt_bs, be: row.tgt_be, ls: row.tgt_ls, le: row.tgt_le, decl: row.tgt_decl, rel: row.tgt_rel };
+    if (!other.name || !other.path) continue;
+    const sourceRel = incoming ? other.rel : row.src_rel;
+    const sourceDeclLine = incoming ? other.decl : row.src_decl;
+    const address = deriveCallSiteAddress({
+      storedLine: storedLineFromRow(row),
+      file: sourceRel ?? "",
+      callerDeclaration: { line: sourceDeclLine }
+    });
+    const callLine0 = addressLine0(address);
+    const declarationRow = isDeclarationRelationship(row.relationship_type);
+    const servesCallSite = callLine0 !== null && incoming && !declarationRow;
+    let loc;
+    if (servesCallSite) {
+      const lineCount = lineCountOf(other.path);
+      if (lineCount === null || callLine0 >= lineCount) {
+        if (omissions !== void 0) omissions.unresolvable++;
+        continue;
+      }
+      loc = { path: other.path, line: callLine0, character: 0, endLine: callLine0, endCharacter: 0 };
+    } else {
+      if (other.bs === null || other.be === null || other.ls === null || other.le === null) continue;
+      const resolved = locationOf(other.path, other.bs, other.be, other.ls, other.le);
+      if (resolved === null) continue;
+      loc = resolved;
+    }
+    const opening = servesCallSite ? { path: loc.path, line: callLine0, character: 0, endLine: callLine0, endCharacter: 0 } : { path: loc.path, line: loc.line, character: loc.character, endLine: loc.endLine, endCharacter: loc.endCharacter };
+    const key = `${opening.path}:${opening.line}:${opening.character}:${incoming ? "in" : "out"}`;
+    const existing = sites.find((x) => `${x.path}:${x.line}:${x.character}:${x.reversed ? "in" : "out"}` === key);
+    if (existing !== void 0) {
+      if (!existing.relationshipTypes.includes(row.relationship_type)) {
+        existing.relationshipTypes.push(row.relationship_type);
+      }
+      continue;
+    }
+    seen.add(key);
+    const enrichment = parseEnrichment(row.metadata);
+    sites.push({
+      name: other.name,
+      symbolType: other.type,
+      path: opening.path,
+      line: opening.line,
+      character: opening.character,
+      endLine: opening.endLine,
+      endCharacter: opening.endCharacter,
+      relationshipType: row.relationship_type,
+      relationshipTypes: [row.relationship_type],
+      reversed: incoming,
+      confidence: row.confidence,
+      enrichment,
+      enrichmentStale: enrichment === null ? false : enrichmentIsStale(enrichment, row.time_updated),
+      callSite: address
+    });
+  }
+  return sites;
+}
+function connectedGroups(sites) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const site of sites) {
+    for (const kind of siteKinds(site)) {
+      if (isDeclarationRelationship(kind)) continue;
+      const verb = verbFor(kind, site.reversed ? "incoming" : "outgoing");
+      if (verb === null) continue;
+      let g = groups.get(verb);
+      if (!g) {
+        g = { verb, sites: [] };
+        groups.set(verb, g);
+      }
+      g.sites.push(site);
+    }
+  }
+  return [...groups.values()];
+}
+function siteKinds(site) {
+  const kinds = site.relationshipTypes;
+  return kinds === void 0 || kinds.length === 0 ? [site.relationshipType] : [...kinds];
+}
+var MAX_SUMMARY_PER_VERB = 3;
+function connectedSummarySection(groups) {
+  if (groups.length === 0) return "";
+  const parts = [];
+  for (const group of groups) {
+    const names = group.sites.slice(0, MAX_SUMMARY_PER_VERB);
+    const overflow = group.sites.length - names.length;
+    const seen = /* @__PURE__ */ new Set();
+    const links = names.map((s) => {
+      const dup = seen.has(s.name);
+      seen.add(s.name);
+      const label = dup ? siteLabel(s) : s.name;
+      return `[${label}](${openUsageUri(s)})`;
+    });
+    if (overflow > 0) links.push(`+${overflow}`);
+    let groupText = `${group.verb} ${links.join(", ")}`;
+    if (group.sites.length === 1 && hasDisplayableEnrichment(group.sites[0].enrichment)) {
+      const s = group.sites[0];
+      const desc = describeEnrichment(s.enrichment);
+      const staleNote = s.enrichmentStale ? ", stale \u2014 row changed after enrichment" : "";
+      groupText += ` \xB7 _${desc} (enriched by index${staleNote})_`;
+    }
+    parts.push(groupText);
+  }
+  return `**connected**: ${parts.join("; ")}`;
+}
+function usageSitesOf(sites) {
+  return usageSites(sites);
+}
+function usagesSection(sites, total, forSymbol, forFile, forLine, forCharacter) {
+  const usage = usageSitesOf(sites);
+  if (usage.length === 0) return "";
+  const lines = [`**usages** \u2014 ${usage.length} stored reference${usage.length === 1 ? "" : "s"} (${USAGE_SITE_FILTER_LABEL})`];
+  const exact = usage.filter((s) => isExactAddress(s.callSite)).length;
+  lines[0] += exact === usage.length ? " \u2014 each opens the stored call site" : exact === 0 ? ` \u2014 the index stores no call-site line for these, so each opens the referencing declaration` : ` \u2014 ${exact} open the stored call site, ${usage.length - exact} open the referencing declaration (no call-site line stored)`;
+  lines[0] += ` _(${USAGE_COUNT_UNIT_LABEL})_`;
+  const shown = usage.slice(0, MAX_USAGE_LINKS);
+  shown.forEach((s, i) => {
+    lines.push(`${i + 1}. [${siteLabel(s)}](${openUsageUri(s)})`);
+  });
+  const rest = Math.max(0, Math.min(total, usage.length) - shown.length);
+  if (rest > 0) {
+    lines.push(`+${rest} more \u2014 [show all usages](${showAllUsagesUri({ file: forFile, line: forLine, character: forCharacter, symbol: forSymbol })})`);
+  }
+  return lines.join("\n");
+}
+var MAX_CONTAINMENT_ROWS = 6;
+function containmentSitesOf(sites) {
+  return sites.filter((s) => siteKinds(s).some((k) => isDeclarationRelationship(k)));
+}
+function containmentSection(sites) {
+  const declared = containmentSitesOf(sites);
+  if (declared.length === 0) return "";
+  const members = declared.filter((s) => !s.reversed);
+  const owners = declared.filter((s) => s.reversed);
+  const parts = [];
+  if (members.length > 0) parts.push(`${CONTAINMENT_VERB_DECLARES} ${linkedList(members)}`);
+  if (owners.length > 0) parts.push(`${CONTAINMENT_VERB_DECLARED_IN} ${linkedList(owners)}`);
+  const multi = declared.map((s) => ({ site: s, kinds: siteKinds(s).filter((k) => isDeclarationRelationship(k)) })).filter((x) => x.kinds.length > 1);
+  for (const x of multi) parts.push(`_(also declared by ${x.kinds.join(", ")})_`);
+  const shown = Math.min(declared.length, MAX_CONTAINMENT_ROWS);
+  const rest = declared.length - shown;
+  const header = `**contained** \u2014 declares ${members.length} member${members.length === 1 ? "" : "s"}, declared in ${owners.length} (declaration containment; never a usage)` + (rest > 0 ? ` \u2014 showing ${shown} of ${declared.length}, +${rest} more on the symbol's own list` : "");
+  return [header, ...parts].join("\n");
+}
+function linkedList(sites) {
+  const seen = /* @__PURE__ */ new Set();
+  const links = sites.map((s) => {
+    const dup = seen.has(s.name);
+    seen.add(s.name);
+    const label = dup ? siteLabel(s) : s.name;
+    return `[${label}](${openUsageUri(s)})`;
+  });
+  return links.join(", ");
+}
+function definitionLink(path3, line, character) {
+  return `_source: bb index ([${path3}:${line + 1}](${openDefinitionUri(path3, line, character)}))_`;
+}
+
+// src/lsp/hover.ts
+var SYMBOL_ROW_SELECT = `s.id, s.name, s.qualified_name, s.symbol_type, s.line_start, s.line_end,
+            s.byte_start, s.byte_end, s.return_type, s.parameters, s.visibility, s.file_id,
+            f.id AS f_id, f.path, f.relative_path, f.language`;
+function findSymbolAtPosition(raw, filePath, position, mapper) {
+  let line1;
+  if (mapper !== void 0) {
+    try {
+      line1 = mapper.lspToIndex(position).line;
+    } catch (error) {
+      if (error instanceof PositionError) return null;
+      throw error;
+    }
+  } else {
+    let content;
+    try {
+      content = readFileSync4(filePath, "utf8");
+    } catch {
+      return null;
+    }
+    try {
+      line1 = createPositionMapper(content).lspToIndex(position).line;
+    } catch (error) {
+      if (error instanceof PositionError) return null;
+      throw error;
+    }
+  }
+  const rows = raw.prepare(
+    `SELECT ${SYMBOL_ROW_SELECT}
+       FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+       WHERE f.path = ? AND s.line_start IS NOT NULL AND s.line_end IS NOT NULL
+         AND s.line_start <= ? AND s.line_end >= ?`
+  ).all(filePath, line1, line1);
+  if (rows.length === 0) return null;
+  let best = null;
+  let bestWidth = Number.MAX_SAFE_INTEGER;
+  for (const row of rows) {
+    const width = (row.line_end ?? 0) - (row.line_start ?? 0);
+    if (width < bestWidth) {
+      bestWidth = width;
+      best = {
+        symbol: row,
+        file: { id: row.f_id, path: row.path, relative_path: row.relative_path ?? "", language: row.language }
+      };
+    }
+  }
+  return best;
+}
+function indexedFileCountFor(raw, fileId) {
+  if (fileId === null || fileId === void 0 || fileId === "") return null;
+  try {
+    const row = raw.prepare("SELECT count(*) AS c FROM brain_file WHERE project_id = (SELECT project_id FROM brain_file WHERE id = ?)").get(fileId);
+    const n = Number(row?.c);
+    return Number.isFinite(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveOccurrenceSymbol(raw, filePath, position) {
+  let content;
+  try {
+    content = readFileSync4(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const mapper = createPositionMapper(content);
+  let indexPos;
+  try {
+    indexPos = mapper.lspToIndex({ line: position.line, character: position.character });
+  } catch (e) {
+    if (e instanceof PositionError) return null;
+    throw e;
+  }
+  let parsed;
+  try {
+    parsed = await parseForCursor(filePath, content);
+  } catch (error) {
+    if (error instanceof ParseUnavailable) return null;
+    throw error;
+  }
+  const cursorOcc = occurrenceAtPoint(parsed.tree, indexPos.line, indexPos.column);
+  if (!cursorOcc) return null;
+  const sameFile = raw.prepare(`SELECT ${SYMBOL_ROW_SELECT} FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE f.path = ? AND s.name = ?`).all(filePath, cursorOcc.text);
+  let rows = sameFile;
+  if (sameFile.length === 0) {
+    const workspace = raw.prepare(`SELECT ${SYMBOL_ROW_SELECT} FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE s.name = ?`).all(cursorOcc.text);
+    rows = workspace;
+  }
+  if (rows.length !== 1) return null;
+  const row = rows[0];
+  return {
+    symbol: row,
+    file: { id: row.f_id, path: row.path, relative_path: row.relative_path ?? "", language: row.language },
+    occurrence: { startLine: cursorOcc.startLine, startColumn: cursorOcc.startColumn, endColumn: cursorOcc.endColumn },
+    // Lane 6: the mapper for THIS file's text, handed back so the containing-
+    // symbol fallback can convert its line through the same owner without a
+    // second read. Two P1 mappers over the same bytes would be two answers to
+    // the same question, which is the drift §5.1 exists to prevent.
+    mapper,
+    // the declaration's own documentation, read from the comment sites
+    // this parse already produced. Attached to the DECLARATION, not to the
+    // cursor: a doc describes the symbol, and the cursor is often a use of it.
+    // Same rule as doc_comment.ts (a comment ending on the line directly above), read from the point that
+    // can satisfy it instead of a whole-file comment walk — equivalence gated line-by-line.
+    docComment: docCommentAt(parsed.tree, row.line_start)
+  };
+}
+function evidenceTiersFor(raw, symbolId) {
+  const rows = raw.prepare(
+    "SELECT relationship_type, confidence, metadata FROM brain_relationship WHERE target_symbol_id = ? UNION SELECT relationship_type, confidence, metadata FROM brain_relationship WHERE source_symbol_id = ?"
+  ).all(symbolId, symbolId);
+  return orderTiers(rows.map(classifyStoredRow));
+}
+function formatHoverMarkdown(data) {
+  const lines = [];
+  lines.push(`\`\`\`
+${data.signature}
+\`\`\``);
+  if (data.docComment.length > 0) {
+    lines.push(data.docComment);
+    lines.push("");
+  }
+  lines.push(renderTypeLine(data.typeLine));
+  lines.push(
+    `**${data.name}** \u2014 ${data.symbolType}, ${data.usageCount} usage${data.usageCount === 1 ? "" : "s"}${data.indexedFileCount === null ? " (indexed scope unknown \u2014 this count is bounded by something not measured)" : ` in ${data.indexedFileCount} indexed file${data.indexedFileCount === 1 ? "" : "s"}`} _(${USAGE_SITE_FILTER_LABEL})_`
+  );
+  if (data.evidenceTiers.length > 0) {
+    lines.push(`evidence: ${data.evidenceTiers.join(", ")}`);
+  } else {
+    lines.push("evidence: none (no indexed relationships)");
+  }
+  if (data.connectedSection && data.connectedSection.length > 0) {
+    lines.push(data.connectedSection);
+  }
+  if (data.usagesSection && data.usagesSection.length > 0) {
+    lines.push(data.usagesSection);
+  }
+  if (data.omittedUsageRows.unresolvable > 0) {
+    const n = data.omittedUsageRows.unresolvable;
+    lines.push(
+      `**usages omitted** \u2014 ${n} stored row${n === 1 ? "" : "s"} name a call-site line past the end of the source file, so ${n === 1 ? "it is" : "they are"} not served (\xA715.3: omitted and counted, never clamped); \`textDocument/references\` omits the same ${n === 1 ? "row" : "rows"}.`
+    );
+  }
+  if (data.unresolvedNameMatches && data.unresolvedNameMatches.total > 0) {
+    const m = data.unresolvedNameMatches;
+    lines.push(
+      `**name matches without identity** \u2014 ${m.total} stored row${m.total === 1 ? "" : "s"} name \`${m.name}\` but resolve to no indexed declaration (${m.external} classified external, ${m.unresolved} unresolved); these are not counted as usages.`
+    );
+  }
+  if (data.containmentSection && data.containmentSection.length > 0) {
+    lines.push(data.containmentSection);
+  }
+  if (data.actionsSection && data.actionsSection.length > 0) {
+    lines.push(data.actionsSection);
+  }
+  if (data.crossLanguageSection && data.crossLanguageSection.length > 0) {
+    lines.push(data.crossLanguageSection);
+  }
+  if (data.annotationSection && data.annotationSection.length > 0) {
+    lines.push(data.annotationSection);
+  }
+  if (data.stale) {
+    lines.push(`\u26A0\uFE0F **stale** \u2014 file changed since indexing (${data.freshnessStatus})`);
+  }
+  if (data.definition !== null) {
+    lines.push(definitionLink(data.filePath, data.definition.line, data.definition.character));
+  } else {
+    lines.push(`_source: bb index (${data.filePath}:${data.lineStart ?? "?"})_`);
+  }
+  return lines.join("\n\n");
+}
+async function hover(raw, request, deps = {}) {
+  const startedAt = (deps.now ?? Date.now)();
+  const language = languageForPath(request.filePath);
+  if (!isLaunchLanguage(language)) {
+    return {
+      contents: null,
+      range: null,
+      data: null,
+      provenance: {
+        source: "bb_index",
+        evidenceClass: "unknown",
+        engine: "bb_lsp hover@m24.l2",
+        limitations: [
+          language === null ? "file type not in the launch language set" : `${language} is not a launch language (launch: ${LAUNCH_LANGUAGES.join(", ")})`
+        ],
+        stale: false
+      }
+    };
+  }
+  const occurrence = await resolveOccurrenceSymbol(raw, request.filePath, request.position);
+  const containing = findSymbolAtPosition(raw, request.filePath, request.position, occurrence?.mapper);
+  const found = occurrence ?? containing;
+  if (!found) {
+    return {
+      contents: null,
+      range: null,
+      data: null,
+      provenance: {
+        source: "bb_index",
+        evidenceClass: "unknown",
+        engine: "bb_lsp hover@m24.l2",
+        limitations: ["no indexed symbol at this position (not indexed)"],
+        stale: false
+      }
+    };
+  }
+  const { symbol, file } = found;
+  const freshness = checkFileFreshness(raw, file.id);
+  const freshnessStatus = freshness?.status ?? "missing";
+  const stale = freshnessStatus !== "fresh";
+  const tiers = evidenceTiersFor(raw, symbol.id);
+  const omittedUsageRows = { unresolvable: 0 };
+  const sites = richSitesForSymbol(raw, symbol.id, omittedUsageRows);
+  const usageSiteRows = usageSitesOf(sites);
+  const usageCount = usageSiteRows.length;
+  const unresolvedNameMatches = countUnresolvedNameMatches(raw, symbol.id);
+  const indexedFileCount = indexedFileCountFor(raw, file.id);
+  const crossSection = crossLanguageSection(factsFromRows(storedCrossLanguageRows(raw, symbol.id), file.language));
+  const annotationRows = raw.prepare(
+    "SELECT symbol_name, symbol_path, author_class, tool_identity, body, time_created, time_updated FROM brain_annotation WHERE project_id = (SELECT project_id FROM brain_file WHERE id = ?) AND (symbol_name = ? OR symbol_name = ?) AND (symbol_path IS NULL OR symbol_path = ? OR symbol_path = ?) ORDER BY time_updated DESC, id"
+  ).all(file.id, symbol.name, symbol.qualified_name, file.relative_path, file.path);
+  const annotationSection = annotationHoverSection(annotationRows);
+  let range = null;
+  if (symbol.line_start !== null && symbol.line_end !== null && symbol.byte_start !== null && symbol.byte_end !== null) {
+    try {
+      const sourceText = readFileSync4(file.path, "utf8");
+      const startCol = resolveRowByteColumns(sourceText, symbol.line_start, symbol.byte_start);
+      const endCol = resolveRowByteColumns(sourceText, symbol.line_end, symbol.byte_end);
+      if (startCol === null || endCol === null) {
+      } else {
+        const mapper = createPositionMapper(sourceText);
+        const indexRange = {
+          start: { line: startCol.line, column: startCol.column },
+          end: { line: endCol.line, column: endCol.column }
+        };
+        range = mapper.indexRangeToLsp(indexRange);
+      }
+    } catch (error) {
+      if (!(error instanceof PositionError)) throw error;
+    }
+  }
+  const jumped = occurrence !== null && (containing === null || containing.symbol.id !== symbol.id);
+  let responseRange = range;
+  if (jumped) {
+    try {
+      const sourceText = readFileSync4(request.filePath, "utf8");
+      const startCol = resolveRowByteColumns(sourceText, occurrence.occurrence.startLine, occurrence.occurrence.startColumn);
+      const endCol = resolveRowByteColumns(sourceText, occurrence.occurrence.startLine, occurrence.occurrence.endColumn);
+      if (startCol !== null && endCol !== null) {
+        const cursorMapper = createPositionMapper(sourceText);
+        responseRange = cursorMapper.indexRangeToLsp({
+          start: { line: startCol.line, column: startCol.column },
+          end: { line: endCol.line, column: endCol.column }
+        });
+      }
+    } catch (error) {
+      if (!(error instanceof PositionError)) throw error;
+      responseRange = null;
+    }
+  }
+  let typeLine;
+  try {
+    const typeSource = readFileSync4(file.path, "utf8");
+    typeLine = (await resolveTypeLine(
+      file.path,
+      typeSource,
+      {
+        name: symbol.name,
+        symbol_type: symbol.symbol_type,
+        return_type: symbol.return_type,
+        line_start: symbol.line_start,
+        line_end: symbol.line_end,
+        language: file.language
+      },
+      symbol.return_type
+    )).line;
+    typeLine.stale = stale;
+  } catch {
+    typeLine = {
+      provenance: "unknown",
+      text: UNRESOLVED_TYPE,
+      confidence: null,
+      reason: "the type could not be resolved; the hover renders the declared marker",
+      withheld: "parse-failed",
+      withheldText: null,
+      storedProvenanceUnknown: false,
+      stale,
+      witness: null
+    };
+  }
+  const data = {
+    name: symbol.name,
+    qualifiedName: symbol.qualified_name,
+    symbolType: symbol.symbol_type,
+    signature: renderSignature(symbol, file.language),
+    // structured data stays structured (see the field's declaration).
+    parameters: (() => {
+      const parsed = parseParameters(symbol.parameters);
+      if (parsed.shape === "empty") return [];
+      if (parsed.shape !== "list") return null;
+      return parsed.entries.map((e) => ({
+        name: e.name,
+        type: e.type ?? null,
+        isOptional: e.isOptional === true,
+        defaultValue: e.defaultValue ?? null,
+        isRest: e.isRest === true
+      }));
+    })(),
+    usageCount,
+    unresolvedNameMatches,
+    omittedUsageRows,
+    indexedFileCount,
+    evidenceTiers: tiers,
+    // rich sections composed from stored relationship rows.
+    connectedSection: connectedSummarySection(connectedGroups(sites)),
+    usagesSection: usagesSection(usageSiteRows, usageCount, symbol.name, file.path, request.position.line, request.position.character),
+    // The declaration-containment rows come from the SAME collected array the
+    // usage list and the connected summary read (one collection, three
+    // renderings), so a containment count can never disagree with a usage count
+    // about the same rows.
+    containmentSection: containmentSection(sites),
+    // LSP definition location (range.start) when resolvable; null otherwise
+    // (the footnote then renders the plain location — still honest).
+    definition: range === null ? null : { line: range.start.line, character: range.start.character },
+    // the actions row targets the same resolved declaration (the
+    // actions carry the server-resolved symbol identity — ).
+    actionsSection: range === null ? "" : actionsSection(symbol.name, file.path, range.start.line, range.start.character),
+    crossLanguageSection: crossSection,
+    annotationSection,
+    stale,
+    freshnessStatus,
+    filePath: file.path,
+    lineStart: symbol.line_start,
+    lineEnd: symbol.line_end,
+    typeLine,
+    docComment: occurrence?.docComment ?? ""
+  };
+  const elapsed = (deps.now ?? Date.now)() - startedAt;
+  void elapsed;
+  return {
+    contents: { value: formatHoverMarkdown(data), kind: "markdown" },
+    range: responseRange,
+    data,
+    provenance: {
+      source: "bb_index",
+      // the primary is the STRONGEST tier the symbol carries, by the
+      // declared rank — a member of `tiers` by construction, so the primary
+      // can never disagree with the tier list it headlines.
+      evidenceClass: stale ? "stale" : primaryTier(tiers),
+      engine: "bb_lsp hover@m24.l2",
+      limitations: [
+        "index-sourced; no compiler-backed types (complement stance)"
+      ],
+      stale
+    }
+  };
+}
+
+// src/lsp/document_highlight.ts
+var SAFETY_CACHE_LIMIT = 8;
+var safetyCache = /* @__PURE__ */ new Map();
+function cachedSafety(filePath, content) {
+  const hit = safetyCache.get(filePath);
+  if (!hit || hit.content !== content) return null;
+  safetyCache.delete(filePath);
+  safetyCache.set(filePath, hit);
+  return hit.safety;
+}
+function rememberSafety(filePath, content, safety) {
+  safetyCache.delete(filePath);
+  safetyCache.set(filePath, { content, safety });
+  while (safetyCache.size > SAFETY_CACHE_LIMIT) {
+    const oldest = safetyCache.keys().next().value;
+    if (oldest === void 0) break;
+    safetyCache.delete(oldest);
+  }
+}
+async function documentHighlight(raw, request) {
+  let content;
+  try {
+    content = readFileSync5(request.filePath, "utf8");
+  } catch {
+    return { highlights: [], evidenceTier: "not_indexed", staleness: null, symbol: null };
+  }
+  const mapper = new PositionMapper(content);
+  const absence = (tier) => ({
+    highlights: [],
+    evidenceTier: tier,
+    staleness: null,
+    symbol: null
+  });
+  let safety = cachedSafety(request.filePath, content);
+  if (safety === null) {
+    try {
+      const parsed = await parseForSafety(request.filePath, content);
+      rememberSafety(request.filePath, content, parsed);
+      safety = parsed;
+    } catch {
+      return absence("unsupported_language");
+    }
+  }
+  let indexPos;
+  try {
+    indexPos = mapper.lspToIndex({ line: request.line, character: request.character });
+  } catch (e) {
+    if (e instanceof PositionError) return absence("not_indexed");
+    throw e;
+  }
+  const cursorOcc = safety.occurrences.find(
+    (o) => o.startLine === indexPos.line && o.startColumn <= indexPos.column && indexPos.column < o.endColumn
+  );
+  const DECL_COLS = `s.id, s.name, s.line_start, s.line_end, s.byte_start, s.byte_end, s.file_id`;
+  if (!cursorOcc) return absence("not_indexed");
+  const sameFile = raw.prepare(
+    `SELECT ${DECL_COLS} FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+       WHERE f.path = ? AND s.name = ?`
+  ).all(request.filePath, cursorOcc.text);
+  let symbol = sameFile.length === 1 ? sameFile[0] : null;
+  if (symbol === null && sameFile.length === 0) {
+    const workspace = raw.prepare(
+      `SELECT ${DECL_COLS} FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+         WHERE s.name = ?`
+    ).all(cursorOcc.text);
+    if (workspace.length === 1) symbol = workspace[0];
+  }
+  if (symbol === null) {
+    return absence(sameFile.length > 1 ? "ambiguous" : "not_indexed");
+  }
+  const edges = raw.prepare(`SELECT source_symbol_id, target_symbol_id FROM brain_relationship
+              WHERE target_symbol_id = ? OR source_symbol_id = ?`).all(symbol.id, symbol.id);
+  const related = /* @__PURE__ */ new Set([symbol.id]);
+  for (const e of edges) {
+    if (e.target_symbol_id === symbol.id) related.add(e.source_symbol_id);
+    else related.add(e.target_symbol_id);
+  }
+  const fileSymbols = raw.prepare(`SELECT ${DECL_COLS}
+              FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+              WHERE f.path = ? AND s.line_start IS NOT NULL AND s.line_end IS NOT NULL`).all(request.filePath);
+  const highlights = [];
+  for (const occ of safety.occurrences) {
+    if (occ.text !== symbol.name) continue;
+    const occLine = occ.startLine;
+    let inner = null;
+    let innerSpan = Number.MAX_SAFE_INTEGER;
+    for (const s of fileSymbols) {
+      if (s.line_start === null || s.line_end === null) continue;
+      if (occLine < s.line_start || occLine > s.line_end) continue;
+      const span = s.line_end - s.line_start;
+      if (span < innerSpan) {
+        inner = s;
+        innerSpan = span;
+      }
+    }
+    if (inner === null || !related.has(inner.id)) continue;
+    const start = resolveRowByteColumns(content, occ.startLine, occ.startColumn);
+    const end = resolveRowByteColumns(content, occ.endLine, occ.endColumn);
+    if (start === null || end === null) continue;
+    const range = mapper.indexRangeToLsp({
+      start: { line: start.line, column: start.column },
+      end: { line: end.line, column: end.column }
+    });
+    highlights.push({
+      start: range.start,
+      end: range.end,
+      kind: inner.id === symbol.id ? 3 : 2
+    });
+  }
+  highlights.sort((a, b) => a.start.line - b.start.line || a.start.character - b.start.character);
+  const tiers = evidenceTiersFor(raw, symbol.id);
+  const freshness = checkFileFreshness(raw, symbol.file_id);
+  const freshnessStatus = freshness?.status ?? "missing";
+  return {
+    highlights,
+    evidenceTier: tiers[0] ?? "unknown",
+    staleness: { stale: freshnessStatus !== "fresh", freshnessStatus },
+    symbol: { id: symbol.id, name: symbol.name }
+  };
+}
+
+// src/lsp/server.ts
+import { fileURLToPath } from "url";
+
+// src/lsp/symbols.ts
+import { readFileSync as readFileSync6 } from "fs";
+var MAX_WORKSPACE_SYMBOLS = 200;
+function declaredAbsenceFor(filePath) {
+  const language = languageForPath(filePath);
+  if (language === null) {
+    return {
+      code: "file_type_unknown",
+      message: `the file's extension maps to no language in the launch map, so bb declares no symbols for it (launch: ${LAUNCH_LANGUAGES.join(", ")})`,
+      language: null,
+      launchLanguages: LAUNCH_LANGUAGES
+    };
+  }
+  if (!isLaunchLanguage(language)) {
+    return {
+      code: "language_outside_launch_set",
+      message: `${language} is not a launch language, so bb declares no symbols for it (launch: ${LAUNCH_LANGUAGES.join(", ")})`,
+      language,
+      launchLanguages: LAUNCH_LANGUAGES
+    };
+  }
+  return null;
+}
+function absenceWith(code, message, filePath = null) {
+  return {
+    code,
+    message,
+    language: filePath === null ? null : languageForPath(filePath),
+    launchLanguages: LAUNCH_LANGUAGES
+  };
+}
+function markerFor(raw, rows) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!seen.has(row.file_id)) seen.set(row.file_id, row.path);
+  }
+  let fresh = 0;
+  let stale = 0;
+  let missing = 0;
+  const filesUnverified = [];
+  for (const [fileId, path3] of seen) {
+    const status = checkFileFreshness(raw, fileId);
+    if (status === null) {
+      filesUnverified.push(path3);
+    } else if (status.status === "fresh") {
+      fresh++;
+    } else if (status.status === "stale") {
+      stale++;
+    } else {
+      missing++;
+    }
+  }
+  return {
+    stale: stale > 0 || missing > 0 || filesUnverified.length > 0,
+    status: missing > 0 ? "missing" : stale > 0 ? "stale" : filesUnverified.length > 0 ? "unknown" : fresh > 0 ? "fresh" : "unknown",
+    filesChecked: seen.size - filesUnverified.length,
+    filesUnverified
+  };
+}
+var WORD_CHAR = /[A-Za-z0-9_$]/;
+function isWordChar(ch) {
+  return ch !== void 0 && WORD_CHAR.test(ch);
+}
+function identifierSpanAt(mapper, start, name) {
+  if (name.length === 0) return null;
+  const text = mapper.lineTexts[start.line];
+  if (text === void 0) return null;
+  const probed = text.slice(start.character, start.character + name.length);
+  if (probed !== name) return null;
+  if (isWordChar(text[start.character - 1])) return null;
+  if (isWordChar(text[start.character + name.length])) return null;
+  return {
+    line: start.line,
+    character: start.character,
+    endLine: start.line,
+    endCharacter: start.character + name.length
+  };
+}
+function symbolRanges(sourceText, row) {
+  if (row.byte_start === null || row.byte_end === null || row.line_start === null || row.line_end === null) {
+    return null;
+  }
+  const startCol = resolveRowByteColumns(sourceText, row.line_start, row.byte_start);
+  const endCol = resolveRowByteColumns(sourceText, row.line_end, row.byte_end);
+  if (startCol === null || endCol === null) return null;
+  const mapper = createPositionMapper(sourceText);
+  const selection = mapper.indexRangeToLsp({
+    start: { line: startCol.line, column: startCol.column },
+    end: { line: endCol.line, column: endCol.column }
+  });
+  const range = {
+    line: selection.start.line,
+    character: selection.start.character,
+    endLine: selection.end.line,
+    endCharacter: selection.end.character
+  };
+  const identifier = identifierSpanAt(mapper, selection.start, row.name);
+  return {
+    range,
+    selectionRange: identifier ?? range,
+    selectionRangeBasis: identifier === null ? "declaration_span" : "identifier_at_stored_start"
+  };
+}
+function documentSymbols(raw, filePath) {
+  const scope = declaredAbsenceFor(filePath);
+  if (scope !== null) {
+    return {
+      symbols: [],
+      evidenceTier: "not_indexed",
+      notIndexed: true,
+      absence: scope,
+      omitted: [],
+      staleness: {
+        stale: true,
+        status: "unknown",
+        filesChecked: 0,
+        filesUnverified: [filePath]
+      },
+      selectionRangeBasis: "declaration_span"
+    };
+  }
+  const rows = raw.prepare(
+    `SELECT s.id, s.name, s.qualified_name, s.symbol_type, s.owner_symbol_id,
+              s.file_id, s.byte_start, s.byte_end, s.line_start, s.line_end,
+              s.gravity_score, f.path, f.language
+       FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+       WHERE f.path = ?
+       ORDER BY s.line_start, s.byte_start, s.id`
+  ).all(filePath);
+  const staleness = markerFor(raw, rows);
+  if (rows.length === 0) {
+    return {
+      symbols: [],
+      evidenceTier: "not_indexed",
+      notIndexed: true,
+      absence: absenceWith(
+        "not_in_index",
+        "the index stores no symbol rows for this file (bb has no declaration to show)",
+        filePath
+      ),
+      omitted: [],
+      staleness,
+      selectionRangeBasis: "declaration_span"
+    };
+  }
+  let sourceText = null;
+  try {
+    sourceText = readFileSync6(filePath, "utf8");
+  } catch {
+    return {
+      symbols: [],
+      evidenceTier: "not_indexed",
+      notIndexed: true,
+      absence: absenceWith(
+        "source_unreadable",
+        "the file text could not be read, so no stored span can be converted to an LSP position (no symbol is placed)",
+        filePath
+      ),
+      omitted: rows.map((row) => ({
+        id: row.id,
+        name: row.name,
+        reason: "source_unreadable"
+      })),
+      staleness,
+      selectionRangeBasis: "declaration_span"
+    };
+  }
+  const byId = /* @__PURE__ */ new Map();
+  const roots = [];
+  const omitted = [];
+  let identifierPinned = 0;
+  for (const row of rows) {
+    const spans = symbolRanges(sourceText, row);
+    if (spans === null) {
+      omitted.push({
+        id: row.id,
+        name: row.name,
+        reason: row.byte_start === null || row.byte_end === null || row.line_start === null || row.line_end === null ? "coordinates_missing" : "range_unresolvable_from_source"
+      });
+      continue;
+    }
+    if (spans.selectionRangeBasis === "identifier_at_stored_start") identifierPinned++;
+    const entry = {
+      id: row.id,
+      name: row.name,
+      qualifiedName: row.qualified_name,
+      symbolType: row.symbol_type,
+      range: spans.range,
+      selectionRange: spans.selectionRange,
+      selectionRangeBasis: spans.selectionRangeBasis,
+      children: []
+    };
+    byId.set(row.id, entry);
+    const parentId = row.owner_symbol_id;
+    const parent = parentId !== null ? byId.get(parentId) : void 0;
+    if (parent !== void 0 && parent.children !== void 0) {
+      parent.children.push(entry);
+    } else {
+      roots.push(entry);
+    }
+  }
+  return {
+    symbols: roots,
+    evidenceTier: "indexed",
+    notIndexed: false,
+    absence: null,
+    omitted,
+    staleness,
+    // The response-level basis is the WEAKEST basis any entry used: a client
+    // that renders one declaration for the whole tree must not claim an
+    // identifier-precision surface when some entries are declaration spans.
+    selectionRangeBasis: identifierPinned === rows.length - omitted.length ? "identifier_at_stored_start" : "declaration_span"
+  };
+}
+function workspaceSymbols(raw, request) {
+  const limit = Math.max(
+    1,
+    Math.min(request.limit ?? MAX_WORKSPACE_SYMBOLS, MAX_WORKSPACE_SYMBOLS)
+  );
+  const query = request.query.trim();
+  const emptyStaleness = {
+    stale: true,
+    status: "unknown",
+    filesChecked: 0,
+    filesUnverified: []
+  };
+  if (query === "") {
+    return {
+      symbols: [],
+      truncated: false,
+      totalCount: 0,
+      limit,
+      evidenceTier: "indexed",
+      absence: absenceWith(
+        "not_in_index",
+        "the query was empty, so no symbol name was searched for"
+      ),
+      omitted: [],
+      staleness: emptyStaleness
+    };
+  }
+  const columns = "SELECT s.id, s.name, s.qualified_name, s.symbol_type, s.owner_symbol_id, s.file_id, s.byte_start, s.byte_end, s.line_start, s.line_end, s.gravity_score, f.path, f.language FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id ";
+  const order = "ORDER BY s.gravity_score DESC, s.name, s.id LIMIT ?";
+  let rows = raw.prepare(columns + "WHERE s.name = ? " + order).all(query, limit);
+  if (rows.length === 0) {
+    rows = raw.prepare(columns + "WHERE s.name LIKE ? " + order).all(`%${query}%`, limit);
+  }
+  const countBase = "SELECT COUNT(*) AS c FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE s.name = ?";
+  let totalRow = raw.prepare(countBase).get(query);
+  if ((totalRow?.c ?? 0) === 0) {
+    const fuzzyCount = "SELECT COUNT(*) AS c FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE s.name LIKE ?";
+    totalRow = raw.prepare(fuzzyCount).get(`%${query}%`);
+  }
+  const sourceCache = /* @__PURE__ */ new Map();
+  const readSource = (path3) => {
+    const hit = sourceCache.get(path3);
+    if (hit !== void 0) return hit;
+    let text = null;
+    try {
+      text = readFileSync6(path3, "utf8");
+    } catch {
+      text = null;
+    }
+    sourceCache.set(path3, text);
+    return text;
+  };
+  const symbols = [];
+  const omitted = [];
+  for (const row of rows) {
+    if (row.line_start === null) {
+      omitted.push({
+        id: row.id,
+        name: row.name,
+        reason: "coordinates_missing"
+      });
+      continue;
+    }
+    const text = readSource(row.path);
+    if (text === null) {
+      omitted.push({ id: row.id, name: row.name, reason: "source_unreadable" });
+      continue;
+    }
+    let lspLine;
+    try {
+      lspLine = createPositionMapper(text).indexToLsp({
+        line: row.line_start,
+        column: 1
+      }).line;
+    } catch {
+      omitted.push({
+        id: row.id,
+        name: row.name,
+        reason: "line_outside_file"
+      });
+      continue;
+    }
+    symbols.push({
+      id: row.id,
+      name: row.name,
+      qualifiedName: row.qualified_name,
+      symbolType: row.symbol_type,
+      path: row.path,
+      line: lspLine
+    });
+  }
+  const staleness = markerFor(raw, rows);
+  const totalCount = totalRow?.c ?? rows.length;
+  return {
+    symbols,
+    truncated: totalCount > symbols.length,
+    totalCount,
+    limit,
+    evidenceTier: symbols.length > 0 ? "indexed" : "not_indexed",
+    absence: symbols.length === 0 ? rows.length === 0 ? absenceWith(
+      "not_in_index",
+      `no indexed symbol is named "${query}" (this is an indexed, served language: the answer is "no such symbol", not "no such language")`
+    ) : absenceWith(
+      "coordinates_missing",
+      `every match for "${query}" was omitted because its stored position could not be resolved from the file (${omitted.length} omitted) \u2014 no symbol is placed at an invented line`
+    ) : null,
+    omitted,
+    staleness
+  };
+}
+
+// src/lsp/call_hierarchy.ts
+import { readFileSync as readFileSync7 } from "fs";
+var CH_MAX_DEPTH = 5;
+var CH_FANOUT_BUDGET = 50;
+var CALL_HIERARCHY_RELATIONSHIP_TYPES = ["calls"];
+var KIND_MAP = {
+  class: 5,
+  // Class
+  interface: 11,
+  // Interface
+  enum: 13,
+  // Enum
+  function: 12,
+  // Function
+  method: 6,
+  // Method
+  constructor: 9,
+  // Constructor
+  variable: 13,
+  // Variable (LSP has no variable kind; 13 is Enum — see below)
+  field: 8,
+  // Field
+  property: 10,
+  // Property
+  struct: 23,
+  // Struct
+  trait: 24,
+  // Trait (LSP SymbolKind has no trait; closest is Interface)
+  macro: 25
+  // Macro
+};
+KIND_MAP["variable"] = 13;
+var CALLABLE_SYMBOL_TYPES2 = /* @__PURE__ */ new Set([
+  "function",
+  "method",
+  "constructor",
+  "procedure",
+  "subroutine",
+  "getter",
+  "setter"
+]);
+var defaultTraverse = traverseGraph;
+function symbolKindFor(symbolType) {
+  return KIND_MAP[symbolType] ?? 2;
+}
+function lspLineWindow(mapper, line, lineEnd) {
+  try {
+    const start = mapper.indexToLsp({ line, column: 1 }).line;
+    const endLine = Number.isInteger(lineEnd) && lineEnd >= line ? lineEnd : line;
+    const end = mapper.indexToLsp({ line: endLine, column: 1 }).line;
+    return { start, end: Math.max(start, end) };
+  } catch {
+    return null;
+  }
+}
+function unresolvableRange() {
+  return { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
+}
+function emptyCrossCheck() {
+  return {
+    edges: 0,
+    agree: 0,
+    disagree: 0,
+    sourceOnly: 0,
+    storeOnly: 0,
+    neither: 0,
+    addressMissing: 0,
+    direct: 0,
+    hop: 0,
+    directnessUnstated: 0,
+    comparisonNotRun: 0
+  };
+}
+function crossCheckEdge(edge, sourceLines0, renderedLine0, edgeTargetName) {
+  const address = edge.callSite ?? null;
+  const sourceLines = [...new Set(sourceLines0)].sort((a, b) => a - b);
+  const storedLine0 = address === null ? null : addressLine0(address);
+  const storeNamesCallSite = address !== null && isExactAddress(address);
+  const depth = typeof edge.depth === "number" ? edge.depth : Number.NaN;
+  const direct = depth === 0;
+  let agreement;
+  if (storeNamesCallSite && storedLine0 !== null && sourceLines.includes(storedLine0)) {
+    agreement = "agree";
+  } else if (storeNamesCallSite && storedLine0 !== null && sourceLines.length > 0) {
+    agreement = "disagree";
+  } else if (storeNamesCallSite && storedLine0 !== null) {
+    agreement = "store-only";
+  } else if (sourceLines.length > 0) {
+    agreement = "source-only";
+  } else {
+    agreement = "neither";
+  }
+  return { agreement, sourceLines0: sourceLines, address, renderedLine0, edgeTargetName, direct, depth };
+}
+function tallyCrossCheck(census, agreement, addressPresent) {
+  census.edges++;
+  if (!addressPresent) census.addressMissing++;
+  const depth = agreement.depth;
+  if (depth === 0) census.direct++;
+  else if (Number.isInteger(depth) && depth >= 1) census.hop++;
+  else census.directnessUnstated++;
+  switch (agreement.agreement) {
+    case "agree":
+      census.agree++;
+      break;
+    case "disagree":
+      census.disagree++;
+      break;
+    case "source-only":
+      census.sourceOnly++;
+      break;
+    case "store-only":
+      census.storeOnly++;
+      break;
+    case "neither":
+      census.neither++;
+      break;
+  }
+}
+function declarationTokenOf(sourceText, mapper, name, declLine1) {
+  const window = lspLineWindow(mapper, declLine1, declLine1);
+  if (window === null) return void 0;
+  const token = nameTokenRange(sourceText, name, { start: window.start, end: window.start });
+  return token === null ? void 0 : token.start;
+}
+function unknownStaleness(paths = []) {
+  return { stale: true, status: "unknown", filesChecked: 0, filesUnverified: paths };
+}
+function symbolStaleness(raw, fileId, filePath) {
+  const status = checkFileFreshness(raw, fileId);
+  if (status === null) return unknownStaleness([filePath]);
+  return {
+    stale: status.status !== "fresh",
+    status: status.status,
+    filesChecked: 1,
+    filesUnverified: []
+  };
+}
+function expandStaleness(raw, rootFileId, rootFilePath, edgePaths) {
+  const distinct = [...new Set(edgePaths)].filter((p) => p !== "" && p !== rootFilePath);
+  const idByPath = /* @__PURE__ */ new Map();
+  if (distinct.length > 0) {
+    const placeholders = distinct.map(() => "?").join(", ");
+    let rows = [];
+    try {
+      rows = raw.prepare(`SELECT id, path FROM brain_file WHERE path IN (${placeholders})`).all(...distinct);
+    } catch {
+      rows = [];
+    }
+    for (const row of rows) idByPath.set(row.path, row.id);
+  }
+  let fresh = 0;
+  let stale = 0;
+  let missing = 0;
+  const unverified = [];
+  const account = (fileId, filePath) => {
+    if (fileId === null) {
+      unverified.push(filePath);
+      return;
+    }
+    const status = checkFileFreshness(raw, fileId);
+    if (status === null) unverified.push(filePath);
+    else if (status.status === "fresh") fresh++;
+    else if (status.status === "stale") stale++;
+    else missing++;
+  };
+  account(rootFileId, rootFilePath);
+  for (const path3 of distinct) account(idByPath.get(path3) ?? null, path3);
+  return {
+    stale: stale > 0 || missing > 0 || unverified.length > 0,
+    status: missing > 0 ? "missing" : stale > 0 ? "stale" : unverified.length > 0 ? "unknown" : fresh > 0 ? "fresh" : "unknown",
+    filesChecked: 1 + distinct.length - unverified.length,
+    filesUnverified: unverified
+  };
+}
+var WORD_CHAR2 = /[A-Za-z0-9_$]/;
+function isWordChar2(ch) {
+  return ch !== void 0 && WORD_CHAR2.test(ch);
+}
+function codeBeforeComment(line) {
+  const i = line.indexOf("//");
+  return i === -1 ? line : line.slice(0, i);
+}
+function receiverBefore(line, at) {
+  let i = at - 1;
+  while (i >= 0 && /\s/.test(line[i])) i--;
+  if (line[i] !== ".") return "";
+  let j = i - 1;
+  while (j >= 0 && /\s/.test(line[j])) j--;
+  const end = j + 1;
+  while (j >= 0 && (isWordChar2(line[j]) || line[j] === ".")) j--;
+  return line.slice(j + 1, end).replace(/\.+$/, "");
+}
+function classify(receiver, isConstruct, ownNames) {
+  if (isConstruct) return "construct";
+  if (receiver === "") return "plain";
+  const segments = receiver.split(".").filter((s) => s !== "");
+  const last = segments[segments.length - 1] ?? "";
+  if (last === "this") return "this";
+  if (ownNames.has(last)) return "this";
+  return "receiver";
+}
+function resolveInvocations(sourceText, targetName, callerLines0, skip, ownNames = /* @__PURE__ */ new Set(), skipDeclarations = []) {
+  if (targetName.length === 0) return [];
+  const mapper = createPositionMapper(sourceText);
+  const out = [];
+  const last = Math.min(callerLines0.end, mapper.lineTexts.length - 1);
+  const excluded = skip === void 0 ? skipDeclarations : [skip, ...skipDeclarations];
+  for (let line0 = Math.max(0, callerLines0.start); line0 <= last; line0++) {
+    const line = codeBeforeComment(mapper.lineTexts[line0] ?? "");
+    let from = 0;
+    for (; ; ) {
+      const at = line.indexOf(targetName, from);
+      if (at === -1) break;
+      from = at + targetName.length;
+      if (isWordChar2(line[at - 1]) || isWordChar2(line[at + targetName.length])) continue;
+      if (excluded.some((p) => p.line === line0 && p.character === at)) continue;
+      let k = at + targetName.length;
+      while (k < line.length && /\s/.test(line[k])) k++;
+      const isCall = line[k] === "(";
+      const isConstruct = /(^|[^\w$])new\s+$/.test(line.slice(0, at));
+      if (!isCall && !isConstruct) continue;
+      const receiver = receiverBefore(line, at);
+      let range;
+      try {
+        const start = mapper.lspToIndex({ line: line0, character: at });
+        const end = mapper.lspToIndex({ line: line0, character: at + targetName.length });
+        range = { start: mapper.indexToLsp(start), end: mapper.indexToLsp(end) };
+      } catch {
+        continue;
+      }
+      out.push({
+        range,
+        kind: classify(receiver, isConstruct, ownNames),
+        receiver
+      });
+    }
+  }
+  return out;
+}
+function nameTokenRange(sourceText, name, lines0) {
+  if (name.length === 0) return null;
+  const mapper = createPositionMapper(sourceText);
+  const last = Math.min(lines0.end, mapper.lineTexts.length - 1);
+  for (let line0 = Math.max(0, lines0.start); line0 <= last; line0++) {
+    const line = mapper.lineTexts[line0] ?? "";
+    let from = 0;
+    for (; ; ) {
+      const at = line.indexOf(name, from);
+      if (at === -1) break;
+      from = at + name.length;
+      if (isWordChar2(line[at - 1]) || isWordChar2(line[at + name.length])) continue;
+      try {
+        const start = mapper.lspToIndex({ line: line0, character: at });
+        const end = mapper.lspToIndex({ line: line0, character: at + name.length });
+        return { start: mapper.indexToLsp(start), end: mapper.indexToLsp(end) };
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function lineIndent(sourceText, line0) {
+  const line = createPositionMapper(sourceText).lineTexts[line0] ?? "";
+  const m = /^(\s*)/.exec(line);
+  return (m?.[1] ?? "").length;
+}
+function lineLength(sourceText, line0) {
+  return (createPositionMapper(sourceText).lineTexts[line0] ?? "").length;
+}
+function makeSourceReader() {
+  const cache = /* @__PURE__ */ new Map();
+  return (filePath) => {
+    if (filePath === "") return null;
+    const hit = cache.get(filePath);
+    if (hit !== void 0) return hit;
+    let text = null;
+    try {
+      text = readFileSync7(filePath, "utf8");
+    } catch {
+      text = null;
+    }
+    cache.set(filePath, text);
+    return text;
+  };
+}
+function prepareCallHierarchy(raw, request) {
+  const scope = declaredAbsenceFor(request.filePath);
+  if (scope !== null) {
+    return { item: null, notIndexed: true, absence: scope, staleness: unknownStaleness([request.filePath]) };
+  }
+  const symbol = findIndexedSymbol(raw, request.filePath, request.line, request.character);
+  if (symbol === null) {
+    return {
+      item: null,
+      notIndexed: true,
+      absence: absenceWith(
+        "symbol_not_at_position",
+        "the index stores no symbol covering this position (this is a served language: the answer is 'no symbol here', not 'no call hierarchy')",
+        request.filePath
+      ),
+      staleness: unknownStaleness([request.filePath])
+    };
+  }
+  const staleness = symbolStaleness(raw, symbol.file_id, symbol.path);
+  if (!CALLABLE_SYMBOL_TYPES2.has((symbol.symbol_type ?? "").toLowerCase())) {
+    return {
+      item: null,
+      notIndexed: true,
+      absence: absenceWith(
+        "no_stored_calls",
+        `symbol kind '${symbol.symbol_type}' is not callable \u2014 call hierarchy does not apply (this is NOT 'no callers': the surface has no callable identity for this kind)`,
+        request.filePath
+      ),
+      staleness
+    };
+  }
+  let sourceText;
+  try {
+    sourceText = readFileSync7(symbol.path, "utf8");
+  } catch {
+    return {
+      item: null,
+      notIndexed: true,
+      absence: absenceWith(
+        "source_unreadable",
+        "the file text could not be read, so no stored span can be converted to an LSP position (no item is placed)",
+        symbol.path
+      ),
+      staleness
+    };
+  }
+  if (symbol.byte_start === null || symbol.byte_end === null || symbol.line_start === null || symbol.line_end === null) {
+    return {
+      item: null,
+      notIndexed: true,
+      absence: absenceWith(
+        "coordinates_missing",
+        "the indexed symbol stored no byte/line coordinates, so no position can be derived from it (no item is placed)",
+        symbol.path
+      ),
+      staleness
+    };
+  }
+  const startCol = resolveRowByteColumns(sourceText, symbol.line_start, symbol.byte_start);
+  const endCol = resolveRowByteColumns(sourceText, symbol.line_end, symbol.byte_end);
+  if (startCol === null || endCol === null) {
+    return {
+      item: null,
+      notIndexed: true,
+      absence: absenceWith(
+        "coordinates_missing",
+        "the indexed span could not be resolved against the file's own byte columns (no item is placed)",
+        symbol.path
+      ),
+      staleness
+    };
+  }
+  const mapper = createPositionMapper(sourceText);
+  const range = mapper.indexRangeToLsp({
+    start: { line: startCol.line, column: startCol.column },
+    end: { line: endCol.line, column: endCol.column }
+  });
+  const lspRange = {
+    start: { line: range.start.line, character: range.start.character },
+    end: { line: range.end.line, character: range.end.character }
+  };
+  const nameRange = nameTokenRange(
+    sourceText,
+    symbol.name,
+    { start: lspRange.start.line, end: lspRange.end.line }
+  ) ?? lspRange;
+  const sigRow = raw.prepare("SELECT parameters, return_type, visibility FROM brain_symbol WHERE id = ?").get(symbol.id);
+  const detail = sigRow === void 0 ? symbol.symbol_type : renderSignature(
+    {
+      name: symbol.name,
+      symbol_type: symbol.symbol_type,
+      parameters: sigRow.parameters,
+      return_type: sigRow.return_type,
+      visibility: null
+    },
+    languageForPath(symbol.path)
+  );
+  return {
+    item: {
+      name: symbol.name,
+      kind: symbolKindFor(symbol.symbol_type),
+      uri: `file://${symbol.path}`,
+      range: lspRange,
+      selectionRange: nameRange,
+      detail,
+      positionBasis: "source_resolved",
+      data: { symbolId: symbol.id, isExternal: false }
+    },
+    notIndexed: false,
+    absence: null,
+    staleness
+  };
+}
+function itemFromNode(node, source, detail) {
+  const filePath = node.filePath !== "" ? node.filePath : node.file;
+  const mapper = source === null ? null : createPositionMapper(source);
+  const window = mapper === null ? null : lspLineWindow(mapper, node.line, node.lineEnd);
+  const start0 = window === null ? 0 : window.start;
+  const end0 = window === null ? 0 : window.end;
+  let range = unresolvableRange();
+  let selectionRange = range;
+  if (source !== null && window !== null) {
+    range = {
+      start: { line: start0, character: lineIndent(source, start0) },
+      end: { line: end0, character: lineLength(source, end0) }
+    };
+    selectionRange = nameTokenRange(source, node.name, { start: start0, end: end0 }) ?? range;
+  }
+  const resolved = source !== null && window !== null;
+  return {
+    name: node.name,
+    kind: symbolKindFor(node.symbolType),
+    uri: filePath !== "" ? `file://${filePath}` : "",
+    range,
+    selectionRange,
+    detail: resolved ? detail : `${detail} \xB7 position unresolvable (no readable source for this node)`,
+    positionBasis: resolved ? "source_resolved" : "declared_unresolvable",
+    data: { symbolId: node.id, isExternal: node.isExternal }
+  };
+}
+async function expandCalls(raw, projectId, request, traverse = defaultTraverse, readSource = makeSourceReader()) {
+  const { item } = request;
+  if (item.data.isExternal) {
+    return {
+      calls: [],
+      truncated: false,
+      maxDepthReached: 0,
+      evidenceTier: "not_indexed",
+      callSitesResolved: 0,
+      callSitesApproximate: 0,
+      droppedEdges: [],
+      absence: absenceWith(
+        "external_target",
+        "the expanded item is an external node with no index identity, so there is nothing for bb to traverse (this is NOT 'this symbol has no callers')"
+      ),
+      declaredAbsentNodes: [],
+      staleness: unknownStaleness(),
+      callSiteEntries: { resolved: 0, approximate: 0 },
+      addressCrossCheck: emptyCrossCheck(),
+      addressDisagreements: [],
+      relationshipTypes: [...CALL_HIERARCHY_RELATIONSHIP_TYPES]
+    };
+  }
+  const rootRow = raw.prepare(
+    `SELECT s.id, s.name, s.symbol_type, COALESCE(s.qualified_name,'') AS qualifiedName,
+              COALESCE(s.line_start,0) AS line,
+              COALESCE(s.line_end,0) AS lineEnd,
+              COALESCE(f.relative_path,'') AS relativePath,
+              COALESCE(f.path,'') AS filePath,
+              f.id AS fileId,
+              COALESCE(f.language,'unknown') AS language,
+              COALESCE(s.complexity,0) AS complexity
+       FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id
+       WHERE s.id = ?`
+  ).get(item.data.symbolId);
+  if (rootRow === void 0) {
+    return {
+      calls: [],
+      truncated: false,
+      maxDepthReached: 0,
+      evidenceTier: "not_indexed",
+      callSitesResolved: 0,
+      callSitesApproximate: 0,
+      droppedEdges: [],
+      absence: absenceWith(
+        "symbol_not_in_index",
+        `the index stores no symbol with id "${item.data.symbolId}", so there is no hierarchy to traverse (this is NOT 'this symbol has no callers')`
+      ),
+      declaredAbsentNodes: [],
+      staleness: unknownStaleness(),
+      callSiteEntries: { resolved: 0, approximate: 0 },
+      addressCrossCheck: emptyCrossCheck(),
+      addressDisagreements: [],
+      relationshipTypes: [...CALL_HIERARCHY_RELATIONSHIP_TYPES]
+    };
+  }
+  const rootScope = declaredAbsenceFor(rootRow.filePath);
+  if (rootScope !== null) {
+    return {
+      calls: [],
+      truncated: false,
+      maxDepthReached: 0,
+      evidenceTier: "not_indexed",
+      callSitesResolved: 0,
+      callSitesApproximate: 0,
+      droppedEdges: [],
+      absence: rootScope,
+      declaredAbsentNodes: [],
+      staleness: unknownStaleness([rootRow.filePath]),
+      callSiteEntries: { resolved: 0, approximate: 0 },
+      addressCrossCheck: emptyCrossCheck(),
+      addressDisagreements: [],
+      relationshipTypes: [...CALL_HIERARCHY_RELATIONSHIP_TYPES]
+    };
+  }
+  const ownNames = /* @__PURE__ */ new Set([rootRow.name]);
+  const qualified = rootRow.qualifiedName ?? "";
+  if (qualified.includes(".")) {
+    const ownerSegment = qualified.slice(0, qualified.lastIndexOf(".")).split(".").pop() ?? "";
+    if (ownerSegment.length > 0) ownNames.add(ownerSegment);
+  }
+  const maxDepth = Math.max(1, Math.min(request.maxDepth ?? CH_MAX_DEPTH, 10));
+  const direction = request.direction === "incoming" ? "callers" : "callees";
+  const engineRoot = {
+    id: rootRow.id,
+    name: rootRow.name,
+    symbolType: rootRow.symbol_type,
+    line: rootRow.line,
+    lineEnd: rootRow.lineEnd,
+    relativePath: rootRow.relativePath,
+    filePath: rootRow.filePath,
+    language: rootRow.language,
+    complexity: rootRow.complexity
+  };
+  const result = await traverse(projectId, engineRoot, {
+    direction,
+    maxDepth,
+    callerBudget: CH_FANOUT_BUDGET,
+    calleeBudget: CH_FANOUT_BUDGET,
+    // §15.3: ask for CALL rows only. Without this the engine's default ten-kind
+    // superset reaches a renderer whose `fromRanges` must name a call site.
+    relationshipTypes: [...CALL_HIERARCHY_RELATIONSHIP_TYPES]
+  });
+  const rootSource = readSource(rootRow.filePath);
+  const edges = direction === "callers" ? result.callers : result.callees;
+  const calls = [];
+  const seenFrom = /* @__PURE__ */ new Set();
+  const droppedEdges = [];
+  const declaredAbsentNodes = [];
+  const addressDisagreements = [];
+  const edgePaths = [];
+  let callSitesResolved = 0;
+  let callSitesApproximate = 0;
+  let resolvedEntries = 0;
+  let approximateEntries = 0;
+  const crossCheck = emptyCrossCheck();
+  for (const edge of edges) {
+    const otherId = direction === "callers" ? edge.from : edge.to;
+    if (seenFrom.has(otherId)) continue;
+    const node = result.nodes[otherId];
+    if (node === void 0) continue;
+    const nodePath = node.filePath !== "" ? node.filePath : node.file;
+    if (!node.isExternal && declaredAbsenceFor(nodePath) !== null) {
+      declaredAbsentNodes.push({
+        name: node.name,
+        symbolId: otherId,
+        reason: `the node's own file (${nodePath}) is outside the bb launch set, so bb declares no call sites for it`
+      });
+      continue;
+    }
+    edgePaths.push(nodePath);
+    const callerSource = direction === "callers" ? readSource(nodePath) : rootSource;
+    const callerWindow = callerSource === null ? null : lspLineWindow(
+      createPositionMapper(callerSource),
+      direction === "callers" ? node.line : rootRow.line,
+      direction === "callers" ? node.lineEnd : rootRow.lineEnd
+    );
+    const callerLines0 = callerWindow;
+    const invokedName = direction === "callers" ? rootRow.name : node.name;
+    const callerOwnName = direction === "callers" ? node.name : rootRow.name;
+    const callerNamePos = callerSource === null || callerLines0 === null ? void 0 : nameTokenRange(callerSource, callerOwnName, callerLines0)?.start;
+    const scannedPath = direction === "callers" ? nodePath : rootRow.filePath;
+    const targetDeclLine1 = direction === "callers" ? rootRow.line : node.line;
+    const targetDeclPath = direction === "callers" ? rootRow.filePath : nodePath;
+    const targetDeclPos = callerSource === null || scannedPath !== targetDeclPath ? void 0 : declarationTokenOf(callerSource, createPositionMapper(callerSource), invokedName, targetDeclLine1);
+    const invocations = callerSource === null || callerLines0 === null ? [] : resolveInvocations(
+      callerSource,
+      invokedName,
+      callerLines0,
+      callerNamePos,
+      ownNames,
+      targetDeclPos === void 0 ? [] : [targetDeclPos]
+    );
+    const isSelfEdge = otherId === item.data.symbolId;
+    if (isSelfEdge) {
+      const receiverQualified = invocations.length > 0 && invocations.every((i) => i.kind === "receiver");
+      if (receiverQualified) {
+        droppedEdges.push({
+          name: node.name,
+          symbolId: otherId,
+          reason: `receiver-qualified self-name call (${invocations[0].receiver}.${invokedName}) targets another value, not this symbol`
+        });
+        continue;
+      }
+    }
+    const scanLines0 = invocations.map((i) => i.range.start.line);
+    const edgeTarget = result.nodes[edge.to];
+    const edgeTargetName = edgeTarget?.name ?? "";
+    const edgeSource = result.nodes[edge.from];
+    const likeForLike = edge.depth === 0 && edgeTargetName === invokedName && edgeSource !== void 0;
+    let crossLines0 = scanLines0;
+    let crossScanRan = true;
+    if (!likeForLike) {
+      crossScanRan = false;
+      const hopPath = edgeSource === void 0 ? "" : edgeSource.filePath !== "" ? edgeSource.filePath : edgeSource.file;
+      const hopSource = hopPath === "" ? null : readSource(hopPath);
+      if (hopSource !== null && edgeSource !== void 0 && edgeTargetName !== "") {
+        const hopMapper = createPositionMapper(hopSource);
+        const hopWindow = lspLineWindow(hopMapper, edgeSource.line, edgeSource.lineEnd);
+        if (hopWindow !== null) {
+          const hopTargetPath = edgeTarget === void 0 ? "" : edgeTarget.filePath !== "" ? edgeTarget.filePath : edgeTarget.file;
+          const hopDeclPos = hopTargetPath !== "" && hopPath === hopTargetPath ? declarationTokenOf(hopSource, hopMapper, edgeTargetName, edgeTarget.line) : void 0;
+          crossLines0 = resolveInvocations(
+            hopSource,
+            edgeTargetName,
+            hopWindow,
+            void 0,
+            /* @__PURE__ */ new Set(),
+            hopDeclPos === void 0 ? [] : [hopDeclPos]
+          ).map((i) => i.range.start.line);
+          crossScanRan = true;
+        }
+      }
+    }
+    const agreement = crossCheckEdge(edge, crossLines0, scanLines0[0] ?? null, edgeTargetName);
+    if (!crossScanRan) agreement.agreement = "neither";
+    tallyCrossCheck(crossCheck, agreement, agreement.address !== null);
+    if (!crossScanRan) crossCheck.comparisonNotRun++;
+    if (!CALL_HIERARCHY_RELATIONSHIP_TYPES.includes(edge.relationshipType)) {
+      droppedEdges.push({
+        name: node.name,
+        symbolId: otherId,
+        reason: `the stored row is a "${edge.relationshipType}" relation, not a call; a call hierarchy renders call sites and this relation names none, so the row is omitted rather than rendered with a range (contract 15.3)`
+      });
+      continue;
+    }
+    if (invocations.length === 0 && callerSource !== null && callerLines0 !== null && !node.isExternal && edge.relationshipType === "calls") {
+      const hop = Number.isInteger(edge.depth) && edge.depth >= 1;
+      const storeLine = agreement.address !== null && isExactAddress(agreement.address) ? agreement.address.line : null;
+      const reason = hop ? `${node.name} does not invoke ${invokedName} in its own source; the engine reports this row at depth ${edge.depth}, so it is a transitive hop (${node.name} reaches ${invokedName} through an intermediate symbol), not a direct ${direction === "callers" ? "caller" : "callee"}` : storeLine !== null ? `${node.name} does not invoke ${invokedName} anywhere in its own source, yet the stored row names call site line ${storeLine} - the store and the caller's own text disagree about this DIRECT row; this surface renders the source-resolved position and declares the difference (contract 15.1), because rendering the stored line would be rendering a position this surface cannot verify (15.3)` : `${node.name} does not invoke ${invokedName} in its own source and the stored row names no call site for it - a stale stored row, not a direct ${direction === "callers" ? "caller" : "callee"}`;
+      droppedEdges.push({ name: node.name, symbolId: otherId, reason });
+      if (agreement.agreement !== "neither") {
+        addressDisagreements.push({
+          name: node.name,
+          symbolId: otherId,
+          reason,
+          agreement
+        });
+      }
+      continue;
+    }
+    seenFrom.add(otherId);
+    const recursiveMarker = isSelfEdge ? " \xB7 recursive" : "";
+    const unplaceable = callerLines0 === null && callerSource !== null;
+    const baseDetail = `${node.symbolType} \xB7 ${edge.relationshipType} \xB7 ${recursiveMarker ? "self" : "1 call site"}${recursiveMarker}`;
+    const detail = unplaceable ? `${baseDetail} \xB7 caller declaration line unresolvable in its own source` : baseDetail;
+    const expanded = itemFromNode(node, direction === "callers" ? callerSource : readSource(nodePath), detail);
+    let fromRanges;
+    if (invocations.length > 0) {
+      fromRanges = invocations.map((i) => i.range);
+      callSitesResolved += invocations.length;
+      resolvedEntries++;
+    } else {
+      fromRanges = [expanded.selectionRange];
+      callSitesApproximate += 1;
+      approximateEntries++;
+    }
+    const withPosition = invocations.length === 0 ? { ...expanded, detail: `${expanded.detail} \xB7 position approximate` } : expanded;
+    if (direction === "callers") {
+      calls.push({ from: withPosition, fromRanges });
+    } else {
+      calls.push({ to: withPosition, fromRanges });
+    }
+    if (agreement.agreement !== "agree" && agreement.agreement !== "neither") {
+      const storeLineText = agreement.address !== null && isExactAddress(agreement.address) ? `${agreement.address.file}:${agreement.address.line}` : agreement.address === null ? "no address at all" : `address kind "${agreement.address.kind}"`;
+      addressDisagreements.push({
+        name: node.name,
+        symbolId: otherId,
+        reason: agreement.agreement === "disagree" ? `the store names call site ${storeLineText} while a like-for-like scan of ${agreement.edgeTargetName} in the row's own source resolved ${JSON.stringify(agreement.sourceLines0.map((l) => l + 1))} (1-based) - the two sources of truth contradict each other for this ${agreement.direct ? "direct" : `depth-${agreement.depth} hop`} row, and this surface renders the source-resolved position` : agreement.agreement === "store-only" ? `the store names call site ${storeLineText} and a like-for-like scan of ${agreement.edgeTargetName} in the row's own source resolves nothing - the invocation is not in the text this surface reads (a macro, a template or a dynamic dispatch), on a ${agreement.direct ? "direct" : `depth-${agreement.depth} hop`} row` : `a like-for-like scan resolved ${JSON.stringify(agreement.sourceLines0.map((l) => l + 1))} (1-based) while the store's address is ${storeLineText} - the store names no call site for this row`,
+        agreement: { ...agreement, renderedLine0: fromRanges[0]?.start.line ?? null }
+      });
+    }
+  }
+  return {
+    calls,
+    truncated: result.truncated,
+    truncationReason: result.truncationReason,
+    maxDepthReached: result.maxDepthReached,
+    evidenceTier: "indexed",
+    callSitesResolved,
+    callSitesApproximate,
+    callSiteEntries: { resolved: resolvedEntries, approximate: approximateEntries },
+    droppedEdges,
+    absence: calls.length === 0 ? absenceWith(
+      // §11.7: the symbol WAS found and served; what is empty is its call
+      // list among the kinds this surface reads. That is a different fact
+      // from "no symbol covers the position" (prepare's code), so it has its
+      // own machine-readable code — a client that branches on the code must
+      // not be told the symbol is missing.
+      "no_stored_calls",
+      // §11.7 + §15.1: the absence names the filter, because an answer
+      // emptied BY the filter is a different claim from an answer emptied
+      // because the STORE holds no row.
+      //
+      // WHAT EACH BRANCH MAY CLAIM, kept strictly to what this answer read.
+      // The surface asks the engine for `calls` alone (measured on the T2
+      // fixture at HEAD: `get/incoming` answers zero caller rows), so no
+      // branch may claim what the engine would have said about another kind:
+      //   edges.length === 0   no stored CALL row reached this answer. "none
+      //                        stored" is scoped to the kinds this surface
+      //                        read, and the sentence says so.
+      //   edges.length >  0    this many stored CALL rows were read and this
+      //                        many were dropped or declared absent. A
+      //                        non-call row the surface DID see is named in
+      //                        `droppedEdges` with its kind, so a reader can
+      //                        find the rows this answer declined rather
+      //                        than being told they do not exist.
+      //
+      // DELIBERATELY NOT CLAIMED: that the engine returned no stored edge of
+      // any kind, or that the store holds no relationship row of another
+      // kind. This surface asked for one kind and cannot know either. The
+      // pre-M55 wording of the first branch claimed both ("the engine
+      // returned no stored … edge of any kind"), which a filtered surface is
+      // not entitled to say; the declared filter is what lets a reader bound
+      // the claim.
+      edges.length === 0 ? `no stored ${direction === "callers" ? "caller" : "callee"} CALL edge was read for this symbol (none stored among the relationship kind(s) this surface reads). This surface asked the engine for ${JSON.stringify(CALL_HIERARCHY_RELATIONSHIP_TYPES)} only and declares that filter (\xA715.1), so "none stored" is a statement about ${JSON.stringify(CALL_HIERARCHY_RELATIONSHIP_TYPES)} only \u2014 it is NOT a statement that the store holds no relationship row of any other kind` : `no stored ${direction === "callers" ? "caller" : "callee"} CALL row of this symbol is rendered. This surface reads the ${CALL_HIERARCHY_RELATIONSHIP_TYPES.length} relationship kind(s) ${JSON.stringify(CALL_HIERARCHY_RELATIONSHIP_TYPES)} only and declares that filter on every response (\xA715.1): ${edges.length} stored CALL row(s) were read and ${droppedEdges.length} were dropped or declared absent, each with its reason and kind named \u2014 rows of other kinds may be stored for this symbol and are not ${direction === "callers" ? "callers" : "callees"} here, so this answer is "no stored call rendered", not "no stored relationship"`,
+      rootRow.filePath
+    ) : null,
+    declaredAbsentNodes,
+    staleness: expandStaleness(raw, rootRow.fileId ?? null, rootRow.filePath, edgePaths),
+    addressCrossCheck: crossCheck,
+    addressDisagreements,
+    // §15.1: stated on the NORMAL answer too, not only on the absence paths —
+    // a reader of a non-empty caller list needs the same filter declaration as
+    // a reader of an empty one.
+    relationshipTypes: [...CALL_HIERARCHY_RELATIONSHIP_TYPES]
+  };
+}
+
+// src/lsp/server.ts
+var STALENESS_SCHEMA_VERSION = 1;
+function stalenessProviderPayload() {
+  return {
+    schemaVersion: STALENESS_SCHEMA_VERSION,
+    marker: {
+      stale: "boolean",
+      status: ["fresh", "stale", "missing", "unknown"],
+      pendingReindex: "boolean"
+    },
+    /** The declared sync model (contract §4.2): filesystem-side, debounced by
+     *  DEBOUNCE_MS in src/lsp/freshness.ts, with a scan-on-read fallback when
+     *  the watcher fails. No latency figure is advertised — this gate measures
+     *  none, and an unmeasured budget presented as a budget is a §1 claim
+     *  violation. */
+    syncModel: {
+      source: "filesystem-watch",
+      debounceMs: 300,
+      fallback: "scan-on-read",
+      clientDocumentSync: false
+    }
+  };
+}
+function impactProviderPayload() {
+  return { schemaVersion: 1 };
+}
+function absenceProviderPayload() {
+  return {
+    schemaVersion: ABSENCE_SCHEMA_VERSION,
+    method: ABSENCE_METHOD,
+    direction: "serverToClient",
+    carriers: [ABSENCE_METHOD, "window/logMessage"],
+    /** The reason vocabulary, advertised so a client renders known reasons
+     *  correctly instead of string-matching on prose. */
+    reasons: ["language_not_launched", "not_indexed", "unresolvable_location", "unsupported_language", "not_callable"],
+    /** What a client is being told, stated plainly: an EMPTY standard result
+     *  on these methods is not evidence that nothing exists. */
+    emptyResultMeans: "absent-or-unserved \u2014 not 'nothing found'; read the bb/absence notice for which"
+  };
+}
+function workspaceProviderPayload() {
+  return { workspaceFolders: { supported: false, changeNotifications: false } };
+}
+var CAPABILITY_COVERAGE = [
+  { key: "hoverProvider", methods: ["textDocument/hover"], kind: "handler", value: () => true },
+  { key: "definitionProvider", methods: ["textDocument/definition"], kind: "handler", value: () => true },
+  { key: "referencesProvider", methods: ["textDocument/references"], kind: "handler", value: () => true },
+  {
+    key: "documentHighlightProvider",
+    methods: ["textDocument/documentHighlight"],
+    kind: "handler",
+    value: () => true
+  },
+  { key: "documentSymbolProvider", methods: ["textDocument/documentSymbol"], kind: "handler", value: () => true },
+  { key: "workspaceSymbolProvider", methods: ["workspace/symbol"], kind: "handler", value: () => true },
+  {
+    key: "callHierarchyProvider",
+    methods: [
+      "textDocument/prepareCallHierarchy",
+      "callHierarchy/incomingCalls",
+      "callHierarchy/outgoingCalls"
+    ],
+    kind: "handler",
+    value: () => true
+  },
+  { key: "graphProvider", methods: ["bb/graph"], kind: "handler", value: () => ({ schemaVersion: 2 }) },
+  {
+    key: "stalenessProvider",
+    methods: ["bb/staleness"],
+    kind: "handler",
+    value: stalenessProviderPayload
+  },
+  {
+    key: "impactProvider",
+    methods: ["bb/impact"],
+    kind: "handler",
+    value: impactProviderPayload
+  },
+  {
+    key: "workspace",
+    methods: [],
+    kind: "static",
+    value: workspaceProviderPayload
+  },
+  {
+    /**
+     * The declared-absence channel. `kind: "static"` because it describes a
+     * SERVER-TO-CLIENT notification, not a request handler: it is offered
+     * whenever the server is running, and there is deliberately no inbound
+     * `bb/absence` handler to advertise (G10 asserts an inbound request gets
+     * MethodNotFound). `direction` is stated so a client cannot build a
+     * request around it.
+     */
+    key: "absenceProvider",
+    methods: [],
+    kind: "static",
+    value: absenceProviderPayload
+  }
+];
+function capabilityKeyForMethod(method) {
+  return CAPABILITY_COVERAGE.find((e) => e.methods.includes(method))?.key;
+}
+var ErrorCodes = {
+  ParseError: -32700,
+  InvalidRequest: -32600,
+  MethodNotFound: -32601,
+  InvalidParams: -32602,
+  InternalError: -32603,
+  ServerNotInitialized: -32002
+};
+function languageForMessage(params) {
+  const uri = params?.textDocument?.uri;
+  if (typeof uri !== "string" || uri.length === 0) return null;
+  return languageForPath(uriToPath(uri));
+}
+var ASTENGINE_UNROUTABLE_PREFIX = "Unsupported file type";
+function asDocumentUnroutable(error) {
+  if (error instanceof DocumentUnroutable) return error;
+  if (error instanceof Error && typeof error.message === "string" && error.message.startsWith(ASTENGINE_UNROUTABLE_PREFIX)) {
+    return new DocumentUnroutable(error.message);
+  }
+  return null;
+}
+function guardUnroutableDocument(method, handler) {
+  return async (params) => {
+    const uri = params?.textDocument?.uri;
+    const hasDocument = typeof uri === "string" && uri.length > 0;
+    try {
+      return await handler(params);
+    } catch (error) {
+      if (asDocumentUnroutable(error) === null) throw error;
+      throw new DeclaredAbsenceThrow({
+        method,
+        reason: "language_not_launched",
+        language: hasDocument ? languageForMessage(params) : null,
+        detail: "this file's type is outside the analyzer's routed set, so it was never routed and the index was not searched",
+        evidenceTier: "unsupported_language",
+        searchedIndex: false,
+        totalCount: null
+      });
+    }
+  };
+}
+var DeclaredParamsError = class extends Error {
+  code = ErrorCodes.InvalidParams;
+  constructor(message) {
+    super(message);
+    this.name = "DeclaredParamsError";
+  }
+};
+var ABSENCE_SCHEMA_VERSION = 1;
+var ABSENCE_METHOD = "bb/absence";
+var ABSENCE_LOG_TYPE = 3;
+var DocumentUnroutable = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DocumentUnroutable";
+  }
+};
+function absenceReasonFor(code) {
+  switch (code) {
+    case "language_outside_launch_set":
+    case "file_type_unknown":
+      return "language_not_launched";
+    case "unsupported_language":
+      return "unsupported_language";
+    case "no_stored_calls":
+      return "not_callable";
+    default:
+      return "not_indexed";
+  }
+}
+var DeclaredAbsenceThrow = class extends Error {
+  absence;
+  constructor(absence) {
+    super(absence.detail);
+    this.name = "DeclaredAbsenceThrow";
+    this.absence = absence;
+  }
+};
+var JSONRPC = "2.0";
+function isNotification(msg) {
+  return msg.method !== void 0 && msg.id === void 0;
+}
+function isResponse(msg) {
+  return msg.method === void 0 && msg.id !== void 0;
+}
+var BbLspServer = class {
+  lifecycleState = "uninitialized";
+  handlers = /* @__PURE__ */ new Map();
+  /** Methods opted into the declared-absence seam (see register). */
+  absentableMethods = /* @__PURE__ */ new Set();
+  /**
+   * Server→client notifications produced by the most recent handleMessage
+   * call, drained by the wire loop. Queueing them here (rather than writing
+   * straight to the stream) keeps handleMessage pure and testable, and is what
+   * lets the verifier assert on EXACTLY what a client would receive.
+   */
+  outboundNotifications = [];
+  protocolEvents = [];
+  hooks;
+  stderrLogPath = process.env.BB_LSP_STDERR_LOG ?? null;
+  context;
+  constructor(root, hooks = {}) {
+    const resolved = path2.resolve(root);
+    let canonical = resolved;
+    try {
+      canonical = realpathSync.native(resolved);
+    } catch {
+    }
+    this.context = {
+      root: canonical,
+      projectId: getProjectId(canonical),
+      serverInfo: { name: "bb_lsp", version: BACKBENCHER_BRAIN_VERSION }
+    };
+    this.hooks = hooks;
+  }
+  /** Register a feature handler. Capabilities derive from this table.
+   *
+   *  `absentable: true` opts the method into the declared-absence seam: a
+   *  component fault of a DECLARED type (PositionError, DeclaredAbsenceThrow,
+   *  DocumentUnroutable) then answers as declared absence with a reason the
+   *  client can read, instead of -32603. The opt-in is per method and
+   *  deliberate: a blanket catch over all handlers would let a genuine bug
+   *  render as "nothing here", and G10 gates exactly that regression. */
+  register(method, handler, opts = {}) {
+    this.handlers.set(method, opts.absentable ? guardUnroutableDocument(method, handler) : handler);
+    if (opts.absentable) this.absentableMethods.add(method);
+  }
+  /** The LSP methods this instance can actually serve — the honest successor
+   *  to the deleted `IMPLEMENTED_METHODS` export, which was a frozen empty
+   *  array while twelve handlers were registered. Handler set is per-instance
+   *  (it is whatever `register`/`wireFeatures` put there), so the truth is an
+   *  instance read, not a module constant. */
+  implementedMethods() {
+    return [...this.handlers.keys()].sort();
+  }
+  /** Capabilities advertised in the initialize result — derived from the
+   *  registered handler set so advertisement can never outrun reality, and
+   *  cross-checked against CAPABILITY_COVERAGE by script/m24/verify-server.ts
+   *  (G6) in both directions.
+   *
+   *  The three additions below are the ones a client could not previously
+   *  discover:
+   *    - stalenessProvider / impactProvider: bb/staleness and bb/impact were
+   *      registered but had NO capability key, so a client could only reach
+   *      them blind. LSP 3.18 has no standard `impactProvider`, and the
+   *      `bb/` namespace is private honesty plumbing rather than a standard
+   *      provider, so these ride top-level keys exactly as bb/graph already
+   *      did (`graphProvider`) — with the schemaVersion the handler ENFORCES
+   *      on inbound requests, so a client can detect a version mismatch before
+   *      it sends one. The G6 table makes their absence a gate failure.
+   *    - workspace: the single-root limitation is a server CONSTANT, not a
+   *      handler-derived fact, so it is declared unconditionally. Advertising
+   *      `workspaceFolders.supported: false` is how a client learns it from the
+   *      wire (contract §11.6) instead of inferring it from a hang.
+   *  What is deliberately NOT here: `textDocumentSync`. This server registers
+   *  no `textDocument/did*` handler, so advertising a sync kind would tell the
+   *  client to send notifications into a void — a capability we do not
+   *  implement, which contract §2 calls a gate failure. The sync model is
+   *  filesystem-side (see the file header) and is advertised, truthfully, as
+   *  `stalenessProvider.syncModel`. G8 pins the absence so a future edit that
+   *  advertises a sync kind without a did* handler fails the gate. */
+  capabilities() {
+    const caps = {};
+    if (this.handlers.has("textDocument/hover")) caps.hoverProvider = true;
+    if (this.handlers.has("textDocument/definition")) caps.definitionProvider = true;
+    if (this.handlers.has("textDocument/references")) caps.referencesProvider = true;
+    if (this.handlers.has("textDocument/documentHighlight")) caps.documentHighlightProvider = true;
+    if (this.handlers.has("textDocument/documentSymbol")) caps.documentSymbolProvider = true;
+    if (this.handlers.has("workspace/symbol")) caps.workspaceSymbolProvider = true;
+    if (this.handlers.has("textDocument/prepareCallHierarchy") && this.handlers.has("callHierarchy/incomingCalls") && this.handlers.has("callHierarchy/outgoingCalls")) {
+      caps.callHierarchyProvider = true;
+    }
+    if (this.handlers.has("bb/graph")) caps.graphProvider = { schemaVersion: 2 };
+    if (this.handlers.has("bb/staleness")) caps.stalenessProvider = stalenessProviderPayload();
+    if (this.handlers.has("bb/impact")) caps.impactProvider = impactProviderPayload();
+    caps.absenceProvider = absenceProviderPayload();
+    caps.workspace = workspaceProviderPayload();
+    return caps;
+  }
+  state() {
+    return this.lifecycleState;
+  }
+  /** The server→client notifications queued by the last handleMessage call.
+   *  Read-only: a test may inspect them, and the wire loop still drains the
+   *  same queue, so what the test asserts on is byte-for-byte what a client
+   *  receives. */
+  notifications() {
+    return [...this.outboundNotifications];
+  }
+  /** Take the queued notifications, leaving the queue empty. */
+  drainNotifications() {
+    const queued = this.outboundNotifications;
+    this.outboundNotifications = [];
+    return queued;
+  }
+  /** Queue a server→client notification. Every notification this server emits
+   *  goes through here so the carriers cannot drift: `bb/absence` for the
+   *  machine-readable record and `window/logMessage` for the human line are
+   *  emitted as ONE unit from `emitAbsence`, never separately. */
+  notify(method, params) {
+    this.outboundNotifications.push({ jsonrpc: JSONRPC, method, params });
+  }
+  /**
+   * Announce a declared absence on BOTH carriers, from one call, so they cannot
+   * disagree:
+   *   - `bb/absence` (versioned, machine-readable; what a client should read)
+   *   - `window/logMessage` (the protocol's own channel; reaches a client that
+   *     has never heard of bb/*)
+   * Emitted ONLY on the absence path — never on a served request (G9's negative
+   * case gates that; logging every successful hover would be noise the user
+   * learns to ignore, which is how a warning channel dies).
+   */
+  emitAbsence(absence) {
+    this.notify(ABSENCE_METHOD, { schemaVersion: ABSENCE_SCHEMA_VERSION, ...absence });
+    this.notify("window/logMessage", {
+      type: ABSENCE_LOG_TYPE,
+      // Named by method so the log line is actionable on its own: a user who
+      // only sees this in an output panel learns WHICH request was not
+      // answered, and why.
+      message: `bb ${absence.method}: declared absence (${absence.reason}) \u2014 ${absence.detail}`
+    });
+  }
+  events() {
+    return this.protocolEvents;
+  }
+  record(direction, method, errorCode) {
+    const event = { direction, method, at: (/* @__PURE__ */ new Date()).toISOString() };
+    if (errorCode !== void 0) event.errorCode = errorCode;
+    this.protocolEvents.push(event);
+    this.hooks.onEvent?.(event);
+  }
+  /**
+   * Handle one decoded JSON-RPC message. Returns the response message to send
+   * (null for notifications and responses, which produce no reply).
+   */
+  async handleMessage(message) {
+    if (!message || typeof message !== "object") {
+      return this.errorResponse(null, ErrorCodes.InvalidRequest, "invalid message");
+    }
+    if (isResponse(message)) return null;
+    const method = message.method;
+    if (typeof method !== "string") {
+      return this.errorResponse(message.id ?? null, ErrorCodes.InvalidRequest, "missing method");
+    }
+    if (this.lifecycleState === "uninitialized" && method !== "initialize" && method !== "exit") {
+      this.record("in", method, ErrorCodes.ServerNotInitialized);
+      if (isNotification(message)) return null;
+      return this.errorResponse(message.id, ErrorCodes.ServerNotInitialized, "server not initialized");
+    }
+    if (this.lifecycleState === "shutdown" && method !== "exit") {
+      this.record("in", method, ErrorCodes.InvalidRequest);
+      if (isNotification(message)) return null;
+      return this.errorResponse(message.id, ErrorCodes.InvalidRequest, "invalid request after shutdown");
+    }
+    if (method === "exit") {
+      this.record("in", "exit");
+      return null;
+    }
+    if (method === "initialize") {
+      this.record("in", "initialize");
+      this.lifecycleState = "initialized";
+      this.record("out", "initialize");
+      return {
+        jsonrpc: JSONRPC,
+        id: message.id,
+        result: {
+          capabilities: this.capabilities(),
+          serverInfo: this.context.serverInfo,
+          protocolVersion: "3.18"
+        }
+      };
+    }
+    if (method === "initialized") {
+      this.record("in", "initialized");
+      return null;
+    }
+    if (method === "shutdown") {
+      this.record("in", "shutdown");
+      this.lifecycleState = "shutdown";
+      this.record("out", "shutdown");
+      return { jsonrpc: JSONRPC, id: message.id, result: null };
+    }
+    const handler = this.handlers.get(method);
+    if (handler) {
+      this.record("in", method);
+      this.outboundNotifications = [];
+      try {
+        const result = await handler(message.params);
+        this.record("out", method);
+        return { jsonrpc: JSONRPC, id: message.id, result };
+      } catch (error) {
+        if (error instanceof DeclaredParamsError) {
+          this.record("out", method, ErrorCodes.InvalidParams);
+          return this.errorResponse(message.id, ErrorCodes.InvalidParams, error.message);
+        }
+        const absentable = this.absentableMethods.has(method);
+        if (absentable && error instanceof DeclaredAbsenceThrow) {
+          this.emitAbsence(error.absence);
+          this.record("out", method);
+          return { jsonrpc: JSONRPC, id: message.id, result: null };
+        }
+        if (absentable && error instanceof PositionError) {
+          this.emitAbsence({
+            method,
+            reason: "unresolvable_location",
+            language: languageForMessage(message.params),
+            detail: `${error.message} \u2014 the position does not resolve, so there is no answer to give (contract \xA713.10)`,
+            evidenceTier: null,
+            searchedIndex: false,
+            totalCount: null
+          });
+          this.record("out", method);
+          return { jsonrpc: JSONRPC, id: message.id, result: null };
+        }
+        if (absentable && error instanceof DocumentUnroutable) {
+          this.emitAbsence({
+            method,
+            reason: "language_not_launched",
+            language: null,
+            detail: `${error.message} \u2014 this file type is outside the analyzer's routed set, so the index was never searched`,
+            evidenceTier: null,
+            searchedIndex: false,
+            totalCount: null
+          });
+          this.record("out", method);
+          return { jsonrpc: JSONRPC, id: message.id, result: null };
+        }
+        this.record("out", method, ErrorCodes.InternalError);
+        return this.errorResponse(message.id, ErrorCodes.InternalError, error?.message ?? String(error));
+      }
+    }
+    this.record("in", method, ErrorCodes.MethodNotFound);
+    if (isNotification(message)) return null;
+    return this.errorResponse(message.id, ErrorCodes.MethodNotFound, `method not implemented: ${method}`);
+  }
+  /**
+   * Wire loop: read Content-Length-framed JSON-RPC messages from stdin, feed
+   * each to handleMessage, and write responses to stdout. Resolves when the
+   * exit notification arrives (or stdin closes).
+   */
+  async run(input = process.stdin, output = process.stdout) {
+    const onEpipe = (err) => {
+      if (err?.code === "EPIPE") {
+        try {
+          output.end();
+        } catch {
+        }
+        process.exit(0);
+      }
+    };
+    process.on("error", onEpipe);
+    if (output === process.stdout) process.stdout.on("error", onEpipe);
+    if (input === process.stdin) process.stdin.on("error", onEpipe);
+    const writeMessage = (message) => {
+      if (!message) return;
+      const body = Buffer.from(JSON.stringify(message), "utf8");
+      output.write(`Content-Length: ${body.length}\r
+\r
+`);
+      output.write(body);
+    };
+    const writeNotification = (notification) => {
+      const body = Buffer.from(JSON.stringify(notification), "utf8");
+      output.write(`Content-Length: ${body.length}\r
+\r
+`);
+      output.write(body);
+    };
+    const drainNotifications = () => {
+      for (const notification of this.drainNotifications()) writeNotification(notification);
+    };
+    return new Promise((resolve) => {
+      let finished = false;
+      const finish = () => {
+        if (!finished) {
+          finished = true;
+          resolve();
+        }
+      };
+      let chunks = [];
+      let buffered = 0;
+      let contentLength = -1;
+      const tryExtract = () => {
+        while (true) {
+          if (contentLength < 0) {
+            const combined = Buffer.concat(chunks);
+            const idx = combined.indexOf("\r\n\r\n");
+            if (idx === -1) return;
+            const headerText = combined.subarray(0, idx).toString("utf8");
+            const match = /Content-Length:\s*(\d+)\s*(?:\r\n.*)?$/is.exec(headerText);
+            if (!match) {
+              writeMessage(this.errorResponse(null, ErrorCodes.ParseError, "missing Content-Length header"));
+              chunks = [];
+              buffered = 0;
+              return;
+            }
+            contentLength = parseInt(match[1], 10);
+            const rest = combined.subarray(idx + 4);
+            chunks = [rest];
+            buffered = rest.length;
+          }
+          if (contentLength >= 0 && buffered >= contentLength) {
+            const combined = Buffer.concat(chunks);
+            const body = combined.subarray(0, contentLength);
+            chunks = [combined.subarray(contentLength)];
+            buffered = chunks[0].length;
+            contentLength = -1;
+            void this.dispatch(body.toString("utf8"), writeMessage, finish, drainNotifications);
+            if (finished) return;
+            continue;
+          }
+          return;
+        }
+      };
+      input.on("data", (chunk) => {
+        chunks.push(chunk);
+        buffered += chunk.length;
+        tryExtract();
+      });
+      input.on("end", finish);
+      input.on("error", finish);
+    });
+  }
+  async dispatch(body, write, finish, drainNotifications) {
+    let message;
+    try {
+      message = JSON.parse(body);
+    } catch {
+      write(this.errorResponse(null, ErrorCodes.ParseError, "parse error"));
+      return;
+    }
+    if (message && isNotification(message) && message.method === "exit") {
+      this.record("in", "exit");
+      finish();
+      return;
+    }
+    const response = await this.handleMessage(message);
+    if (this.stderrLogPath) {
+      const req = message;
+      const err = response?.error;
+      try {
+        appendFileSync(this.stderrLogPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${req.method ?? "?"} id=${String(req.id)} params=${JSON.stringify(req.params ?? null)?.slice(0, 220)} -> ${err ? "ERROR " + String(err.message).slice(0, 200) : "ok"}
+`);
+      } catch {
+      }
+    }
+    write(response);
+    drainNotifications();
+  }
+  errorResponse(id, code, message) {
+    return {
+      jsonrpc: JSONRPC,
+      id: id ?? null,
+      error: { code, message }
+    };
+  }
+};
+function createServer(root, hooks = {}) {
+  return new BbLspServer(root, hooks);
+}
+function uriToPath(uri) {
+  if (uri.startsWith("file://")) {
+    try {
+      return fileURLToPath(uri);
+    } catch {
+      return uri.slice("file://".length);
+    }
+  }
+  return uri;
+}
+function wireFeatures(server) {
+  const projectId = server.context.projectId;
+  let monitor = null;
+  async function freshnessMonitor() {
+    if (monitor !== null) return monitor;
+    const { createFreshnessMonitor } = await import("../freshness-3K6VU5OT.js");
+    const { reindexFilesParallel } = await import("../parallel-indexer-FK2XKZXY.js");
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    monitor = createFreshnessMonitor({
+      projectId,
+      projectPath: server.context.root,
+      raw,
+      fileIdForPath: (p) => {
+        try {
+          const row = raw.prepare("SELECT id FROM brain_file WHERE path = ?").get(p);
+          return row?.id ?? null;
+        } catch {
+          return null;
+        }
+      },
+      // LSP-safety-critical: the indexer's DEFAULT logger writes progress to
+      // process.stdout — protocol poison on a stdio server (progress lines
+      // corrupt JSON-RPC framing; the editor client dies with "Header must
+      // provide a Content-Length property", found live by E5). All server-side
+      // indexer output must go to stderr; worker forks already do the same.
+      reindex: (changes) => reindexFilesParallel(projectId, server.context.root, changes, {
+        logger: { log: (...args) => console.error(...args), write: (s) => process.stderr.write(s) }
+      }),
+      log: (msg, meta) => console.error(`[bb_lsp] ${msg}`, meta ?? "")
+    });
+    monitor.start();
+    return monitor;
+  }
+  server.register("bb/staleness", async (params) => {
+    const mon = await freshnessMonitor();
+    const filePath = uriToPath(params?.uri ?? "");
+    let fileId = null;
+    try {
+      const raw = await BrainDatabase.getRawInstance(projectId);
+      const row = raw.prepare("SELECT id FROM brain_file WHERE path = ?").get(filePath);
+      fileId = row?.id ?? null;
+    } catch {
+    }
+    if (fileId === null) {
+      return { stale: true, status: "missing", pendingReindex: false };
+    }
+    return mon.marker(fileId);
+  });
+  server.register("bb/graph", async (params) => {
+    const { handleGraphRequest } = await import("../graph_request-Q6NKB6N2.js");
+    let raw = null;
+    try {
+      raw = await BrainDatabase.getRawInstance(projectId);
+    } catch {
+    }
+    return handleGraphRequest(raw, projectId, params);
+  });
+  server.register("bb/impact", async (params) => {
+    const { handleImpactRequest } = await import("../impact_request-LYP672WE.js");
+    let raw = null;
+    try {
+      raw = await BrainDatabase.getRawInstance(projectId);
+    } catch {
+    }
+    return handleImpactRequest(raw, projectId, params);
+  });
+  server.register("textDocument/hover", async (params) => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = await hover(raw, {
+      filePath: uriToPath(params?.textDocument?.uri ?? ""),
+      position: params?.position ?? { line: 0, character: 0 }
+    });
+    if (r.contents === null || r.range === null || r.data === null) {
+      const limits = r.provenance?.limitations ?? [];
+      const notLaunched = limits.some((l) => l.includes("launch language set"));
+      throw new DeclaredAbsenceThrow({
+        method: "textDocument/hover",
+        reason: notLaunched ? "language_not_launched" : "not_indexed",
+        language: languageForMessage(params),
+        // Human prose, never a JSON blob (§15.4): the component's own
+        // limitation sentences, joined.
+        detail: limits.length > 0 ? limits.join("; ") : "no indexed symbol at this position (the index was searched and stores nothing here)",
+        evidenceTier: r.provenance?.evidenceClass ?? null,
+        // A launch-language miss means the index WAS asked. A non-launch file
+        // means it never was — the distinction that lets a client label the
+        // difference instead of guessing.
+        searchedIndex: !notLaunched,
+        totalCount: null
+      });
+    }
+    return {
+      contents: r.contents,
+      range: { start: r.range.start, end: r.range.end },
+      data: { provenance: r.provenance, symbol: r.data }
+    };
+  }, { absentable: true });
+  server.register("textDocument/definition", async (params) => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = await resolveDefinition(raw, {
+      filePath: uriToPath(params?.textDocument?.uri ?? ""),
+      line: params?.position?.line ?? 0,
+      character: params?.position?.character ?? 0
+    });
+    if (!r.found || r.location === null) {
+      throw new DeclaredAbsenceThrow(
+        navigationAbsence("textDocument/definition", params, r.evidenceTier, {
+          limit: r.symbol?.qualifiedName ?? r.symbol?.name ?? null
+        })
+      );
+    }
+    return navLocationToWire(r.location);
+  }, { absentable: true });
+  server.register("textDocument/documentHighlight", async (params) => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = await documentHighlight(raw, {
+      filePath: uriToPath(params?.textDocument?.uri ?? ""),
+      line: params?.position?.line ?? 0,
+      character: params?.position?.character ?? 0
+    });
+    if (r.highlights.length === 0) {
+      const tier = r.evidenceTier;
+      const notLaunched = tier === "unsupported_language";
+      throw new DeclaredAbsenceThrow({
+        method: "textDocument/documentHighlight",
+        reason: notLaunched ? "language_not_launched" : "not_indexed",
+        language: languageForMessage(params),
+        detail: notLaunched ? "this file's type is outside the analyzer's routed set, so it was never routed and the index was not searched" : "the index was searched and stores no occurrence of this symbol at the requested position",
+        evidenceTier: tier,
+        searchedIndex: !notLaunched,
+        totalCount: 0
+      });
+    }
+    return r.highlights.map((h) => ({
+      range: { start: h.start, end: h.end },
+      kind: h.kind,
+      data: { evidenceTier: r.evidenceTier, staleness: r.staleness, symbol: r.symbol }
+    }));
+  }, { absentable: true });
+  server.register("textDocument/references", async (params) => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = await resolveReferences(raw, {
+      filePath: uriToPath(params?.textDocument?.uri ?? ""),
+      line: params?.position?.line ?? 0,
+      character: params?.position?.character ?? 0,
+      includeDeclaration: params?.context?.includeDeclaration ?? false
+    });
+    if (r.locations.length === 0) {
+      throw new DeclaredAbsenceThrow(navigationAbsence("textDocument/references", params, r.evidenceTier));
+    }
+    return r.locations.map(navLocationToWire);
+  }, { absentable: true });
+  server.register("textDocument/documentSymbol", async (params) => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = documentSymbols(raw, uriToPath(params?.textDocument?.uri ?? ""));
+    const tier = r.evidenceTier;
+    const notIndexed = r.notIndexed;
+    const toWire = (e) => ({
+      name: e.name,
+      detail: e.qualifiedName ?? void 0,
+      kind: symbolKindFor(e.symbolType),
+      range: symbolRangeToWire(e.range),
+      selectionRange: symbolRangeToWire(e.selectionRange),
+      children: e.children?.map(toWire),
+      data: { id: e.id, evidenceTier: tier, notIndexed }
+    });
+    return r.symbols.map(toWire);
+  });
+  server.register("workspace/symbol", async (params) => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = workspaceSymbols(raw, {
+      query: params?.query ?? "",
+      limit: params?.limit
+    });
+    return r.symbols.map((s) => ({
+      name: s.name,
+      kind: symbolKindFor(s.symbolType),
+      containerName: s.qualifiedName ?? void 0,
+      location: {
+        uri: `file://${s.path}`,
+        range: {
+          start: { line: s.line, character: 0 },
+          end: { line: s.line, character: 0 }
+        }
+      }
+    }));
+  });
+  server.register("textDocument/prepareCallHierarchy", async (params) => {
+    const p = requireObject(params, "params");
+    const doc = requireObject(p.textDocument, "params.textDocument");
+    if (typeof doc.uri !== "string" || doc.uri.length === 0) {
+      throw new DeclaredParamsError("bb/callHierarchy: params.textDocument.uri must be a non-empty string");
+    }
+    const pos = requireObject(p.position, "params.position");
+    if (typeof pos.line !== "number" || typeof pos.character !== "number") {
+      throw new DeclaredParamsError("bb/callHierarchy: params.position must carry numeric line and character");
+    }
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = await prepareCallHierarchy(raw, {
+      filePath: uriToPath(doc.uri),
+      line: pos.line,
+      character: pos.character
+    });
+    if (r.item === null && r.absence) {
+      const code = r.absence.code;
+      throw new DeclaredAbsenceThrow({
+        method: "textDocument/prepareCallHierarchy",
+        reason: absenceReasonFor(code),
+        language: r.absence.language ?? null,
+        detail: r.absence.message,
+        evidenceTier: null,
+        searchedIndex: code !== "language_outside_launch_set" && code !== "file_type_unknown",
+        totalCount: null
+      });
+    }
+    return r.item === null ? null : [r.item];
+  }, { absentable: true });
+  server.register("callHierarchy/incomingCalls", async (params) => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = await expandCalls(raw, projectId, {
+      item: requireCallHierarchyItem(params),
+      direction: "incoming"
+    });
+    return r.calls;
+  });
+  server.register("callHierarchy/outgoingCalls", async (params) => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const r = await expandCalls(raw, projectId, {
+      item: requireCallHierarchyItem(params),
+      direction: "outgoing"
+    });
+    return r.calls;
+  });
+}
+function requireObject(value, what, shape) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new DeclaredParamsError(
+      `bb/callHierarchy: ${what} must be an object${shape === void 0 ? "" : ` carrying { ${shape} }`}`
+    );
+  }
+  return value;
+}
+function requireCallHierarchyItem(params) {
+  const p = requireObject(params, "params");
+  const item = requireObject(p.item, "params.item", "symbolId: string, isExternal: boolean");
+  const data = requireObject(item.data, "params.item.data", "symbolId: string, isExternal: boolean");
+  if (typeof data.symbolId !== "string" || data.symbolId.length === 0) {
+    throw new DeclaredParamsError("bb/callHierarchy: params.item.data.symbolId must be a non-empty string");
+  }
+  if (typeof data.isExternal !== "boolean") {
+    throw new DeclaredParamsError("bb/callHierarchy: params.item.data.isExternal must be a boolean");
+  }
+  return item;
+}
+function navigationAbsence(method, params, evidenceTier, extra = {}) {
+  const language = languageForMessage(params);
+  const notLaunched = language === null || !isLaunchLanguage(language);
+  const what = extra.limit ? ` (asked for ${extra.limit})` : "";
+  const which = language === null ? "this file's type is not routed by any analyzer" : `${language} is outside the launch-language set`;
+  return {
+    method,
+    reason: notLaunched ? "language_not_launched" : "not_indexed",
+    language,
+    detail: notLaunched ? `${which}, so the index was never searched for this position${what}` : `the index was searched and stores no matching symbol at this position${what}`,
+    evidenceTier,
+    searchedIndex: !notLaunched,
+    totalCount: null
+  };
+}
+function navLocationToWire(loc) {
+  return {
+    uri: `file://${loc.path}`,
+    range: {
+      start: { line: loc.line, character: loc.character },
+      end: { line: loc.endLine, character: loc.endCharacter }
+    }
+  };
+}
+function symbolRangeToWire(r) {
+  return {
+    start: { line: r.line, character: r.character },
+    end: { line: r.endLine, character: r.endCharacter }
+  };
+}
+var isMain = typeof globalThis.Bun !== "undefined" ? import.meta.main === true : process.argv[1] !== void 0 && // Windows argv[1] uses backslashes (…\dist\lsp\server.js) — normalize
+// so the entry check is separator-independent (found by the E7 win32
+// CI leg: the server silently exited 0 without starting, 2026-09-05).
+(process.argv[1].replace(/\\/g, "/").endsWith("lsp/server.js") || process.argv[1].replace(/\\/g, "/").endsWith("lsp/server.ts"));
+if (isMain) {
+  const dirIdx = process.argv.indexOf("--dir");
+  const root = dirIdx !== -1 ? process.argv[dirIdx + 1] : process.cwd();
+  if (process.env.BB_LSP_STDERR_LOG) {
+    const trace = (what, err) => {
+      try {
+        appendFileSync(process.env.BB_LSP_STDERR_LOG, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${what}: ${err?.stack ?? String(err)}
+`);
+      } catch {
+      }
+    };
+    process.on("uncaughtException", (e) => trace("uncaughtException", e));
+    process.on("unhandledRejection", (e) => trace("unhandledRejection", e));
+  }
+  const server = createServer(root);
+  wireFeatures(server);
+  server.run().catch((error) => {
+    console.error("bb_lsp failed:", error?.message ?? String(error));
+    if (process.env.BB_LSP_STDERR_LOG) {
+      try {
+        appendFileSync(process.env.BB_LSP_STDERR_LOG, `[${(/* @__PURE__ */ new Date()).toISOString()}] run-failed: ${error?.stack ?? String(error)}
+`);
+      } catch {
+      }
+    }
+    process.exit(1);
+  });
+}
+export {
+  ABSENCE_LOG_TYPE,
+  ABSENCE_METHOD,
+  ABSENCE_SCHEMA_VERSION,
+  BbLspServer,
+  CAPABILITY_COVERAGE,
+  DeclaredAbsenceThrow,
+  DeclaredParamsError,
+  DocumentUnroutable,
+  ErrorCodes,
+  LAUNCH_LANGUAGES,
+  STALENESS_SCHEMA_VERSION,
+  absenceProviderPayload,
+  asDocumentUnroutable,
+  capabilityKeyForMethod,
+  createServer,
+  impactProviderPayload,
+  isLaunchLanguage,
+  languageForPath,
+  stalenessProviderPayload,
+  uriToPath,
+  wireFeatures,
+  workspaceProviderPayload
+};