@quolu/lattice 0.69.5 → 0.71.0

package/sensor/dist/extraction/tree-sitter.js

@@ -47,6 +47,7 @@ const function_ref_1 = require("./function-ref");
 const generated_detection_1 = require("./generated-detection");
 const languages_1 = require("./languages");
 const c_cpp_1 = require("./languages/c-cpp");
+const rust_1 = require("./languages/rust");
 const liquid_extractor_1 = require("./liquid-extractor");
 const razor_extractor_1 = require("./razor-extractor");
 const svelte_extractor_1 = require("./svelte-extractor");
@@ -73,6 +74,19 @@ const RTK_HOOK_NAME_RE = /^use[A-Z][A-Za-z0-9]*(?:Query|Mutation)$/;
 /** React HOC callees whose result is itself a component — a PascalCase const
  *  initialized with one of these is a component, not a constant (#841). */
 const REACT_COMPONENT_HOCS = new Set(['forwardRef', 'memo', 'React.forwardRef', 'React.memo']);
+/**
+ * Method node types that spell a SIGNATURE — a declaration with no body (#1638).
+ *
+ * They are a method of whatever type declares them and nothing on their own, so
+ * they must not take `extractMethod`'s "no class-like parent, so treat it as a
+ * free function" fallback. The other `methodTypes` can: a `method_definition`
+ * outside a class really is a function. This one appears outside a class only
+ * inside a type literal (`type Handle = { stop(): void }`), whose members
+ * `extractTypeAlias` already extracts and attaches to the alias (#359) — take
+ * the fallback and the file gains a phantom top-level `function stop` beside
+ * the real `Handle::stop`.
+ */
+const SIGNATURE_METHOD_NODE_TYPES = new Set(['method_signature']);
 /** Vue store collections whose object-literal members are the symbols an agent
  *  looks for. Extracted as function nodes so `actions`/`mutations`/`getters` are
  *  findable + readable (the foundation under any later dispatch-bridge synth). */
@@ -187,7 +201,7 @@ function extractNameRaw(node, source, extractor) {
     // not from identifiers in their body. Without this, single-expression arrow
     // functions like `const fn = () => someIdentifier` get named "someIdentifier"
     // instead of "fn", because the fallback below finds the body identifier.
-    if (node.type === 'arrow_function' || node.type === 'function_expression') {
+    if (node.type === 'arrow_function' || node.type === 'function_expression' || node.type === 'generator_function') {
         return '<anonymous>';
     }
     // Fall back to first identifier child
@@ -385,12 +399,107 @@ const LITERAL_RECEIVER_TYPES = new Set([
     'list', 'list_literal', 'array', 'array_literal', 'array_creation_expression',
     'dictionary', 'dict_literal', 'object', 'tuple', 'set',
 ]);
+/**
+ * Languages whose member calls go through the TS/JS grammars.
+ */
+const TS_JS_CHAIN_LANGUAGES = new Set(['typescript', 'tsx', 'javascript', 'jsx']);
+/** Receiver node types (TS/JS grammars) that continue a member chain downward. */
+const TS_JS_CHAIN_RECEIVER_TYPES = new Set(['member_expression', 'subscript_expression']);
+/** The field of a `this.<field>.<method>()` receiver: public or ES private (#1496, #1987). */
+const THIS_FIELD_PROPERTY_TYPES = new Set(['property_identifier', 'private_property_identifier']);
+/**
+ * Identifier-rooted member chains have no inferred property type (#1566),
+ * including host API chains (#1707). Keep the existing `window.MyNamespace`
+ * escape for project globals; call-result and `this` receivers have their own
+ * paths and are outside this guard.
+ */
+function isUnresolvedTsJsChain(node, source) {
+    let cur = node;
+    while (cur && TS_JS_CHAIN_RECEIVER_TYPES.has(cur.type)) {
+        cur = (0, tree_sitter_helpers_1.getChildByField)(cur, 'object');
+    }
+    return !!cur && cur.type === 'identifier' && (0, tree_sitter_helpers_1.getNodeText)(cur, source) !== 'window';
+}
+/**
+ * TS/JS wrappers that leave a member call's receiver the same object:
+ * `(x).m()`, `x!.m()`, `(x as T).m()`, `(x satisfies T).m()`, `(<T>x).m()`
+ * and `(await x).m()` all call `m` on what `x` holds.
+ */
+const TS_JS_TRANSPARENT_RECEIVER_TYPES = new Set([
+    'parenthesized_expression', 'non_null_expression', 'as_expression',
+    'satisfies_expression', 'type_assertion', 'await_expression',
+]);
+/**
+ * Strip {@link TS_JS_TRANSPARENT_RECEIVER_TYPES} wrappers off a receiver.
+ * tree-sitter-typescript parses `a && b!.c()` as `(a && b)!.c()`; the `!`
+ * belongs to the right operand, so a non-null over a binary expression peels
+ * to that operand.
+ */
+function peelTsJsReceiver(node) {
+    let cur = node;
+    while (TS_JS_TRANSPARENT_RECEIVER_TYPES.has(cur.type)) {
+        let inner = cur.type === 'type_assertion'
+            ? cur.namedChild(cur.namedChildCount - 1)
+            : cur.namedChild(0);
+        if (cur.type === 'non_null_expression') {
+            while (inner?.type === 'binary_expression')
+                inner = (0, tree_sitter_helpers_1.getChildByField)(inner, 'right');
+        }
+        if (!inner)
+            break;
+        cur = inner;
+    }
+    return cur;
+}
+/**
+ * Whether a TS/JS receiver still collapses to the bare method name: `this` /
+ * `super` (the resolver reads the owner off the enclosing class), a member
+ * chain rooted at either or at `window` (the project-global escape of
+ * {@link isUnresolvedTsJsChain}), and `new C()` (its class is written at the
+ * call).
+ */
+function keepsBareTsJsReceiver(node, source) {
+    let cur = node;
+    while (cur && TS_JS_CHAIN_RECEIVER_TYPES.has(cur.type)) {
+        const object = (0, tree_sitter_helpers_1.getChildByField)(cur, 'object');
+        cur = object ? peelTsJsReceiver(object) : null;
+    }
+    if (!cur)
+        return false;
+    if (cur.type === 'this' || cur.type === 'super')
+        return true;
+    if (cur.type === 'identifier')
+        return (0, tree_sitter_helpers_1.getNodeText)(cur, source) === 'window';
+    return cur === node && cur.type === 'new_expression';
+}
+/**
+ * React hooks that bind a NAME to a handler function (`const onPress =
+ * useCallback(() => {…}, [])`). The arrow inside is extracted as a function
+ * node named by the declarator — see `reactHookBoundName`.
+ */
+const REACT_HANDLER_HOOKS = /^(?:React\.)?use(?:Callback|EffectEvent|Event)$/;
 class TreeSitterExtractor {
+    /**
+     * The node's prose, from either place it can live: a preceding comment
+     * sibling (every language) or a docstring inside the body (Python's bare
+     * first-statement string, and the same shape in other languages that opt in
+     * via `getBodyDocstring`). When a node carries both, they are joined rather
+     * than one winning — they are two separate things the author wrote about the
+     * same symbol, and the column holds free text (#1905).
+     */
+    docstringFor(node) {
+        const preceding = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const body = this.extractor?.getBodyDocstring?.(node, this.source);
+        if (preceding && body)
+            return `${preceding}\n\n${body}`;
+        return body || preceding;
+    }
     filePath;
     language;
     source;
     tree = null;
     nodes = [];
+    nodeIds = new tree_sitter_helpers_1.NodeIdAllocator();
     edges = [];
     unresolvedReferences = [];
     // Value-reference edges (default ON; set LATTICE_SENSOR_VALUE_REFS=0 to disable; see flushValueRefs).
@@ -506,6 +615,9 @@ class TreeSitterExtractor {
                 isExported: false,
                 updatedAt: Date.now(),
             };
+            const fileDocstring = this.extractor?.getBodyDocstring?.(this.tree.rootNode, this.source);
+            if (fileDocstring)
+                fileNode.docstring = fileDocstring;
             this.nodes.push(fileNode);
             // Push file node onto stack so top-level declarations get contains edges
             this.nodeStack.push(fileNode.id);
@@ -524,6 +636,16 @@ class TreeSitterExtractor {
             if (packageNodeId)
                 this.nodeStack.pop();
             this.nodeStack.pop();
+            // hasError is routine for several grammars; warn only when no symbols survived.
+            const symbolCount = this.nodes.filter((n) => n.kind !== 'file').length;
+            if (this.tree?.rootNode.hasError && symbolCount === 0) {
+                this.errors.push({
+                    message: `${this.filePath}: parse produced no symbols (tree has errors) — ` +
+                        `the file is indexed but contributes nothing to the graph`,
+                    severity: 'warning',
+                    code: 'parse_error',
+                });
+            }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
@@ -589,6 +711,7 @@ class TreeSitterExtractor {
             return;
         const nodeType = node.type;
         if (depth > 0 && (this.extractor?.functionTypes.includes(nodeType) ||
+            ((this.language === 'lua' || this.language === 'luau') && nodeType === 'function_definition') ||
             nodeType === 'arrow_function' ||
             nodeType === 'function_expression' ||
             nodeType === 'lambda_literal' ||
@@ -983,7 +1106,14 @@ class TreeSitterExtractor {
                 if (n.type === 'identifier' || n.type === 'constant' ||
                     n.type === 'name' || n.type === 'simple_identifier') {
                     const refName = (0, tree_sitter_helpers_1.getNodeText)(n, this.source);
-                    const targetId = targets.get(refName);
+                    // C/C++: the callee of a call is a call, not a value read — even when a
+                    // same-named function-like macro (`#define helper(x) …`) is a file-scope
+                    // constant. The call edge resolves it; a value ref here would be a second,
+                    // wrong reading of the same token (upstream #2070 made such macros nodes).
+                    const calleePosition = (this.language === 'c' || this.language === 'cpp')
+                        && n.parent?.type === 'call_expression'
+                        && (0, tree_sitter_helpers_1.getChildByField)(n.parent, 'function')?.startIndex === n.startIndex;
+                    const targetId = calleePosition ? undefined : targets.get(refName);
                     // Skip self and same-name targets: a symbol referencing a file-scope
                     // sibling of its own name (the two halves of a conditional `try: X=…;
                     // except: X=…`) is never a meaningful value read.
@@ -1039,6 +1169,25 @@ class TreeSitterExtractor {
             if (skipChildren)
                 return;
         }
+        if (this.language === 'cpp' && (0, c_cpp_1.isCppConstructorDeclaration)(node)) {
+            this.extractMethod(node);
+            return;
+        }
+        // C/C++ function-like macros (`#define TRACE(x) ...`) become `constant`
+        // nodes carrying the directive as their signature. A macro is a value,
+        // never an executable callee: the resolver reads these to recognize a
+        // call whose name is a macro visible in the translation unit and refuses
+        // to bind it to a same-named function elsewhere (#1838). Mirrored in the
+        // kernel (ccpp/mod.rs visit_node).
+        if ((this.language === 'c' || this.language === 'cpp') && nodeType === 'preproc_function_def') {
+            const name = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
+            if (name) {
+                this.createNode('constant', (0, tree_sitter_helpers_1.getNodeText)(name, this.source), node, {
+                    signature: (0, tree_sitter_helpers_1.getNodeText)(node, this.source).trim(),
+                });
+            }
+            return;
+        }
         // C++ namespace blocks: carry the namespace name as a qualifiedName prefix
         // while walking the body, so `namespace flash { void compute_attn(); }`
         // indexes compute_attn with qualifiedName `flash::compute_attn` and a
@@ -1097,6 +1246,9 @@ class TreeSitterExtractor {
             else if (classification === 'trait') {
                 this.extractClass(node, 'trait');
             }
+            else if (classification === 'module') {
+                this.extractClass(node, 'module');
+            }
             else {
                 this.extractClass(node);
             }
@@ -1107,12 +1259,23 @@ class TreeSitterExtractor {
             this.extractClass(node);
             skipChildren = true;
         }
-        // Check for method declarations (only if not already handled by functionTypes)
-        else if (this.extractor.methodTypes.includes(nodeType)) {
+        // Check for method declarations (only if not already handled by functionTypes).
+        // A bodiless SIGNATURE only counts as one where a type declares it — see
+        // SIGNATURE_METHOD_NODE_TYPES for what falling through would otherwise mint.
+        else if (this.extractor.methodTypes.includes(nodeType)
+            && (!(TS_JS_CHAIN_LANGUAGES.has(this.language) || this.language === 'arkts')
+                || !SIGNATURE_METHOD_NODE_TYPES.has(nodeType) || this.isInsideClassLikeNode())) {
             // TS/JS class fields parse as a methodTypes node; only function-valued
             // fields are methods — a plain field (`public fonts: Fonts;`) is a
-            // property (#808). classifyMethodNode is absent for other languages.
-            if (this.extractor.classifyMethodNode?.(node) === 'property') {
+            // property (#808). C++ lists `field_declaration` so pure-virtual methods
+            // mint nodes (#1727); non-callable ones return 'skip' and fall through to
+            // the children walk. classifyMethodNode is absent for other languages.
+            const methodClass = this.extractor.classifyMethodNode?.(node) ?? 'method';
+            if (methodClass === 'skip') {
+                // Not a method — leave skipChildren false so data-member initializers
+                // still contribute call/instantiation edges under the enclosing class.
+            }
+            else if (methodClass === 'property') {
                 const propNode = this.extractProperty(node);
                 // Walk the initializer so its calls/instantiations attribute to the
                 // property (`history = createHistory()` → history calls
@@ -1145,6 +1308,11 @@ class TreeSitterExtractor {
             this.extractStruct(node);
             skipChildren = true; // extractStruct visits body children
         }
+        // Check for union declarations
+        else if (this.extractor.unionTypes?.includes(nodeType)) {
+            this.extractUnion(node);
+            skipChildren = true; // extractUnion visits body children
+        }
         // Check for enum declarations
         else if (this.extractor.enumTypes.includes(nodeType)) {
             this.extractEnum(node);
@@ -1350,20 +1518,16 @@ class TreeSitterExtractor {
         else if (nodeType === 'impl_item') {
             this.extractRustImplItem(node);
         }
-        // TypeScript interface members: property_signature (`foo: T`, `foo?: T`)
-        // and method_signature (`foo(arg: A): R`) both carry type annotations the
-        // interface walker would otherwise drop. Extract them as `references`
-        // edges from the interface so resolvers can wire callers/impact for
-        // types that only appear in interface members.
-        else if ((nodeType === 'property_signature' || nodeType === 'method_signature') &&
-            this.isInsideClassLikeNode() &&
-            this.TYPE_ANNOTATION_LANGUAGES.has(this.language)) {
-            const parentId = this.nodeStack[this.nodeStack.length - 1];
-            if (parentId) {
-                this.extractTypeAnnotations(node, parentId);
-            }
-            // don't skipChildren — nested signatures still need traversal
-        }
+        // NOTE: `property_signature` / `method_signature` used to be handled here,
+        // hanging their type annotations off the ENCLOSING INTERFACE — the only
+        // anchor available while the members themselves went unextracted. Since
+        // #1638 they are in the TS extractor's `methodTypes` / `propertyTypes`, so
+        // the branches above claim them first (under the same `isInsideClassLikeNode`
+        // guard this branch had, so nothing it used to reach is now missed) and this
+        // one was dead. The `references` edges survive — `extractMethod` and
+        // `extractProperty` each call `extractTypeAnnotations` — but now hang off
+        // the member, which is the more precise anchor: `Api::fetch → PageId` says
+        // which member wants the type, where `Api → PageId` only said the file did.
         // Visit children (unless the extract method already visited them)
         if (!skipChildren) {
             for (let i = 0; i < node.namedChildCount; i++) {
@@ -1383,7 +1547,7 @@ class TreeSitterExtractor {
         if (!name) {
             return null;
         }
-        const id = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, kind, name, node.startPosition.row + 1);
+        const id = this.nodeIds.generate(this.filePath, kind, name, node.startPosition.row + 1, node.startPosition.column);
         // Some grammars (e.g. Dart) model a function/method body as a *sibling* of
         // the signature node, so the declaration node's own range is just the
         // signature line. Extend endLine to the resolved body when it sits beyond
@@ -1537,7 +1701,7 @@ class TreeSitterExtractor {
     }
     /**
      * Check if the current node stack indicates we are inside a class-like node
-     * (class, struct, interface, trait). File nodes do not count as class-like.
+     * (class, struct, union, interface, trait). File nodes do not count as class-like.
      */
     isInsideClassLikeNode() {
         if (this.nodeStack.length === 0)
@@ -1550,6 +1714,7 @@ class TreeSitterExtractor {
             return false;
         return (parentNode.kind === 'class' ||
             parentNode.kind === 'struct' ||
+            parentNode.kind === 'union' ||
             parentNode.kind === 'interface' ||
             parentNode.kind === 'trait' ||
             parentNode.kind === 'enum' ||
@@ -1584,13 +1749,15 @@ class TreeSitterExtractor {
         // — SvelteKit actions). Inline-object arrows reached by the general walker
         // get no override, so they still fall through to the <anonymous> skip below.
         let name = nameOverride ?? extractName(node, this.source, this.extractor);
+        // A CommonJS export assignment names the function it holds — see below.
+        let commonJsExport = false;
         // For arrow functions and function expressions assigned to variables,
         // resolve the name from the parent variable_declarator.
         // e.g. `export const useAuth = () => { ... }` — the arrow_function node
         // has no `name` field; the name lives on the variable_declarator.
         if (!nameOverride &&
             name === '<anonymous>' &&
-            (node.type === 'arrow_function' || node.type === 'function_expression')) {
+            (node.type === 'arrow_function' || node.type === 'function_expression' || node.type === 'generator_function')) {
             const parent = node.parent;
             if (parent?.type === 'variable_declarator') {
                 const varName = (0, tree_sitter_helpers_1.getChildByField)(parent, 'name');
@@ -1598,6 +1765,19 @@ class TreeSitterExtractor {
                     name = (0, tree_sitter_helpers_1.getNodeText)(varName, this.source);
                 }
             }
+            else if (parent?.type === 'assignment_expression') {
+                // `exports.getItems = async (req, res) => {…}` / `module.exports.x =
+                // function () {…}` — the CommonJS controller style. The function is
+                // anonymous only syntactically: the export property is the name every
+                // `router.get('/items', getItems)` resolves. Without a node the handler
+                // is invisible to callers/impact and its calls attribute to the file
+                // (#1675). Same treatment `const X = () => {}` already gets.
+                const exportName = this.commonJsExportName(parent, node);
+                if (exportName) {
+                    name = exportName;
+                    commonJsExport = true;
+                }
+            }
         }
         if (name === '<anonymous>') {
             // Don't emit a node for the anonymous wrapper itself, but still visit its
@@ -1622,10 +1802,10 @@ class TreeSitterExtractor {
             }
             return;
         }
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const signature = this.extractor.getSignature?.(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
-        const isExported = this.extractor.isExported?.(node, this.source);
+        const isExported = commonJsExport || this.extractor.isExported?.(node, this.source);
         const isAsync = this.extractor.isAsync?.(node);
         const isStatic = this.extractor.isStatic?.(node);
         const returnType = this.extractor.getReturnType?.(node, this.source);
@@ -1735,7 +1915,7 @@ class TreeSitterExtractor {
         if (this.extractor.skipBodilessClass && !resolvedBody)
             return;
         const name = extractName(node, this.source, this.extractor);
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const visibility = this.extractor.getVisibility?.(node);
         const isExported = this.extractor.isExported?.(node, this.source);
         const classNode = this.createNode(kind, name, node, {
@@ -1807,11 +1987,14 @@ class TreeSitterExtractor {
             }
             return;
         }
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const signature = this.extractor.getSignature?.(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
         const isAsync = this.extractor.isAsync?.(node);
         const isStatic = this.extractor.isStatic?.(node);
+        // Only persist abstract when true — a false return must not mint `isAbstract: false`
+        // on every ordinary method (breaks kernel↔wasm parity JSON equality).
+        const isAbstract = this.extractor.isAbstract?.(node) ? true : undefined;
         const returnType = this.extractor.getReturnType?.(node, this.source);
         const extraProps = {
             docstring,
@@ -1819,6 +2002,7 @@ class TreeSitterExtractor {
             visibility,
             isAsync,
             isStatic,
+            isAbstract,
             returnType,
         };
         if (receiverType) {
@@ -1832,7 +2016,7 @@ class TreeSitterExtractor {
         if (receiverType && !this.isInsideClassLikeNode()) {
             const ownerNode = this.nodes.find((n) => n.name === receiverType &&
                 n.filePath === this.filePath &&
-                (n.kind === 'struct' || n.kind === 'class' || n.kind === 'enum' || n.kind === 'trait'));
+                (n.kind === 'struct' || n.kind === 'union' || n.kind === 'class' || n.kind === 'enum' || n.kind === 'trait'));
             if (ownerNode) {
                 this.edges.push({
                     source: ownerNode.id,
@@ -1861,7 +2045,7 @@ class TreeSitterExtractor {
         if (!this.extractor)
             return;
         const name = extractName(node, this.source, this.extractor);
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const isExported = this.extractor.isExported?.(node, this.source);
         const kind = this.extractor.interfaceKind ?? 'interface';
         const interfaceNode = this.createNode(kind, name, node, {
@@ -1890,38 +2074,53 @@ class TreeSitterExtractor {
      * Extract a struct
      */
     extractStruct(node) {
+        this.extractAggregate(node, 'struct');
+    }
+    /** Extract a union while sharing the member-walk behavior of aggregate types. */
+    extractUnion(node) {
+        this.extractAggregate(node, 'union');
+    }
+    /** Extract a struct-like declaration without conflating its semantic kind. */
+    extractAggregate(node, kind) {
         if (!this.extractor)
             return;
         // Skip forward declarations and type references (no body = not a definition)
         // — EXCEPT C# positional records (`record struct M(decimal Amount);`),
         // complete definitions with no body block. (#831)
+        //
+        // `allowBodilessStruct` is the per-language escape hatch for the same
+        // situation: a bodiless struct that IS a complete definition (Rust's unit
+        // struct `struct Unit;`). Opposite polarity from `skipBodilessClass`
+        // (#1093) because the two defaults differ — a bodiless CLASS is kept
+        // unless a language opts into skipping, a bodiless STRUCT is skipped
+        // unless a language opts into keeping.
         const body = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
-        if (!body && node.type !== 'record_declaration')
+        if (!body && node.type !== 'record_declaration' && !this.extractor.allowBodilessStruct)
             return;
         const name = extractName(node, this.source, this.extractor);
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const visibility = this.extractor.getVisibility?.(node);
         const isExported = this.extractor.isExported?.(node, this.source);
-        const structNode = this.createNode('struct', name, node, {
+        const aggregateNode = this.createNode(kind, name, node, {
             docstring,
             visibility,
             isExported,
         });
-        if (!structNode)
+        if (!aggregateNode)
             return;
         // Rust `#[derive]`/attributes precede the struct as siblings — without this
         // the widened extent (v11) never covers them and a cut struct silently
         // loses its derives.
-        this.extractDecoratorsFor(node, structNode.id);
+        this.extractDecoratorsFor(node, aggregateNode.id);
         // Extract inheritance (e.g. Swift: struct HTTPMethod: RawRepresentable)
-        this.extractInheritance(node, structNode.id);
+        this.extractInheritance(node, aggregateNode.id);
         // C# primary-constructor parameter dependencies (`struct P(int x)`, and
         // `record struct M(decimal Amount)` which the grammar nests here).
-        this.extractCsharpPrimaryCtorParamRefs(node, structNode.id);
+        this.extractCsharpPrimaryCtorParamRefs(node, aggregateNode.id);
         // Push to stack for field extraction (bodiless positional records have
         // no members to visit)
         if (body) {
-            this.nodeStack.push(structNode.id);
+            this.nodeStack.push(aggregateNode.id);
             for (let i = 0; i < body.namedChildCount; i++) {
                 const child = body.namedChild(i);
                 if (child) {
@@ -1943,7 +2142,7 @@ class TreeSitterExtractor {
         if (!body)
             return;
         const name = extractName(node, this.source, this.extractor);
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const visibility = this.extractor.getVisibility?.(node);
         const isExported = this.extractor.isExported?.(node, this.source);
         const enumNode = this.createNode('enum', name, node, {
@@ -2003,7 +2202,7 @@ class TreeSitterExtractor {
     extractProperty(node) {
         if (!this.extractor)
             return null;
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const visibility = this.extractor.getVisibility?.(node);
         const isStatic = this.extractor.isStatic?.(node) ?? false;
         const hookName = this.extractor.extractPropertyName?.(node, this.source);
@@ -2022,7 +2221,17 @@ class TreeSitterExtractor {
         // and the initializer VALUE, which the generic finder below would
         // wrongly pick — so fields use the type field only (#808). Other
         // languages (C# property_declaration) keep the generic scan.
-        const isTsJsField = node.type === 'public_field_definition' || node.type === 'field_definition';
+        //
+        // A `property_signature` (an interface member, #1638) carries a `type`
+        // field and no value, so it reads the type field too. It cannot take the
+        // generic scan: that scan's exclusion list covers `identifier` but not the
+        // `property_identifier` an interface member is named with, so it stops on
+        // the name and `interface Stats { counts: Record<string, number> }` yields
+        // `signature: "counts counts"` instead of the type. Named explicitly
+        // rather than folded into the field test so no other language's
+        // `property_declaration` moves off the generic scan.
+        const isTsJsField = node.type === 'public_field_definition' || node.type === 'field_definition'
+            || node.type === 'property_signature';
         const typeNode = isTsJsField
             ? (0, tree_sitter_helpers_1.getChildByField)(node, 'type')
             : node.namedChildren.find(c => c.type !== 'modifier' && c.type !== 'modifiers'
@@ -2056,7 +2265,7 @@ class TreeSitterExtractor {
     extractField(node) {
         if (!this.extractor)
             return;
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const visibility = this.extractor.getVisibility?.(node);
         const isStatic = this.extractor.isStatic?.(node) ?? false;
         // A class field that is actually a CONSTANT (Java `static final`, C# `const`
@@ -2136,6 +2345,21 @@ class TreeSitterExtractor {
                     // and the language-aware path in `extractTypeAnnotations` descends
                     // into that wrapper (#381).
                     this.extractTypeAnnotations(node, fieldNode.id);
+                    // Walk the initializer ATTRIBUTED to the declared field (#693, the
+                    // Go fix; same shape as the TS/JS class-field walk above). The
+                    // dispatcher only scanned this subtree for function-as-value
+                    // candidates, so a lambda / method reference / anonymous class in
+                    // `private final Runnable r = () -> target();` contributed NO call
+                    // edge at all and `target` looked callerless. Keyed on the `value`
+                    // FIELD, which only Java's `variable_declarator` carries — C#,
+                    // VB.NET and PHP spell their initializer differently and are
+                    // deliberately untouched here.
+                    const valueNode = (0, tree_sitter_helpers_1.getChildByField)(decl, 'value');
+                    if (valueNode) {
+                        this.nodeStack.push(fieldNode.id);
+                        this.visitFunctionBody(valueNode, fieldNode.id);
+                        this.nodeStack.pop();
+                    }
                 }
             }
         }
@@ -2171,6 +2395,13 @@ class TreeSitterExtractor {
                 if (key && value && (value.type === 'arrow_function' || value.type === 'function_expression')) {
                     this.extractFunction(value, this.objectKeyName(key));
                 }
+                else if (value?.type === 'call_expression') {
+                    // `key: Effect.fn("…")(function* () {…})` — see curriedWrapperBoundName.
+                    const fn = (0, tree_sitter_helpers_1.getChildByField)(value, 'arguments')?.namedChild(0);
+                    const bound = fn ? this.curriedWrapperBoundName(fn) : null;
+                    if (fn && bound)
+                        this.extractFunction(fn, bound);
+                }
             }
             else if (member.type === 'method_definition') {
                 // Method shorthand: `{ fetchUser() {...} }`. extractMethod deliberately
@@ -2183,6 +2414,21 @@ class TreeSitterExtractor {
             }
         }
     }
+    /**
+     * A top-level binding exported by a LATER statement rather than at its
+     * declaration: `export default NAME`, `export { NAME }`, `export { NAME as
+     * default }`. The declaration's own `isExported` (an `export_statement`
+     * ancestor) cannot see these, so a store written as `const useStore =
+     * create(…)` + `export default useStore` read as unexported and its actions
+     * were never extracted. One anchored regex over the file source; JS-family
+     * callers only.
+     */
+    isExportedLater(name) {
+        if (!/^[A-Za-z_$][\w$]*$/.test(name))
+            return false;
+        const re = new RegExp(`^[ \\t]*export\\s+(?:default\\s+${name}\\s*;?[ \\t]*$|\\{[^}]*\\b${name}\\b[^}]*\\})`, 'm');
+        return re.test(this.source);
+    }
     /** Property-key text with surrounding quotes stripped (`'foo'` → `foo`). */
     objectKeyName(key) {
         return (0, tree_sitter_helpers_1.getNodeText)(key, this.source).replace(/^['"`]|['"`]$/g, '');
@@ -2587,7 +2833,7 @@ class TreeSitterExtractor {
         // Go: var_declaration, short_var_declaration, const_declaration
         const isConst = this.extractor.isConst?.(node) ?? false;
         const kind = isConst ? 'constant' : 'variable';
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const isExported = this.extractor.isExported?.(node, this.source) ?? false;
         // Extract variable declarators based on language
         if (this.language === 'typescript' || this.language === 'javascript' ||
@@ -2615,7 +2861,7 @@ class TreeSitterExtractor {
                         }
                         const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                         // Arrow functions / function expressions: extract as function instead of variable
-                        if (valueNode && (valueNode.type === 'arrow_function' || valueNode.type === 'function_expression')) {
+                        if (valueNode && (valueNode.type === 'arrow_function' || valueNode.type === 'function_expression' || valueNode.type === 'generator_function')) {
                             this.extractFunction(valueNode);
                             continue;
                         }
@@ -2665,7 +2911,10 @@ class TreeSitterExtractor {
                         //     never nodes — so `node`/`callers` on `fetchUser` return "not
                         //     found" and the agent Reads the store to reconstruct the flow.
                         // Scoped to EXPORTED consts to exclude inline-object noise
-                        // (`ctx.set({...})`) the object-method skip deliberately avoids.
+                        // (`ctx.set({...})`) the object-method skip deliberately avoids —
+                        // where "exported" includes the two-statement form `const useStore
+                        // = create(…)` … `export default useStore` (see isExportedLater),
+                        // the shape most React Native stores are written in.
                         const objectOfFns = valueNode && (valueNode.type === 'object' || valueNode.type === 'object_expression')
                             ? valueNode
                             : valueNode?.type === 'call_expression'
@@ -2677,7 +2926,7 @@ class TreeSitterExtractor {
                         // whose functions are body-local consts — it must fall through to a
                         // normal body walk (extracting those consts), not be skipped here.
                         const hasInlineFns = !!objectOfFns && this.objectHasInlineFunctions(objectOfFns);
-                        const extractObjectMethods = isExported && !!objectOfFns && hasInlineFns;
+                        const extractObjectMethods = (isExported || this.isExportedLater(name)) && !!objectOfFns && hasInlineFns;
                         // RTK Query: `createApi`/`injectEndpoints` define endpoints as
                         // object-literal properties whose values are `build.query/mutation(...)`
                         // calls — nested under an `endpoints` arrow, so neither the
@@ -2704,19 +2953,25 @@ class TreeSitterExtractor {
                             VUE_STORE_COLLECTION_NAMES.has(name) && this.looksLikeVueStoreFile()) {
                             storeCollections.push(objectOfFns);
                         }
-                        // Visit the initializer body for calls — EXCEPT object literals (their
-                        // function-valued properties are extracted below) and the store-factory
-                        // / createApi / store-collection call whose nested objects we extract
-                        // method-by-method below (walking the whole call would re-visit those
-                        // method arrows and mis-attribute their inner calls to the file scope).
-                        if (valueNode &&
-                            valueNode.type !== 'object' &&
-                            valueNode.type !== 'object_expression' &&
-                            !(extractObjectMethods && valueNode.type === 'call_expression') &&
-                            !rtkEndpoints &&
-                            !piniaSetup &&
-                            storeCollections.length === 0) {
+                        // Visit the initializer body for calls, ATTRIBUTED to the declared
+                        // symbol (#693) — EXCEPT the shapes whose members are extracted
+                        // one-by-one below (the store-factory / createApi / store-collection
+                        // objects), where walking the whole initializer would re-visit each
+                        // member arrow and double-count its calls.
+                        //
+                        // Two things were wrong here before. The walk ran with only the FILE
+                        // on the stack, so `const cfg = load()` recorded the FILE as load's
+                        // caller — the exact leak Go's #693 fixed. And an object literal was
+                        // skipped outright, so `const obj = { handler: () => target() }`
+                        // contributed nothing at all unless the const was exported (only then
+                        // does extractObjectLiteralFunctions mint the members).
+                        const membersExtractedSeparately = extractObjectMethods || !!rtkEndpoints || !!piniaSetup || storeCollections.length > 0;
+                        if (valueNode && !membersExtractedSeparately) {
+                            if (varNode)
+                                this.nodeStack.push(varNode.id);
                             this.visitFunctionBody(valueNode, '');
+                            if (varNode)
+                                this.nodeStack.pop();
                         }
                         if (extractObjectMethods && objectOfFns) {
                             this.extractObjectLiteralFunctions(objectOfFns);
@@ -2740,17 +2995,32 @@ class TreeSitterExtractor {
             const right = (0, tree_sitter_helpers_1.getChildByField)(node, 'right') || node.namedChild(1);
             // Ruby constant assignments (`MAX = 3`) have a `constant`-typed LHS, not
             // `identifier`; without this they were never extracted as symbols at all.
+            let assigned = null;
             if (left && (left.type === 'identifier' || left.type === 'constant')) {
                 const name = (0, tree_sitter_helpers_1.getNodeText)(left, this.source);
                 // Skip if name starts with lowercase and looks like a function call result
                 // Python constants are usually UPPER_CASE
                 const initValue = right ? (0, tree_sitter_helpers_1.getNodeText)(right, this.source).slice(0, 100) : undefined;
                 const initSignature = initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined;
-                this.createNode(kind, name, node, {
+                assigned = this.createNode(kind, name, node, {
                     docstring,
                     signature: initSignature,
                 });
             }
+            // Walk the initializer ATTRIBUTED to the assigned name (#693). A
+            // module-level `app = FastAPI()` / `ENGINE = create_engine(url)` /
+            // `handler = lambda: run()` dropped every call on the right-hand side, so
+            // whatever the module builds at import time linked to nothing. A tuple
+            // target (`a, b = f(), g()`) mints no symbol, so its RHS is walked at the
+            // enclosing scope rather than lost. Python only: Ruby shares this branch
+            // and gets its own turn.
+            if (this.language === 'python' && right) {
+                if (assigned)
+                    this.nodeStack.push(assigned.id);
+                this.visitFunctionBody(right, '');
+                if (assigned)
+                    this.nodeStack.pop();
+            }
         }
         else if (this.language === 'go') {
             // Go: var_declaration, short_var_declaration, const_declaration
@@ -2816,15 +3086,26 @@ class TreeSitterExtractor {
             const varList = assign.namedChildren.find((c) => c.type === 'variable_list');
             const exprList = assign.namedChildren.find((c) => c.type === 'expression_list');
             const values = exprList ? exprList.namedChildren : [];
-            const names = varList ? varList.namedChildren.filter((c) => c.type === 'identifier') : [];
-            names.forEach((nameNode, i) => {
-                const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
-                if (!name)
-                    return;
+            const targets = varList ? varList.namedChildren : [];
+            targets.forEach((nameNode, i) => {
                 const valueNode = values[i];
+                const target = this.luaAssignmentTarget(nameNode);
+                if (!target)
+                    return;
+                if (valueNode?.type === 'function_definition') {
+                    this.extractLuaFunctionValue(valueNode, target.name, target.receiver, docstring);
+                    return;
+                }
+                if (valueNode?.type === 'table_constructor') {
+                    this.extractLuaTableFunctions(valueNode, target.fullName);
+                }
+                // A dotted assignment updates a table member; it is not a standalone
+                // variable node. Function-valued members were handled above.
+                if (target.receiver || node.type === 'assignment_statement')
+                    return;
                 const initValue = valueNode ? (0, tree_sitter_helpers_1.getNodeText)(valueNode, this.source).slice(0, 100) : undefined;
                 const initSignature = initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined;
-                this.createNode(kind, name, nameNode, { docstring, signature: initSignature, isExported });
+                this.createNode(kind, target.name, nameNode, { docstring, signature: initSignature, isExported });
             });
         }
         else if (this.language === 'c') {
@@ -2889,6 +3170,8 @@ class TreeSitterExtractor {
         else {
             // Generic fallback for other languages
             // Try to find identifier children
+            const nameField = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
+            let declared = null;
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
                 if (child?.type === 'identifier' || child?.type === 'variable_declarator') {
@@ -2896,13 +3179,103 @@ class TreeSitterExtractor {
                         ? (0, tree_sitter_helpers_1.getNodeText)(child, this.source)
                         : extractName(child, this.source, this.extractor);
                     if (name && name !== '<anonymous>') {
-                        this.createNode(kind, name, child, {
+                        const created = this.createNode(kind, name, child, {
                             docstring,
                             isExported,
                         });
+                        if (created && nameField && child.startIndex === nameField.startIndex) {
+                            declared = created;
+                        }
                     }
                 }
             }
+            // Walk the initializer ATTRIBUTED to the declared symbol (#693). Rust
+            // only for now: `const N: usize = compute()` and
+            // `static REGISTRY: Lazy<T> = Lazy::new(|| build())` dropped every call
+            // inside the initializer, so a handler table or a lazily-built singleton
+            // linked to nothing. The other languages sharing this fallback spell
+            // their initializer differently and get their own turn.
+            if (this.language === 'rust') {
+                const valueNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'value');
+                if (valueNode) {
+                    if (declared)
+                        this.nodeStack.push(declared.id);
+                    this.visitFunctionBody(valueNode, '');
+                    if (declared)
+                        this.nodeStack.pop();
+                }
+            }
+        }
+    }
+    /** Resolve a Lua assignment target into its callable name and optional table receiver. */
+    luaAssignmentTarget(node) {
+        if (node.type === 'identifier') {
+            const name = (0, tree_sitter_helpers_1.getNodeText)(node, this.source).trim();
+            return name ? { name, fullName: name } : null;
+        }
+        if (node.type !== 'dot_index_expression' &&
+            node.type !== 'method_index_expression' &&
+            node.type !== 'bracket_index_expression')
+            return null;
+        const table = (0, tree_sitter_helpers_1.getChildByField)(node, 'table');
+        const field = (0, tree_sitter_helpers_1.getChildByField)(node, 'field') ?? (0, tree_sitter_helpers_1.getChildByField)(node, 'method');
+        if (!table || !field)
+            return null;
+        const receiver = (0, tree_sitter_helpers_1.getNodeText)(table, this.source).trim();
+        const name = this.luaStaticFieldName(field, node.type === 'bracket_index_expression');
+        if (!receiver || !name)
+            return null;
+        return { name, receiver, fullName: `${receiver}.${name}` };
+    }
+    /** A statically-known Lua field name; dynamic bracket keys are not callable identities. */
+    luaStaticFieldName(node, bracketed) {
+        if (node.type === 'identifier') {
+            return bracketed ? '' : (0, tree_sitter_helpers_1.getNodeText)(node, this.source).trim();
+        }
+        if (node.type === 'string') {
+            const content = node.namedChildren.find((child) => child.type === 'string_content');
+            return content ? (0, tree_sitter_helpers_1.getNodeText)(content, this.source).trim() : '';
+        }
+        return '';
+    }
+    /** Extract an anonymous Lua function using the name supplied by its assignment target. */
+    extractLuaFunctionValue(node, name, receiver, docstring) {
+        if (!this.extractor)
+            return;
+        const signature = this.extractor.getSignature?.(node, this.source);
+        const extra = { docstring, signature };
+        if (receiver)
+            extra.qualifiedName = this.composeReceiverQualifiedName(receiver, name);
+        else
+            extra.isExported = this.extractor.isExported?.(node, this.source);
+        const functionNode = this.createNode(receiver ? 'method' : 'function', name, node, extra);
+        if (!functionNode)
+            return;
+        this.nodeStack.push(functionNode.id);
+        const body = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+        if (body)
+            this.visitFunctionBody(body, functionNode.id);
+        this.nodeStack.pop();
+    }
+    /** Extract function-valued keyed fields from a Lua table, including nested tables. */
+    extractLuaTableFunctions(table, receiver) {
+        for (const field of table.namedChildren) {
+            if (field.type !== 'field')
+                continue;
+            const nameNode = (0, tree_sitter_helpers_1.getChildByField)(field, 'name');
+            const valueNode = (0, tree_sitter_helpers_1.getChildByField)(field, 'value');
+            if (!nameNode || !valueNode)
+                continue;
+            const bracketed = (0, tree_sitter_helpers_1.getNodeText)(field, this.source).trimStart().startsWith('[');
+            const name = this.luaStaticFieldName(nameNode, bracketed);
+            if (!name)
+                continue;
+            if (valueNode.type === 'function_definition') {
+                this.extractLuaFunctionValue(valueNode, name, receiver);
+            }
+            else if (valueNode.type === 'table_constructor') {
+                this.extractLuaTableFunctions(valueNode, `${receiver}.${name}`);
+            }
         }
     }
     /**
@@ -2917,23 +3290,23 @@ class TreeSitterExtractor {
         const name = extractName(node, this.source, this.extractor);
         if (name === '<anonymous>')
             return false;
-        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const docstring = this.docstringFor(node);
         const isExported = this.extractor.isExported?.(node, this.source);
         // Check if this type alias is actually a struct or interface definition
         // (e.g. Go: `type Foo struct { ... }` is a type_spec wrapping struct_type)
         const resolvedKind = this.extractor.resolveTypeAliasKind?.(node, this.source);
-        if (resolvedKind === 'struct') {
-            const structNode = this.createNode('struct', name, node, { docstring, isExported });
-            if (!structNode)
+        if (resolvedKind === 'struct' || resolvedKind === 'union') {
+            const aggregateNode = this.createNode(resolvedKind, name, node, { docstring, isExported });
+            if (!aggregateNode)
                 return true;
             // Visit body children for field extraction
-            this.nodeStack.push(structNode.id);
-            // Try Go-style 'type' field first, then find inner struct child (C typedef struct)
+            this.nodeStack.push(aggregateNode.id);
+            // Try Go-style 'type' field first, then find the matching inner aggregate child.
             const typeChild = (0, tree_sitter_helpers_1.getChildByField)(node, 'type')
-                || this.findChildByTypes(node, this.extractor.structTypes);
+                || this.findChildByTypes(node, resolvedKind === 'union' ? (this.extractor.unionTypes ?? []) : this.extractor.structTypes);
             if (typeChild) {
                 // Extract struct embedding (e.g. Go: `type DB struct { *Head; Queryable }`)
-                this.extractInheritance(typeChild, structNode.id);
+                this.extractInheritance(typeChild, aggregateNode.id);
                 const body = (0, tree_sitter_helpers_1.getChildByField)(typeChild, this.extractor.bodyField) || typeChild;
                 for (let i = 0; i < body.namedChildCount; i++) {
                     const child = body.namedChild(i);
@@ -3081,7 +3454,7 @@ class TreeSitterExtractor {
                 const memberKind = child.type === 'method_signature'
                     ? 'method'
                     : this.isTsFunctionTypedProperty(child) ? 'method' : 'property';
-                const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(child, this.source);
+                const docstring = this.docstringFor(child);
                 const signature = (0, tree_sitter_helpers_1.getNodeText)(child, this.source);
                 this.createNode(memberKind, memberName, child, {
                     docstring,
@@ -3935,15 +4308,18 @@ class TreeSitterExtractor {
         }
         // Erlang: a local call is `call(expr: atom, args)`; a remote call nests it
         // under `remote(module: remote_module, fun: call)` — the module qualifier
-        // lives on the PARENT. Remote calls are emitted as `mod::fn`, which is
-        // byte-identical to the qualifiedName the module namespace gives every
-        // function (see packageTypes in languages/erlang.ts), so they resolve via
-        // matchByQualifiedName. A var/macro callee or module (`F(X)`, `?M(X)`,
-        // `Mod:handle(X)`) has no static target — except `?MODULE:fn(X)`, which the
-        // bare name + same-file preference resolves correctly. `fun name/1` /
-        // `fun mod:name/1` values are function REFERENCES (callback registration),
-        // and record construction/update/index/field-access are `references` to the
-        // record's struct node.
+        // lives on the PARENT. Arity is part of a function's identity (#1610), so
+        // refs carry the call-site arity: remote calls are emitted as `mod::fn/2`,
+        // byte-identical to the qualifiedName the module namespace + arity suffix
+        // gives every function (see languages/erlang.ts), so they resolve via
+        // matchByQualifiedName; local calls are emitted `fn/2` and resolved by the
+        // erlang arity step in matchReference (same-file first). A var/macro callee
+        // or module (`F(X)`, `?M(X)`, `Mod:handle(X)`) has no static target —
+        // except `?MODULE:fn(X)`, which the bare-name-with-arity + same-file
+        // preference resolves correctly. `fun name/1` / `fun mod:name/1` values
+        // are function REFERENCES (callback registration) carrying their own
+        // written arity, and record construction/update/index/field-access are
+        // `references` to the record's struct node.
         if (this.language === 'erlang') {
             const line = node.startPosition.row + 1;
             const column = node.startPosition.column;
@@ -3977,9 +4353,13 @@ class TreeSitterExtractor {
                         if (!macroName || (0, tree_sitter_helpers_1.getNodeText)(macroName, this.source) !== 'MODULE')
                             return;
                     }
+                    // Arity from the call site's own argument list — part of the callee's
+                    // identity, and what disambiguates `f/1` from `f/2` (#1610).
+                    const callArgsNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'args');
+                    const callArity = callArgsNode ? callArgsNode.namedChildCount : 0;
                     this.unresolvedReferences.push({
                         fromNodeId: callerId,
-                        referenceName: calleeName,
+                        referenceName: `${calleeName}/${callArity}`,
                         referenceKind: 'calls',
                         line,
                         column,
@@ -4000,9 +4380,10 @@ class TreeSitterExtractor {
                         const target = argsNode?.namedChild(0) ?? null;
                         const targetModule = target ? this.resolveErlangGenServerTarget(target) : null;
                         if (targetModule) {
+                            // OTP fixes the handler arities: handle_call/3, handle_cast/2.
                             this.unresolvedReferences.push({
                                 fromNodeId: callerId,
-                                referenceName: `${targetModule}::${fnBare === 'cast' ? 'handle_cast' : 'handle_call'}`,
+                                referenceName: `${targetModule}::${fnBare === 'cast' ? 'handle_cast/2' : 'handle_call/3'}`,
                                 referenceKind: 'calls',
                                 line,
                                 column,
@@ -4034,9 +4415,17 @@ class TreeSitterExtractor {
                                 (0, tree_sitter_helpers_1.getNodeText)((0, tree_sitter_helpers_1.getChildByField)(m, 'name'), this.source) === 'MODULE';
                             if (m.type !== 'atom' && !isLocalModule)
                                 continue;
+                            // Arity of the spawned/applied function = the length of the
+                            // static args-list literal directly after the (M, F) pair, when
+                            // present (`spawn_link(?MODULE, request_process, [Req, Env])` →
+                            // /2). A var/absent list leaves the ref arity-less; the
+                            // qualified matcher then resolves it only when the module
+                            // defines exactly one arity of that name.
+                            const mfaList = argExprs[i + 2];
+                            const arityTail = mfaList?.type === 'list' ? `/${mfaList.namedChildCount}` : '';
                             this.unresolvedReferences.push({
                                 fromNodeId: callerId,
-                                referenceName: isLocalModule ? erlAtom(f) : `${erlAtom(m)}::${erlAtom(f)}`,
+                                referenceName: (isLocalModule ? erlAtom(f) : `${erlAtom(m)}::${erlAtom(f)}`) + arityTail,
                                 referenceKind: 'calls',
                                 line: f.startPosition.row + 1,
                                 column: f.startPosition.column,
@@ -4059,6 +4448,12 @@ class TreeSitterExtractor {
                         return;
                     refName = `${erlAtom(moduleAtom)}::${refName}`;
                 }
+                // `fun f/1` writes its arity — carry it so the ref lands on the
+                // matching arity's node (#1610).
+                const funArityNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'arity');
+                const funArityValue = funArityNode ? (0, tree_sitter_helpers_1.getChildByField)(funArityNode, 'value') : null;
+                if (funArityValue)
+                    refName = `${refName}/${(0, tree_sitter_helpers_1.getNodeText)(funArityValue, this.source)}`;
                 this.unresolvedReferences.push({
                     fromNodeId: callerId,
                     referenceName: refName,
@@ -4603,10 +4998,17 @@ class TreeSitterExtractor {
                         // This helps the resolver distinguish method calls from bare function calls
                         // (e.g., Python's console.print() vs builtin print())
                         // Skip self/this/cls as they don't aid resolution
-                        const receiver = (0, tree_sitter_helpers_1.getChildByField)(func, 'object') ||
+                        const rawReceiver = (0, tree_sitter_helpers_1.getChildByField)(func, 'object') ||
                             (0, tree_sitter_helpers_1.getChildByField)(func, 'operand') ||
                             (0, tree_sitter_helpers_1.getChildByField)(func, 'argument') ||
                             func.namedChild(0);
+                        // TS/JS: look through wrappers that keep the receiver the same
+                        // object (`(x).m()`, `x!.m()`, `(x as T).m()`, `(await f()).m()`),
+                        // so the branches below see the identifier / call / chain the
+                        // call is really made on.
+                        const receiver = rawReceiver && TS_JS_CHAIN_LANGUAGES.has(this.language)
+                            ? peelTsJsReceiver(rawReceiver)
+                            : rawReceiver;
                         // A LITERAL receiver — `", ".join(...)`, `"x".toUpperCase()`,
                         // `5.times`, `[].concat(...)` — calls a builtin of the literal's
                         // type, never a project symbol. The bare-name fallback below let
@@ -4627,6 +5029,37 @@ class TreeSitterExtractor {
                                 calleeName = methodName;
                             }
                         }
+                        else if (this.language === 'rust' && receiver && receiver.type === 'self') {
+                            // Rust `self.method()`. Keep the `self.` prefix, exactly as the
+                            // field shape below does (#1585): the resolver reads the owner
+                            // off the CALLING method's qualified name and resolves the
+                            // method on that type. Collapsing to the bare method name handed
+                            // the resolver a name with no owner, which it then matched among
+                            // all same-named methods by file proximity — so `self.reset()`
+                            // inside `impl Target` landed on a `Decoy::reset` that happened
+                            // to sit nearer, with nothing in the edge to show it was a guess
+                            // (#1861). Mirrored in the kernel's extract_call (rustlang.rs).
+                            calleeName = `self.${methodName}`;
+                        }
+                        else if (this.language === 'rust' &&
+                            receiver &&
+                            receiver.type === 'field_expression' &&
+                            (0, tree_sitter_helpers_1.getChildByField)(receiver, 'value')?.type === 'self' &&
+                            (0, tree_sitter_helpers_1.getChildByField)(receiver, 'field')?.type === 'field_identifier') {
+                            // Rust `self.<field>.<method>()` — a call through a field of the
+                            // enclosing type (#1585). Keep the `self.` prefix: the resolver
+                            // recognizes the shape, reads the field's declared type off the
+                            // owner struct's declaration, and resolves the method on THAT
+                            // type — or leaves the ref unresolved when the type is external
+                            // or unknown. Previously this collapsed to the bare method name,
+                            // which exact-matched whichever same-named method was nearest —
+                            // often the calling method itself, a self-edge not in the source.
+                            // Deeper chains (`self.a.b.m()`), `self.f().m()` and parenthesized
+                            // receivers keep the bare name. Mirrored in the kernel's
+                            // extract_call (rustlang.rs).
+                            const fieldName = (0, tree_sitter_helpers_1.getNodeText)((0, tree_sitter_helpers_1.getChildByField)(receiver, 'field'), this.source);
+                            calleeName = `self.${fieldName}.${methodName}`;
+                        }
                         else if ((this.language === 'cpp' ||
                             this.language === 'c' ||
                             this.language === 'kotlin' ||
@@ -4702,6 +5135,56 @@ class TreeSitterExtractor {
                             // name, which either failed to resolve or resolved ambiguously.
                             calleeName = `${(0, tree_sitter_helpers_1.getNodeText)(receiver, this.source)}.${methodName}`;
                         }
+                        else if ((this.language === 'typescript' ||
+                            this.language === 'javascript' ||
+                            this.language === 'tsx' ||
+                            this.language === 'jsx') &&
+                            receiver &&
+                            receiver.type === 'member_expression' &&
+                            (0, tree_sitter_helpers_1.getChildByField)(receiver, 'object')?.type === 'this' &&
+                            THIS_FIELD_PROPERTY_TYPES.has((0, tree_sitter_helpers_1.getChildByField)(receiver, 'property')?.type ?? '')) {
+                            // TS/JS call through a field of the enclosing class —
+                            // `this.mailer.send()` (#1496). Keep the `this.<field>` prefix:
+                            // the resolver reads the field's declared type off the class's
+                            // own declaration (`private mailer: Mailer`, `mailer = new
+                            // Mailer()`) and resolves the method on THAT type — or leaves the
+                            // ref unresolved when the type is external or unknown. Previously
+                            // this collapsed to the bare method name, which exact-matched
+                            // whichever same-named method was nearest — the calling method
+                            // itself when the two share a name, a self-edge not in the
+                            // source. Same discipline as Rust's `self.<field>` (#1585).
+                            // Mirrored in the kernel's extract_call (tsjs/extractors.rs).
+                            // An ES private field (`this.#items.add()`) is the same shape;
+                            // its name keeps the `#` (#1987).
+                            const fieldName = (0, tree_sitter_helpers_1.getNodeText)((0, tree_sitter_helpers_1.getChildByField)(receiver, 'property'), this.source);
+                            calleeName = `this.${fieldName}.${methodName}`;
+                        }
+                        else if ((this.language === 'typescript' ||
+                            this.language === 'javascript' ||
+                            this.language === 'tsx' ||
+                            this.language === 'jsx' ||
+                            this.language === 'python') &&
+                            receiver &&
+                            (receiver.type === 'call_expression' || receiver.type === 'call')) {
+                            // Receiver that is itself a call — `d.setdefault(k, []).append(v)`,
+                            // `make().run()`, `res.json().data` (#1683). The bare method name
+                            // this used to emit exact-matched any top-level project symbol of
+                            // that name and fabricated a call edge from an unrelated function
+                            // (`append`, `get`, `run`…). Keep the inner callee, encoded as
+                            // `<inner>().<method>` like the Java/Kotlin/C++ chains: the
+                            // marker never appears in an ordinary ref, so nothing name-matches
+                            // it, and a chain resolver can later infer the receiver's type
+                            // from what the inner call returns. An inner callee that is not a
+                            // plain name or member chain (`(await x)()`, `arr[0]()`) has no
+                            // static receiver at all — emit nothing: a silent miss, never a
+                            // wrong edge. The inner call is visited on its own either way.
+                            // Mirrored in the kernel (tsjs/extractors.rs, python.rs).
+                            const innerFn = (0, tree_sitter_helpers_1.getChildByField)(receiver, 'function');
+                            const innerCallee = innerFn ? (0, tree_sitter_helpers_1.getNodeText)(innerFn, this.source).replace(/\s+/g, '') : '';
+                            if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(innerCallee))
+                                return;
+                            calleeName = `${innerCallee}().${methodName}`;
+                        }
                         else if (this.language === 'go' &&
                             receiver &&
                             receiver.type === 'selector_expression' &&
@@ -4716,6 +5199,30 @@ class TreeSitterExtractor {
                             // inference (see matchGoFieldChainCall) or stay unresolved.
                             calleeName = `${(0, tree_sitter_helpers_1.getNodeText)(receiver, this.source).replace(/\s+/g, '')}.${methodName}`;
                         }
+                        else if (TS_JS_CHAIN_LANGUAGES.has(this.language) &&
+                            receiver &&
+                            TS_JS_CHAIN_RECEIVER_TYPES.has(receiver.type) &&
+                            isUnresolvedTsJsChain(receiver, this.source)) {
+                            // Keep the source call for effect reporting, but never collapse
+                            // it to a guessed method. The resolver only lets frameworks
+                            // with receiver evidence handle these qualified chains.
+                            const chain = (0, tree_sitter_helpers_1.getNodeText)(func, this.source).replace(/\s+/g, '').replace(/\?\./g, '.');
+                            if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*){2,}$/.test(chain))
+                                return;
+                            calleeName = chain;
+                        }
+                        else if (TS_JS_CHAIN_LANGUAGES.has(this.language) &&
+                            receiver &&
+                            !keepsBareTsJsReceiver(receiver, this.source)) {
+                            // Any other TS/JS receiver is an expression with no static
+                            // type here — `(a ?? b).map()`, `f().list.map()`,
+                            // `arr[0].run()`, `(() => {}).call()`. The bare method name this
+                            // used to emit exact-matched whichever project method shared the
+                            // name (`(await list()).map()` onto an adapter class's `map`).
+                            // Emit nothing: a silent miss, never a wrong edge. Mirrored in
+                            // the kernel's extract_call (tsjs/extractors.rs).
+                            return;
+                        }
                         else {
                             calleeName = methodName;
                         }
@@ -4919,43 +5426,103 @@ class TreeSitterExtractor {
         }
     }
     /**
-     * Is this C++ `declaration` a stack/direct-initialization object construction
-     * that invokes a constructor — `Calculator calc(0)` (direct-init) or
-     * `Widget w{1, 2}` (brace-init) — as opposed to a plain variable or a
-     * function declaration? Used to emit an `instantiates` edge for the
+     * C++ stack construction — `Calculator calc(0)` / `Widget w{1, 2}` — is
      * call-less construction syntax (#1035); heap `new T(...)` is handled
      * separately by INSTANTIATION_KINDS.
      *
-     * Two signals, both required:
-     *  - the `type` field is a class-like NAMED type (`type_identifier`,
-     *    `template_type`, or `qualified_identifier`). Primitives (`int x(0)`),
-     *    `auto` (`placeholder_type_specifier` — that form always carries a real
-     *    `call_expression`, already handled), and sized specifiers are excluded —
-     *    they construct no class; and
-     *  - a declarator carries constructor arguments: an `init_declarator` whose
-     *    `value` is an `argument_list` (`(args)`) or `initializer_list` (`{args}`).
-     *    This skips default construction `Calculator c;` (no value) and the
-     *    most-vexing-parse `Calculator c();` (a bodyless `function_declarator`,
-     *    a function decl — not a construction).
+     * The `type` field must be a class-like NAMED type (`type_identifier`,
+     * `template_type`, or `qualified_identifier`). Primitives (`int x(0)`),
+     * `auto` (`placeholder_type_specifier` — that form always carries a real
+     * `call_expression`, already handled), and sized specifiers are excluded —
+     * they construct no class. `extern T x;` declares, it constructs nothing.
+     *
+     * Per declarator:
+     *  - a bare `identifier` is default construction (`T item;`) — arity 0;
+     *  - an `init_declarator` whose `value` is an `argument_list` (`(args)`) or
+     *    `initializer_list` (`{args}`) carries constructor arguments — arity is
+     *    the argument count. An array declarator's braces hold ELEMENTS, not
+     *    constructor arguments, so each braced element has its own arity;
+     *  - pointer / reference / function declarators construct nothing:
+     *    `T* p{}` is a null pointer, `T& r{x}` binds a reference, and the
+     *    most-vexing-parse `T c();` is a function declaration.
+     *
+     * `instantiates` (the type) is retained for initialized declarations,
+     * preserving the #1035 dependency edges. `calls` (`T::T/arity`, resolved to
+     * the constructor by src/resolution/cpp-constructor.ts, #1839) is emitted
+     * for every declarator with an arity, default construction included.
+     * Mirrored in the kernel (ccpp/mod.rs cpp_stack_constructions).
      */
-    isCppStackConstruction(node) {
+    cppStackConstructions(node) {
+        const none = { instantiates: false, arities: [] };
         const typeNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
         if (!typeNode ||
             (typeNode.type !== 'type_identifier' &&
                 typeNode.type !== 'template_type' &&
                 typeNode.type !== 'qualified_identifier')) {
-            return false;
+            return none;
         }
+        let instantiates = false;
+        const arities = [];
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
-            if (child?.type !== 'init_declarator')
+            if (!child)
+                continue;
+            if (child.type === 'storage_class_specifier' && (0, tree_sitter_helpers_1.getNodeText)(child, this.source) === 'extern')
+                return none;
+            if (child.type === 'identifier' || child.type === 'array_declarator') {
+                if (child.type === 'array_declarator' && !this.cppObjectArray(child))
+                    continue;
+                arities.push(0);
+                continue;
+            }
+            if (child.type !== 'init_declarator')
+                continue;
+            const declarator = (0, tree_sitter_helpers_1.getChildByField)(child, 'declarator');
+            if (declarator?.type !== 'identifier' && declarator?.type !== 'array_declarator')
                 continue;
             const value = (0, tree_sitter_helpers_1.getChildByField)(child, 'value');
-            if (value && (value.type === 'argument_list' || value.type === 'initializer_list')) {
-                return true;
+            if (!value || (value.type !== 'argument_list' && value.type !== 'initializer_list'))
+                continue;
+            instantiates = true;
+            if (declarator.type === 'identifier') {
+                arities.push(value.namedChildren.filter((c) => c.type !== 'comment').length);
+            }
+            else if (this.cppObjectArray(declarator)) {
+                const dimensions = [];
+                let array = declarator;
+                while (array?.type === 'array_declarator') {
+                    const size = (0, tree_sitter_helpers_1.getChildByField)(array, 'size')?.text ?? '';
+                    dimensions.unshift(/^\d+$/.test(size) && Number.isSafeInteger(Number(size)) ? Number(size) : NaN);
+                    array = (0, tree_sitter_helpers_1.getChildByField)(array, 'declarator');
+                }
+                const elements = (list, depth) => {
+                    const entries = list.namedChildren.filter((c) => c.type !== 'comment');
+                    let elided = false;
+                    for (const entry of entries) {
+                        if (depth + 1 < dimensions.length) {
+                            if (entry.type === 'initializer_list')
+                                elements(entry, depth + 1);
+                            else
+                                elided = true; // Unbraced multidimensional layout needs type information.
+                        }
+                        else {
+                            arities.push(entry.type === 'initializer_list'
+                                ? entry.namedChildren.filter((c) => c.type !== 'comment').length : 1);
+                        }
+                    }
+                    if (!elided && (entries.length === 0 || dimensions[depth] > entries.length))
+                        arities.push(0);
+                };
+                elements(value, 0);
             }
         }
-        return false;
+        return { instantiates, arities };
+    }
+    cppObjectArray(node) {
+        let element = (0, tree_sitter_helpers_1.getChildByField)(node, 'declarator');
+        while (element?.type === 'array_declarator')
+            element = (0, tree_sitter_helpers_1.getChildByField)(element, 'declarator');
+        return element?.type === 'identifier';
     }
     /**
      * Static-member / value-read pass. A type/enum/class used only via a member
@@ -5123,6 +5690,24 @@ class TreeSitterExtractor {
             if (extentRow === null || row < extentRow)
                 extentRow = row;
         };
+        // Rust outer attributes are siblings, not children of the function.
+        // Preserve Tauri's runtime registration for the dead-code decorator rule.
+        if (this.language === 'rust' && declNode.type === 'function_item') {
+            for (let sibling = declNode.previousNamedSibling; sibling; sibling = sibling.previousNamedSibling) {
+                if (sibling.type === 'line_comment' || sibling.type === 'block_comment')
+                    continue;
+                if (sibling.type !== 'attribute_item')
+                    break;
+                const attribute = sibling.namedChild(0);
+                const name = attribute?.namedChild(0)?.text.replace(/\s/g, '');
+                if (name === 'tauri::command') {
+                    const decorated = this.nodes.find(n => n.id === decoratedId);
+                    if (decorated)
+                        decorated.decorators = ['tauri::command'];
+                    break;
+                }
+            }
+        }
         const consider = (n) => {
             if (!n)
                 return;
@@ -5375,11 +5960,166 @@ class TreeSitterExtractor {
         }
         targets.add(target);
     }
+    /**
+     * Whether an anonymous function is the whole value of a `variable_declarator`
+     * with a plain identifier name — `const NAME = () => {…}` / `= function () {…}`.
+     * JS-family only.
+     */
+    declaratorBoundFunction(node) {
+        if (this.language !== 'typescript' &&
+            this.language !== 'javascript' &&
+            this.language !== 'tsx' &&
+            this.language !== 'jsx') {
+            return false;
+        }
+        if (node.type !== 'arrow_function' && node.type !== 'function_expression')
+            return false;
+        const declarator = node.parent;
+        if (!declarator || declarator.type !== 'variable_declarator')
+            return false;
+        const value = (0, tree_sitter_helpers_1.getChildByField)(declarator, 'value');
+        if (!value || value.startIndex !== node.startIndex || value.endIndex !== node.endIndex)
+            return false;
+        return (0, tree_sitter_helpers_1.getChildByField)(declarator, 'name')?.type === 'identifier';
+    }
+    /**
+     * The property a CommonJS export assignment binds a function to —
+     * `exports.NAME = <node>` or `module.exports.NAME = <node>` — or null for
+     * any other assignment. JS-family only; the node must be the assignment's
+     * whole right-hand side.
+     */
+    commonJsExportName(assignment, value) {
+        if (this.language !== 'typescript' &&
+            this.language !== 'javascript' &&
+            this.language !== 'tsx' &&
+            this.language !== 'jsx') {
+            return null;
+        }
+        const right = (0, tree_sitter_helpers_1.getChildByField)(assignment, 'right');
+        if (!right || right.startIndex !== value.startIndex || right.endIndex !== value.endIndex)
+            return null;
+        const left = (0, tree_sitter_helpers_1.getChildByField)(assignment, 'left');
+        if (!left || left.type !== 'member_expression')
+            return null;
+        const object = (0, tree_sitter_helpers_1.getChildByField)(left, 'object');
+        const property = (0, tree_sitter_helpers_1.getChildByField)(left, 'property');
+        if (!object || !property || property.type !== 'property_identifier')
+            return null;
+        const objectText = (0, tree_sitter_helpers_1.getNodeText)(object, this.source);
+        if (objectText !== 'exports' && objectText !== 'module.exports')
+            return null;
+        return (0, tree_sitter_helpers_1.getNodeText)(property, this.source);
+    }
+    /**
+     * The declarator name a React handler hook binds an anonymous function to —
+     * `const NAME = useCallback(<node>, [...])` — or null for any other shape.
+     * JS-family only; the node must be the hook call's FIRST argument, and the
+     * call's value must be bound directly by a `variable_declarator`.
+     */
+    reactHookBoundName(node) {
+        if (this.language !== 'typescript' &&
+            this.language !== 'javascript' &&
+            this.language !== 'tsx' &&
+            this.language !== 'jsx') {
+            return null;
+        }
+        if (node.type !== 'arrow_function' && node.type !== 'function_expression')
+            return null;
+        const args = node.parent;
+        if (!args || args.type !== 'arguments')
+            return null;
+        const first = args.namedChild(0);
+        if (!first || first.startIndex !== node.startIndex || first.endIndex !== node.endIndex)
+            return null;
+        const call = args.parent;
+        if (!call || call.type !== 'call_expression')
+            return null;
+        const callee = (0, tree_sitter_helpers_1.getChildByField)(call, 'function');
+        if (!callee || !REACT_HANDLER_HOOKS.test((0, tree_sitter_helpers_1.getNodeText)(callee, this.source)))
+            return null;
+        const declarator = call.parent;
+        if (!declarator || declarator.type !== 'variable_declarator')
+            return null;
+        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(declarator, 'name');
+        return nameNode?.type === 'identifier' ? (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source) : null;
+    }
+    /**
+     * The declarator name for an anonymous function passed to a CURRIED wrapper
+     * call — `const NAME = factory(...)(function () {…})` — or the property key
+     * when the call is an object member, `{ NAME: factory(...)(fn) }`; else null.
+     *
+     * `reactHookBoundName` above already names a function through the declarator
+     * that binds it; the shape is general, but that method is deliberately
+     * bounded to the three React handler hooks. This is the same shape with a
+     * different, equally decidable bound: the callee is itself a call, i.e. a
+     * factory that returns the wrapper (#1747).
+     *
+     * Requiring the callee to be a call is what keeps this narrow. It admits
+     * `Effect.fn("Session.run")(function* () {…})`, `connect(mapState)(fn)` and
+     * a project's own `wrap("name")(fn)`, and it does not admit the one-call
+     * forms where the argument is a computation rather than a body worth a node
+     * of its own — `useMemo(() => 1 + 1, [])`, `arr.map(() => …)` — which stay
+     * anonymous exactly as before.
+     *
+     * Generators are included here and not in `reactHookBoundName`: a React
+     * handler is never a generator, while `function*` is the common form in the
+     * ecosystem this shape comes from.
+     */
+    curriedWrapperBoundName(node) {
+        if (this.language !== 'typescript' &&
+            this.language !== 'javascript' &&
+            this.language !== 'tsx' &&
+            this.language !== 'jsx') {
+            return null;
+        }
+        if (node.type !== 'arrow_function' &&
+            node.type !== 'function_expression' &&
+            node.type !== 'generator_function') {
+            return null;
+        }
+        const args = node.parent;
+        if (!args || args.type !== 'arguments')
+            return null;
+        const first = args.namedChild(0);
+        if (!first || first.startIndex !== node.startIndex || first.endIndex !== node.endIndex)
+            return null;
+        const call = args.parent;
+        if (!call || call.type !== 'call_expression')
+            return null;
+        // The bound that replaces the hook allowlist: the thing being called is
+        // itself a call, so this is the second application of a curried wrapper.
+        const callee = (0, tree_sitter_helpers_1.getChildByField)(call, 'function');
+        if (!callee || callee.type !== 'call_expression')
+            return null;
+        const binder = call.parent;
+        if (!binder)
+            return null;
+        // `{ getMode: Effect.fn("…")(function* () {…}) }` — a service is often an
+        // object a factory returns, so the wrapper's result lands in a `pair`. The
+        // property key names it, as extractObjectLiteralFunctions names
+        // `key: () => {}`.
+        if (binder.type === 'pair') {
+            const key = (0, tree_sitter_helpers_1.getChildByField)(binder, 'key');
+            const value = (0, tree_sitter_helpers_1.getChildByField)(binder, 'value');
+            if (!key || !value || value.startIndex !== call.startIndex || value.endIndex !== call.endIndex)
+                return null;
+            return this.objectKeyName(key);
+        }
+        if (binder.type !== 'variable_declarator')
+            return null;
+        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(binder, 'name');
+        return nameNode?.type === 'identifier' ? (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source) : null;
+    }
     visitFunctionBody(body, _functionId) {
         if (!this.extractor)
             return;
         const visitForCallsAndStructure = (node) => {
             const nodeType = node.type;
+            // A function-like macro defined inside a body is still a macro (#1838).
+            if ((this.language === 'c' || this.language === 'cpp') && nodeType === 'preproc_function_def') {
+                this.visitNode(node);
+                return;
+            }
             // Function-as-value capture (#756) — function bodies are walked here,
             // not in visitNode, so the capture hook must fire in both walkers.
             this.maybeCaptureFnRefs(node, nodeType);
@@ -5429,8 +6169,30 @@ class TreeSitterExtractor {
             // (which strips template args / namespace and emits the `instantiates`
             // ref). Children still recurse below, so a nested ctor-arg call
             // (`Calculator calc(make())`) keeps its own `calls` ref.
-            if (nodeType === 'declaration' && this.language === 'cpp' && this.isCppStackConstruction(node)) {
-                this.extractInstantiation(node);
+            if (nodeType === 'declaration' && this.language === 'cpp') {
+                const { instantiates, arities } = this.cppStackConstructions(node);
+                if (instantiates)
+                    this.extractInstantiation(node);
+                // One `calls` ref per constructed object, naming the constructor and
+                // its argument count (`ns::T::T/1`) so the resolver can pick the
+                // overload — a type is not a callee (#1839).
+                const callerId = this.nodeStack[this.nodeStack.length - 1];
+                const typeNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+                if (callerId && typeNode && arities.length) {
+                    const className = (0, c_cpp_1.stripCppTemplateArgs)((0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source));
+                    const name = className.split('::').filter(Boolean).pop();
+                    if (name) {
+                        for (const arity of arities) {
+                            this.unresolvedReferences.push({
+                                fromNodeId: callerId,
+                                referenceName: `${className}::${name}/${arity}`,
+                                referenceKind: 'calls',
+                                line: node.startPosition.row + 1,
+                                column: node.startPosition.column,
+                            });
+                        }
+                    }
+                }
             }
             // C++ local function-pointer bindings (see cppLocalFnPtrs): record
             // `auto kernel = &fn<…>;` declarations and `kernel = &other_fn<…>;`
@@ -5488,6 +6250,43 @@ class TreeSitterExtractor {
                     this.extractFunction(node);
                     return;
                 }
+                // `const handleSubmit = useCallback(() => {…}, [deps])` — React's
+                // memoised handler. The function is anonymous only syntactically: the
+                // arrow is the first argument of a call whose result the declarator
+                // binds, and that binding is the name every `onPress={handleSubmit}`
+                // and `addListener('x', handleSubmit)` uses. Without a node of its own
+                // the handler's calls attribute to the component and the JSX prop or
+                // event registration has nothing to resolve to — the trigger of a flow
+                // is invisible. Bounded to the hooks React documents for handlers
+                // (`useCallback`, `useEffectEvent`, the experimental `useEvent`):
+                // `useMemo` / `useEffect` callbacks are computations, not handlers.
+                const hookBound = this.reactHookBoundName(node);
+                if (hookBound) {
+                    this.extractFunction(node, hookBound);
+                    return;
+                }
+                // `const run = Effect.fn("Session.run")(function* () {…})` (#1747) —
+                // the same declarator binding through a curried wrapper. Without a node
+                // the body's calls attribute to the enclosing container, so the file or
+                // the outer function picks up an outgoing edge that belongs to this
+                // function and the callee's caller list names the wrong thing.
+                const wrapperBound = this.curriedWrapperBoundName(node);
+                if (wrapperBound) {
+                    this.extractFunction(node, wrapperBound);
+                    return;
+                }
+                // `const handleClear = () => {…}` inside a body (#1669) — the same
+                // binding that names a function at module scope names one here, and in
+                // a React component it is how every handler that skips `useCallback`
+                // is written. Without a node the handler is absent from callers /
+                // impact ("Symbol not found" reads like "no callers") and its calls
+                // attribute to the component. extractFunction resolves the name from
+                // the declarator; a destructuring or otherwise unnamed binding stays
+                // anonymous and falls through.
+                if (this.declaratorBoundFunction(node)) {
+                    this.extractFunction(node);
+                    return;
+                }
             }
             // Extract structural nodes found inside function bodies.
             // Each extract method visits its own children, so we return after extracting.
@@ -5501,6 +6300,8 @@ class TreeSitterExtractor {
                     this.extractInterface(node);
                 else if (classification === 'trait')
                     this.extractClass(node, 'trait');
+                else if (classification === 'module')
+                    this.extractClass(node, 'module');
                 else
                     this.extractClass(node);
                 return;
@@ -5509,6 +6310,10 @@ class TreeSitterExtractor {
                 this.extractStruct(node);
                 return;
             }
+            if (this.extractor.unionTypes?.includes(nodeType)) {
+                this.extractUnion(node);
+                return;
+            }
             if (this.extractor.enumTypes.includes(nodeType)) {
                 this.extractEnum(node);
                 return;
@@ -5917,31 +6722,20 @@ class TreeSitterExtractor {
      * For plain `impl Type { ... }` (no trait), no inheritance edge is needed.
      */
     extractRustImplItem(node) {
-        // Check if this is `impl Trait for Type` by looking for a `for` keyword
-        const hasFor = node.children.some((c) => c.type === 'for' && !c.isNamed);
-        if (!hasFor)
+        // `impl Trait for Type` carries the trait in the grammar's `trait` field;
+        // an inherent `impl Type { … }` has none and needs no inheritance edge.
+        const traitNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'trait');
+        if (!traitNode)
             return;
-        // In `impl Trait for Type`, the type_identifiers are:
-        // first = Trait name, last = implementing Type name
-        // Also handle generic types like `impl<T> Trait for MyStruct<T>`
-        const typeIdents = node.namedChildren.filter((c) => c.type === 'type_identifier' || c.type === 'generic_type' || c.type === 'scoped_type_identifier');
-        if (typeIdents.length < 2)
+        // Full text, so a scoped path (`std::fmt::Display`) and a generic trait
+        // (`From<u32>`) keep their spelling.
+        const traitName = (0, tree_sitter_helpers_1.getNodeText)(traitNode, this.source);
+        // The implementing type from the `type` field (#1588). The old positional
+        // scan took the LAST type-shaped child, which for a parameterized
+        // implementing type (`BufSource<T>`, `Parents<'a>`, `&Foo`) was the trait.
+        const typeName = (0, rust_1.rustImplTypeName)((0, tree_sitter_helpers_1.getChildByField)(node, 'type'), this.source);
+        if (!typeName)
             return;
-        const traitNode = typeIdents[0];
-        const typeNode = typeIdents[typeIdents.length - 1];
-        // Get the trait name (handle scoped paths like std::fmt::Display)
-        const traitName = traitNode.type === 'scoped_type_identifier'
-            ? this.source.substring(traitNode.startIndex, traitNode.endIndex)
-            : (0, tree_sitter_helpers_1.getNodeText)(traitNode, this.source);
-        // Get the implementing type name (extract inner type_identifier for generics)
-        let typeName;
-        if (typeNode.type === 'generic_type') {
-            const inner = typeNode.namedChildren.find((c) => c.type === 'type_identifier');
-            typeName = inner ? (0, tree_sitter_helpers_1.getNodeText)(inner, this.source) : (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source);
-        }
-        else {
-            typeName = (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source);
-        }
         // Find the struct/type node for the implementing type
         const typeNodeId = this.findNodeByName(typeName);
         if (typeNodeId) {
@@ -5959,7 +6753,7 @@ class TreeSitterExtractor {
      */
     findNodeByName(name) {
         for (const node of this.nodes) {
-            if (node.name === name && (node.kind === 'struct' || node.kind === 'enum' || node.kind === 'class')) {
+            if (node.name === name && (node.kind === 'struct' || node.kind === 'union' || node.kind === 'enum' || node.kind === 'class')) {
                 return node.id;
             }
         }