@maxgfr/codeindex 2.11.0 → 2.12.0

package/src/extract/code.ts

@@ -1,6 +1,7 @@
 import type { CodeSymbol, RawRef } from "../types.js";
 import { extractSymbols } from "../lang/registry.js";
 import { extractAst } from "../ast/extract.js";
+import { extractReexports } from "../lang/common.js";
 
 export interface CodeInfo {
   symbols: CodeSymbol[];
@@ -253,62 +254,6 @@ function extractImports(ext: string, content: string): RawRef[] {
   return [...specs].map((spec) => ({ kind: "import" as const, spec }));
 }
 
-// Barrel re-exports (`export { A, B as C } from './x'`, `export * from './y'`).
-// The line-based lang extractor can't capture multi-name lists, but these ARE
-// the public facade of a module — so list them as exported symbols here.
-//
-// An ALIAS with no `from` clause (`export { b as c }`) renames an in-file
-// declaration — `localSymbols` (already extracted by the AST or regex tier)
-// lets us resolve `b` and mirror ITS kind onto `c` (e.g. "function"), so the
-// alias reads as the real symbol it is rather than the generic "reexport".
-// A true cross-module re-export (`export { b as c } from "./mod"`) has no
-// local `b` to resolve — and an alias the local pass genuinely can't see
-// (destructured/ambient/etc.) falls back the same way — both keep "reexport".
-function extractReexports(rel: string, content: string, localSymbols: CodeSymbol[]): CodeSymbol[] {
-  if (!JS_TS.has(rel.slice(rel.lastIndexOf(".")))) return [];
-  const lang = /\.(ts|tsx|mts|cts)$/.test(rel) ? "typescript" : "javascript";
-  const out: CodeSymbol[] = [];
-  const seen = new Set<string>();
-  const lineAt = (idx: number): number => content.slice(0, idx).split(/\r?\n/).length;
-  const localKindOf = new Map<string, string>();
-  for (const s of localSymbols) if (!localKindOf.has(s.name)) localKindOf.set(s.name, s.kind);
-
-  const named = /export\s*\{([\s\S]*?)\}\s*(?:from\s*['"]([^'"]+)['"])?\s*;?/g;
-  let m: RegExpExecArray | null;
-  while ((m = named.exec(content)) && out.length < 60) {
-    const from = m[2];
-    for (const part of m[1]!.split(",")) {
-      const p = part.trim().replace(/^type\s+/, "");
-      const as = /^(\S+)\s+as\s+([A-Za-z_$][\w$]*)$/.exec(p);
-      const orig = as ? as[1]! : p;
-      const name = as ? as[2]! : p;
-      if (!/^[A-Za-z_$][\w$]*$/.test(name) || name === "default" || seen.has(name)) continue;
-      seen.add(name);
-      const mirroredKind = !from ? localKindOf.get(orig) : undefined;
-      out.push({
-        name, kind: mirroredKind ?? "reexport", file: rel, line: lineAt(m.index),
-        signature: from ? `export { ${name} } from "${from}"` : `export { ${name} }`,
-        exported: true, lang,
-      });
-    }
-  }
-
-  const star = /export\s*\*\s*(?:as\s+([A-Za-z_$][\w$]*)\s+)?from\s*['"]([^'"]+)['"]/g;
-  while ((m = star.exec(content)) && out.length < 60) {
-    const ns = m[1];
-    const from = m[2]!;
-    const key = "*" + (ns ?? from);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push({
-      name: ns ?? `* (${from})`, kind: ns ? "reexport" : "reexport-all", file: rel,
-      line: lineAt(m.index), signature: `export * ${ns ? `as ${ns} ` : ""}from "${from}"`,
-      exported: true, lang,
-    });
-  }
-  return out;
-}
-
 // Control-flow and declaration keywords that syntactically precede `(` but are
 // never call targets — the union across supported languages. Deliberately does
 // NOT list real builtins (python's `print`, go's `make`…): a false call to a
@@ -331,8 +276,35 @@ const DEF_INTRODUCERS = /(?:\bfunction|\bdef|\bfunc|\bfun|\bfn|\bclass|\bsub|\bm
 // immediate `receiver.` prefix is captured too (`axios.get(` → receiver
 // "axios"; `a.b.c(` → receiver "b" — the group anchors to the segment right
 // before the called name); bare calls carry no receiver.
-function collectCallsRegex(content: string): { name: string; line: number; receiver?: string }[] {
+//
+// `symbols` is the file's OWN regex-extracted symbols (name + definition
+// line). DEF_INTRODUCERS already excludes definitions that read `function
+// foo(`/`def foo(`/etc. (per OCCURRENCE, wherever on the line it sits), but
+// C/C++ function definitions have no such introducer (`void load(void) {`) —
+// the bare name reads exactly like a call to itself on its own definition
+// line. For those, a call candidate whose (name, line) exactly matches one of
+// `symbols` is excluded too — but ONLY its first (leftmost) occurrence on that
+// line, never every same-named occurrence: dense/minified one-liners can pack
+// a genuine call to the same name on the same physical line as its own
+// definition (`function aa(){}function bb(){return aa()+cc()}function cc(){}`
+// — bb's calls to aa() and cc() must survive), and even a bodyless
+// single-line recursive definition (`function foo(){foo();}`) has a real self
+// -call to keep. Two-tier: if ANY occurrence of a def'd name on this line is
+// already caught by DEF_INTRODUCERS (JS/Python/…), that occurrence alone is
+// excluded (existing per-occurrence check below) and no further exclusion is
+// applied — every OTHER occurrence is a genuine call. Only when NO occurrence
+// carries an introducer (C/C++) does this fall back to excluding just the
+// first occurrence: C/C++'s own definition regex requires column 0, so on a
+// line where it matches at all, the first occurrence IS that definition.
+// Exported for direct testing (extraction-v8.test.ts): once a wasm sidecar/
+// grammar is loaded, extractCode never reaches this path for C/C++, so tests
+// exercise it directly rather than through extractCode.
+export function collectCallsRegex(
+  content: string,
+  symbols: Pick<CodeSymbol, "name" | "line">[] = [],
+): { name: string; line: number; receiver?: string }[] {
   const out = new Map<string, { name: string; line: number; receiver?: string }>();
+  const ownDefLines = new Set(symbols.map((s) => `${s.name} ${s.line}`));
   const lines = content.split("\n");
   const CALL_RE = /(?:\bnew\s+)?(?:([A-Za-z_$][\w$]*)\s*\.\s*)?([A-Za-z_$][\w$]*)\s*\(/g;
   for (let i = 0; i < lines.length && out.size < 512; i++) {
@@ -342,14 +314,36 @@ function collectCallsRegex(content: string): { name: string; line: number; recei
     // regexes — noise resolves to nothing in the global call pass).
     const trimmed = line.trimStart();
     if (trimmed.startsWith("//") || trimmed.startsWith("#") || trimmed.startsWith("*")) continue;
+
+    // Pass 1: which own-def keys on this line have at least one occurrence
+    // DEF_INTRODUCERS already catches? Those are fully handled per-occurrence
+    // below — no fallback exclusion needed (or wanted) for them.
+    CALL_RE.lastIndex = 0;
+    let probe: RegExpExecArray | null;
+    const introducerCaught = new Set<string>();
+    while ((probe = CALL_RE.exec(line)) !== null) {
+      const name = probe[2]!;
+      const key = `${name} ${i + 1}`;
+      if (ownDefLines.has(key) && DEF_INTRODUCERS.test(line.slice(0, probe.index))) introducerCaught.add(key);
+    }
+
+    // Pass 2: the real collection. Own-def keys with no introducer occurrence
+    // fall back to excluding just their first occurrence on the line.
     CALL_RE.lastIndex = 0;
     let m: RegExpExecArray | null;
+    const fallbackExcluded = new Set<string>();
     while ((m = CALL_RE.exec(line)) !== null && out.size < 512) {
       const receiver = m[1];
       const name = m[2]!;
       if (name.length < 2 || CALL_KEYWORDS.has(name)) continue;
       if (DEF_INTRODUCERS.test(line.slice(0, m.index))) continue;
       const key = `${name} ${i + 1}`;
+      if (ownDefLines.has(key) && !introducerCaught.has(key)) {
+        if (!fallbackExcluded.has(key)) {
+          fallbackExcluded.add(key);
+          continue;
+        }
+      }
       if (!out.has(key)) out.set(key, receiver ? { name, line: i + 1, receiver } : { name, line: i + 1 });
     }
   }
@@ -382,7 +376,9 @@ export function extractCode(rel: string, ext: string, content: string): CodeInfo
     idents: ast?.idents,
     // AST call sites when a grammar parsed the file; the conservative regex
     // collector otherwise, so caller indexes exist without the wasm sidecar.
-    calls: ast ? ast.calls : collectCallsRegex(content),
+    // `symbols` (this file's own regex-extracted defs) lets the collector
+    // exclude a definition's own name+line from its call candidates.
+    calls: ast ? ast.calls : collectCallsRegex(content, symbols),
     importedNames: ast?.importedNames,
   };
 }

package/src/lang/common.ts

@@ -66,3 +66,78 @@ const EXT_LANG: Record<string, string> = {
 export function extToLang(ext: string): string {
   return EXT_LANG[ext] ?? "other";
 }
+
+const REEXPORT_EXTS = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+
+// Barrel re-exports (`export { A, B as C } from './x'`, `export * from './y'`).
+// The line-based lang extractor can't capture multi-name lists, but these ARE
+// the public facade of a module — so list them as exported symbols here.
+//
+// An ALIAS with no `from` clause (`export { b as c }`) renames an in-file
+// declaration — `localSymbols` (already extracted by the AST or regex tier)
+// lets us resolve `b` and mirror ITS kind, declaration line, and endLine (AST
+// tier only) onto `c` (e.g. "function" at b's own line), so the alias reads
+// as the real symbol it is — citeable at its actual declaration — rather than
+// the generic "reexport" pinned to the export statement's line.
+// A true cross-module re-export (`export { b as c } from "./mod"`) has no
+// local `b` to resolve — and an alias the local pass genuinely can't see
+// (destructured/ambient/etc.) falls back the same way — both keep "reexport"
+// and cite the export statement's own line, the only line they have.
+//
+// Shared by extractCode (extract/code.ts) AND the standalone extractSymbols
+// (lang/registry.ts) — ultradoc and other direct extractSymbols consumers hit
+// the same barrels a repo scan does, so both entry points must agree; this is
+// the one place the alias-mirroring logic lives, reused rather than
+// reimplemented on either side.
+export function extractReexports(rel: string, content: string, localSymbols: CodeSymbol[]): CodeSymbol[] {
+  if (!REEXPORT_EXTS.has(rel.slice(rel.lastIndexOf(".")))) return [];
+  const lang = /\.(ts|tsx|mts|cts)$/.test(rel) ? "typescript" : "javascript";
+  const out: CodeSymbol[] = [];
+  const seen = new Set<string>();
+  const lineAt = (idx: number): number => content.slice(0, idx).split(/\r?\n/).length;
+  // Keyed on the whole CodeSymbol (not just kind) so the alias branch below
+  // can also cite the resolved declaration's own line/endLine, not just mirror
+  // its kind.
+  const localDeclOf = new Map<string, CodeSymbol>();
+  for (const s of localSymbols) if (!localDeclOf.has(s.name)) localDeclOf.set(s.name, s);
+
+  const named = /export\s*\{([\s\S]*?)\}\s*(?:from\s*['"]([^'"]+)['"])?\s*;?/g;
+  let m: RegExpExecArray | null;
+  while ((m = named.exec(content)) && out.length < 60) {
+    const from = m[2];
+    for (const part of m[1]!.split(",")) {
+      const p = part.trim().replace(/^type\s+/, "");
+      const as = /^(\S+)\s+as\s+([A-Za-z_$][\w$]*)$/.exec(p);
+      const orig = as ? as[1]! : p;
+      const name = as ? as[2]! : p;
+      if (!/^[A-Za-z_$][\w$]*$/.test(name) || name === "default" || seen.has(name)) continue;
+      seen.add(name);
+      // A resolved decl means this is a same-file alias: cite ITS line (and
+      // endLine, when the AST tier populated one) rather than the export
+      // statement's — an unresolved alias or a `from`-clause re-export has no
+      // local declaration to point at, so it keeps lineAt(m.index) below.
+      const decl = !from ? localDeclOf.get(orig) : undefined;
+      out.push({
+        name, kind: decl?.kind ?? "reexport", file: rel, line: decl ? decl.line : lineAt(m.index),
+        ...(decl?.endLine !== undefined ? { endLine: decl.endLine } : {}),
+        signature: from ? `export { ${name} } from "${from}"` : `export { ${name} }`,
+        exported: true, lang,
+      });
+    }
+  }
+
+  const star = /export\s*\*\s*(?:as\s+([A-Za-z_$][\w$]*)\s+)?from\s*['"]([^'"]+)['"]/g;
+  while ((m = star.exec(content)) && out.length < 60) {
+    const ns = m[1];
+    const from = m[2]!;
+    const key = "*" + (ns ?? from);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({
+      name: ns ?? `* (${from})`, kind: ns ? "reexport" : "reexport-all", file: rel,
+      line: lineAt(m.index), signature: `export * ${ns ? `as ${ns} ` : ""}from "${from}"`,
+      exported: true, lang,
+    });
+  }
+  return out;
+}

package/src/lang/registry.ts

@@ -1,5 +1,5 @@
 import type { CodeSymbol } from "../types.js";
-import { extToLang } from "./common.js";
+import { extToLang, extractReexports } from "./common.js";
 import { jsTs } from "./js-ts.js";
 import { python } from "./python.js";
 import { go } from "./go.js";
@@ -35,14 +35,29 @@ for (const e of EXTRACTORS) for (const ext of e.exts) BY_EXT.set(ext, e);
 
 // Extract declared symbols from one file. Returns [] for languages without a
 // dedicated extractor (their content is still fully searchable via ripgrep).
+//
+// Also mirrors extractCode's barrel re-export/alias pass (extractReexports):
+// a direct extractSymbols consumer (ultradoc, or any tool that doesn't go
+// through extractCode) hits the same `export { a, b as c }` barrels a repo
+// scan does, and should see the same alias-mirrors-b's-own-kind symbols —
+// not the bare "reexport" kind extractReexports falls back to when there's
+// no local declaration to mirror. extractCode already runs extractReexports
+// itself and filters by name, so this can't double-add: whichever entry point
+// adds "c" first wins, the other's re-run is a no-op duplicate filtered out.
 export function extractSymbols(rel: string, ext: string, content: string): CodeSymbol[] {
   const extractor = BY_EXT.get(ext);
-  if (!extractor) return [];
-  try {
-    return extractor.extract(rel, content);
-  } catch {
-    return [];
+  let symbols: CodeSymbol[];
+  if (!extractor) symbols = [];
+  else {
+    try {
+      symbols = extractor.extract(rel, content);
+    } catch {
+      symbols = [];
+    }
   }
+  const known = new Set(symbols.map((s) => s.name));
+  const reexports = extractReexports(rel, content, symbols).filter((s) => !known.has(s.name));
+  return reexports.length ? [...symbols, ...reexports] : symbols;
 }
 
 // Human-readable language label for an extension (used for the language

package/src/mcp.ts

@@ -10,7 +10,7 @@ import { ENGINE_VERSION } from "./types.js";
 import { ensureGrammars, allGrammarKeys } from "./ast/loader.js";
 import { buildIndexArtifacts } from "./pipeline.js";
 import { renderGraphJson } from "./render/graph-json.js";
-import { scanRepo } from "./scan.js";
+import { scanRepo, type RepoScan } from "./scan.js";
 import { buildCallerIndex } from "./callers.js";
 import { detectWorkspaces } from "./workspaces.js";
 import { gitChurn } from "./git.js";
@@ -26,9 +26,10 @@ import { writeMemory, readMemory, deleteMemory, listMemories } from "./memory.js
 import { searchIndex } from "./bm25.js";
 import { checkRules, parseRules } from "./rules.js";
 import { EMBED_VERSION, resolveEmbedModelDir, loadEmbedModel } from "./embed/model.js";
-import { buildEmbeddingIndex } from "./embed/index.js";
+import { buildEmbeddingIndex, type EmbeddingIndex } from "./embed/index.js";
 import { searchSemantic } from "./embed/search.js";
 import { resolveEmbedEndpoint, buildEndpointIndex, encodeQueryViaEndpoint, probeEndpoint } from "./embed/endpoint.js";
+import { sha1 } from "./hash.js";
 
 interface RpcRequest {
   jsonrpc: "2.0";
@@ -270,7 +271,7 @@ const TOOLS = [
   {
     name: "search",
     description:
-      'Natural-language-ish lexical search: BM25 ranking (k1=1.2, b=0.75) over symbol names (camelCase/snake_case subtokens), file path segments, markdown headings and summary lines. NOT embeddings by default — deterministic, diacritic-folded, zero API keys. Answers "where is auth handled?"-style queries with ranked files, matched terms and top symbols. Query terms with zero document frequency get a deterministic trigram-fuzzy fallback (typo-tolerant) unless `fuzzy: false`. Set `semantic: true` to RRF-fuse the deterministic static-embedding tier when a model asset is present (degrades to lexical otherwise — see embed_status).',
+      'Natural-language-ish lexical search: BM25 ranking (k1=1.2, b=0.75) over symbol names (camelCase/snake_case subtokens), file path segments, markdown headings and summary lines. NOT embeddings by default — deterministic, diacritic-folded, zero API keys. Answers "where is auth handled?"-style queries with ranked files, matched terms and top symbols. Query terms with zero document frequency get a deterministic trigram-fuzzy fallback (typo-tolerant) unless `fuzzy: false`. Set `semantic: true` to RRF-fuse an embedding tier (HTTP endpoint, else a local static model) with lexical — the response then wraps the ranked list as `{ results, tier, degradedReason? }`, `tier` being "endpoint"/"static" when fusion happened or "lexical" (with `degradedReason`) when it did not (see embed_status). Without `semantic`, the response is the bare ranked array, unchanged.',
     inputSchema: {
       type: "object",
       properties: {
@@ -286,7 +287,7 @@ const TOOLS = [
         semantic: {
           type: "boolean",
           description:
-            "RRF-fuse an embedding tier with lexical (default false). Precedence: the HTTP endpoint (CODEINDEX_EMBED_ENDPOINT) if set, else a local static model. Degrades silently to lexical-only when neither is available/reachable — see embed_status.",
+            'RRF-fuse an embedding tier with lexical (default false). Precedence: the HTTP endpoint (CODEINDEX_EMBED_ENDPOINT) if set, else a local static model. The response reports the effective tier as a top-level `tier` field ("endpoint"/"static" on success, "lexical" plus `degradedReason` when neither is available/reachable) instead of degrading silently — see embed_status.',
         },
       },
       required: ["repo", "query"],
@@ -320,6 +321,50 @@ function str(v: unknown): string | undefined {
 function strArray(v: unknown): string[] | undefined {
   return Array.isArray(v) && v.every((x) => typeof x === "string") && v.length ? (v as string[]) : undefined;
 }
+function errMessage(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}
+
+// --- embedding index memoization --------------------------------------------
+// The MCP server process is long-lived, but every `search` call used to redo
+// the FULL corpus embedding build — N `buildEndpointIndex` HTTP round-trips,
+// or a full `buildEmbeddingIndex` re-encode pass — even when nothing in the
+// repo changed between requests. Memoize the last build behind a fingerprint
+// of the scan contents plus the tier's identity, so an unchanged repo reuses
+// the cached index and any file add/edit/remove (or a switch of endpoint/model)
+// still rebuilds. RepoScan carries no fingerprint of its own (checked
+// scan.ts/types.ts) — every FileRecord already carries a content hash, so
+// hashing the (rel, hash) pairs is the staleness oracle scan.ts itself uses.
+export function scanFingerprint(scan: RepoScan): string {
+  return sha1(scan.files.map((f) => `${f.rel}:${f.hash}`).join("\n"));
+}
+
+export interface EmbeddingIndexCacheKey {
+  mode: "endpoint" | "static";
+  // Distinguishes cache entries across configs sharing the same scan: the
+  // endpoint URL, or the model dir + modelId for the static tier.
+  identity: string;
+  scan: RepoScan;
+}
+
+// A SINGLE entry — never an unbounded map — holding the most recent build.
+let embeddingIndexCache: { key: string; index: EmbeddingIndex } | undefined;
+
+// Reuse the cached index when (mode, identity, scanFingerprint) matches the
+// last build; otherwise call `build` and cache its result. A failed build is
+// NEVER cached (matches today's per-call error behavior: the next request
+// retries from scratch, and a still-valid previous entry — under a different
+// key — is left untouched).
+export async function memoizedEmbeddingIndex(
+  key: EmbeddingIndexCacheKey,
+  build: () => Promise<EmbeddingIndex> | EmbeddingIndex,
+): Promise<EmbeddingIndex> {
+  const cacheKey = `${key.mode}:${key.identity}:${scanFingerprint(key.scan)}`;
+  if (embeddingIndexCache && embeddingIndexCache.key === cacheKey) return embeddingIndexCache.index;
+  const index = await build();
+  embeddingIndexCache = { key: cacheKey, index };
+  return index;
+}
 
 async function callTool(name: string, args: Record<string, unknown>): Promise<string> {
   const repo = str(args.repo);
@@ -459,25 +504,49 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<st
     const limit = typeof args.limit === "number" ? args.limit : undefined;
     const fuzzy = typeof args.fuzzy === "boolean" ? args.fuzzy : undefined;
     if (args.semantic === true) {
+      // semantic:true changes the response SHAPE (wraps the ranked list with a
+      // `tier`/`degradedReason?`) so a caller can tell "fusion happened" apart
+      // from "degraded to lexical" — see the `search` tool description. This
+      // branch is the ONLY place that shape appears; plain lexical search below
+      // stays the bare array, byte-compat for existing consumers.
       const endpoint = resolveEmbedEndpoint();
       if (endpoint) {
         // Rich tier — endpoint takes PRECEDENCE over a local static model. An
-        // unreachable/malformed endpoint degrades to lexical (no throw).
+        // unreachable/malformed endpoint degrades to lexical, now with a reason.
+        // The corpus index is memoized per (endpoint, scan state) — the query
+        // itself is always re-encoded fresh (it differs per call).
         try {
-          const index = await buildEndpointIndex(scan);
+          const index = await memoizedEmbeddingIndex({ mode: "endpoint", identity: endpoint, scan }, () => buildEndpointIndex(scan));
           const queryVec = await encodeQueryViaEndpoint(query);
-          return JSON.stringify(searchSemantic(scan, query, index, { queryVec, limit, fuzzy }), null, 2);
-        } catch {
-          return JSON.stringify(searchIndex(scan, query, { limit, fuzzy }), null, 2);
+          const results = searchSemantic(scan, query, index, { queryVec, limit, fuzzy });
+          return JSON.stringify({ results, tier: "endpoint" }, null, 2);
+        } catch (e) {
+          const results = searchIndex(scan, query, { limit, fuzzy });
+          return JSON.stringify(
+            { results, tier: "lexical", degradedReason: `embedding endpoint failed: ${errMessage(e)}` },
+            null,
+            2,
+          );
         }
       }
       const modelDir = resolveEmbedModelDir(repo);
       const model = modelDir ? loadEmbedModel(modelDir) : undefined;
       if (model) {
-        const index = buildEmbeddingIndex(scan, model);
-        return JSON.stringify(searchSemantic(scan, query, index, { model, limit, fuzzy }), null, 2);
+        const index = await memoizedEmbeddingIndex(
+          { mode: "static", identity: `${modelDir}#${model.modelId}`, scan },
+          () => buildEmbeddingIndex(scan, model),
+        );
+        const results = searchSemantic(scan, query, index, { model, limit, fuzzy });
+        return JSON.stringify({ results, tier: "static" }, null, 2);
       }
-      // Degrade to lexical (opt-in tier not activated) — no throw.
+      // Opt-in tier not activated (no endpoint, no model asset) — degrade to
+      // lexical with a reason instead of failing silently.
+      const results = searchIndex(scan, query, { limit, fuzzy });
+      return JSON.stringify(
+        { results, tier: "lexical", degradedReason: "no embedding endpoint or static model configured — see embed_status" },
+        null,
+        2,
+      );
     }
     return JSON.stringify(searchIndex(scan, query, { limit, fuzzy }), null, 2);
   }

package/src/types.ts

@@ -1,7 +1,7 @@
 // Single source of truth for the engine version the bundle reports. Kept in
 // lockstep with package.json by the release pipeline. Do not edit by hand
 // outside a release.
-export const ENGINE_VERSION = "2.11.0";
+export const ENGINE_VERSION = "2.12.0";
 
 // Bumped whenever the on-disk artifact shape changes, so a consumer can reject
 // an index written by an incompatible engine instead of misreading it. The
@@ -27,8 +27,18 @@ export const SCHEMA_VERSION = 4;
 // named after the file stem, `export default Foo` marking the declaration);
 // v7 makes an export-alias symbol (`export { b as c }`) mirror the aliased
 // local declaration's own kind (e.g. "function") instead of the generic
-// "reexport" when it resolves in-file.
-export const EXTRACTOR_VERSION = 7;
+// "reexport" when it resolves in-file. v8 fixes the C/C++ regex tier
+// reporting a function DEFINITION as a call to itself (`void load(void) {`
+// yielding a spurious call `load@<defline>`, found during the ultrasec
+// consumer migration) by excluding, from call candidates, only the
+// definition's own token on its definition line — not every occurrence of
+// that name+line pair, which would also drop genuine same-line calls (dense
+// one-liners packing several definitions, one-line recursion); v9 makes a
+// resolved export-alias symbol also cite the original declaration's own line
+// (and endLine, when the AST tier populated one) instead of the export
+// statement's line — a citation-precision fix (issue #9) for consumers
+// (ultradoc) that use file:line as evidence.
+export const EXTRACTOR_VERSION = 9;
 
 // How a file is classified. `code` gets symbol/import extraction; `doc` gets
 // link/heading extraction; the rest are catalogued but not deeply parsed.