@remnic/coding-graph 9.3.759

package/dist/index.js

@@ -0,0 +1,3509 @@
+import {
+  VALID_CYPHER_LABELS,
+  executeAst,
+  executeCypher,
+  parseCypher
+} from "./chunk-5I2DBHOQ.js";
+import {
+  DEAD_CODE_EXCLUSION,
+  DEFAULT_TRAVERSE_PATHS_MAX,
+  GraphStore,
+  MAX_TRAVERSE_PATHS_HOPS,
+  nodeIdFor
+} from "./chunk-CPYJACC5.js";
+import {
+  CODING_GRAPH_SCHEMA_VERSION,
+  EDGE_PROVENANCE_VALUES,
+  applyCodingGraphSchema,
+  isEdgeProvenance,
+  readSchemaVersion
+} from "./chunk-ZVCMIM4T.js";
+
+// src/index.ts
+import {
+  CODING_GRAPH_ENGINE_VERSION as CODING_GRAPH_ENGINE_VERSION2,
+  TIER_1_LANGUAGES as TIER_1_LANGUAGES3
+} from "@remnic/core";
+
+// src/engine/engine.ts
+import {
+  CODING_GRAPH_ENGINE_VERSION,
+  TIER_1_LANGUAGES as TIER_1_LANGUAGES2
+} from "@remnic/core";
+
+// src/engine/parser-backend.ts
+import { Parser, Language } from "web-tree-sitter";
+import { fileURLToPath } from "url";
+import path from "path";
+import { statSync } from "fs";
+function resolveGrammarDir() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.join(here, "..", "grammars"),
+    // dist/ → ../grammars
+    path.join(here, "..", "..", "grammars"),
+    // src/engine/ → ../../grammars
+    path.join(here, "grammars")
+    // flat layout fallback
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (statSync(candidate).isDirectory()) return candidate;
+    } catch {
+    }
+  }
+  throw new Error(
+    `coding-graph: could not locate the grammars/ directory from ${here}. Expected one of: ${candidates.join(", ")}`
+  );
+}
+var WasmTreeSitterBackend = class {
+  initialized = false;
+  initializing = null;
+  parser = null;
+  languages = /* @__PURE__ */ new Map();
+  loadingLanguages = /* @__PURE__ */ new Map();
+  grammarDir = "";
+  grammarDirResolved = false;
+  grammarDirHint;
+  constructor(grammarDir) {
+    this.grammarDirHint = grammarDir ?? null;
+  }
+  getGrammarDir() {
+    if (this.grammarDirResolved) return this.grammarDir;
+    this.grammarDir = this.grammarDirHint ?? resolveGrammarDir();
+    this.grammarDirResolved = true;
+    return this.grammarDir;
+  }
+  async init() {
+    if (this.initialized) return;
+    if (this.initializing) return this.initializing;
+    this.initializing = (async () => {
+      try {
+        await Parser.init();
+        this.parser = new Parser();
+        this.initialized = true;
+      } finally {
+        this.initializing = null;
+      }
+    })();
+    return this.initializing;
+  }
+  async ensureLanguage(lang) {
+    await this.init();
+    if (this.languages.has(lang)) return;
+    if (this.loadingLanguages.has(lang)) return this.loadingLanguages.get(lang);
+    const p = (async () => {
+      try {
+        const wasmPath = path.join(this.getGrammarDir(), grammarFileName(lang));
+        const language = await Language.load(wasmPath);
+        this.languages.set(lang, language);
+      } finally {
+        this.loadingLanguages.delete(lang);
+      }
+    })();
+    this.loadingLanguages.set(lang, p);
+    return p;
+  }
+  parse(lang, content) {
+    if (!this.parser) return null;
+    const language = this.languages.get(lang);
+    if (!language) return null;
+    this.parser.setLanguage(language);
+    return this.parser.parse(content);
+  }
+  /** Return the loaded Language object for `lang`, or null if not loaded. */
+  getLanguage(lang) {
+    return this.languages.get(lang) ?? null;
+  }
+  async dispose() {
+    if (this.parser) {
+      try {
+        this.parser.delete();
+      } catch {
+      }
+      this.parser = null;
+    }
+    this.languages.clear();
+    this.loadingLanguages.clear();
+    this.initialized = false;
+    this.initializing = null;
+    this.grammarDirResolved = false;
+    this.grammarDir = "";
+  }
+};
+function grammarFileName(lang) {
+  const map = {
+    typescript: "tree-sitter-typescript.wasm",
+    tsx: "tree-sitter-tsx.wasm",
+    javascript: "tree-sitter-javascript.wasm",
+    python: "tree-sitter-python.wasm",
+    go: "tree-sitter-go.wasm",
+    rust: "tree-sitter-rust.wasm",
+    java: "tree-sitter-java.wasm",
+    c: "tree-sitter-c.wasm",
+    cpp: "tree-sitter-cpp.wasm",
+    csharp: "tree-sitter-c_sharp.wasm",
+    ruby: "tree-sitter-ruby.wasm",
+    php: "tree-sitter-php.wasm",
+    kotlin: "tree-sitter-kotlin.wasm",
+    swift: "tree-sitter-swift.wasm",
+    bash: "tree-sitter-bash.wasm"
+  };
+  return map[lang];
+}
+
+// src/engine/emit.ts
+import { createHash } from "crypto";
+import { Query } from "web-tree-sitter";
+
+// src/engine/extractors.ts
+var JS_FAMILY_DEFINITIONS = `
+(function_declaration name: (identifier) @name) @def.function
+(method_definition name: (property_identifier) @name) @def.method
+(class_declaration name: (type_identifier) @name) @def.class
+(interface_declaration name: (type_identifier) @name) @def.interface
+(enum_declaration name: (identifier) @name) @def.enum
+(type_alias_declaration name: (type_identifier) @name) @def.type
+
+; const handler = () => {} / const handler = function () {}
+; Indexes arrow-function and function-expression declarations so route
+; handlers and React components defined this way appear as symbols.
+(variable_declarator
+  name: (identifier) @name
+  value: [(arrow_function) (function_expression)]) @def.function
+`.trim();
+var JS_IMPORTS = `
+(import_statement
+  source: (string (string_fragment) @import.module)) @__import.stmt
+(import_statement
+  (import_clause (identifier) @import.name)
+  source: (string (string_fragment) @import.module)) @__import.stmt
+(import_statement
+  (import_clause (namespace_import (identifier) @import.name))
+  source: (string (string_fragment) @import.module)) @__import.stmt
+(import_statement
+  (import_clause (named_imports (import_specifier name: (identifier) @import.name)))
+  source: (string (string_fragment) @import.module)) @__import.stmt
+
+; CommonJS require("...") \u2014 capture the module specifier so dependency
+; edges exist for Node/CommonJS codebases, not just ES-module imports.
+(call_expression
+  function: (identifier) @__import.require
+  arguments: (arguments (string (string_fragment) @import.module))
+  (#eq? @__import.require "require")) @__import.stmt
+`.trim();
+var TS_EXPORTS = `
+(export_statement declaration: (function_declaration name: (identifier) @export.name))
+(export_statement declaration: (class_declaration name: (type_identifier) @export.name))
+(export_statement (lexical_declaration (variable_declarator name: (identifier) @export.name)))
+(export_statement declaration: (enum_declaration name: (identifier) @export.name))
+(export_statement declaration: (interface_declaration name: (type_identifier) @export.name))
+(export_statement (export_clause (export_specifier name: (identifier) @export.name)))
+
+; export default App; (bare identifier re-export)
+(export_statement (identifier) @export.name)
+`.trim();
+var JS_EXPORTS = `
+(export_statement declaration: (function_declaration name: (identifier) @export.name))
+(export_statement declaration: (class_declaration name: (identifier) @export.name))
+(export_statement (lexical_declaration (variable_declarator name: (identifier) @export.name)))
+(export_statement (export_clause (export_specifier name: (identifier) @export.name)))
+
+; export default App; (bare identifier re-export)
+(export_statement (identifier) @export.name)
+
+; CommonJS: module.exports = { App, createRouter }
+(assignment_expression
+  left: (member_expression object: (identifier) @__cjs.mod property: (property_identifier) @__cjs.exp)
+  right: (object (shorthand_property_identifier) @export.name)
+  (#eq? @__cjs.mod "module") (#eq? @__cjs.exp "exports"))
+; CommonJS: module.exports = { publicName: createRouter }
+; Capture the VALUE identifier (the actual symbol), not the key (public alias).
+(assignment_expression
+  left: (member_expression object: (identifier) @__cjs.mod2 property: (property_identifier) @__cjs.exp2)
+  right: (object (pair key: (property_identifier) @__cjs.key2 value: (identifier) @export.name))
+  (#eq? @__cjs.mod2 "module") (#eq? @__cjs.exp2 "exports"))
+; Fallback: { foo: <non-identifier-value> } \u2014 capture the key as the public name
+; when the value is not a named symbol (arrow fn, literal, etc).
+(assignment_expression
+  left: (member_expression object: (identifier) @__cjs.mod2b property: (property_identifier) @__cjs.exp2b)
+  right: (object (pair key: (property_identifier) @export.name value: (_) @__cjs.nonId))
+  (#eq? @__cjs.mod2b "module") (#eq? @__cjs.exp2b "exports")
+  (#not-match? @__cjs.nonId "^[A-Za-z_$][A-Za-z0-9_$]*$"))
+; CommonJS: module.exports = App
+(assignment_expression
+  left: (member_expression object: (identifier) @__cjs.mod3 property: (property_identifier) @__cjs.exp3)
+  right: (identifier) @export.name
+  (#eq? @__cjs.mod3 "module") (#eq? @__cjs.exp3 "exports"))
+; CommonJS: exports.handler = handler
+(assignment_expression
+  left: (member_expression object: (identifier) @__cjs.exp4 property: (property_identifier) @export.name)
+  (#eq? @__cjs.exp4 "exports"))
+`.trim();
+var JS_CALLS = `
+(call_expression function: (identifier) @call.callee)
+(call_expression function: (member_expression property: (property_identifier) @call.callee))
+`.trim();
+var JS_ROUTES = `
+; Unified route pattern: captures verb + path + the arguments node.
+; emit.ts extracts the handler from the LAST argument (identifier,
+; arrow_function, or function_expression), correctly handling middleware:
+;   app.get("/users", requireAuth, getUsers) \u2192 handler=getUsers
+(call_expression
+  function: (member_expression
+    object: (_) @__route.app
+    property: (property_identifier) @route.verb)
+  arguments: (arguments
+    . (string (string_fragment) @route.path)
+  ) @route.args
+  (#match? @route.verb "^(get|post|put|patch|delete|head|options|all|use)$"))
+`.trim();
+var TYPESCRIPT_EXTRACTOR = {
+  definitionsQuery: JS_FAMILY_DEFINITIONS,
+  importsQuery: JS_IMPORTS,
+  exportsQuery: TS_EXPORTS,
+  callSitesQuery: JS_CALLS,
+  routesQuery: JS_ROUTES
+};
+var TSX_EXTRACTOR = TYPESCRIPT_EXTRACTOR;
+var JAVASCRIPT_EXTRACTOR = {
+  definitionsQuery: `
+(function_declaration name: (identifier) @name) @def.function
+(method_definition name: (property_identifier) @name) @def.method
+(class_declaration name: (identifier) @name) @def.class
+
+; const handler = () => {} / const handler = function () {}
+(variable_declarator
+  name: (identifier) @name
+  value: [(arrow_function) (function_expression)]) @def.function
+`.trim(),
+  importsQuery: JS_IMPORTS,
+  exportsQuery: JS_EXPORTS,
+  callSitesQuery: JS_CALLS,
+  routesQuery: JS_ROUTES
+};
+var PYTHON_EXTRACTOR = {
+  definitionsQuery: `
+(function_definition name: (identifier) @name) @def.function
+(class_definition name: (identifier) @name) @def.class
+`.trim(),
+  importsQuery: `
+(import_statement (dotted_name) @import.module) @__import.stmt
+(import_from_statement module_name: (dotted_name) @import.module) @__import.stmt
+; Python relative imports: from .models import User / from ..parent import X
+; tree-sitter-python wraps the module inside a relative_import node, so the
+; module_name field is NOT set. Capture the relative_import node itself so
+; the prefix dots are preserved (..parent, not just parent) \u2014 different
+; relative levels must not collapse to the same module name
+; (chatgpt-codex-connector #1688 P2: 'Preserve dots in Python relative imports').
+(import_from_statement (relative_import) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(call function: (identifier) @call.callee)
+(call function: (attribute attribute: (identifier) @call.callee))
+`.trim(),
+  routesQuery: `
+(decorated_definition
+  (decorator
+    (call function: (attribute attribute: (identifier) @route.verb)
+      arguments: (argument_list (string) @route.path)))
+  definition: (function_definition name: (identifier) @route.handler)
+  (#match? @route.verb "^(get|post|put|patch|delete|route|api_route)$"))
+`.trim()
+};
+var GO_EXTRACTOR = {
+  definitionsQuery: `
+(function_declaration name: (identifier) @name) @def.function
+
+; Go methods sit outside their receiver struct, so byte-span nesting
+; cannot compute qualified names. Capture the receiver type_identifier
+; so extractSymbols can prefix the method name (Server.Start).
+(method_declaration
+  receiver: (parameter_list
+    (parameter_declaration type: (type_identifier) @__receiver.type))
+  name: (field_identifier) @name) @def.method
+(method_declaration
+  receiver: (parameter_list
+    (parameter_declaration type: (pointer_type (type_identifier) @__receiver.type)))
+  name: (field_identifier) @name) @def.method
+(type_spec name: (type_identifier) @name type: (struct_type)) @def.class
+(type_spec name: (type_identifier) @name type: (interface_type)) @def.interface
+(type_spec name: (type_identifier) @name type: (type_identifier)) @def.type
+`.trim(),
+  importsQuery: `
+(import_spec path: (interpreted_string_literal) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(call_expression function: (identifier) @call.callee)
+(call_expression function: (selector_expression field: (field_identifier) @call.callee))
+`.trim(),
+  routesQuery: ``
+};
+var RUST_EXTRACTOR = {
+  definitionsQuery: `
+(function_item name: (identifier) @name) @def.function
+(function_signature_item name: (identifier) @name) @def.function
+(struct_item name: (type_identifier) @name) @def.class
+(enum_item name: (type_identifier) @name) @def.enum
+(trait_item name: (type_identifier) @name) @def.interface
+(type_item name: (type_identifier) @name) @def.type
+(mod_item name: (identifier) @name) @def.module
+
+; Rust impl methods \u2014 the impl block sits outside the struct's byte span,
+; so byte-span nesting cannot compute the parent struct. Capture the impl
+; type_identifier so extractSymbols can prefix qualified names (Config.new).
+; These also match functions caught by the general patterns above;
+; extractSymbols deduplicates by node identity (startByte+endByte+name).
+(impl_item
+  type: (type_identifier) @__receiver.type
+  body: (declaration_list
+    (function_item name: (identifier) @name) @def.method))
+(impl_item
+  type: (type_identifier) @__receiver.type
+  body: (declaration_list
+    (function_signature_item name: (identifier) @name) @def.method))
+`.trim(),
+  importsQuery: `
+(use_declaration (scoped_identifier) @import.module) @__import.stmt
+(use_declaration (scoped_use_list) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(call_expression function: (identifier) @call.callee)
+(call_expression function: (field_expression field: (field_identifier) @call.callee))
+(call_expression function: (scoped_identifier) @call.callee)
+`.trim(),
+  routesQuery: ``
+};
+var JAVA_EXTRACTOR = {
+  definitionsQuery: `
+(class_declaration name: (identifier) @name) @def.class
+(interface_declaration name: (identifier) @name) @def.interface
+(enum_declaration name: (identifier) @name) @def.enum
+(record_declaration name: (identifier) @name) @def.class
+(method_declaration name: (identifier) @name) @def.method
+(constructor_declaration name: (identifier) @name) @def.method
+`.trim(),
+  importsQuery: `
+(import_declaration (scoped_identifier) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(method_invocation name: (identifier) @call.callee)
+`.trim(),
+  routesQuery: ``
+};
+var C_EXTRACTOR = {
+  definitionsQuery: `
+(function_definition declarator: (function_declarator declarator: (identifier) @name)) @def.function
+(type_definition declarator: (type_identifier) @name) @def.type
+`.trim(),
+  importsQuery: `
+(preproc_include path: (system_lib_string) @import.module) @__import.stmt
+(preproc_include path: (string_literal) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(call_expression function: (identifier) @call.callee)
+`.trim(),
+  routesQuery: ``
+};
+var CPP_EXTRACTOR = {
+  definitionsQuery: `
+(function_definition declarator: (function_declarator declarator: (identifier) @name)) @def.function
+(function_definition declarator: (function_declarator declarator: (field_identifier) @name)) @def.method
+; C++ out-of-class method definitions: void A::start() {}
+; The qualified_identifier (A::start) encodes the full qualified name.
+(function_definition declarator: (function_declarator declarator: (qualified_identifier) @name)) @def.method
+(class_specifier name: (type_identifier) @name) @def.class
+(struct_specifier name: (type_identifier) @name) @def.class
+(enum_specifier name: (type_identifier) @name) @def.enum
+(namespace_definition name: (namespace_identifier) @name) @def.module
+`.trim(),
+  importsQuery: `
+(preproc_include path: (system_lib_string) @import.module) @__import.stmt
+(preproc_include path: (string_literal) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(call_expression function: (identifier) @call.callee)
+(call_expression function: (field_expression field: (field_identifier) @call.callee))
+`.trim(),
+  routesQuery: ``
+};
+var CSHARP_EXTRACTOR = {
+  definitionsQuery: `
+(class_declaration name: (identifier) @name) @def.class
+(interface_declaration name: (identifier) @name) @def.interface
+(enum_declaration name: (identifier) @name) @def.enum
+(struct_declaration name: (identifier) @name) @def.class
+(method_declaration name: (identifier) @name) @def.method
+`.trim(),
+  importsQuery: `
+(using_directive (identifier) @import.module) @__import.stmt
+(using_directive (qualified_name) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(invocation_expression function: (identifier) @call.callee)
+(invocation_expression function: (member_access_expression name: (identifier) @call.callee))
+`.trim(),
+  routesQuery: ``
+};
+var RUBY_EXTRACTOR = {
+  definitionsQuery: `
+(class name: (constant) @name) @def.class
+(module name: (constant) @name) @def.module
+(method name: (identifier) @name) @def.method
+(singleton_method name: (identifier) @name) @def.method
+`.trim(),
+  importsQuery: `
+(call
+  method: (identifier) @__import.method
+  arguments: (argument_list (string) @import.module)
+  (#match? @__import.method "^(require|require_relative|load)$")) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(call method: (identifier) @call.callee)
+`.trim(),
+  routesQuery: ``
+};
+var PHP_EXTRACTOR = {
+  definitionsQuery: `
+(class_declaration name: (name) @name) @def.class
+(interface_declaration name: (name) @name) @def.interface
+(trait_declaration name: (name) @name) @def.class
+(function_definition name: (name) @name) @def.function
+(method_declaration name: (name) @name) @def.method
+`.trim(),
+  importsQuery: `
+(namespace_use_declaration (namespace_use_clause (qualified_name) @import.module)) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(function_call_expression function: (name) @call.callee)
+(member_call_expression (name) @call.callee)
+`.trim(),
+  routesQuery: ``
+};
+var KOTLIN_EXTRACTOR = {
+  definitionsQuery: `
+(class_declaration (type_identifier) @name) @def.class
+(object_declaration (type_identifier) @name) @def.module
+(function_declaration (simple_identifier) @name) @def.function
+`.trim(),
+  importsQuery: `
+; Capture the full identifier node \u2014 its .text is the complete import
+; path (e.g. "kotlin.collections"). Do NOT capture nested simple_identifier
+; children, which would emit bogus segment-level modules.
+(import_header (identifier) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(call_expression (simple_identifier) @call.callee)
+`.trim(),
+  routesQuery: ``
+};
+var SWIFT_EXTRACTOR = {
+  definitionsQuery: `
+(class_declaration name: (type_identifier) @name) @def.class
+(protocol_declaration name: (type_identifier) @name) @def.interface
+(function_declaration name: (simple_identifier) @name) @def.function
+`.trim(),
+  importsQuery: `
+(import_declaration (identifier) @import.module) @__import.stmt
+`.trim(),
+  exportsQuery: ``,
+  callSitesQuery: `
+(call_expression (simple_identifier) @call.callee)
+`.trim(),
+  routesQuery: ``
+};
+var BASH_EXTRACTOR = {
+  definitionsQuery: `
+(function_definition name: (word) @name) @def.function
+`.trim(),
+  importsQuery: ``,
+  exportsQuery: ``,
+  callSitesQuery: `
+(command name: (command_name (word) @call.callee))
+`.trim(),
+  routesQuery: ``
+};
+var EXTRACTORS = {
+  typescript: TYPESCRIPT_EXTRACTOR,
+  tsx: TSX_EXTRACTOR,
+  javascript: JAVASCRIPT_EXTRACTOR,
+  python: PYTHON_EXTRACTOR,
+  go: GO_EXTRACTOR,
+  rust: RUST_EXTRACTOR,
+  java: JAVA_EXTRACTOR,
+  c: C_EXTRACTOR,
+  cpp: CPP_EXTRACTOR,
+  csharp: CSHARP_EXTRACTOR,
+  ruby: RUBY_EXTRACTOR,
+  php: PHP_EXTRACTOR,
+  kotlin: KOTLIN_EXTRACTOR,
+  swift: SWIFT_EXTRACTOR,
+  bash: BASH_EXTRACTOR
+};
+var VALID_KINDS = /* @__PURE__ */ new Set([
+  "function",
+  "method",
+  "class",
+  "interface",
+  "enum",
+  "type",
+  "module"
+]);
+function kindFromCapture(captureName) {
+  if (!captureName.startsWith("def.")) return null;
+  const kind = captureName.slice(4);
+  if (!VALID_KINDS.has(kind)) return null;
+  return kind;
+}
+
+// src/engine/utf16-offsets.ts
+function buildUtf16ToByteOffsetMap(content) {
+  const map = new Uint32Array(content.length + 1);
+  let byteOffset = 0;
+  for (let i = 0; i < content.length; i++) {
+    map[i] = byteOffset;
+    const code = content.charCodeAt(i);
+    if (code < 128) {
+      byteOffset += 1;
+    } else if (code < 2048) {
+      byteOffset += 2;
+    } else if (code >= 55296 && code <= 56319) {
+      byteOffset += 4;
+      map[i + 1] = map[i];
+      i++;
+    } else if (code >= 56320 && code <= 57343) {
+      byteOffset += 3;
+    } else {
+      byteOffset += 3;
+    }
+  }
+  map[content.length] = byteOffset;
+  return map;
+}
+function utf16ToByte(map, utf16Offset) {
+  if (utf16Offset <= 0) return 0;
+  if (utf16Offset >= map.length) return map[map.length - 1];
+  return map[utf16Offset];
+}
+
+// src/engine/emit.ts
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function cleanModuleSpecifier(raw) {
+  let s = raw.trim();
+  if (s.startsWith("<") && s.endsWith(">")) return s.slice(1, -1);
+  if (s.length >= 2) {
+    const f = s[0];
+    const l = s[s.length - 1];
+    if ((f === '"' || f === "'" || f === "`") && f === l) return s.slice(1, -1);
+  }
+  return s;
+}
+function extractSymbols(root, language, lang) {
+  const extractor = EXTRACTORS[lang];
+  const query = new Query(language, extractor.definitionsQuery);
+  try {
+    const matches = query.matches(root);
+    const rawDefs = [];
+    for (const match of matches) {
+      let kind = null;
+      let nameNode = null;
+      let defNode = null;
+      let receiverType = "";
+      for (const cap of match.captures) {
+        const k = kindFromCapture(cap.name);
+        if (k) {
+          kind = k;
+          defNode = cap.node;
+        } else if (cap.name === "name") {
+          nameNode = cap.node;
+        } else if (cap.name === "__receiver.type") {
+          receiverType = cap.node.text;
+        }
+      }
+      if (!kind || !defNode || !nameNode) continue;
+      rawDefs.push({
+        kind,
+        name: nameNode.text,
+        startByte: defNode.startIndex,
+        endByte: defNode.endIndex,
+        receiverType: receiverType || void 0
+      });
+    }
+    const seen = /* @__PURE__ */ new Map();
+    for (const def of rawDefs) {
+      const key = `${def.startByte}:${def.endByte}:${def.name}`;
+      const existing = seen.get(key);
+      if (!existing || def.receiverType && !existing.receiverType) {
+        seen.set(key, def);
+      }
+    }
+    const deduped = [...seen.values()];
+    deduped.sort((a, b) => a.startByte - b.startByte || a.name.localeCompare(b.name));
+    const stack = [];
+    const symbols = [];
+    for (const def of deduped) {
+      while (stack.length > 0 && stack[stack.length - 1].endByte <= def.startByte) {
+        stack.pop();
+      }
+      const parentQualifiedName = def.receiverType ?? (stack.length > 0 ? stack[stack.length - 1].qualifiedName : void 0);
+      const qualifiedName = parentQualifiedName ? `${parentQualifiedName}.${def.name}` : def.name;
+      const symbol = parentQualifiedName ? {
+        kind: def.kind,
+        name: def.name,
+        qualifiedName,
+        span: { startByte: def.startByte, endByte: def.endByte },
+        parentQualifiedName
+      } : {
+        kind: def.kind,
+        name: def.name,
+        qualifiedName,
+        span: { startByte: def.startByte, endByte: def.endByte }
+      };
+      symbols.push(symbol);
+      stack.push({ endByte: def.endByte, qualifiedName });
+    }
+    return symbols;
+  } finally {
+    query.delete();
+  }
+}
+function extractImports(root, language, lang) {
+  const extractor = EXTRACTORS[lang];
+  if (!extractor.importsQuery) return [];
+  const query = new Query(language, extractor.importsQuery);
+  try {
+    const matches = query.matches(root);
+    const groups = /* @__PURE__ */ new Map();
+    for (const match of matches) {
+      let moduleText = "";
+      let stmtStart = -1;
+      let stmtEnd = -1;
+      const names = [];
+      for (const cap of match.captures) {
+        if (cap.name === "import.module") {
+          moduleText = cleanModuleSpecifier(cap.node.text);
+        } else if (cap.name === "import.name") {
+          names.push(cap.node.text);
+        } else if (cap.name === "__import.stmt") {
+          stmtStart = cap.node.startIndex;
+          stmtEnd = cap.node.endIndex;
+        }
+      }
+      if (stmtStart < 0) {
+        const firstCap = match.captures[0];
+        if (firstCap) {
+          stmtStart = firstCap.node.startIndex;
+          stmtEnd = firstCap.node.endIndex;
+        } else {
+          continue;
+        }
+      }
+      const key = `${stmtStart}:${moduleText}`;
+      const existing = groups.get(key);
+      if (existing) {
+        for (const n of names) existing.names.add(n);
+      } else {
+        groups.set(key, {
+          module: moduleText,
+          names: new Set(names),
+          startByte: stmtStart,
+          endByte: stmtEnd
+        });
+      }
+    }
+    return Array.from(groups.values()).map((g) => ({
+      module: g.module,
+      importedNames: Array.from(g.names).sort(),
+      span: { startByte: g.startByte, endByte: g.endByte }
+    })).sort((a, b) => a.span.startByte - b.span.startByte || a.module.localeCompare(b.module));
+  } finally {
+    query.delete();
+  }
+}
+function extractExports(root, language, lang) {
+  const extractor = EXTRACTORS[lang];
+  if (!extractor.exportsQuery) return [];
+  const query = new Query(language, extractor.exportsQuery);
+  try {
+    const captures = query.captures(root);
+    const valueExportedPairs = /* @__PURE__ */ new Set();
+    const pairOf = (node) => {
+      let cur = node;
+      for (let i = 0; i < 5 && cur; i++) {
+        if (cur.type === "pair") return cur;
+        cur = cur.parent;
+      }
+      return null;
+    };
+    for (const cap of captures) {
+      if (cap.name !== "export.name") continue;
+      const pair = pairOf(cap.node);
+      if (pair && cap.node.type === "identifier") {
+        valueExportedPairs.add(pair.id);
+      }
+    }
+    const exports = [];
+    for (const cap of captures) {
+      if (cap.name !== "export.name") continue;
+      const pair = pairOf(cap.node);
+      if (pair && cap.node.type === "property_identifier" && valueExportedPairs.has(pair.id)) {
+        continue;
+      }
+      exports.push({
+        name: cap.node.text,
+        span: { startByte: cap.node.startIndex, endByte: cap.node.endIndex }
+      });
+    }
+    return exports.sort(
+      (a, b) => a.span.startByte - b.span.startByte || a.name.localeCompare(b.name)
+    );
+  } finally {
+    query.delete();
+  }
+}
+function extractCallSites(root, language, lang) {
+  const extractor = EXTRACTORS[lang];
+  if (!extractor.callSitesQuery) return [];
+  const query = new Query(language, extractor.callSitesQuery);
+  try {
+    const captures = query.captures(root);
+    const callSites = [];
+    for (const cap of captures) {
+      if (cap.name === "call.callee") {
+        callSites.push({
+          calleeNameCandidates: [cap.node.text],
+          span: { startByte: cap.node.startIndex, endByte: cap.node.endIndex }
+        });
+      }
+    }
+    return callSites.sort(
+      (a, b) => a.span.startByte - b.span.startByte || (a.calleeNameCandidates[0] ?? "").localeCompare(b.calleeNameCandidates[0] ?? "")
+    );
+  } finally {
+    query.delete();
+  }
+}
+var HTTP_CLIENT_OBJECT_PATTERNS = /^(http|https|client|httpClient|axios|fetch|request|req|res|\$|superagent|got)$/;
+function extractRoutes(root, language, lang) {
+  const extractor = EXTRACTORS[lang];
+  if (!extractor.routesQuery) return [];
+  const query = new Query(language, extractor.routesQuery);
+  try {
+    const matches = query.matches(root);
+    const routes = [];
+    for (const match of matches) {
+      let verb = "";
+      let pathTemplate = "";
+      let handler = "";
+      let startByte = 0;
+      let endByte = 0;
+      let argsNode = null;
+      let routeObject = "";
+      for (const cap of match.captures) {
+        if (cap.name === "route.verb") {
+          verb = cap.node.text.toUpperCase();
+          startByte = cap.node.parent?.startIndex ?? cap.node.startIndex;
+          const memberExpr = cap.node.parent;
+          const objectNode = memberExpr?.childForFieldName("object");
+          if (objectNode) {
+            let receiver = objectNode;
+            for (let prop = receiver.childForFieldName("property"); prop; prop = receiver.childForFieldName("property")) {
+              receiver = prop;
+            }
+            routeObject = receiver.text;
+          }
+        } else if (cap.name === "route.path") {
+          pathTemplate = cleanModuleSpecifier(cap.node.text);
+        } else if (cap.name === "route.handler") {
+          handler = cap.node.type === "identifier" ? cap.node.text : findHandlerName(cap.node) ?? "anonymous";
+          endByte = cap.node.endIndex;
+        } else if (cap.name === "route.args") {
+          argsNode = cap.node;
+          endByte = cap.node.endIndex;
+        }
+      }
+      if (argsNode) {
+        handler = extractHandlerFromArgs(argsNode);
+      }
+      const isRoutePath = pathTemplate.startsWith("/") || pathTemplate.startsWith("*");
+      const isHttpClient = HTTP_CLIENT_OBJECT_PATTERNS.test(routeObject);
+      if (verb && pathTemplate && handler && isRoutePath && !isHttpClient) {
+        routes.push({
+          verb,
+          pathTemplate,
+          handlerQualifiedName: handler,
+          span: { startByte, endByte }
+        });
+      }
+    }
+    return routes.sort(
+      (a, b) => a.span.startByte - b.span.startByte || a.pathTemplate.localeCompare(b.pathTemplate)
+    );
+  } finally {
+    query.delete();
+  }
+}
+function extractHandlerFromArgs(argsNode) {
+  const realArgs = [];
+  for (let i = 0; i < argsNode.namedChildCount; i++) {
+    const child = argsNode.namedChild(i);
+    if (child && child.type !== "comment") realArgs.push(child);
+  }
+  if (realArgs.length < 2) return "";
+  const lastArg = realArgs[realArgs.length - 1];
+  if (lastArg.type === "identifier") {
+    return lastArg.text;
+  }
+  if (lastArg.type === "function_expression") {
+    return findHandlerName(lastArg) ?? "anonymous";
+  }
+  if (lastArg.type === "arrow_function") {
+    return "anonymous";
+  }
+  return "";
+}
+function findHandlerName(node) {
+  for (const child of node.namedChildren) {
+    if (child && child.type === "identifier") return child.text;
+  }
+  const nameChild = node.childForFieldName("name");
+  if (nameChild) return nameChild.text;
+  return null;
+}
+function emitFileIR(filePath, lang, content, root, language, contentStr) {
+  const symbols = extractSymbols(root, language, lang);
+  const imports = extractImports(root, language, lang);
+  const exports = extractExports(root, language, lang);
+  const callSites = extractCallSites(root, language, lang);
+  const routes = extractRoutes(root, language, lang);
+  const offsetMap = buildUtf16ToByteOffsetMap(contentStr);
+  const convSymbols = symbols.map((s) => ({
+    ...s,
+    span: {
+      startByte: utf16ToByte(offsetMap, s.span.startByte),
+      endByte: utf16ToByte(offsetMap, s.span.endByte)
+    }
+  }));
+  const convImports = imports.map((i) => ({
+    ...i,
+    span: {
+      startByte: utf16ToByte(offsetMap, i.span.startByte),
+      endByte: utf16ToByte(offsetMap, i.span.endByte)
+    }
+  }));
+  const convExports = exports.map((e) => ({
+    ...e,
+    span: {
+      startByte: utf16ToByte(offsetMap, e.span.startByte),
+      endByte: utf16ToByte(offsetMap, e.span.endByte)
+    }
+  }));
+  const convCallSites = callSites.map((c) => ({
+    ...c,
+    span: {
+      startByte: utf16ToByte(offsetMap, c.span.startByte),
+      endByte: utf16ToByte(offsetMap, c.span.endByte)
+    }
+  }));
+  const convRoutes = routes.map((r) => ({
+    ...r,
+    span: {
+      startByte: utf16ToByte(offsetMap, r.span.startByte),
+      endByte: utf16ToByte(offsetMap, r.span.endByte)
+    }
+  }));
+  return {
+    path: filePath,
+    language: lang,
+    contentHash: hashContent(content),
+    symbols: convSymbols,
+    imports: convImports,
+    exports: convExports,
+    callSites: convCallSites,
+    routes: convRoutes
+  };
+}
+
+// src/engine/language-sniff.ts
+import { TIER_1_LANGUAGES } from "@remnic/core";
+var EXTENSION_MAP = {
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".pyi": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  ".cs": "csharp",
+  ".rb": "ruby",
+  ".php": "php",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".swift": "swift",
+  ".sh": "bash",
+  ".bash": "bash"
+};
+function sniffLanguage(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  if (dot < 0) return null;
+  const ext = filePath.slice(dot).toLowerCase();
+  return EXTENSION_MAP[ext] ?? null;
+}
+function isTier1Language(lang) {
+  return TIER_1_LANGUAGES.includes(lang);
+}
+
+// src/engine/engine.ts
+var CodingGraphEngineImpl = class {
+  engineVersion;
+  supportedLanguages;
+  backend;
+  disposed = false;
+  /**
+   * Serialize parse calls. The backend's single Parser instance is shared
+   * across all languages, so concurrent setLanguage/parse calls would race.
+   * Each parseFile call awaits the previous before touching the parser.
+   */
+  parseChain = Promise.resolve();
+  constructor(backend) {
+    this.engineVersion = CODING_GRAPH_ENGINE_VERSION;
+    this.supportedLanguages = TIER_1_LANGUAGES2;
+    this.backend = backend;
+  }
+  async parseFile(input) {
+    if (this.disposed) {
+      return {
+        ok: false,
+        code: "parse_failed",
+        path: input.path,
+        message: "engine has been disposed"
+      };
+    }
+    const previous = this.parseChain;
+    let release;
+    this.parseChain = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    if (this.disposed) {
+      release();
+      return {
+        ok: false,
+        code: "parse_failed",
+        path: input.path,
+        message: "engine has been disposed"
+      };
+    }
+    try {
+      return await this.doParseFile(input);
+    } finally {
+      release();
+    }
+  }
+  async doParseFile(input) {
+    const lang = input.language ?? sniffLanguage(input.path);
+    if (!lang || !isTier1Language(lang)) {
+      return {
+        ok: false,
+        code: "parse_failed",
+        path: input.path,
+        message: `unsupported language for path "${input.path}"; supported extensions map to: ${TIER_1_LANGUAGES2.join(", ")}`
+      };
+    }
+    try {
+      await this.backend.ensureLanguage(lang);
+    } catch (err) {
+      return {
+        ok: false,
+        code: "parse_failed",
+        path: input.path,
+        message: `failed to load grammar for ${lang}: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const contentStr = Buffer.from(input.content).toString("utf-8");
+    const tree = this.backend.parse(lang, contentStr);
+    if (!tree) {
+      return {
+        ok: false,
+        code: "parse_failed",
+        path: input.path,
+        message: `tree-sitter returned null for ${lang} (grammar may be corrupt)`
+      };
+    }
+    try {
+      const root = tree.rootNode;
+      const language = this.backend.getLanguage(lang);
+      if (!language) {
+        return {
+          ok: false,
+          code: "parse_failed",
+          path: input.path,
+          message: `language object unavailable for ${lang}`
+        };
+      }
+      const ir = emitFileIR(
+        input.path,
+        lang,
+        input.content,
+        root,
+        language,
+        contentStr
+      );
+      return { ok: true, ir };
+    } catch (err) {
+      return {
+        ok: false,
+        code: "parse_failed",
+        path: input.path,
+        message: `extraction failed for ${lang}: ${err instanceof Error ? err.message : String(err)}`
+      };
+    } finally {
+      tree.delete();
+    }
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    await this.parseChain;
+    await this.backend.dispose();
+  }
+};
+function createCodingGraphEngine(_options = {}) {
+  const backend = new WasmTreeSitterBackend();
+  return new CodingGraphEngineImpl(backend);
+}
+
+// src/reindex.ts
+import { readFile as fsReadFile, realpath as fsRealpath } from "fs/promises";
+import path2 from "path";
+var META_KEY_LAST_HEAD = "last_indexed_head";
+var META_KEY_PENDING_PARSE_FAILURES = "pending_parse_failures";
+function planReindex(lastState, facts) {
+  if (facts.currentHead === null) {
+    return { mode: "noop", reason: "repo has no commits (HEAD is null)" };
+  }
+  if (lastState.lastHead === null) {
+    return { mode: "full", reason: "no prior last_indexed_head \u2014 first index" };
+  }
+  if (lastState.lastHead === facts.currentHead) {
+    return { mode: "noop", reason: "HEAD unchanged since last index" };
+  }
+  if (!facts.lastHeadReachable) {
+    return {
+      mode: "hash_scan",
+      reason: `last_indexed_head ${lastState.lastHead.slice(0, 12)} is unreachable (rebase/force-push)`,
+      // mismatchedPaths is filled by the executor (needs to read files).
+      mismatchedPaths: []
+    };
+  }
+  const changedPaths = [];
+  for (const entry of facts.changedFiles) {
+    changedPaths.push(entry.path);
+    if (entry.oldPath !== void 0 && entry.oldPath !== entry.path) {
+      changedPaths.push(entry.oldPath);
+    }
+  }
+  return { mode: "incremental", changedPaths };
+}
+function readLastIndexedHead(store) {
+  return store.readMeta(META_KEY_LAST_HEAD);
+}
+function readFileHashes(store) {
+  return store.readFileHashes();
+}
+function isCanonicalRelativePath(p) {
+  if (typeof p !== "string" || p.length === 0) return false;
+  if (p.includes("\\")) return false;
+  if (p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p)) return false;
+  if (p.split("/").some((seg) => seg === "." || seg === "..")) return false;
+  return true;
+}
+async function probeRead(repoRoot, relPath, readFile2) {
+  if (!isCanonicalRelativePath(relPath)) return { kind: "skip" };
+  const probeAbs = resolveRepoPath(repoRoot, relPath);
+  if (await symlinkEscapesRoot(repoRoot, probeAbs)) return { kind: "skip" };
+  try {
+    const content = await readFile2(probeAbs);
+    return { kind: "exists", content };
+  } catch (e) {
+    const code = e && typeof e === "object" ? e.code : void 0;
+    if (code === "ENOENT") return { kind: "missing" };
+    return { kind: "unknown" };
+  }
+}
+function resolveRepoPath(repoRoot, relPath) {
+  return path2.resolve(repoRoot, ...relPath.split("/"));
+}
+async function symlinkEscapesRoot(repoRoot, absPath) {
+  try {
+    const [realRoot, realAbs] = await Promise.all([
+      fsRealpath(repoRoot),
+      fsRealpath(absPath)
+    ]);
+    const rel = path2.relative(realRoot, realAbs);
+    return rel === ".." || rel.startsWith(".." + path2.sep) || path2.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+async function defaultReadFile(absPath) {
+  const buf = await fsReadFile(absPath);
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+var reindexLocks = /* @__PURE__ */ new WeakMap();
+async function executeReindex(options) {
+  const { store, git, repoRoot, parseFile } = options;
+  const readFile2 = options.readFile ?? defaultReadFile;
+  const prev = reindexLocks.get(store) ?? Promise.resolve();
+  let release;
+  const next = new Promise((resolve) => {
+    release = resolve;
+  });
+  reindexLocks.set(store, prev.then(() => next));
+  await prev;
+  try {
+    return await runReindex(store, git, repoRoot, parseFile, readFile2, options);
+  } finally {
+    release();
+  }
+}
+async function runReindex(store, git, repoRoot, parseFile, readFile2, options) {
+  const lastHeadRead = readLastIndexedHead(store);
+  if (!lastHeadRead.ok) {
+    return {
+      ok: false,
+      code: "store_error",
+      message: `read last_indexed_head: ${lastHeadRead.code}`
+    };
+  }
+  const lastHead = lastHeadRead.value;
+  const headResult = git.revParseHead(repoRoot);
+  if (!headResult.ok) return headResult;
+  let reachable = true;
+  if (lastHead !== null && headResult.head !== null) {
+    const reachResult = git.isReachable(repoRoot, lastHead);
+    if (!reachResult.ok) return reachResult;
+    reachable = reachResult.reachable;
+  }
+  let changedFiles = [];
+  if (lastHead !== null && headResult.head !== null && reachable && lastHead !== headResult.head) {
+    const diffResult = git.diffNameStatus(
+      repoRoot,
+      `${lastHead}..${headResult.head}`
+    );
+    if (!diffResult.ok) {
+      reachable = false;
+    } else {
+      changedFiles = [...diffResult.entries];
+    }
+  }
+  const facts = {
+    currentHead: headResult.head,
+    lastHeadReachable: reachable,
+    changedFiles
+  };
+  const fileHashesRead = readFileHashes(store);
+  if (!fileHashesRead.ok) {
+    return {
+      ok: false,
+      code: "store_error",
+      message: `readFileHashes: ${fileHashesRead.code}`
+    };
+  }
+  const fileHashes = fileHashesRead.hashes;
+  const lastState = {
+    lastHead,
+    fileHashes
+  };
+  const plan = planReindex(lastState, facts);
+  const pendingRetryRead = readPendingParseFailures(store);
+  if (!pendingRetryRead.ok) {
+    return {
+      ok: false,
+      code: "store_error",
+      message: `read pending_parse_failures: ${pendingRetryRead.code}`
+    };
+  }
+  const pendingRetry = pendingRetryRead.paths;
+  switch (plan.mode) {
+    case "noop": {
+      if (pendingRetry.length === 0) {
+        return { ok: true, mode: "noop", filesIngested: 0, head: lastHead };
+      }
+      const ingestResult = await ingestFiles(
+        store,
+        repoRoot,
+        parseFile,
+        readFile2,
+        pendingRetry
+      );
+      if (!ingestResult.ok) return ingestResult;
+      store.writeMeta(
+        META_KEY_PENDING_PARSE_FAILURES,
+        JSON.stringify(ingestResult.parseFailedPaths)
+      );
+      return {
+        ok: true,
+        mode: "noop",
+        filesIngested: ingestResult.count,
+        head: lastHead
+      };
+    }
+    case "full": {
+      const candidatesProvided = options.candidatePaths !== void 0 && options.candidatePaths.length > 0;
+      const candidates = options.candidatePaths ?? [];
+      if (candidates.length === 0 && pendingRetry.length === 0) {
+        return { ok: true, mode: "noop", filesIngested: 0, head: lastHead };
+      }
+      const toIngest = [.../* @__PURE__ */ new Set([...candidates, ...pendingRetry])];
+      let fullDelete = [];
+      if (candidatesProvided) {
+        const fullCandidateSet = new Set(toIngest);
+        fullDelete = [...fileHashes.keys()].filter(
+          (p) => !fullCandidateSet.has(p)
+        );
+      }
+      const ingestResult = await ingestFiles(
+        store,
+        repoRoot,
+        parseFile,
+        readFile2,
+        toIngest,
+        fullDelete
+      );
+      if (!ingestResult.ok) return ingestResult;
+      store.writeMeta(
+        META_KEY_PENDING_PARSE_FAILURES,
+        JSON.stringify(
+          computeNextPending({
+            priorPending: pendingRetry,
+            parseFailedPaths: ingestResult.parseFailedPaths,
+            ingestedCandidates: toIngest,
+            deleted: fullDelete
+          })
+        )
+      );
+      if (candidatesProvided) {
+        store.writeMeta(META_KEY_LAST_HEAD, headResult.head ?? "");
+      }
+      return {
+        ok: true,
+        mode: "full",
+        filesIngested: ingestResult.count,
+        head: candidatesProvided ? headResult.head : lastHead
+      };
+    }
+    case "incremental": {
+      const seen = /* @__PURE__ */ new Set();
+      for (const p2 of plan.changedPaths) seen.add(p2);
+      for (const p2 of pendingRetry) seen.add(p2);
+      const knownFiles = fileHashes;
+      const toDelete = [];
+      const toIngest = [];
+      const missingNew = [];
+      for (const p2 of seen) {
+        const probe = await probeRead(repoRoot, p2, readFile2);
+        if (probe.kind === "skip") {
+          if (knownFiles.has(p2)) toDelete.push(p2);
+          continue;
+        }
+        if (probe.kind === "exists" || probe.kind === "unknown") {
+          toIngest.push(p2);
+        } else if (probe.kind === "missing") {
+          if (knownFiles.has(p2)) toDelete.push(p2);
+          else missingNew.push(p2);
+        }
+      }
+      const ingestResult = await ingestFiles(
+        store,
+        repoRoot,
+        parseFile,
+        readFile2,
+        toIngest,
+        toDelete
+      );
+      if (!ingestResult.ok) return ingestResult;
+      store.writeMeta(
+        META_KEY_PENDING_PARSE_FAILURES,
+        JSON.stringify(
+          computeNextPending({
+            priorPending: pendingRetry,
+            parseFailedPaths: ingestResult.parseFailedPaths,
+            extraRetry: missingNew,
+            ingestedCandidates: toIngest,
+            deleted: toDelete
+          })
+        )
+      );
+      store.writeMeta(META_KEY_LAST_HEAD, headResult.head ?? "");
+      return {
+        ok: true,
+        mode: "incremental",
+        filesIngested: ingestResult.count,
+        head: headResult.head
+      };
+    }
+    case "hash_scan": {
+      const hashScanCandidatesProvided = options.candidatePaths !== void 0 && options.candidatePaths.length > 0;
+      const candidateSet = /* @__PURE__ */ new Set([
+        ...options.candidatePaths ?? [],
+        ...lastState.fileHashes.keys(),
+        ...pendingRetry
+      ]);
+      const knownFiles = fileHashes;
+      const toDelete = [];
+      const toIngest = [];
+      const hashScanRetry = [];
+      for (const candidatePath of candidateSet) {
+        const probe = await probeRead(repoRoot, candidatePath, readFile2);
+        if (probe.kind === "skip") {
+          if (knownFiles.has(candidatePath)) toDelete.push(candidatePath);
+          continue;
+        }
+        if (probe.kind === "missing") {
+          if (knownFiles.has(candidatePath)) toDelete.push(candidatePath);
+          else hashScanRetry.push(candidatePath);
+          continue;
+        }
+        if (probe.kind === "unknown") {
+          hashScanRetry.push(candidatePath);
+          continue;
+        }
+        const currentHash = hashContent(probe.content);
+        const storedHash = lastState.fileHashes.get(candidatePath);
+        if (storedHash !== currentHash) {
+          toIngest.push(candidatePath);
+        }
+      }
+      const ingestResult = await ingestFiles(
+        store,
+        repoRoot,
+        parseFile,
+        readFile2,
+        toIngest,
+        toDelete
+      );
+      if (!ingestResult.ok) return ingestResult;
+      store.writeMeta(
+        META_KEY_PENDING_PARSE_FAILURES,
+        JSON.stringify(
+          computeNextPending({
+            priorPending: pendingRetry,
+            parseFailedPaths: ingestResult.parseFailedPaths,
+            extraRetry: hashScanRetry,
+            ingestedCandidates: toIngest,
+            deleted: toDelete
+          })
+        )
+      );
+      if (hashScanCandidatesProvided) {
+        store.writeMeta(META_KEY_LAST_HEAD, headResult.head ?? "");
+      }
+      return {
+        ok: true,
+        mode: "hash_scan",
+        filesIngested: ingestResult.count,
+        head: hashScanCandidatesProvided ? headResult.head : lastHead
+      };
+    }
+  }
+}
+function readPendingParseFailures(store) {
+  const rawRead = store.readMeta(META_KEY_PENDING_PARSE_FAILURES);
+  if (!rawRead.ok) return rawRead;
+  const raw = rawRead.value;
+  if (raw === null) return { ok: true, paths: [] };
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return { ok: true, paths: [] };
+    return {
+      ok: true,
+      paths: parsed.filter((p) => typeof p === "string")
+    };
+  } catch {
+    return { ok: true, paths: [] };
+  }
+}
+function computeNextPending(args) {
+  const failed = new Set(args.parseFailedPaths);
+  const successfullyIngested = new Set(
+    args.ingestedCandidates.filter((p) => !failed.has(p))
+  );
+  const deleted = new Set(args.deleted);
+  const next = /* @__PURE__ */ new Set();
+  for (const path7 of [
+    ...args.priorPending,
+    ...args.parseFailedPaths,
+    ...args.extraRetry ?? []
+  ]) {
+    if (successfullyIngested.has(path7) || deleted.has(path7)) continue;
+    next.add(path7);
+  }
+  return [...next];
+}
+async function ingestFiles(store, repoRoot, parseFile, readFile2, paths, deletePaths = []) {
+  const batch = [];
+  const parseFailedPaths = [];
+  for (const relPath of paths) {
+    if (!isCanonicalRelativePath(relPath)) {
+      parseFailedPaths.push(relPath);
+      continue;
+    }
+    const ingestAbs = resolveRepoPath(repoRoot, relPath);
+    if (await symlinkEscapesRoot(repoRoot, ingestAbs)) continue;
+    let content;
+    try {
+      content = await readFile2(ingestAbs);
+    } catch {
+      parseFailedPaths.push(relPath);
+      continue;
+    }
+    const parseResult = await parseFile({ path: relPath, content });
+    if (!parseResult.ok) {
+      parseFailedPaths.push(relPath);
+      continue;
+    }
+    batch.push(parseResult.ir);
+  }
+  const upsertResult = await store.upsertFileBatch(batch, deletePaths);
+  if (!upsertResult.ok) {
+    return {
+      ok: false,
+      code: "store_error",
+      message: `upsertFileBatch failed: ${upsertResult.code}`
+    };
+  }
+  return { ok: true, count: batch.length, parseFailedPaths };
+}
+
+// src/detect-changes.ts
+var BLAST_RADIUS_EDGE_TYPES = [
+  "CALLS",
+  "IMPORTS",
+  "USES_TYPE"
+];
+var FAN_IN_ESCALATION_THRESHOLD = 5;
+var DEFAULT_BLAST_RADIUS_DEPTH = 3;
+var STORE_FAILURE_CODES = /* @__PURE__ */ new Set([
+  "db_locked",
+  "db_corrupt",
+  "db_error",
+  "store_closed"
+]);
+function isStoreFailureCode(code) {
+  return STORE_FAILURE_CODES.has(code);
+}
+function byteSpanToLines(content, startByte, endByte) {
+  let line = 1;
+  let startLine = 1;
+  let endLine = 1;
+  for (let i = 0; i < content.length; i += 1) {
+    if (i === startByte) startLine = line;
+    if (content[i] === 10) line += 1;
+    if (i === endByte - 1 && content[i] === 10) {
+      endLine = line;
+    } else if (i + 1 === endByte) {
+      endLine = line + (content[i] === 10 ? 0 : 1);
+    }
+  }
+  if (startByte >= content.length) startLine = line;
+  if (endByte > content.length) endLine = line + 1;
+  return { startLine, endLine };
+}
+function rangesOverlap(a, b) {
+  return a.startLine < b.endLine && b.startLine < a.endLine;
+}
+function classifyRisk(depth, fanIn) {
+  let base;
+  if (depth === 0) base = "direct";
+  else if (depth === 1) base = "near";
+  else base = "transitive";
+  if (fanIn >= FAN_IN_ESCALATION_THRESHOLD) {
+    if (base === "near") base = "direct";
+    else if (base === "transitive") base = "near";
+  }
+  return base;
+}
+function findDirectlyAffectedSymbols(hunksByPath, freshIRs, contentsByPath) {
+  const affected = /* @__PURE__ */ new Set();
+  for (const [filePath, hunks] of hunksByPath) {
+    const ir = freshIRs.get(filePath);
+    if (!ir) continue;
+    const content = contentsByPath.get(filePath);
+    if (!content) continue;
+    for (const sym of ir.symbols) {
+      const symLines = byteSpanToLines(
+        content,
+        sym.span.startByte,
+        sym.span.endByte
+      );
+      for (const hunk of hunks) {
+        if (rangesOverlap(symLines, hunk.newRange)) {
+          affected.add(nodeIdFor({ qualifiedName: sym.qualifiedName, filePath, label: sym.kind }));
+          break;
+        }
+      }
+    }
+  }
+  return affected;
+}
+function computeBlastRadius(store, directlyAffected, maxDepth = DEFAULT_BLAST_RADIUS_DEPTH) {
+  if (directlyAffected.size === 0) return { ok: true, affected: [] };
+  const hitByDepth = /* @__PURE__ */ new Map();
+  const hitMeta = /* @__PURE__ */ new Map();
+  for (const qname of directlyAffected) {
+    const result = store.traverse({
+      start: qname,
+      direction: "incoming",
+      edgeTypes: [...BLAST_RADIUS_EDGE_TYPES],
+      maxDepth
+    });
+    if (!result.ok) {
+      if (isStoreFailureCode(result.code)) {
+        return { ok: false, code: "store_error" };
+      }
+      continue;
+    }
+    for (const hit of result.hits) {
+      const existing = hitByDepth.get(hit.nodeId);
+      if (existing === void 0 || hit.depth < existing) {
+        hitByDepth.set(hit.nodeId, hit.depth);
+        hitMeta.set(hit.nodeId, {
+          qualifiedName: hit.qualifiedName,
+          name: hit.name,
+          label: hit.label,
+          filePath: hit.filePath
+        });
+      }
+    }
+  }
+  const out = [];
+  for (const [nodeId, depth] of hitByDepth) {
+    const meta = hitMeta.get(nodeId);
+    if (!meta) continue;
+    const inboundResult = store.traverse({
+      start: nodeId,
+      direction: "incoming",
+      edgeTypes: [...BLAST_RADIUS_EDGE_TYPES],
+      maxDepth: 1
+    });
+    let fanIn;
+    if (inboundResult.ok) {
+      fanIn = inboundResult.hits.filter((h) => h.depth > 0).length;
+    } else if (isStoreFailureCode(inboundResult.code)) {
+      return { ok: false, code: "store_error" };
+    } else {
+      fanIn = 0;
+    }
+    const risk = classifyRisk(depth, fanIn);
+    out.push({
+      qualifiedName: meta.qualifiedName,
+      name: meta.name,
+      label: meta.label,
+      filePath: meta.filePath,
+      risk,
+      depth,
+      fanIn
+    });
+  }
+  const riskOrder = {
+    direct: 0,
+    near: 1,
+    transitive: 2
+  };
+  const nodeIdByQFile = /* @__PURE__ */ new Map();
+  for (const [nodeId, depth] of hitByDepth) {
+    const m = hitMeta.get(nodeId);
+    if (m) nodeIdByQFile.set(`${m.qualifiedName}\0${m.filePath}\0${m.label}`, nodeId);
+    void depth;
+  }
+  out.sort((a, b) => {
+    const riskDiff = riskOrder[a.risk] - riskOrder[b.risk];
+    if (riskDiff !== 0) return riskDiff;
+    const qCmp = a.qualifiedName.localeCompare(b.qualifiedName);
+    if (qCmp !== 0) return qCmp;
+    const fCmp = a.filePath.localeCompare(b.filePath);
+    if (fCmp !== 0) return fCmp;
+    const lCmp = a.label.localeCompare(b.label);
+    if (lCmp !== 0) return lCmp;
+    const aId = nodeIdByQFile.get(`${a.qualifiedName}\0${a.filePath}\0${a.label}`) ?? "";
+    const bId = nodeIdByQFile.get(`${b.qualifiedName}\0${b.filePath}\0${b.label}`) ?? "";
+    return aId.localeCompare(bId);
+  });
+  return { ok: true, affected: out };
+}
+
+// src/co-change.ts
+var DEFAULT_CO_CHANGE_CONFIG = {
+  maxCommits: 500,
+  minSupport: 3,
+  minConfidence: 0.3
+};
+function mineCoChangeEdges(entries, config = DEFAULT_CO_CHANGE_CONFIG) {
+  const totalChanges = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const file of entry.files) {
+      totalChanges.set(file, (totalChanges.get(file) ?? 0) + 1);
+    }
+  }
+  const coChangeCounts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const files = entry.files;
+    for (let i = 0; i < files.length; i += 1) {
+      for (let j = i + 1; j < files.length; j += 1) {
+        const [a, b] = files[i] < files[j] ? [files[i], files[j]] : [files[j], files[i]];
+        const key = `${a}\0${b}`;
+        const existing = coChangeCounts.get(key);
+        if (existing) {
+          existing.count += 1;
+        } else {
+          coChangeCounts.set(key, { a, b, count: 1 });
+        }
+      }
+    }
+  }
+  const edges = [];
+  for (const { a, b, count } of coChangeCounts.values()) {
+    if (count < config.minSupport) continue;
+    const totalA = totalChanges.get(a) ?? 0;
+    const totalB = totalChanges.get(b) ?? 0;
+    const minTotal = Math.min(totalA, totalB);
+    if (minTotal === 0) continue;
+    const confidence = count / minTotal;
+    if (confidence < config.minConfidence) continue;
+    edges.push({ fileA: a, fileB: b, support: count, confidence });
+  }
+  edges.sort((x, y) => {
+    const cmp = x.fileA.localeCompare(y.fileA);
+    if (cmp !== 0) return cmp;
+    return x.fileB.localeCompare(y.fileB);
+  });
+  return edges;
+}
+async function mineAndStoreCoChanges(options) {
+  const { store, git, repoRoot } = options;
+  const config = options.config ?? DEFAULT_CO_CHANGE_CONFIG;
+  const logResult = git.logFiles(repoRoot, config.maxCommits);
+  if (!logResult.ok) return logResult;
+  const edges = mineCoChangeEdges(logResult.entries, config);
+  const persistResult = await store.upsertCoChanges(edges);
+  if (!persistResult.ok) {
+    return { ok: false, code: persistResult.code };
+  }
+  return { ok: true, edges };
+}
+
+// src/index-status.ts
+function getIndexStatus(store, git, repoRoot) {
+  const lastHeadResult = store.readMeta(META_KEY_LAST_HEAD);
+  const lastIndexedHead = lastHeadResult.ok ? lastHeadResult.value : null;
+  const headResult = git.revParseHead(repoRoot);
+  const stats = store.schemaStats();
+  const fileCount = stats.ok ? stats.stats.files : 0;
+  const nodeCount = stats.ok ? stats.stats.nodes : 0;
+  if (!headResult.ok) {
+    return {
+      lastIndexedHead,
+      currentHead: null,
+      dirty: true,
+      mode: "git_unavailable",
+      fileCount,
+      nodeCount
+    };
+  }
+  const currentHead = headResult.head;
+  if (lastIndexedHead === null) {
+    return {
+      lastIndexedHead: null,
+      currentHead,
+      dirty: currentHead !== null,
+      mode: "empty",
+      fileCount,
+      nodeCount
+    };
+  }
+  if (currentHead === null) {
+    return {
+      lastIndexedHead,
+      currentHead: null,
+      dirty: true,
+      mode: "stale",
+      fileCount,
+      nodeCount
+    };
+  }
+  const pendingResult = store.readMeta(META_KEY_PENDING_PARSE_FAILURES);
+  const pendingRaw = pendingResult.ok ? pendingResult.value : null;
+  let hasPendingFailures = false;
+  if (pendingRaw !== null) {
+    try {
+      const parsed = JSON.parse(pendingRaw);
+      hasPendingFailures = Array.isArray(parsed) && parsed.length > 0;
+    } catch {
+      hasPendingFailures = false;
+    }
+  }
+  const dirty = lastIndexedHead !== currentHead || hasPendingFailures;
+  const mode = hasPendingFailures ? "stale" : dirty ? "stale" : "fresh";
+  return {
+    lastIndexedHead,
+    currentHead,
+    dirty,
+    mode,
+    fileCount,
+    nodeCount
+  };
+}
+
+// src/git-invoker.ts
+import { launchProcessSync } from "@remnic/core/runtime/child-process";
+var GIT_TIMEOUT_MS = 2e3;
+function runGit(cwd, args) {
+  const result = launchProcessSync("git", [...args], {
+    cwd,
+    encoding: "utf-8",
+    timeout: GIT_TIMEOUT_MS,
+    shell: false
+  });
+  if (result.error) {
+    return { ok: false, code: "git_unavailable" };
+  }
+  return {
+    ok: true,
+    stdout: typeof result.stdout === "string" ? result.stdout : "",
+    exitCode: typeof result.status === "number" ? result.status : 1
+  };
+}
+function defaultCodingGitInvoker() {
+  return {
+    revParseHead(cwd) {
+      const r = runGit(cwd, ["rev-parse", "HEAD"]);
+      if (!r.ok) return r;
+      const trimmed = r.stdout.trim();
+      if (r.exitCode === 0 && trimmed.length > 0) {
+        return { ok: true, head: trimmed };
+      }
+      const wt = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+      if (wt.ok && wt.exitCode === 0 && wt.stdout.trim() === "true") {
+        return { ok: true, head: null };
+      }
+      return { ok: false, code: "git_error" };
+    },
+    isReachable(cwd, ref) {
+      const r = runGit(cwd, ["rev-parse", "--verify", `${ref}^{commit}`]);
+      if (!r.ok) return r;
+      return { ok: true, reachable: r.exitCode === 0 };
+    },
+    diffNameStatus(cwd, range) {
+      const r = runGit(cwd, ["diff", "--name-status", range]);
+      if (!r.ok) return r;
+      if (r.exitCode !== 0) {
+        return { ok: false, code: "git_error" };
+      }
+      return { ok: true, entries: parseNameStatus(r.stdout) };
+    },
+    diffHunks(cwd, paths) {
+      const pathArgs = [];
+      if (paths.length > 0) {
+        pathArgs.push("--");
+        for (const p of paths) pathArgs.push(p);
+      }
+      const r = runGit(cwd, ["diff", "HEAD", "--unified=0", "--no-color", ...pathArgs]);
+      if (!r.ok) return r;
+      if (r.exitCode !== 0) {
+        const fallback = runGit(cwd, ["diff", "--unified=0", "--no-color", ...pathArgs]);
+        if (!fallback.ok) return fallback;
+        if (fallback.exitCode !== 0) {
+          return { ok: false, code: "git_error" };
+        }
+        return { ok: true, hunks: parseHunks(fallback.stdout) };
+      }
+      return { ok: true, hunks: parseHunks(r.stdout) };
+    },
+    logFiles(cwd, limit) {
+      const r = runGit(cwd, [
+        "log",
+        `--format=%H`,
+        "--name-only",
+        `-n`,
+        String(limit)
+      ]);
+      if (!r.ok) return r;
+      if (r.exitCode !== 0) {
+        return { ok: false, code: "git_error" };
+      }
+      return { ok: true, entries: parseLogFiles(r.stdout) };
+    },
+    listTrackedFiles(cwd) {
+      const r = runGit(cwd, ["ls-files"]);
+      if (!r.ok) return r;
+      if (r.exitCode !== 0) {
+        return { ok: false, code: "git_error" };
+      }
+      const paths = r.stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+      return { ok: true, paths };
+    }
+  };
+}
+function parseNameStatus(stdout) {
+  const out = [];
+  const lines = stdout.split("\n");
+  for (const line of lines) {
+    if (line.length === 0) continue;
+    const tabIdx = line.indexOf("	");
+    if (tabIdx < 0) continue;
+    const status = line.slice(0, tabIdx);
+    const rest = line.slice(tabIdx + 1);
+    const secondTab = rest.indexOf("	");
+    if ((status.startsWith("R") || status.startsWith("C")) && secondTab >= 0) {
+      const oldPath = rest.slice(0, secondTab);
+      const newPath = rest.slice(secondTab + 1);
+      if (oldPath.length > 0 && newPath.length > 0) {
+        out.push({ status, path: newPath, oldPath });
+      }
+    } else {
+      if (rest.length > 0) {
+        out.push({ status, path: rest });
+      }
+    }
+  }
+  return out;
+}
+function parseHunks(stdout) {
+  const out = [];
+  let currentPath = null;
+  const lines = stdout.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("+++ ")) {
+      if (line.startsWith("+++ /dev/null")) {
+        currentPath = null;
+        continue;
+      }
+      const raw = line.slice(4);
+      currentPath = raw.startsWith("b/") ? raw.slice(2) : raw;
+      continue;
+    }
+    if (line.startsWith("@@ ")) {
+      const match = line.match(/\+(\d+)(?:,(\d+))?/);
+      if (!match) continue;
+      const startStr = match[1] ?? "";
+      if (startStr.length === 0) continue;
+      const startLine = parseInt(startStr, 10);
+      const countStr = match[2] ?? "";
+      const count = countStr.length > 0 ? parseInt(countStr, 10) : 1;
+      if (!currentPath) continue;
+      out.push({
+        path: currentPath,
+        newRange: {
+          startLine,
+          endLine: startLine + Math.max(count, 1)
+        }
+      });
+    }
+  }
+  return out;
+}
+function parseLogFiles(stdout) {
+  const out = [];
+  let currentSha = null;
+  let currentFiles = [];
+  const seenInCommit = /* @__PURE__ */ new Set();
+  const flush = () => {
+    if (currentSha !== null) {
+      out.push({ sha: currentSha, files: currentFiles });
+    }
+    currentSha = null;
+    currentFiles = [];
+    seenInCommit.clear();
+  };
+  for (const line of stdout.split("\n")) {
+    if (/^[0-9a-f]{40}$/.test(line)) {
+      flush();
+      currentSha = line;
+    } else if (line.length > 0 && currentSha !== null) {
+      if (!seenInCommit.has(line)) {
+        seenInCommit.add(line);
+        currentFiles.push(line);
+      }
+    }
+  }
+  flush();
+  return out;
+}
+
+// src/lsp/client.ts
+import { spawn } from "child_process";
+import path3 from "path";
+import process2 from "process";
+
+// src/lsp/framing.ts
+function encodeLspFrame(message) {
+  const body = JSON.stringify(message);
+  const byteLength = Buffer.byteLength(body, "utf8");
+  return `Content-Length: ${byteLength}\r
+\r
+${body}`;
+}
+var HEADER_SEPARATOR = Buffer.from("\r\n\r\n");
+var HEADER_SEPARATOR_LEN = HEADER_SEPARATOR.length;
+var LspFrameDecoder = class {
+  buffer = Buffer.alloc(0);
+  /**
+   * Scan offset into {@link buffer}. The header scan resumes here on
+   * the next feed() — never re-scans bytes already confirmed to not
+   * contain the separator (rule 32). Reset to 0 after each consumed
+   * frame because slicing the buffer discards those bytes.
+   */
+  scanOffset = 0;
+  /**
+   * Feed a raw chunk (Buffer or string) from the server's stdout.
+   * Returns all complete messages parsed from the accumulated buffer
+   * since the last call, or the first decode error encountered (the
+   * decoder stops on error — a protocol violation means the stream is
+   * corrupt and further parsing is undefined).
+   */
+  feed(chunk) {
+    const buf = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+    this.buffer = this.buffer.length === 0 ? Buffer.from(buf) : Buffer.concat([this.buffer, buf]);
+    const messages = [];
+    while (true) {
+      const sepIdx = this.buffer.indexOf(HEADER_SEPARATOR, this.scanOffset);
+      if (sepIdx < 0) {
+        this.scanOffset = Math.max(0, this.buffer.length - (HEADER_SEPARATOR_LEN - 1));
+        return { ok: true, messages };
+      }
+      const headerBlock = this.buffer.subarray(0, sepIdx).toString("utf8");
+      const contentLength = parseContentLength(headerBlock);
+      if (contentLength === null) {
+        return {
+          ok: false,
+          error: {
+            kind: "malformed_header",
+            detail: `header block has no valid Content-Length: ${JSON.stringify(headerBlock)}`
+          }
+        };
+      }
+      const bodyStart = sepIdx + HEADER_SEPARATOR_LEN;
+      const bodyEnd = bodyStart + contentLength;
+      if (this.buffer.length < bodyEnd) {
+        this.scanOffset = Math.max(0, sepIdx - (HEADER_SEPARATOR_LEN - 1));
+        return { ok: true, messages };
+      }
+      const bodyBytes = this.buffer.subarray(bodyStart, bodyEnd);
+      let parsed;
+      try {
+        parsed = JSON.parse(bodyBytes.toString("utf8"));
+      } catch (e) {
+        return {
+          ok: false,
+          error: {
+            kind: "json_parse_error",
+            detail: `body is not valid JSON: ${e instanceof Error ? e.message : String(e)}`
+          }
+        };
+      }
+      messages.push(parsed);
+      this.buffer = this.buffer.subarray(bodyEnd);
+      this.scanOffset = 0;
+    }
+  }
+  /** True if there is un-consumed residual data in the buffer. */
+  get hasResidual() {
+    return this.buffer.length > 0;
+  }
+  /** Reset the decoder to a clean state (test seam). */
+  reset() {
+    this.buffer = Buffer.alloc(0);
+    this.scanOffset = 0;
+  }
+};
+function parseContentLength(headerBlock) {
+  const lines = headerBlock.split("\r\n");
+  for (const line of lines) {
+    const match = /^Content-Length:\s*(\d+)\s*$/i.exec(line);
+    if (match) {
+      const n = Number(match[1]);
+      return Number.isFinite(n) && n >= 0 ? n : null;
+    }
+  }
+  return null;
+}
+
+// src/lsp/degradation.ts
+function lspDegradation(code, detail) {
+  return detail !== void 0 ? { backend: "lsp", code, detail } : { backend: "lsp", code };
+}
+
+// src/lsp/client.ts
+var LspClient = class _LspClient {
+  child;
+  decoder = new LspFrameDecoder();
+  rootUri;
+  timeoutMs;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  disposed = false;
+  crashed = false;
+  crashCode = null;
+  serverCapabilities = null;
+  constructor(child, rootUri, timeoutMs) {
+    this.child = child;
+    this.rootUri = rootUri;
+    this.timeoutMs = timeoutMs;
+    this.child.stdout?.setEncoding("utf8");
+    this.child.stdout?.on("data", (chunk) => this.onStdoutData(chunk));
+    this.child.stderr?.on("data", () => {
+    });
+    this.child.on("exit", (code, signal) => this.onChildExit(code, signal));
+    this.child.on("error", (err) => this.onChildError(err));
+  }
+  /**
+   * Spawn the server and perform the initialize handshake. Returns a
+   * tagged result — `{ ok: true, client }` on success, or a degradation
+   * on failure (server_missing, handshake_timeout, handshake_error).
+   */
+  static async connect(options) {
+    let child;
+    const spawnFn = options.spawnFn ?? spawn;
+    try {
+      child = spawnFn(options.launchSpec.command, [...options.launchSpec.args], {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false,
+        // The server inherits our cwd so relative rootUri paths resolve.
+        cwd: process2.cwd()
+      });
+    } catch {
+      return {
+        ok: false,
+        degradation: lspDegradation(
+          "server_missing",
+          `failed to spawn ${options.launchSpec.command}`
+        )
+      };
+    }
+    if (child.exitCode !== null && child.exitCode !== void 0) {
+      return {
+        ok: false,
+        degradation: lspDegradation("server_missing")
+      };
+    }
+    const client = new _LspClient(child, options.rootUri, options.timeoutMs);
+    if (client.crashed) {
+      return {
+        ok: false,
+        degradation: lspDegradation(client.crashCode ?? "server_crashed")
+      };
+    }
+    const initParams = {
+      processId: process2.pid,
+      rootUri: options.rootUri,
+      capabilities: {}
+    };
+    const initResult = await client.request("initialize", initParams);
+    if (!initResult.ok) {
+      await client.dispose();
+      const code = initResult.degradation.code === "request_timeout" ? "handshake_timeout" : initResult.degradation.code;
+      return {
+        ok: false,
+        degradation: lspDegradation(code, initResult.degradation.detail)
+      };
+    }
+    if (initResult.value === null || typeof initResult.value !== "object") {
+      await client.dispose();
+      return {
+        ok: false,
+        degradation: lspDegradation("protocol_error", "initialize response missing or invalid")
+      };
+    }
+    const initResponse = initResult.value;
+    client.serverCapabilities = initResponse.capabilities;
+    client.notify("initialized", {});
+    return { ok: true, client };
+  }
+  /**
+   * Send `textDocument/didOpen` — notifies the server about an open
+   * document with its full content. No response expected.
+   */
+  didOpen(item) {
+    this.notify("textDocument/didOpen", { textDocument: item });
+  }
+  /**
+   * Send `textDocument/definition` for a position in a document. Returns
+   * the definition locations (may be empty, a single location, or an
+   * array). Degrades on timeout/error/crash — never throws.
+   */
+  async definition(params) {
+    if (this.disposed || this.crashed) {
+      return {
+        ok: false,
+        degradation: lspDegradation("server_crashed")
+      };
+    }
+    const result = await this.request("textDocument/definition", params);
+    if (!result.ok) {
+      return result;
+    }
+    const value = result.value;
+    let locations;
+    if (value === null || value === void 0) {
+      locations = [];
+    } else if (Array.isArray(value)) {
+      locations = value;
+    } else {
+      locations = [value];
+    }
+    return { ok: true, locations };
+  }
+  /**
+   * Send `shutdown`, then `exit`, then SIGKILL if the process lingers.
+   * Idempotent — safe to call multiple times. After dispose, no child
+   * process remains (tested — zombie cleanup).
+   */
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const [id, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(lspDegradation("server_crashed"));
+      this.pending.delete(id);
+    }
+    if (!this.crashed && this.child.stdin && !this.child.stdin.destroyed) {
+      try {
+        const promise = new Promise((resolve) => {
+          this.child.stdin?.write(encodeLspFrame({ jsonrpc: "2.0", id: 0, method: "shutdown" }));
+          this.child.stdin?.write(encodeLspFrame({ jsonrpc: "2.0", method: "exit" }));
+          const timer = setTimeout(resolve, 500);
+          this.child.on("exit", () => {
+            clearTimeout(timer);
+            resolve();
+          });
+        });
+        await promise;
+      } catch {
+      }
+    }
+    this.hardKill();
+  }
+  /** Returns the pid of the child process (for zombie-cleanup tests). */
+  get pid() {
+    return this.child.pid;
+  }
+  /** True if the server reported definitionProvider capability. */
+  get supportsDefinition() {
+    const caps = this.serverCapabilities;
+    return caps !== null && Boolean(caps.definitionProvider);
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Internal — JSON-RPC request/notification machinery
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Send a request and await its response. Returns the `result` field
+   * on success, or a degradation on timeout/error/crash/protocol-error.
+   */
+  request(method, params) {
+    if (this.disposed || this.crashed) {
+      return Promise.resolve({
+        ok: false,
+        degradation: lspDegradation("server_crashed")
+      });
+    }
+    const id = this.nextId++;
+    const message = { jsonrpc: "2.0", id, method, params };
+    const promise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const entry = this.pending.get(id);
+        if (entry) {
+          this.pending.delete(id);
+          entry.reject(lspDegradation("request_timeout", `method=${method}`));
+        }
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        const frame = encodeLspFrame(message);
+        if (!this.child.stdin || this.child.stdin.destroyed) {
+          clearTimeout(timer);
+          this.pending.delete(id);
+          reject(lspDegradation("server_crashed"));
+          return;
+        }
+        this.child.stdin.write(frame);
+      } catch {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(lspDegradation("server_crashed"));
+      }
+    });
+    return promise.then(
+      (value) => ({ ok: true, value }),
+      (degradation) => ({ ok: false, degradation })
+    );
+  }
+  /**
+   * Send a notification (no response expected). Best-effort — if the
+   * write fails, the next request will surface the crash.
+   */
+  notify(method, params) {
+    if (this.disposed || this.crashed) return;
+    try {
+      const message = { jsonrpc: "2.0", method, params };
+      this.child.stdin?.write(encodeLspFrame(message));
+    } catch {
+    }
+  }
+  /**
+   * Dispatch a decoded JSON-RPC message. Correlates responses to pending
+   * requests by id; ignores server-initiated notifications (we don't
+   * need them for the resolution pass).
+   */
+  /**
+   * Dispatch a decoded JSON-RPC message. Correlates responses to pending
+   * requests by id; ignores server-initiated notifications.
+   */
+  dispatchMessage(msg) {
+    if (typeof msg !== "object" || msg === null) return;
+    const rpc = msg;
+    if (rpc.id === void 0 || rpc.result === void 0 && rpc.error === void 0) {
+      return;
+    }
+    const id = typeof rpc.id === "number" ? rpc.id : Number(rpc.id);
+    const entry = this.pending.get(id);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    this.pending.delete(id);
+    if (rpc.error !== void 0) {
+      entry.reject(lspDegradation("request_error", "server returned an error response"));
+    } else {
+      entry.resolve(rpc.result);
+    }
+  }
+  /**
+   * stdout data handler — feed the decoder, dispatch complete messages,
+   * detect protocol errors.
+   */
+  onStdoutData(chunk) {
+    const result = this.decoder.feed(chunk);
+    if (!result.ok) {
+      this.handleProtocolError(result.error.detail);
+      return;
+    }
+    for (const msg of result.messages) {
+      this.dispatchMessage(msg);
+    }
+  }
+  /**
+   * Handle an unexpected child exit. All pending requests are rejected
+   * with server_crashed.
+   */
+  onChildExit(code, signal) {
+    if (this.disposed) return;
+    this.crashed = true;
+    this.crashCode = "server_crashed";
+    const detail = code !== null ? `server exited with code ${code}` : `server killed by ${signal}`;
+    for (const [id, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(lspDegradation("server_crashed", detail));
+      this.pending.delete(id);
+    }
+  }
+  /**
+   * Handle a spawn error (ENOENT etc). Marks the server as missing.
+   */
+  onChildError(err) {
+    this.crashed = true;
+    const isENOENT = err.message.includes("ENOENT");
+    this.crashCode = isENOENT ? "server_missing" : "server_crashed";
+    const detail = isENOENT ? void 0 : "spawn error";
+    for (const [id, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(lspDegradation(this.crashCode, detail));
+      this.pending.delete(id);
+    }
+  }
+  /**
+   * Protocol error — the stream produced a malformed frame. Reject all
+   * pending and mark disposed so no further requests can be sent.
+   */
+  handleProtocolError(detail) {
+    this.crashed = true;
+    for (const [id, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(lspDegradation("protocol_error", detail));
+      this.pending.delete(id);
+    }
+  }
+  /**
+   * Hard-kill the child process: SIGKILL. Called by dispose() as a
+   * final cleanup guarantee. Also called if the graceful shutdown path
+   * fails. Uses `kill` which is a no-op if the process already exited.
+   */
+  hardKill() {
+    try {
+      if (this.child.pid !== void 0 && !this.child.killed) {
+        this.child.kill("SIGKILL");
+      }
+    } catch {
+    }
+  }
+};
+function pathToUri(filePath) {
+  const abs = path3.isAbsolute(filePath) ? filePath : path3.resolve(filePath);
+  const normalized = abs.replace(/\\/g, "/");
+  const withSlash = /^[A-Za-z]:/.test(normalized) ? `/${normalized}` : normalized;
+  return `file://${withSlash}`;
+}
+function uriToPath(uri) {
+  if (uri.startsWith("file://")) {
+    let rest = uri.slice("file://".length);
+    try {
+      rest = decodeURIComponent(rest);
+    } catch {
+    }
+    if (/^\/[A-Za-z]:/.test(rest)) {
+      return rest.slice(1).replace(/\//g, path3.sep);
+    }
+    return rest.replace(/\//g, path3.sep);
+  }
+  return uri;
+}
+
+// src/lsp/config.ts
+import process3 from "process";
+var DEFAULT_LSP_TIMEOUT_MS = 3e3;
+var DEFAULT_LSP_MAX_REQUESTS_PER_RUN = 500;
+var DEFAULT_LSP_CONFIG = {
+  enabled: false,
+  servers: {},
+  timeoutMs: DEFAULT_LSP_TIMEOUT_MS,
+  maxRequestsPerRun: DEFAULT_LSP_MAX_REQUESTS_PER_RUN
+};
+function parseEnabledFlag(v) {
+  if (typeof v === "boolean") return v;
+  if (typeof v === "string") {
+    const lower = v.trim().toLowerCase();
+    return lower !== "false" && lower !== "0" && lower !== "no" && lower !== "";
+  }
+  return Boolean(v);
+}
+function parseLspConfig(raw, knownLanguages) {
+  if (raw === null || raw === void 0) {
+    return { ok: true, config: DEFAULT_LSP_CONFIG };
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    return {
+      ok: false,
+      degradation: {
+        backend: "lsp",
+        code: "protocol_error",
+        detail: "codingGraph.lsp must be an object"
+      }
+    };
+  }
+  const obj = raw;
+  const knownSet = new Set(knownLanguages);
+  const enabled = obj.enabled === void 0 ? false : parseEnabledFlag(obj.enabled);
+  const timeoutMs = obj.timeoutMs === void 0 ? DEFAULT_LSP_TIMEOUT_MS : Number(obj.timeoutMs);
+  const maxRequestsPerRun = obj.maxRequestsPerRun === void 0 ? DEFAULT_LSP_MAX_REQUESTS_PER_RUN : Number(obj.maxRequestsPerRun);
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+    return {
+      ok: false,
+      degradation: {
+        backend: "lsp",
+        code: "protocol_error",
+        detail: `lsp.timeoutMs must be a non-negative number, got ${JSON.stringify(obj.timeoutMs)}`
+      }
+    };
+  }
+  if (!Number.isFinite(maxRequestsPerRun) || maxRequestsPerRun < 0) {
+    return {
+      ok: false,
+      degradation: {
+        backend: "lsp",
+        code: "protocol_error",
+        detail: `lsp.maxRequestsPerRun must be a non-negative number, got ${JSON.stringify(obj.maxRequestsPerRun)}`
+      }
+    };
+  }
+  const servers = {};
+  if (obj.servers !== void 0 && obj.servers !== null) {
+    if (typeof obj.servers !== "object" || Array.isArray(obj.servers)) {
+      return {
+        ok: false,
+        degradation: {
+          backend: "lsp",
+          code: "protocol_error",
+          detail: "lsp.servers must be an object"
+        }
+      };
+    }
+    for (const [lang, spec] of Object.entries(obj.servers)) {
+      if (!knownSet.has(lang)) {
+        return {
+          ok: false,
+          degradation: {
+            backend: "lsp",
+            code: "unknown_language",
+            detail: `unknown language "${lang}" in lsp.servers; supported: ${knownLanguages.join(", ")}`
+          }
+        };
+      }
+      if (typeof spec !== "object" || spec === null || Array.isArray(spec)) {
+        return {
+          ok: false,
+          degradation: {
+            backend: "lsp",
+            code: "protocol_error",
+            detail: `lsp.servers.${lang} must be an object`
+          }
+        };
+      }
+      const s = spec;
+      if (typeof s.command !== "string" || s.command.length === 0) {
+        return {
+          ok: false,
+          degradation: {
+            backend: "lsp",
+            code: "protocol_error",
+            detail: `lsp.servers.${lang}.command must be a non-empty string`
+          }
+        };
+      }
+      if (!Array.isArray(s.args) || s.args.some((a) => typeof a !== "string")) {
+        return {
+          ok: false,
+          degradation: {
+            backend: "lsp",
+            code: "protocol_error",
+            detail: `lsp.servers.${lang}.args must be an array of strings`
+          }
+        };
+      }
+      servers[lang] = {
+        command: s.command,
+        args: [...s.args]
+      };
+    }
+  }
+  return { ok: true, config: { enabled, servers, timeoutMs, maxRequestsPerRun } };
+}
+function readLspEnabledEnv() {
+  return process3.env.REMNIC_CODING_GRAPH_LSP_ENABLED ?? process3.env.ENGRAM_CODING_GRAPH_LSP_ENABLED ?? null;
+}
+
+// src/lsp/resolution.ts
+import path4 from "path";
+
+// src/lsp/byte-position.ts
+function utf8ByteLength(code, nextCode) {
+  if (code >= 55296 && code <= 56319 && nextCode >= 56320 && nextCode <= 57343) {
+    return 4;
+  }
+  if (code < 128) return 1;
+  if (code < 2048) return 2;
+  return 3;
+}
+function isHighSurrogate(code, nextCode) {
+  return code >= 55296 && code <= 56319 && nextCode >= 56320 && nextCode <= 57343;
+}
+function buildLineOffsetMap(content) {
+  const text = typeof content === "string" ? content : content.toString("utf8");
+  const lineStarts = [0];
+  let byteOffset = 0;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    const nextCode = i + 1 < text.length ? text.charCodeAt(i + 1) : 0;
+    if (code === 13 && nextCode === 10) {
+      byteOffset += 2;
+      lineStarts.push(byteOffset);
+      i++;
+    } else if (code === 10 || code === 13) {
+      byteOffset += 1;
+      lineStarts.push(byteOffset);
+    } else {
+      byteOffset += utf8ByteLength(code, nextCode);
+      if (isHighSurrogate(code, nextCode)) i++;
+    }
+  }
+  return { lineStarts };
+}
+function byteOffsetToPosition(content, byteOffset, map) {
+  const lineIdx = binarySearchLine(map.lineStarts, byteOffset);
+  const lineByteStart = map.lineStarts[lineIdx];
+  let strIdx = 0;
+  let byteAccum = 0;
+  for (strIdx = 0; strIdx < content.length; strIdx++) {
+    if (byteAccum >= lineByteStart) break;
+    const code = content.charCodeAt(strIdx);
+    const nextCode = strIdx + 1 < content.length ? content.charCodeAt(strIdx + 1) : 0;
+    byteAccum += utf8ByteLength(code, nextCode);
+    if (isHighSurrogate(code, nextCode)) strIdx++;
+  }
+  let charCount = 0;
+  let currentByte = lineByteStart;
+  for (let i = strIdx; i < content.length; i++) {
+    if (currentByte >= byteOffset) break;
+    const code = content.charCodeAt(i);
+    const nextCode = i + 1 < content.length ? content.charCodeAt(i + 1) : 0;
+    currentByte += utf8ByteLength(code, nextCode);
+    if (isHighSurrogate(code, nextCode)) {
+      charCount += 2;
+      i++;
+    } else {
+      charCount++;
+    }
+  }
+  return { line: lineIdx, character: charCount };
+}
+function positionToByteOffset(content, position, map) {
+  const lineIdx = Math.min(position.line, map.lineStarts.length - 1);
+  const lineByteStart = map.lineStarts[lineIdx];
+  let strIdx = 0;
+  let byteAccum = 0;
+  for (strIdx = 0; strIdx < content.length; strIdx++) {
+    if (byteAccum >= lineByteStart) break;
+    const code = content.charCodeAt(strIdx);
+    const nextCode = strIdx + 1 < content.length ? content.charCodeAt(strIdx + 1) : 0;
+    byteAccum += utf8ByteLength(code, nextCode);
+    if (isHighSurrogate(code, nextCode)) strIdx++;
+  }
+  let charCount = 0;
+  let byteOffset = lineByteStart;
+  for (let i = strIdx; i < content.length && charCount < position.character; i++) {
+    const code = content.charCodeAt(i);
+    const nextCode = i + 1 < content.length ? content.charCodeAt(i + 1) : 0;
+    byteOffset += utf8ByteLength(code, nextCode);
+    if (isHighSurrogate(code, nextCode)) {
+      charCount += 2;
+      i++;
+    } else {
+      charCount++;
+    }
+  }
+  return byteOffset;
+}
+function binarySearchLine(lineStarts, byteOffset) {
+  let lo = 0;
+  let hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (lineStarts[mid] <= byteOffset) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return lo;
+}
+
+// src/lsp/resolution.ts
+function planLspUpgrades(callSites, budget) {
+  const sorted = [...callSites].sort(
+    (a, b) => a.filePath.localeCompare(b.filePath) || a.calleeByteOffset - b.calleeByteOffset
+  );
+  const max = Math.max(0, budget.maxRequests);
+  const planned = sorted.slice(0, max);
+  const exhausted = sorted.length - planned.length;
+  const maps = /* @__PURE__ */ new Map();
+  const requests = planned.map((cs) => {
+    let map = maps.get(cs.filePath);
+    if (!map) {
+      map = buildLineOffsetMap(cs.content);
+      maps.set(cs.filePath, map);
+    }
+    const position = byteOffsetToPosition(cs.content, cs.calleeByteOffset, map);
+    return {
+      filePath: cs.filePath,
+      language: cs.language,
+      content: cs.content,
+      calleeName: cs.calleeName,
+      srcQualifiedName: cs.srcQualifiedName,
+      position
+    };
+  });
+  return { requests, budgetExhausted: exhausted };
+}
+var LANGUAGE_ID_MAP = {
+  tsx: "typescriptreact",
+  bash: "shellscript"
+};
+async function executeLspResolution(requests, options) {
+  const { client, nodeLocator, applyUpgrades } = options;
+  const byFile = /* @__PURE__ */ new Map();
+  for (const req of requests) {
+    let batch = byFile.get(req.filePath);
+    if (!batch) {
+      batch = [];
+      byFile.set(req.filePath, batch);
+    }
+    batch.push(req);
+  }
+  let upgraded = 0;
+  let unresolved = 0;
+  let degradation;
+  for (const [filePath, batchReqs] of byFile) {
+    const upgrades = [];
+    let batchFailed = false;
+    const firstReq = batchReqs[0];
+    client.didOpen({
+      uri: filePathToUri(filePath, options.workspaceRoot),
+      languageId: LANGUAGE_ID_MAP[firstReq.language] ?? firstReq.language,
+      version: 1,
+      text: firstReq.content
+    });
+    for (let i = 0; i < batchReqs.length; i++) {
+      const req = batchReqs[i];
+      if (degradation) {
+        unresolved += batchReqs.length - i;
+        break;
+      }
+      const defResult = await client.definition({
+        textDocument: { uri: filePathToUri(req.filePath, options.workspaceRoot) },
+        position: req.position
+      });
+      if (!defResult.ok) {
+        if (defResult.degradation.code === "server_crashed" || defResult.degradation.code === "protocol_error") {
+          degradation = defResult.degradation;
+          unresolved += batchReqs.length - i;
+          batchFailed = true;
+          break;
+        }
+        unresolved++;
+        continue;
+      }
+      const dstQName = mapLocationToNode(
+        defResult.locations,
+        {
+          callerFilePath: req.filePath,
+          callerContent: req.content,
+          workspaceRoot: options.workspaceRoot,
+          resolveContent: options.resolveContent
+        },
+        nodeLocator
+      );
+      if (dstQName === null) {
+        unresolved++;
+        continue;
+      }
+      upgrades.push({
+        srcQualifiedName: req.srcQualifiedName,
+        dstQualifiedName: dstQName,
+        type: "CALLS",
+        confidence: 0.9,
+        provenance: "lsp"
+      });
+    }
+    if (batchFailed) {
+      unresolved += upgrades.length;
+      break;
+    }
+    if (upgrades.length > 0) {
+      try {
+        await applyUpgrades(upgrades);
+        upgraded += upgrades.length;
+      } catch {
+        unresolved += upgrades.length;
+      }
+    }
+  }
+  return {
+    upgraded,
+    unresolved,
+    budgetExhausted: 0,
+    // set by the caller from the planner result
+    degradation
+  };
+}
+function mapLocationToNode(locations, context, nodeLocator) {
+  for (const loc of locations) {
+    const filePath = normalizeLocationPath(loc.uri, context.workspaceRoot);
+    let content;
+    if (filePath === context.callerFilePath) {
+      content = context.callerContent;
+    } else if (context.resolveContent) {
+      const resolved = context.resolveContent(filePath);
+      if (resolved === null) continue;
+      content = resolved;
+    } else {
+      content = context.callerContent;
+    }
+    const map = buildLineOffsetMap(content);
+    const startByte = positionToByteOffset(content, loc.range.start, map);
+    const qName = nodeLocator(filePath, startByte);
+    if (qName !== null) return qName;
+  }
+  return null;
+}
+function filePathToUri(filePath, workspaceRoot) {
+  const isAbsolute = filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath);
+  if (isAbsolute) {
+    return `file://${filePath.replace(/\\/g, "/")}`;
+  }
+  if (workspaceRoot) {
+    const abs = path4.join(workspaceRoot, filePath).replace(/\\/g, "/");
+    return `file://${abs}`;
+  }
+  return `file:///${filePath.replace(/\\/g, "/")}`;
+}
+function normalizeLocationPath(uri, workspaceRoot) {
+  const absPath = uriToPath(uri);
+  if (workspaceRoot) {
+    const root = path4.resolve(workspaceRoot);
+    const rel = path4.relative(root, absPath);
+    if (!rel.startsWith("..") && rel !== "") {
+      return rel.replace(/\\/g, "/");
+    }
+  }
+  return absPath;
+}
+
+// src/lsp/status.ts
+function getLspStatus(input) {
+  return input.languages.map((lang) => {
+    const probed = input.probeResults.get(lang) ?? false;
+    const degradationCode = input.degradations.get(lang);
+    const requestsUsed = input.requestCounts.get(lang) ?? 0;
+    return {
+      language: lang,
+      enabled: input.config.enabled,
+      probed,
+      degraded: degradationCode !== void 0,
+      degradationCode,
+      requestsUsed
+    };
+  });
+}
+function formatLspStatusLine(entry) {
+  if (!entry.enabled) {
+    return `${entry.language}: lsp [disabled]`;
+  }
+  const parts = [];
+  if (entry.probed) {
+    parts.push("probed");
+  } else {
+    parts.push("not_probed");
+  }
+  if (entry.degraded && entry.degradationCode) {
+    parts[parts.length - 1] = `degraded:${entry.degradationCode}`;
+  }
+  const stateStr = parts.join(" ");
+  return `${entry.language}: lsp [${stateStr}] ${entry.requestsUsed} requests`;
+}
+function resolutionResultToStatusMaps(language, result, degradations, requestCounts) {
+  requestCounts.set(language, result.upgraded + result.unresolved);
+  if (result.degradation) {
+    degradations.set(language, result.degradation.code);
+  }
+}
+
+// src/semantic/config.ts
+var DEFAULT_SIMILAR_TO_THRESHOLD = 0.92;
+var DEFAULT_MAX_SYMBOLS_PER_RUN = 0;
+var MINHASH_ONLY_CONFIDENCE = 0.5;
+var SIMILAR_TO_EDGE_TYPE = "SIMILAR_TO";
+var SEMANTIC_PROVENANCE = "semantic";
+var DEFAULT_CANONICAL_BODY_LINES = 16;
+var MINHASH_SHINGLE_WIDTH = 2;
+var MINHASH_NUM_PERMUTATIONS = 128;
+var LSH_NUM_BANDS = 32;
+var LSH_ROWS_PER_BAND = MINHASH_NUM_PERMUTATIONS / LSH_NUM_BANDS;
+var LSH_CANDIDATE_JACCARD_FLOOR = Math.pow(1 / LSH_NUM_BANDS, 1 / LSH_ROWS_PER_BAND);
+var ENV_ENABLED = ["REMNIC_CODING_GRAPH_SEMANTIC_ENABLED", "ENGRAM_CODING_GRAPH_SEMANTIC_ENABLED"];
+var ENV_THRESHOLD = ["REMNIC_CODING_GRAPH_SEMANTIC_SIMILAR_TO_THRESHOLD", "ENGRAM_CODING_GRAPH_SEMANTIC_SIMILAR_TO_THRESHOLD"];
+var ENV_MAX_SYMBOLS = ["REMNIC_CODING_GRAPH_SEMANTIC_MAX_SYMBOLS_PER_RUN", "ENGRAM_CODING_GRAPH_SEMANTIC_MAX_SYMBOLS_PER_RUN"];
+function coerceHostBool(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const v = value.trim().toLowerCase();
+    if (v === "true" || v === "1" || v === "yes" || v === "on") return true;
+    return false;
+  }
+  if (typeof value === "number") return value !== 0;
+  return Boolean(value);
+}
+function coerceHostNumber(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "string") {
+    const n = Number(value.trim());
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function resolveBoolEnv(names, fallback, env) {
+  for (const name of names) {
+    const raw = env[name];
+    if (raw === void 0) continue;
+    const v = raw.trim().toLowerCase();
+    if (v === "true" || v === "1") return true;
+    if (v === "false" || v === "0") return false;
+  }
+  return fallback;
+}
+function resolveNumberEnv(names, fallback, env) {
+  for (const name of names) {
+    const raw = env[name];
+    if (raw === void 0) continue;
+    const n = Number(raw);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return fallback;
+}
+function resolveSemanticConfig(host, env = process.env) {
+  const enabled = coerceHostBool(host?.enabled) ?? resolveBoolEnv(ENV_ENABLED, false, env);
+  const similarToThreshold = coerceHostNumber(host?.similarToThreshold) ?? resolveNumberEnv(ENV_THRESHOLD, DEFAULT_SIMILAR_TO_THRESHOLD, env);
+  const maxSymbolsPerRun = coerceHostNumber(host?.maxSymbolsPerRun) ?? resolveNumberEnv(ENV_MAX_SYMBOLS, DEFAULT_MAX_SYMBOLS_PER_RUN, env);
+  const canonicalBodyLines = coerceHostNumber(host?.canonicalBodyLines) ?? DEFAULT_CANONICAL_BODY_LINES;
+  return {
+    enabled,
+    // Clamp threshold into [0,1] — a malformed env must not produce an
+    // out-of-range confidence gate.
+    similarToThreshold: Math.min(1, Math.max(0, similarToThreshold)),
+    maxSymbolsPerRun: Math.max(0, Math.floor(maxSymbolsPerRun)),
+    // canonicalBodyLines: a negative/zero value must NOT clamp to 0 because
+    // extractBodyText treats <= 0 as unlimited — sending full symbol bodies to
+    // the embedding provider instead of the bounded excerpt (defeats the
+    // privacy/cost cap). Fall back to the default instead (#1680).
+    canonicalBodyLines: canonicalBodyLines >= 1 ? Math.floor(canonicalBodyLines) : DEFAULT_CANONICAL_BODY_LINES
+  };
+}
+
+// src/semantic/canonical-text.ts
+import { createHash as createHash2 } from "crypto";
+function collapseWhitespace(text) {
+  return text.replace(/([{}()<>\[\],;:?!=+\-*/%&|^~])/g, " $1 ").replace(/\s+/g, " ").trim();
+}
+function splitSignatureBody(normalized) {
+  const braceIdx = normalized.indexOf("{");
+  if (braceIdx >= 0) {
+    const signature = normalized.slice(0, braceIdx + 1).trim();
+    const body = normalized.slice(braceIdx + 1).trim();
+    return { signature, body };
+  }
+  const arrowIdx = normalized.indexOf("=>");
+  const arrowNormIdx = normalized.indexOf("= >");
+  if (arrowIdx >= 0) {
+    const signature = normalized.slice(0, arrowIdx + 2).trim();
+    const body = normalized.slice(arrowIdx + 2).trim();
+    return { signature, body };
+  }
+  if (arrowNormIdx >= 0) {
+    const bodyStart = arrowNormIdx + 3;
+    const signature = normalized.slice(0, bodyStart).trim();
+    const body = normalized.slice(bodyStart).trim();
+    return { signature, body };
+  }
+  return { signature: normalized, body: "" };
+}
+function extractSignatureLine(rawText, _kind) {
+  const normalized = collapseWhitespace(rawText);
+  return splitSignatureBody(normalized).signature;
+}
+function extractBodyText(rawText, maxBodyLines) {
+  const normalized = collapseWhitespace(rawText);
+  const body = splitSignatureBody(normalized).body;
+  if (maxBodyLines <= 0 || body.length === 0) return body;
+  const tokens = body.split(/\s+/);
+  return tokens.slice(0, maxBodyLines).join(" ");
+}
+function buildCanonicalText(input) {
+  const { symbol, rawText, docComment, maxBodyLines } = input;
+  const budget = maxBodyLines ?? DEFAULT_CANONICAL_BODY_LINES;
+  const signature = extractSignatureLine(rawText, symbol.kind);
+  const body = extractBodyText(rawText, budget);
+  const doc = docComment ? collapseWhitespace(docComment) : "";
+  const parts = [
+    `KIND:${symbol.kind}`,
+    `QNAME:${symbol.qualifiedName}`,
+    `SIG:${signature}`
+  ];
+  if (doc.length > 0) parts.push(`DOC:${doc}`);
+  parts.push(`BODY:${body}`);
+  return parts.join("\n");
+}
+function canonicalTextHash(canonicalText) {
+  return createHash2("sha256").update(canonicalText, "utf8").digest("hex");
+}
+function buildCanonicalTextAndHash(input) {
+  const text = buildCanonicalText(input);
+  return { text, hash: canonicalTextHash(text) };
+}
+
+// src/semantic/minhash.ts
+import { createHash as createHash3 } from "crypto";
+function seedFor(index) {
+  const hex = createHash3("sha256").update(`remnic:minhash:seed:${index}`, "utf8").digest("hex").slice(0, 16);
+  return BigInt(`0x${hex}`);
+}
+var MINHASH_SEEDS = Object.freeze(
+  Array.from({ length: MINHASH_NUM_PERMUTATIONS }, (_, i) => seedFor(i))
+);
+function hash64(data) {
+  const buf = createHash3("sha256").update(data, "utf8").digest();
+  let h = 0n;
+  for (let i = 0; i < 8; i++) {
+    h = h << 8n | BigInt(buf[i]);
+  }
+  return h;
+}
+var MINHASH_MODULUS = (1n << 61n) - 1n;
+function tokenizeForShingling(body) {
+  return body.toLowerCase().split(/[^a-z0-9_]+/).filter((t) => t.length > 0);
+}
+function shingleSet(tokens) {
+  if (tokens.length < MINHASH_SHINGLE_WIDTH) {
+    return new Set(tokens.length > 0 ? [tokens.join(" ")] : []);
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (let i = 0; i <= tokens.length - MINHASH_SHINGLE_WIDTH; i++) {
+    out.add(tokens.slice(i, i + MINHASH_SHINGLE_WIDTH).join(" "));
+  }
+  return out;
+}
+function minHashSignature(shingles) {
+  const sig = [];
+  if (shingles.size === 0) {
+    for (let i = 0; i < MINHASH_NUM_PERMUTATIONS; i++) sig.push(MINHASH_MODULUS);
+    return sig;
+  }
+  const shingleArr = Array.from(shingles);
+  for (let p = 0; p < MINHASH_NUM_PERMUTATIONS; p++) {
+    const a = MINHASH_SEEDS[p];
+    const b = MINHASH_SEEDS[(p * 2 + 1) % MINHASH_SEEDS.length];
+    let min = MINHASH_MODULUS;
+    for (const s of shingleArr) {
+      const h = (a * hash64(s) + b) % MINHASH_MODULUS;
+      if (h < min) min = h;
+    }
+    sig.push(min);
+  }
+  return sig;
+}
+function lshBandKeys(signature) {
+  const keys = [];
+  for (let b = 0; b < LSH_NUM_BANDS; b++) {
+    const start = b * LSH_ROWS_PER_BAND;
+    const end = start + LSH_ROWS_PER_BAND;
+    keys.push(signature.slice(start, end).map((v) => v.toString(16)).join("|"));
+  }
+  return keys;
+}
+var MinHasher = class {
+  /** band key → set of node ids in that band. */
+  buckets = /* @__PURE__ */ new Map();
+  /** node id → signature (for Jaccard estimation on candidate pairs). */
+  signatures = /* @__PURE__ */ new Map();
+  /** node id → qualified name (for readable candidate output). */
+  qnames = /* @__PURE__ */ new Map();
+  /**
+   * Add a symbol body to the LSH index. Idempotent — re-adding the same
+   * (nodeId, body) is a no-op.
+   */
+  add(entry) {
+    if (this.signatures.has(entry.nodeId)) return;
+    const tokens = tokenizeForShingling(entry.body);
+    const shingles = shingleSet(tokens);
+    if (shingles.size === 0) return;
+    const sig = minHashSignature(shingles);
+    this.signatures.set(entry.nodeId, sig);
+    this.qnames.set(entry.nodeId, entry.qualifiedName);
+    for (const key of lshBandKeys(sig)) {
+      let bucket = this.buckets.get(key);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Set();
+        this.buckets.set(key, bucket);
+      }
+      bucket.add(entry.nodeId);
+    }
+  }
+  /**
+   * Find all candidate pairs (pairs sharing at least one LSH band) with
+   * their estimated Jaccard similarity. Returns a stable-sorted array
+   * (by aNodeId then bNodeId) so the determinism test can compare runs
+   * byte-for-byte.
+   */
+  findCandidates() {
+    const pairSet = /* @__PURE__ */ new Set();
+    const pairs = [];
+    for (const bucket of this.buckets.values()) {
+      if (bucket.size < 2) continue;
+      const ids = Array.from(bucket).sort();
+      for (let i = 0; i < ids.length; i++) {
+        for (let j = i + 1; j < ids.length; j++) {
+          const a = ids[i];
+          const b = ids[j];
+          const key = `${a}\0${b}`;
+          if (pairSet.has(key)) continue;
+          pairSet.add(key);
+          const sigA = this.signatures.get(a);
+          const sigB = this.signatures.get(b);
+          let matches = 0;
+          for (let k = 0; k < sigA.length; k++) {
+            if (sigA[k] === sigB[k]) matches++;
+          }
+          pairs.push({
+            aNodeId: a,
+            bNodeId: b,
+            aQualifiedName: this.qnames.get(a) ?? a,
+            bQualifiedName: this.qnames.get(b) ?? b,
+            jaccard: matches / sigA.length
+          });
+        }
+      }
+    }
+    pairs.sort((x, y) => {
+      if (x.aNodeId !== y.aNodeId) return x.aNodeId < y.aNodeId ? -1 : 1;
+      return x.bNodeId < y.bNodeId ? -1 : x.bNodeId > y.bNodeId ? 1 : 0;
+    });
+    return pairs;
+  }
+};
+function createMinHasher() {
+  return new MinHasher();
+}
+function cosineSimilarity(a, b) {
+  const len = Math.min(a.length, b.length);
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < len; i++) {
+    const av = a[i];
+    const bv = b[i];
+    dot += av * bv;
+    normA += av * av;
+    normB += bv * bv;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+// src/semantic/vectors.ts
+import { readFile } from "fs/promises";
+import path5 from "path";
+import { normalizeHostEmbeddingVector } from "@remnic/core/host-embedding-provider";
+function modelIdFor(provider) {
+  return provider.model ?? provider.id;
+}
+async function indexSymbolVectors(input) {
+  const { store, provider, repoRoot, config, signal } = input;
+  if (store.isClosed) {
+    return { ok: false, code: "store_closed" };
+  }
+  if (!config.enabled) {
+    return { ok: false, code: "semantic_disabled" };
+  }
+  if (!provider) {
+    return { ok: false, code: "provider_unavailable" };
+  }
+  const modelId = modelIdFor(provider);
+  let nodes;
+  try {
+    nodes = store.readNodesForSemantic();
+  } catch {
+    return { ok: false, code: "db_error" };
+  }
+  const limit = config.maxSymbolsPerRun;
+  let embedded = 0;
+  let cached = 0;
+  let skipped = 0;
+  let embedAttempts = 0;
+  for (const node of nodes) {
+    if (signal?.aborted) break;
+    if (limit > 0 && embedAttempts >= limit) break;
+    const absolutePath = path5.resolve(repoRoot, node.filePath);
+    let bytes;
+    try {
+      bytes = await readFile(absolutePath);
+    } catch {
+      skipped += 1;
+      continue;
+    }
+    const start = Math.max(0, node.startByte);
+    const end = Math.min(bytes.length, node.endByte);
+    if (start > end) {
+      skipped += 1;
+      continue;
+    }
+    const rawText = bytes.subarray(start, end).toString("utf8");
+    const { text: canonicalText, hash } = buildCanonicalTextAndHash({
+      symbol: {
+        kind: node.kind,
+        name: node.qualifiedName.split(/[.#:]/).pop() ?? node.qualifiedName,
+        qualifiedName: node.qualifiedName,
+        span: { startByte: node.startByte, endByte: node.endByte }
+      },
+      rawText,
+      maxBodyLines: config.canonicalBodyLines
+    });
+    const cachedRow = store.readSymbolVector(node.nodeId, modelId);
+    if (cachedRow && cachedRow.contentHash === hash && (provider.dimensions === void 0 || cachedRow.dims === provider.dimensions)) {
+      cached += 1;
+      continue;
+    }
+    embedAttempts += 1;
+    let raw;
+    try {
+      raw = await provider.embed(canonicalText, {
+        signal,
+        inputType: "document"
+      });
+    } catch {
+      if (cachedRow && cachedRow.contentHash !== hash) {
+        await store.deleteSymbolVectors([node.nodeId]);
+      }
+      skipped += 1;
+      continue;
+    }
+    const vec = normalizeHostEmbeddingVector(raw);
+    if (!vec || vec.length === 0) {
+      if (cachedRow && cachedRow.contentHash !== hash) {
+        await store.deleteSymbolVectors([node.nodeId]);
+      }
+      skipped += 1;
+      continue;
+    }
+    const float32 = new Float32Array(vec);
+    const persisted = await store.writeSymbolVector({
+      nodeId: node.nodeId,
+      modelId,
+      contentHash: hash,
+      dims: float32.length,
+      vector: float32
+    });
+    if (persisted) {
+      embedded += 1;
+    } else {
+      skipped += 1;
+    }
+  }
+  return { ok: true, embedded, cached, skipped };
+}
+
+// src/semantic/similarity.ts
+import { readFileSync as fsReadFileSync } from "fs";
+import path6 from "path";
+var fs = { readFileSync: fsReadFileSync };
+var CONFIRM_OPERATOR = ">=";
+var MINHASH_JACCARD_GATE = 0.5;
+function computeSimilarTo(input) {
+  const { store, provider, config } = input;
+  if (!config.enabled) {
+    return { ok: false, code: "semantic_disabled" };
+  }
+  if (!input.bodies && !input.repoRoot) {
+    return {
+      ok: false,
+      code: "repo_root_unset",
+      message: "computeSimilarTo needs either 'bodies' or 'repoRoot' to read source text"
+    };
+  }
+  if (store.isClosed) {
+    return { ok: false, code: "store_closed" };
+  }
+  const bodies = input.bodies ?? readBodiesFromStore(store, input.repoRoot);
+  const modelId = provider ? modelIdFor(provider) : void 0;
+  const vectors = input.vectors ?? (modelId ? readVectorsMap(store, modelId) : /* @__PURE__ */ new Map());
+  const hasher = createMinHasher();
+  for (const [nodeId, entry] of bodies) {
+    hasher.add({ nodeId, qualifiedName: entry.qualifiedName, body: entry.body });
+  }
+  const candidates = hasher.findCandidates();
+  const edges = [];
+  let confirmed = 0;
+  let minhashOnly = 0;
+  for (const c of candidates) {
+    const va = vectors.get(c.aNodeId);
+    const vb = vectors.get(c.bNodeId);
+    if (va && vb && va.length === vb.length) {
+      const cos = cosineSimilarity(va, vb);
+      if (cos >= config.similarToThreshold) {
+        edges.push({
+          srcNodeId: c.aNodeId,
+          dstNodeId: c.bNodeId,
+          srcQualifiedName: c.aQualifiedName,
+          dstQualifiedName: c.bQualifiedName,
+          confidence: cos,
+          confirmed: true
+        });
+        confirmed += 1;
+      }
+    } else if (!provider) {
+      if (c.jaccard >= MINHASH_JACCARD_GATE) {
+        edges.push({
+          srcNodeId: c.aNodeId,
+          dstNodeId: c.bNodeId,
+          srcQualifiedName: c.aQualifiedName,
+          dstQualifiedName: c.bQualifiedName,
+          confidence: MINHASH_ONLY_CONFIDENCE,
+          confirmed: false
+        });
+        minhashOnly += 1;
+      }
+    }
+  }
+  edges.sort((a, b) => {
+    if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+    if (a.srcQualifiedName !== b.srcQualifiedName) return a.srcQualifiedName < b.srcQualifiedName ? -1 : 1;
+    return a.dstQualifiedName < b.dstQualifiedName ? -1 : a.dstQualifiedName > b.dstQualifiedName ? 1 : 0;
+  });
+  return { ok: true, edges, candidates: candidates.length, confirmed, minhashOnly };
+}
+function similarEdgesToEdgeIR(edges) {
+  return edges.map((e) => ({
+    srcQualifiedName: e.srcQualifiedName,
+    dstQualifiedName: e.dstQualifiedName,
+    type: SIMILAR_TO_EDGE_TYPE,
+    confidence: e.confidence,
+    provenance: SEMANTIC_PROVENANCE,
+    srcNodeId: e.srcNodeId,
+    dstNodeId: e.dstNodeId
+  }));
+}
+function readBodiesFromStore(store, repoRoot) {
+  const out = /* @__PURE__ */ new Map();
+  for (const node of store.readNodesForSemantic()) {
+    let rawText = "";
+    if (repoRoot) {
+      try {
+        const abs = path6.resolve(repoRoot, node.filePath);
+        const bytes = fs.readFileSync(abs);
+        const start = Math.max(0, node.startByte);
+        const end = Math.min(bytes.length, node.endByte);
+        if (start <= end) rawText = bytes.subarray(start, end).toString("utf8");
+      } catch {
+      }
+    }
+    const body = extractBodyText(rawText, 0);
+    out.set(node.nodeId, { qualifiedName: node.qualifiedName, body });
+  }
+  return out;
+}
+function readVectorsMap(store, modelId) {
+  const out = /* @__PURE__ */ new Map();
+  for (const row of store.readAllSymbolVectors(modelId)) {
+    out.set(row.nodeId, row.vector);
+  }
+  return out;
+}
+function estimateJaccard(bodyA, bodyB) {
+  const sa = shingleSet(tokenizeForShingling(bodyA));
+  const sb = shingleSet(tokenizeForShingling(bodyB));
+  if (sa.size === 0 && sb.size === 0) return 1;
+  let inter = 0;
+  for (const s of sa) if (sb.has(s)) inter += 1;
+  const union = sa.size + sb.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+
+// src/semantic/semantic-query.ts
+import {
+  EmbeddingProviderUnavailableError,
+  EmbeddingTimeoutError
+} from "@remnic/core/embedding-fallback";
+import { normalizeHostEmbeddingVector as normalizeHostEmbeddingVector2 } from "@remnic/core/host-embedding-provider";
+var DEFAULT_SEMANTIC_QUERY_LIMIT = 10;
+async function semanticQuery(input) {
+  const { store, provider, repoRoot, config, query, signal } = input;
+  if (store.isClosed) {
+    return { ok: false, code: "store_closed" };
+  }
+  if (!config.enabled) {
+    return { ok: false, code: "semantic_disabled" };
+  }
+  if (query.length === 0) {
+    return { ok: false, code: "invalid_query", message: "query must be non-empty" };
+  }
+  if (!provider) {
+    return { ok: false, code: "provider_unavailable" };
+  }
+  let raw;
+  try {
+    raw = await provider.embed(query, { signal, inputType: "query" });
+  } catch (error) {
+    if (error instanceof EmbeddingTimeoutError) {
+      return { ok: false, code: "provider_timeout" };
+    }
+    if (error instanceof EmbeddingProviderUnavailableError) {
+      return { ok: false, code: "provider_unavailable" };
+    }
+    return { ok: false, code: "provider_unavailable" };
+  }
+  const queryVec = normalizeHostEmbeddingVector2(raw);
+  if (!queryVec || queryVec.length === 0) {
+    return { ok: false, code: "malformed_vector" };
+  }
+  const queryF32 = new Float32Array(queryVec);
+  const modelId = modelIdFor(provider);
+  let rows;
+  try {
+    rows = store.readAllSymbolVectors(modelId);
+  } catch {
+    return { ok: false, code: "db_error" };
+  }
+  if (rows.length === 0) {
+    return { ok: false, code: "no_vectors" };
+  }
+  const rawLimit = input.limit;
+  const limit = typeof rawLimit === "number" && Number.isFinite(rawLimit) && rawLimit > 0 ? Math.max(1, Math.floor(rawLimit)) : DEFAULT_SEMANTIC_QUERY_LIMIT;
+  const queryDims = queryF32.length;
+  const scored = rows.filter((r) => r.dims === queryDims).map((r) => ({
+    nodeId: r.nodeId,
+    qualifiedName: r.qualifiedName,
+    filePath: r.filePath,
+    kind: r.kind,
+    dims: r.dims,
+    score: cosineSimilarity(queryF32, r.vector)
+  })).filter((r) => Number.isFinite(r.score)).sort((a, b) => b.score - a.score).slice(0, limit);
+  const hits = [];
+  for (const h of scored) {
+    const neighbors = store.readNeighborsByNodeId(h.nodeId);
+    let snippet = "";
+    try {
+      const snippetResult = await store.snippetFor({ nodeId: h.nodeId, repoRoot });
+      if (snippetResult.ok) snippet = snippetResult.text;
+    } catch {
+    }
+    hits.push({
+      qualifiedName: h.qualifiedName,
+      filePath: h.filePath,
+      kind: h.kind,
+      score: h.score,
+      snippet,
+      callers: neighbors.callers,
+      callees: neighbors.callees
+    });
+  }
+  return { ok: true, hits };
+}
+
+// src/index.ts
+var ENGINE_VERSION = CODING_GRAPH_ENGINE_VERSION2;
+var CodingGraphError = class extends Error {
+  code;
+  engineVersion;
+  constructor(code, message, engineVersion = ENGINE_VERSION) {
+    super(message);
+    this.name = "CodingGraphError";
+    this.code = code;
+    this.engineVersion = engineVersion;
+  }
+};
+export {
+  BLAST_RADIUS_EDGE_TYPES,
+  CODING_GRAPH_ENGINE_VERSION2 as CODING_GRAPH_ENGINE_VERSION,
+  CODING_GRAPH_SCHEMA_VERSION,
+  CONFIRM_OPERATOR,
+  CodingGraphError,
+  DEAD_CODE_EXCLUSION,
+  DEFAULT_BLAST_RADIUS_DEPTH,
+  DEFAULT_CANONICAL_BODY_LINES,
+  DEFAULT_CO_CHANGE_CONFIG,
+  DEFAULT_LSP_CONFIG,
+  DEFAULT_LSP_MAX_REQUESTS_PER_RUN,
+  DEFAULT_LSP_TIMEOUT_MS,
+  DEFAULT_MAX_SYMBOLS_PER_RUN,
+  DEFAULT_SEMANTIC_QUERY_LIMIT,
+  DEFAULT_SIMILAR_TO_THRESHOLD,
+  DEFAULT_TRAVERSE_PATHS_MAX,
+  EDGE_PROVENANCE_VALUES,
+  ENGINE_VERSION,
+  FAN_IN_ESCALATION_THRESHOLD,
+  GraphStore,
+  LspClient,
+  LspFrameDecoder,
+  MAX_TRAVERSE_PATHS_HOPS,
+  META_KEY_LAST_HEAD,
+  META_KEY_PENDING_PARSE_FAILURES,
+  MINHASH_ONLY_CONFIDENCE,
+  MINHASH_SEEDS,
+  MinHasher,
+  SEMANTIC_PROVENANCE,
+  SIMILAR_TO_EDGE_TYPE,
+  TIER_1_LANGUAGES3 as TIER_1_LANGUAGES,
+  VALID_CYPHER_LABELS,
+  WasmTreeSitterBackend,
+  applyCodingGraphSchema,
+  buildCanonicalText,
+  buildCanonicalTextAndHash,
+  buildLineOffsetMap,
+  byteOffsetToPosition,
+  byteSpanToLines,
+  canonicalTextHash,
+  classifyRisk,
+  collapseWhitespace,
+  computeBlastRadius,
+  computeSimilarTo,
+  cosineSimilarity,
+  createCodingGraphEngine,
+  createMinHasher,
+  defaultCodingGitInvoker,
+  encodeLspFrame,
+  estimateJaccard,
+  executeAst,
+  executeCypher,
+  executeLspResolution,
+  executeReindex,
+  extractBodyText,
+  extractSignatureLine,
+  findDirectlyAffectedSymbols,
+  formatLspStatusLine,
+  getIndexStatus,
+  getLspStatus,
+  hashContent,
+  indexSymbolVectors,
+  isEdgeProvenance,
+  lshBandKeys,
+  lspDegradation,
+  mapLocationToNode,
+  minHashSignature,
+  mineAndStoreCoChanges,
+  mineCoChangeEdges,
+  modelIdFor,
+  nodeIdFor,
+  parseCypher,
+  parseHunks,
+  parseLogFiles,
+  parseLspConfig,
+  parseNameStatus,
+  pathToUri,
+  planLspUpgrades,
+  planReindex,
+  positionToByteOffset,
+  rangesOverlap,
+  readFileHashes,
+  readLastIndexedHead,
+  readLspEnabledEnv,
+  readSchemaVersion,
+  resolutionResultToStatusMaps,
+  resolveSemanticConfig,
+  semanticQuery,
+  shingleSet,
+  similarEdgesToEdgeIR,
+  tokenizeForShingling,
+  uriToPath
+};
+//# sourceMappingURL=index.js.map