@maxgfr/codeindex 2.11.0 → 2.11.1

package/README.md

@@ -1,5 +1,7 @@
 # codeindex
 
+[![Site](https://img.shields.io/badge/site-maxgfr.github.io%2Fcodeindex-2a78d6)](https://maxgfr.github.io/codeindex/)
+
 Self-contained, deterministic **repo-indexing engine**: file walking, language
 detection, symbol/import extraction (tree-sitter AST with a regex fallback),
 import resolution, a typed cross-file link-graph, and graph analytics — shipped

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxgfr/codeindex",
-  "version": "2.11.0",
+  "version": "2.11.1",
   "description": "Self-contained, deterministic repo-indexing engine: walk + language detection + symbol/import extraction (tree-sitter AST with regex fallback) + import resolution + typed cross-file link-graph + analytics. Ships as a single zero-dependency engine.mjs that consumer tools vendor.",
   "type": "module",
   "packageManager": "pnpm@10.33.0",

package/scripts/engine.d.mts

@@ -1,6 +1,6 @@
-declare const ENGINE_VERSION = "2.11.0";
+declare const ENGINE_VERSION = "2.11.1";
 declare const SCHEMA_VERSION = 4;
-declare const EXTRACTOR_VERSION = 7;
+declare const EXTRACTOR_VERSION = 8;
 type FileKind = "code" | "doc" | "config" | "asset" | "other";
 type EdgeKind = "contains" | "doc-link" | "import" | "call" | "use" | "mention";
 type Tier = 0 | 1 | 2;

package/scripts/engine.mjs

@@ -14,9 +14,9 @@ var ENGINE_VERSION, SCHEMA_VERSION, EXTRACTOR_VERSION;
 var init_types = __esm({
   "src/types.ts"() {
     "use strict";
-    ENGINE_VERSION = "2.11.0";
+    ENGINE_VERSION = "2.11.1";
     SCHEMA_VERSION = 4;
-    EXTRACTOR_VERSION = 7;
+    EXTRACTOR_VERSION = 8;
   }
 });
 
@@ -731,7 +731,57 @@ function scan(rel, content, lang, rules) {
 function extToLang(ext) {
   return EXT_LANG[ext] ?? "other";
 }
-var EXT_LANG;
+function extractReexports(rel, content, localSymbols) {
+  if (!REEXPORT_EXTS.has(rel.slice(rel.lastIndexOf(".")))) return [];
+  const lang = /\.(ts|tsx|mts|cts)$/.test(rel) ? "typescript" : "javascript";
+  const out2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lineAt = (idx) => content.slice(0, idx).split(/\r?\n/).length;
+  const localKindOf = /* @__PURE__ */ new Map();
+  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;
+  while ((m = named.exec(content)) && out2.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 name2 = as ? as[2] : p;
+      if (!/^[A-Za-z_$][\w$]*$/.test(name2) || name2 === "default" || seen.has(name2)) continue;
+      seen.add(name2);
+      const mirroredKind = !from ? localKindOf.get(orig) : void 0;
+      out2.push({
+        name: name2,
+        kind: mirroredKind ?? "reexport",
+        file: rel,
+        line: lineAt(m.index),
+        signature: from ? `export { ${name2} } from "${from}"` : `export { ${name2} }`,
+        exported: true,
+        lang
+      });
+    }
+  }
+  const star = /export\s*\*\s*(?:as\s+([A-Za-z_$][\w$]*)\s+)?from\s*['"]([^'"]+)['"]/g;
+  while ((m = star.exec(content)) && out2.length < 60) {
+    const ns = m[1];
+    const from = m[2];
+    const key = "*" + (ns ?? from);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out2.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 out2;
+}
+var EXT_LANG, REEXPORT_EXTS;
 var init_common = __esm({
   "src/lang/common.ts"() {
     "use strict";
@@ -799,6 +849,7 @@ var init_common = __esm({
       ".svelte": "svelte",
       ".astro": "astro"
     };
+    REEXPORT_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
   }
 });
 
@@ -1231,12 +1282,18 @@ var init_scala = __esm({
 // src/lang/registry.ts
 function extractSymbols(rel, ext, content) {
   const extractor = BY_EXT.get(ext);
-  if (!extractor) return [];
-  try {
-    return extractor.extract(rel, content);
-  } catch {
-    return [];
+  let symbols;
+  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;
 }
 function languageOf(ext) {
   return BY_EXT.get(ext)?.lang ?? extToLang(ext);
@@ -6340,58 +6397,9 @@ function extractImports(ext, content) {
   }
   return [...specs].map((spec) => ({ kind: "import", spec }));
 }
-function extractReexports(rel, content, localSymbols) {
-  if (!JS_TS.has(rel.slice(rel.lastIndexOf(".")))) return [];
-  const lang = /\.(ts|tsx|mts|cts)$/.test(rel) ? "typescript" : "javascript";
-  const out2 = [];
-  const seen = /* @__PURE__ */ new Set();
-  const lineAt = (idx) => content.slice(0, idx).split(/\r?\n/).length;
-  const localKindOf = /* @__PURE__ */ new Map();
-  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;
-  while ((m = named.exec(content)) && out2.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 name2 = as ? as[2] : p;
-      if (!/^[A-Za-z_$][\w$]*$/.test(name2) || name2 === "default" || seen.has(name2)) continue;
-      seen.add(name2);
-      const mirroredKind = !from ? localKindOf.get(orig) : void 0;
-      out2.push({
-        name: name2,
-        kind: mirroredKind ?? "reexport",
-        file: rel,
-        line: lineAt(m.index),
-        signature: from ? `export { ${name2} } from "${from}"` : `export { ${name2} }`,
-        exported: true,
-        lang
-      });
-    }
-  }
-  const star = /export\s*\*\s*(?:as\s+([A-Za-z_$][\w$]*)\s+)?from\s*['"]([^'"]+)['"]/g;
-  while ((m = star.exec(content)) && out2.length < 60) {
-    const ns = m[1];
-    const from = m[2];
-    const key = "*" + (ns ?? from);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out2.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 out2;
-}
-function collectCallsRegex(content) {
+function collectCallsRegex(content, symbols = []) {
   const out2 = /* @__PURE__ */ new Map();
+  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 i2 = 0; i2 < lines.length && out2.size < 512; i2++) {
@@ -6399,13 +6407,28 @@ function collectCallsRegex(content) {
     const trimmed = line.trimStart();
     if (trimmed.startsWith("//") || trimmed.startsWith("#") || trimmed.startsWith("*")) continue;
     CALL_RE.lastIndex = 0;
+    let probe;
+    const introducerCaught = /* @__PURE__ */ new Set();
+    while ((probe = CALL_RE.exec(line)) !== null) {
+      const name2 = probe[2];
+      const key = `${name2} ${i2 + 1}`;
+      if (ownDefLines.has(key) && DEF_INTRODUCERS.test(line.slice(0, probe.index))) introducerCaught.add(key);
+    }
+    CALL_RE.lastIndex = 0;
     let m;
+    const fallbackExcluded = /* @__PURE__ */ new Set();
     while ((m = CALL_RE.exec(line)) !== null && out2.size < 512) {
       const receiver = m[1];
       const name2 = m[2];
       if (name2.length < 2 || CALL_KEYWORDS.has(name2)) continue;
       if (DEF_INTRODUCERS.test(line.slice(0, m.index))) continue;
       const key = `${name2} ${i2 + 1}`;
+      if (ownDefLines.has(key) && !introducerCaught.has(key)) {
+        if (!fallbackExcluded.has(key)) {
+          fallbackExcluded.add(key);
+          continue;
+        }
+      }
       if (!out2.has(key)) out2.set(key, receiver ? { name: name2, line: i2 + 1, receiver } : { name: name2, line: i2 + 1 });
     }
   }
@@ -6426,7 +6449,9 @@ function extractCode(rel, ext, content) {
     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
   };
 }
@@ -6436,6 +6461,7 @@ var init_code = __esm({
     "use strict";
     init_registry();
     init_extract();
+    init_common();
     JS_TS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
     PY = /* @__PURE__ */ new Set([".py", ".pyi"]);
     C_CPP = /* @__PURE__ */ new Set([".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".hh"]);

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,67 @@ 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 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".
+//
+// 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;
+  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;
+}

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/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.11.1";
 
 // 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,12 @@ 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 call candidates whose name+line match one
+// of the file's own extracted symbols.
+export const EXTRACTOR_VERSION = 8;
 
 // How a file is classified. `code` gets symbol/import extraction; `doc` gets
 // link/heading extraction; the rest are catalogued but not deeply parsed.