@optave/codegraph 3.9.6 → 3.11.0

package/src/domain/parser.ts

@@ -316,16 +316,23 @@ export function getParser(parsers: Map<string, Parser | null>, filePath: string)
  *
  * Name is preserved for caller compatibility; the function now ensures
  * *analysis data* rather than *trees*.
+ *
+ * `needsFn` (optional): when provided, only files for which it returns true are
+ * re-parsed. Without it the function falls back to "any WASM-parseable file
+ * without _tree", which was the source of #1036 — a single file missing one
+ * analysis triggered a full-build re-parse of every WASM-parseable file.
  */
 export async function ensureWasmTrees(
   fileSymbols: Map<string, any>,
   rootDir: string,
+  needsFn?: (relPath: string, symbols: any) => boolean,
 ): Promise<void> {
   // Collect files that still need analysis data and are parseable by WASM.
   const pending: Array<{ relPath: string; absPath: string; symbols: any }> = [];
   for (const [relPath, symbols] of fileSymbols) {
     if (symbols._tree) continue; // legacy path — leave existing trees alone
     if (!_extToLang.has(path.extname(relPath).toLowerCase())) continue;
+    if (needsFn && !needsFn(relPath, symbols)) continue;
     pending.push({ relPath, absPath: path.join(rootDir, relPath), symbols });
   }
   if (pending.length === 0) return;
@@ -450,6 +457,8 @@ export const NATIVE_SUPPORTED_EXTENSIONS: ReadonlySet<string> = new Set([
   '.cc',
   '.cxx',
   '.hpp',
+  '.cu',
+  '.cuh',
   '.kt',
   '.kts',
   '.swift',
@@ -464,6 +473,23 @@ export const NATIVE_SUPPORTED_EXTENSIONS: ReadonlySet<string> = new Set([
   '.hs',
   '.ml',
   '.mli',
+  '.fs',
+  '.fsx',
+  '.fsi',
+  '.m',
+  '.gleam',
+  '.jl',
+  '.clj',
+  '.cljs',
+  '.cljc',
+  '.erl',
+  '.hrl',
+  '.groovy',
+  '.gvy',
+  '.r',
+  '.sol',
+  '.v',
+  '.sv',
 ]);
 
 /**
@@ -805,11 +831,18 @@ export const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
   },
   {
     id: 'fsharp',
-    extensions: ['.fs', '.fsx', '.fsi'],
+    extensions: ['.fs', '.fsx'],
     grammarFile: 'tree-sitter-fsharp.wasm',
     extractor: extractFSharpSymbols,
     required: false,
   },
+  {
+    id: 'fsharp-signature',
+    extensions: ['.fsi'],
+    grammarFile: 'tree-sitter-fsharp_signature.wasm',
+    extractor: extractFSharpSymbols,
+    required: false,
+  },
   {
     id: 'gleam',
     extensions: ['.gleam'],
@@ -1060,6 +1093,71 @@ async function parseFilesWasm(
   return result;
 }
 
+/**
+ * Files at or below this count use the inline parse path (no worker spawn).
+ *
+ * Sized for typical engine-parity drops: a handful of fixture files in one
+ * or two languages (the recurring HCL case is 4 files). Above this, the
+ * worker-pool's IPC + crash-isolation cost (#965) is amortized over enough
+ * parse work to be worth paying; below it, the ~1–2s cold-start dominates.
+ */
+const INLINE_BACKFILL_THRESHOLD = 16;
+
+/**
+ * Inline WASM parse (no worker) for small file batches.
+ *
+ * Used by the engine-parity backfill path when the native engine drops a
+ * handful of files (typically test fixtures). The worker pool's per-call
+ * IPC + grammar-init overhead can cost 1–2s on slow CI runners — for a
+ * 4-file backfill, that dwarfs the ~10ms of actual parse work.
+ *
+ * Returns symbols with `_tree` set so `runAnalyses` can run AST/CFG/dataflow
+ * visitors via the unified walker (mirrors how WASM-engine results behaved
+ * before the worker pool was introduced).
+ */
+async function parseFilesWasmInline(
+  filePaths: string[],
+  rootDir: string,
+): Promise<Map<string, ExtractorOutput>> {
+  const result = new Map<string, ExtractorOutput>();
+  if (filePaths.length === 0) return result;
+  const parsers = await ensureParsersForFiles(filePaths);
+  for (const filePath of filePaths) {
+    if (!_extToLang.has(path.extname(filePath).toLowerCase())) continue;
+    let code: string;
+    try {
+      code = fs.readFileSync(filePath, 'utf-8');
+    } catch (err: unknown) {
+      warn(`Skipping ${path.relative(rootDir, filePath)}: ${(err as Error).message}`);
+      continue;
+    }
+    const extracted = wasmExtractSymbols(parsers, filePath, code);
+    if (!extracted) continue;
+    const relPath = path.relative(rootDir, filePath).split(path.sep).join('/');
+    const symbols = extracted.symbols as ExtractorOutput & { _tree?: unknown; _langId?: string };
+    symbols._tree = extracted.tree;
+    symbols._langId = extracted.langId;
+    result.set(relPath, symbols);
+  }
+  return result;
+}
+
+/**
+ * Backfill helper: small batches use the inline (main-thread) path; larger
+ * batches keep the worker-pool isolation against tree-sitter WASM crashes
+ * (#965). Threshold matches typical engine-parity drop sizes (a few fixture
+ * files in one or two languages).
+ */
+export async function parseFilesWasmForBackfill(
+  filePaths: string[],
+  rootDir: string,
+): Promise<Map<string, ExtractorOutput>> {
+  if (filePaths.length <= INLINE_BACKFILL_THRESHOLD) {
+    return parseFilesWasmInline(filePaths, rootDir);
+  }
+  return parseFilesWasm(filePaths, rootDir);
+}
+
 /**
  * Parse multiple files in bulk and return a Map<relPath, symbols>.
  */
@@ -1110,7 +1208,7 @@ export async function parseFilesAuto(
   );
   if (dropped.length > 0) {
     warn(`Native engine dropped ${dropped.length} file(s); falling back to WASM for parity`);
-    const wasmResults = await parseFilesWasm(dropped, rootDir);
+    const wasmResults = await parseFilesWasmForBackfill(dropped, rootDir);
     for (const [relPath, symbols] of wasmResults) {
       result.set(relPath, symbols);
     }
@@ -1125,15 +1223,17 @@ export async function parseFilesAuto(
 export function getActiveEngine(opts: ParseEngineOpts = {}): {
   name: 'native' | 'wasm';
   version: string | null;
+  binaryVersion: string | null;
 } {
   const { name, native } = resolveEngine(opts);
-  let version: string | null = native
-    ? typeof native.engineVersion === 'function'
-      ? native.engineVersion()
-      : null
-    : null;
-  // Prefer platform package.json version over binary-embedded version
-  // to handle stale binaries that weren't recompiled during a release
+  const binaryVersion: string | null =
+    native && typeof native.engineVersion === 'function' ? native.engineVersion() : null;
+  // The display version prefers the platform package.json so the "Using native
+  // engine (vX)" log matches the npm release the user installed. The Rust
+  // orchestrator's check_version_mismatch compares against CARGO_PKG_VERSION
+  // (the binary's own value), so build_meta writes must use `binaryVersion`,
+  // not this display value — see pipeline.ts and finalize.ts (#1066).
+  let version: string | null = binaryVersion;
   if (native) {
     try {
       version = getNativePackageVersion() ?? version;
@@ -1141,7 +1241,7 @@ export function getActiveEngine(opts: ParseEngineOpts = {}): {
       debug(`getNativePackageVersion failed: ${(e as Error).message}`);
     }
   }
-  return { name, version };
+  return { name, version, binaryVersion };
 }
 
 /**

package/src/domain/search/models.ts

@@ -1,8 +1,40 @@
 import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { info } from '../../infrastructure/logger.js';
 import { ConfigError, EngineError } from '../../shared/errors.js';
 
+const _require = createRequire(import.meta.url);
+
+/**
+ * Resolve the directory where `npm install` should run so the installed
+ * package ends up reachable by `await import(pkg)` from inside this module.
+ *
+ * Without a `cwd`, `execFileSync('npm', ['install', ...])` operates on
+ * `process.cwd()` — when the user runs codegraph against a repo that is *not*
+ * the directory where codegraph itself is installed, npm installs into the
+ * wrong `node_modules`, the dynamic import still fails, and the user gets
+ * `ENGINE_UNAVAILABLE: ... installed but failed to load`.
+ *
+ * Pin cwd to the directory that contains @optave/codegraph's `node_modules`
+ * so the install lands where Node's resolution algorithm will find it.
+ *
+ * @internal Exported for unit tests; not part of the public barrel.
+ */
+export function resolveNpmInstallCwd(): string | undefined {
+  try {
+    const pkgJsonPath = _require.resolve('@optave/codegraph/package.json');
+    // pkgJsonPath = <host>/node_modules/@optave/codegraph/package.json
+    // dirname x4: package.json → codegraph → @optave → node_modules → <host>
+    return path.dirname(path.dirname(path.dirname(path.dirname(pkgJsonPath))));
+  } catch {
+    // Source-of-truth checkout (no @optave/codegraph in node_modules) — fall back
+    // to process.cwd() so legacy behavior survives in tests.
+    return undefined;
+  }
+}
+
 export interface ModelConfig {
   name: string;
   dim: number;
@@ -42,7 +74,7 @@ export const MODELS: Record<string, ModelConfig> = {
     quantized: false,
   },
   'jina-code': {
-    name: 'Xenova/jina-embeddings-v2-base-code',
+    name: 'jinaai/jina-embeddings-v2-base-code',
     dim: 768,
     contextWindow: 8192,
     desc: 'Code-aware (~137MB). Trained on code+text, best for code search.',
@@ -104,12 +136,14 @@ export function getModelConfig(modelKey?: string): ModelConfig {
  * @internal Not part of the public barrel.
  */
 export function promptInstall(packageName: string): Promise<boolean> {
+  const installCwd = resolveNpmInstallCwd();
   if (!process.stdin.isTTY) {
     info(`Installing ${packageName} (optional dependency for semantic search)…`);
     try {
       execFileSync(NPM_BIN, ['install', '--no-save', packageName], {
         stdio: 'inherit',
         timeout: 300_000,
+        cwd: installCwd,
       });
       return Promise.resolve(true);
     } catch (err) {
@@ -128,9 +162,10 @@ export function promptInstall(packageName: string): Promise<boolean> {
         rl.close();
         if (answer.trim().toLowerCase() !== 'y') return resolve(false);
         try {
-          execFileSync(NPM_BIN, ['install', packageName], {
+          execFileSync(NPM_BIN, ['install', '--no-save', packageName], {
             stdio: 'inherit',
             timeout: 300_000,
+            cwd: installCwd,
           });
           resolve(true);
         } catch (err) {

package/src/domain/wasm-worker-entry.ts

@@ -306,11 +306,18 @@ const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
   },
   {
     id: 'fsharp',
-    extensions: ['.fs', '.fsx', '.fsi'],
+    extensions: ['.fs', '.fsx'],
     grammarFile: 'tree-sitter-fsharp.wasm',
     extractor: extractFSharpSymbols,
     required: false,
   },
+  {
+    id: 'fsharp-signature',
+    extensions: ['.fsi'],
+    grammarFile: 'tree-sitter-fsharp_signature.wasm',
+    extractor: extractFSharpSymbols,
+    required: false,
+  },
   {
     id: 'gleam',
     extensions: ['.gleam'],
@@ -708,18 +715,18 @@ async function handleParse(msg: WorkerParseRequest): Promise<SerializedExtractor
           file?: string;
           parentNodeId?: number | null;
         }>;
-        if (astRows.length > 0) {
-          // Strip `file` and `parentNodeId` — main thread re-resolves parent IDs
-          // against its DB in features/ast.ts::collectFileAstRows, and `file` is
-          // known from the map key.
-          serializedAstNodes = astRows.map((n) => ({
-            line: n.line,
-            kind: n.kind,
-            name: n.name ?? '',
-            text: n.text ?? undefined,
-            receiver: n.receiver ?? undefined,
-          }));
-        }
+        // Always set an array (even empty) — leaving astNodes undefined makes
+        // engine.ts::fileNeedsWasmTree treat the file as un-walked and trigger
+        // a full ensureWasmTrees re-parse of every WASM-parseable file (#1036).
+        // Strip `file` and `parentNodeId` — main thread re-resolves both in
+        // features/ast.ts::collectFileAstRows.
+        serializedAstNodes = astRows.map((n) => ({
+          line: n.line,
+          kind: n.kind,
+          name: n.name ?? '',
+          text: n.text ?? undefined,
+          receiver: n.receiver ?? undefined,
+        }));
       }
 
       if (complexityVisitor) storeComplexityResults(results, defs, entry.id);

package/src/extractors/c.ts

@@ -159,6 +159,31 @@ function handleCCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
+const C_DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+  'function_declarator',
+]);
+
+/**
+ * Drill through pointer/array/parenthesized/function declarator wrappers to
+ * recover the bare identifier. Mirrors `unwrap_declarator` in the native C
+ * extractor so both engines agree on the name for parameters such as
+ * `void process(int callback(int))` (function-type parameter → `callback`) or
+ * `int *func(int)` (pointer-returning function → `func`).
+ */
+function unwrapCDeclaratorName(node: TreeSitterNode): string {
+  let current: TreeSitterNode | null = node;
+  while (current && C_DECLARATOR_WRAPPERS.has(current.type)) {
+    current = current.childForFieldName('declarator');
+  }
+  if (current?.type === 'identifier' || current?.type === 'field_identifier') {
+    return current.text;
+  }
+  return current?.text ?? node.text;
+}
+
 function extractCParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
   const params: SubDeclaration[] = [];
   if (!paramListNode) return params;
@@ -167,10 +192,7 @@ function extractCParameters(paramListNode: TreeSitterNode | null): SubDeclaratio
     if (!param || param.type !== 'parameter_declaration') continue;
     const nameNode = param.childForFieldName('declarator');
     if (nameNode) {
-      const name =
-        nameNode.type === 'identifier'
-          ? nameNode.text
-          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      const name = unwrapCDeclaratorName(nameNode);
       params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
     }
   }
@@ -186,10 +208,7 @@ function extractStructFields(structNode: TreeSitterNode): SubDeclaration[] {
     if (!member || member.type !== 'field_declaration') continue;
     const nameNode = member.childForFieldName('declarator');
     if (nameNode) {
-      const name =
-        nameNode.type === 'identifier'
-          ? nameNode.text
-          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      const name = unwrapCDeclaratorName(nameNode);
       fields.push({ name, kind: 'property', line: member.startPosition.row + 1 });
     }
   }

package/src/extractors/cpp.ts

@@ -239,6 +239,54 @@ function findCppParentClass(node: TreeSitterNode): string | null {
   return null;
 }
 
+const CPP_DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'reference_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+  'function_declarator',
+]);
+
+/**
+ * Drill through pointer/reference/array/parenthesized/function declarator
+ * wrappers to recover the bare identifier. Mirrors `unwrap_cpp_declarator` in
+ * the native C++ extractor. tree-sitter-cpp's `reference_declarator` does not
+ * expose a `declarator` field, so the loop falls back to scanning children
+ * for the next nested declarator or identifier.
+ */
+function unwrapCppDeclaratorName(node: TreeSitterNode): string {
+  let current: TreeSitterNode | null = node;
+  while (current && CPP_DECLARATOR_WRAPPERS.has(current.type)) {
+    const named = current.childForFieldName('declarator');
+    if (named) {
+      current = named;
+      continue;
+    }
+    const fallback = nextCppDeclaratorChild(current);
+    if (!fallback) break;
+    current = fallback;
+  }
+  if (current?.type === 'identifier' || current?.type === 'field_identifier') {
+    return current.text;
+  }
+  return current?.text ?? node.text;
+}
+
+function nextCppDeclaratorChild(node: TreeSitterNode): TreeSitterNode | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'identifier' ||
+      child.type === 'field_identifier' ||
+      CPP_DECLARATOR_WRAPPERS.has(child.type)
+    ) {
+      return child;
+    }
+  }
+  return null;
+}
+
 function extractCppParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
   const params: SubDeclaration[] = [];
   if (!paramListNode) return params;
@@ -247,10 +295,7 @@ function extractCppParameters(paramListNode: TreeSitterNode | null): SubDeclarat
     if (!param || param.type !== 'parameter_declaration') continue;
     const nameNode = param.childForFieldName('declarator');
     if (nameNode) {
-      const name =
-        nameNode.type === 'identifier'
-          ? nameNode.text
-          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      const name = unwrapCppDeclaratorName(nameNode);
       params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
     }
   }
@@ -267,10 +312,7 @@ function extractCppClassFields(classNode: TreeSitterNode): SubDeclaration[] {
     if (!member || member.type !== 'field_declaration') continue;
     const nameNode = member.childForFieldName('declarator');
     if (nameNode) {
-      const name =
-        nameNode.type === 'identifier'
-          ? nameNode.text
-          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      const name = unwrapCppDeclaratorName(nameNode);
       fields.push({
         name,
         kind: 'property',

package/src/extractors/cuda.ts

@@ -265,10 +265,10 @@ function extractCudaParameters(paramListNode: TreeSitterNode | null): SubDeclara
     if (!param || param.type !== 'parameter_declaration') continue;
     const nameNode = param.childForFieldName('declarator');
     if (nameNode) {
-      const name =
-        nameNode.type === 'identifier'
-          ? nameNode.text
-          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      // Reuse the field-name drill helper so function-type parameters like
+      // `void process(int callback(int))` yield the bare name `callback`
+      // instead of the raw declarator text, matching the native unwrap path.
+      const name = extractCudaFieldName(nameNode);
       params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
     }
   }
@@ -284,22 +284,96 @@ function extractCudaClassFields(classNode: TreeSitterNode): SubDeclaration[] {
     const member = body.child(i);
     if (!member || member.type !== 'field_declaration') continue;
     const nameNode = member.childForFieldName('declarator');
-    if (nameNode) {
-      const name =
-        nameNode.type === 'identifier'
-          ? nameNode.text
-          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
-      fields.push({
-        name,
-        kind: 'property',
-        line: member.startPosition.row + 1,
-        visibility: extractModifierVisibility(member),
-      });
-    }
+    if (!nameNode) continue;
+    // Skip method declarations — a `field_declaration` whose declarator
+    // (after unwrapping pointer/reference/array) is a `function_declarator`
+    // is a method signature in a header, not a data field. Native and WASM
+    // previously diverged on how to format these (native stripped the `*`
+    // from pointer-return types, WASM kept it), and both produced
+    // method-signature-shaped "property" entries that are not real fields.
+    if (isCudaMethodDeclarator(nameNode)) continue;
+    const name = extractCudaFieldName(nameNode);
+    fields.push({
+      name,
+      kind: 'property',
+      line: member.startPosition.row + 1,
+      visibility: extractModifierVisibility(member),
+    });
   }
   return fields;
 }
 
+const CUDA_DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'reference_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+]);
+
+function isCudaMethodDeclarator(node: TreeSitterNode): boolean {
+  let current: TreeSitterNode | null = node;
+  while (current && CUDA_DECLARATOR_WRAPPERS.has(current.type)) {
+    current = current.childForFieldName('declarator');
+  }
+  if (current?.type !== 'function_declarator') return false;
+  // A `function_declarator` whose inner declarator is a `parenthesized_declarator`
+  // is a function-pointer (or function-reference) field — e.g. `void (*cb)(int)`
+  // parses as function_declarator > parenthesized_declarator > pointer_declarator >
+  // field_identifier. Those are real data fields, not method declarations.
+  const inner = current.childForFieldName('declarator');
+  return inner?.type !== 'parenthesized_declarator';
+}
+
+/**
+ * Resolve the identifier of a declarator by walking through any combination of
+ * pointer/reference/array/parenthesized wrappers and `function_declarator`
+ * nodes. Used by both class-field extraction (where `function_declarator`
+ * indicates a function-pointer field after method declarations have been
+ * filtered out) and parameter extraction (where `function_declarator` wraps a
+ * bare function-type parameter name like `callback` in
+ * `void process(int callback(int))`).
+ */
+function extractCudaFieldName(decl: TreeSitterNode): string {
+  let current: TreeSitterNode | null = decl;
+  while (current) {
+    if (current.type === 'identifier' || current.type === 'field_identifier') {
+      return current.text;
+    }
+    if (CUDA_DECLARATOR_WRAPPERS.has(current.type) || current.type === 'function_declarator') {
+      const next = innerCudaDeclarator(current);
+      if (!next) break;
+      current = next;
+      continue;
+    }
+    break;
+  }
+  return decl.text;
+}
+
+/**
+ * Find the inner declarator of a wrapper node. Most C++ declarator wrappers
+ * expose it via the `declarator` field, but some (e.g. `parenthesized_declarator`
+ * and `reference_declarator` in tree-sitter-cuda) have unnamed children — so
+ * fall back to scanning children for a declarator-shaped node.
+ */
+function innerCudaDeclarator(node: TreeSitterNode): TreeSitterNode | null {
+  const named = node.childForFieldName('declarator');
+  if (named) return named;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'identifier' ||
+      child.type === 'field_identifier' ||
+      child.type === 'function_declarator' ||
+      CUDA_DECLARATOR_WRAPPERS.has(child.type)
+    ) {
+      return child;
+    }
+  }
+  return null;
+}
+
 function extractCudaEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
   const entries: SubDeclaration[] = [];
   const body = findChild(enumNode, 'enumerator_list');

package/src/extractors/elixir.ts

@@ -190,14 +190,86 @@ function extractElixirParams(defCallNode: TreeSitterNode): SubDeclaration[] {
     for (let j = 0; j < innerArgs.childCount; j++) {
       const param = innerArgs.child(j);
       if (!param) continue;
-      if (param.type === 'identifier') {
-        params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
-      }
+      collectElixirParamIdentifiers(param, params);
     }
   }
   return params;
 }
 
+/**
+ * Recursively walk a parameter pattern and emit each bound identifier as a
+ * `parameter` child. Handles bare identifiers, default-value `a \\ default`,
+ * list-cons `[head | tail]`, list `[a, b, c]`, tuple `{x, y}`, and
+ * map / struct destructuring (`%{k: v}`, `%Foo{k: v}`).
+ */
+function collectElixirParamIdentifiers(node: TreeSitterNode, out: SubDeclaration[]): void {
+  switch (node.type) {
+    case 'identifier':
+      out.push({ name: node.text, kind: 'parameter', line: node.startPosition.row + 1 });
+      return;
+    case 'binary_operator': {
+      // `name \\ default` (default-value) binds the left operand only.
+      // `head | tail` (list-cons, appears inside a `list` pattern) binds both operands.
+      const op = node.child(1);
+      if (!op) return;
+      if (op.type === '\\\\') {
+        const left = node.child(0);
+        if (left) collectElixirParamIdentifiers(left, out);
+        return;
+      }
+      if (op.type === '|') {
+        const left = node.child(0);
+        const right = node.child(2);
+        if (left) collectElixirParamIdentifiers(left, out);
+        if (right) collectElixirParamIdentifiers(right, out);
+        return;
+      }
+      return;
+    }
+    case 'list':
+      // `[a, b, c]` or `[head | tail]` — walk children, skipping punctuation. The
+      // `|` cons case is handled by the `binary_operator` arm when we recurse.
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c || c.type === '[' || c.type === ']' || c.type === ',') continue;
+        collectElixirParamIdentifiers(c, out);
+      }
+      return;
+    case 'tuple':
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c || c.type === '{' || c.type === '}' || c.type === ',') continue;
+        collectElixirParamIdentifiers(c, out);
+      }
+      return;
+    case 'map':
+      // `%{k: v}` or `%Foo{k: v}` — walk map_content > keywords > pair and emit each
+      // pair's value side (the bound name). The struct alias (`Foo`) is a type, not a
+      // bound identifier, so the leading `struct` child is intentionally skipped.
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === 'map_content') collectElixirMapBindings(c, out);
+      }
+      return;
+  }
+}
+
+function collectElixirMapBindings(content: TreeSitterNode, out: SubDeclaration[]): void {
+  for (let i = 0; i < content.childCount; i++) {
+    const kws = content.child(i);
+    if (!kws || kws.type !== 'keywords') continue;
+    for (let j = 0; j < kws.childCount; j++) {
+      const pair = kws.child(j);
+      if (!pair || pair.type !== 'pair') continue;
+      for (let k = 0; k < pair.childCount; k++) {
+        const part = pair.child(k);
+        if (!part || part.type === 'keyword') continue;
+        collectElixirParamIdentifiers(part, out);
+      }
+    }
+  }
+}
+
 function handleDefprotocol(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const args = findChild(node, 'arguments');
   if (!args) return;