@colbymchenry/codegraph-darwin-x64 1.0.1 → 1.1.0

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

@@ -57,6 +57,25 @@ const frameworks_1 = require("../resolution/frameworks");
 // Re-export for backward compatibility
 var tree_sitter_helpers_2 = require("./tree-sitter-helpers");
 Object.defineProperty(exports, "generateNodeId", { enumerable: true, get: function () { return tree_sitter_helpers_2.generateNodeId; } });
+/**
+ * RTK Query generated-hook naming convention: `use` + PascalCase endpoint (with
+ * an optional `Lazy` variant prefix) + `Query`/`Mutation`. Matches the hook
+ * bindings to extract from an `export const {...} = api` destructuring. Kept in
+ * sync with the same convention in `callback-synthesizer.ts` (the synth side).
+ */
+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']);
+/** 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). */
+const VUE_STORE_COLLECTION_NAMES = new Set(['actions', 'mutations', 'getters']);
+/** Store-definition callees whose config object carries those collections. */
+const VUE_STORE_FACTORY_CALLEES = new Set(['defineStore', 'createStore']);
+/** Distinct signals that a file is a Vuex/Pinia store (≥2 ⇒ treat a bare
+ *  `const actions = {…}` as a store collection — see looksLikeVueStoreFile). */
+const VUE_STORE_FILE_SIGNAL = /\bdefineStore\b|\bcreateStore\b|\bVuex\b|\bmutations\b|\bactions\b|\bgetters\b|\bnamespaced\b/g;
 /**
  * Extract the name from a node based on language
  */
@@ -164,6 +183,77 @@ function scalaBaseTypeName(node, source) {
         }
     }
 }
+/**
+ * Resolve the declared identifier inside a C declarator. A `declaration`'s
+ * `declarator` field nests the name through `init_declarator` (with value),
+ * `pointer_declarator`/`array_declarator`/`parenthesized_declarator`
+ * wrappers (each via their own `declarator` field) down to an `identifier`.
+ * A `function_declarator` means the declaration is a function prototype (or a
+ * function-pointer var) — return null so it isn't extracted as a variable.
+ */
+function cDeclaratorIdentifier(node) {
+    let cur = node;
+    let guard = 0;
+    while (cur && guard++ < 12) {
+        switch (cur.type) {
+            case 'identifier':
+                return cur;
+            case 'function_declarator':
+                return null;
+            case 'init_declarator':
+            case 'pointer_declarator':
+            case 'array_declarator':
+            case 'parenthesized_declarator':
+                cur = (0, tree_sitter_helpers_1.getChildByField)(cur, 'declarator');
+                break;
+            default:
+                return null;
+        }
+    }
+    return null;
+}
+/** First `simple_identifier` in `node`'s subtree (breadth-ish, first-found).
+ * Swift's property name nests as `property_declaration → <name> pattern →
+ * bound_identifier → simple_identifier`; this resolves it (and the bound name of
+ * a Kotlin/Swift property declarator for the shadow prune). For a tuple pattern
+ * (`let (a, b)`) it returns the first — acceptable, those are rare for consts. */
+function firstSimpleIdentifier(node) {
+    const stack = node ? [node] : [];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 40) {
+        const n = stack.shift();
+        if (n.type === 'simple_identifier')
+            return n;
+        for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c)
+                stack.push(c);
+        }
+    }
+    return null;
+}
+/** Swift property facts: the bound name, whether it's a `let`, and whether it's
+ * a *computed* property (a getter block, no stored value — never a constant). */
+function swiftPropertyInfo(node, source) {
+    const pattern = (0, tree_sitter_helpers_1.getChildByField)(node, 'name') ??
+        node.namedChildren.find((c) => c.type === 'value_binding_pattern' || c.type === 'pattern') ??
+        null;
+    const binding = node.namedChildren.find((c) => c.type === 'value_binding_pattern');
+    const isLet = binding != null && (0, tree_sitter_helpers_1.getNodeText)(binding, source).trimStart().startsWith('let');
+    const isComputed = node.namedChildren.some((c) => c.type === 'computed_property' || c.type === 'protocol_property_requirements');
+    return { nameNode: firstSimpleIdentifier(pattern), isLet, isComputed };
+}
+/** True when `node` is (transitively) inside a C function body — i.e. a local,
+ * not a file/namespace-scope declaration. Walks the parent chain to the root. */
+function hasFunctionAncestor(node) {
+    let p = node.parent;
+    while (p) {
+        if (p.type === 'function_definition')
+            return true;
+        p = p.parent;
+    }
+    return false;
+}
 /**
  * PHP type-position wrapper node kinds (a type-hint is `named_type`,
  * `?Foo` is `optional_type`, `A|B` is `union_type`, `A&B` is
@@ -230,6 +320,15 @@ class TreeSitterExtractor {
     nodes = [];
     edges = [];
     unresolvedReferences = [];
+    // Value-reference edges (default ON; set CODEGRAPH_VALUE_REFS=0 to disable; see flushValueRefs).
+    // Same-file reads of file-scope const/var symbols → `references` edges so impact analysis catches
+    // value consumers ("change this constant/table, affect its readers").
+    static VALUE_REF_LANGS = new Set(['typescript', 'javascript', 'tsx', 'go', 'python', 'rust', 'ruby', 'c', 'java', 'csharp', 'php', 'scala', 'kotlin', 'swift', 'dart', 'pascal']);
+    static MAX_VALUE_REF_NODES = 20_000;
+    valueRefsEnabled = process.env.CODEGRAPH_VALUE_REFS !== '0';
+    fileScopeValues = new Map();
+    fileScopeValueCounts = new Map(); // file-scope nodes per name (conditional-def detection)
+    valueRefScopes = [];
     errors = [];
     extractor = null;
     nodeStack = []; // Stack of parent node IDs
@@ -239,6 +338,8 @@ class TreeSitterExtractor {
     // (see flushFnRefCandidates).
     fnRefSpec;
     fnRefCandidates = [];
+    // Memoized "is this a Vue store file" verdict (per-extractor = per-file).
+    vueStoreFile = null;
     constructor(filePath, source, language) {
         this.filePath = filePath;
         this.source = source;
@@ -326,6 +427,7 @@ class TreeSitterExtractor {
             // Gate + flush function-as-value candidates (#756) while the file's
             // nodes and import refs are complete and the file node is still pushed.
             this.flushFnRefCandidates();
+            this.flushValueRefs();
             if (packageNodeId)
                 this.nodeStack.pop();
             this.nodeStack.pop();
@@ -514,6 +616,213 @@ class TreeSitterExtractor {
             });
         }
     }
+    /**
+     * Record value-reference bookkeeping as nodes are created: file-scope const/var symbols with
+     * distinctive names become reference targets; function/method/const/var symbols become reader
+     * scopes whose bodies flushValueRefs scans.
+     */
+    captureValueRefScope(kind, name, id, node) {
+        // Pascal targets `constant` only: its extractor emits function PARAMETERS
+        // (`Dest: TBufferWriter`) and class fields (`declField`) as `variable` at the
+        // enclosing scope, which would otherwise become noisy targets (a param name
+        // shared across many procs collapses to one file-wide target). Genuine
+        // Pascal shared values are `const` (`constant`), so restrict to that. (Unit
+        // `var` globals are the rare cost; the parameter/field noise dominates.)
+        const targetKindOk = this.language === 'pascal' ? kind === 'constant' : kind === 'constant' || kind === 'variable';
+        if (targetKindOk && name.length >= 3 && /[A-Z_]/.test(name)) {
+            const parentId = this.nodeStack[this.nodeStack.length - 1];
+            // file-scope OR class/module/struct/enum-scope constants are targets.
+            // Class/module scope matters for languages (Ruby) that keep nearly all
+            // constants inside a class or module; struct/enum scope matters for Swift,
+            // which namespaces shared constants in `struct`/`enum` (`enum Constants {
+            // static let X }`). Readers are same-file methods of that type.
+            if (parentId &&
+                (parentId.startsWith('file:') || parentId.startsWith('class:') ||
+                    parentId.startsWith('module:') || parentId.startsWith('struct:') ||
+                    parentId.startsWith('enum:'))) {
+                this.fileScopeValues.set(name, id);
+                // How many target nodes carry this name. A conditional def
+                // (`try: X = a; except: X = b`) makes >1 — distinct from a local shadow,
+                // which adds a binding the prune must catch (see flushValueRefs).
+                this.fileScopeValueCounts.set(name, (this.fileScopeValueCounts.get(name) ?? 0) + 1);
+            }
+        }
+        if (kind === 'function' || kind === 'method' || kind === 'constant' || kind === 'variable') {
+            this.valueRefScopes.push({ id, node, name });
+        }
+    }
+    /**
+     * Emit same-file `references` edges from a symbol to the file-scope const/var it reads (TS/JS).
+     * The engine doesn't edge const→consumer, so impact analysis misses "change this table, affect
+     * its readers" (the ReScript-PR false positive). Same-file only (resolution is unambiguous),
+     * distinctive target names only (dodges the local-shadowing precision trap documented on
+     * function_ref), deduped per (reader, target). Default on (CODEGRAPH_VALUE_REFS=0 disables) +
+     * additive. Shadowed targets are pruned — see below.
+     */
+    flushValueRefs() {
+        const scopes = this.valueRefScopes;
+        const targets = this.fileScopeValues;
+        const fileScopeCounts = this.fileScopeValueCounts;
+        this.valueRefScopes = [];
+        this.fileScopeValues = new Map();
+        this.fileScopeValueCounts = new Map();
+        if (!this.valueRefsEnabled || !TreeSitterExtractor.VALUE_REF_LANGS.has(this.language))
+            return;
+        if (targets.size === 0 || scopes.length === 0 || (0, generated_detection_1.isGeneratedFile)(this.filePath))
+            return;
+        // Prune SHADOWED targets. A target re-bound in an INNER scope (a
+        // bundled/Emscripten `const Module` re-declared as a nested `var Module`; a
+        // Go package `const Timeout` shadowed by a local `Timeout := …`; a Python
+        // module `CONFIG` shadowed by a local `CONFIG = …`) resolves to the inner
+        // binding for nested readers, so a file-scope edge is a false positive.
+        // Inner re-bindings aren't graph nodes, so detect them at the syntax level:
+        // count every declarator of the name across the tree and compare against how
+        // many FILE-SCOPE nodes carry it. A real shadow makes (declarators >
+        // file-scope nodes) — the excess is the local binding. A conditional
+        // module-level def (`try: X = a; except: X = b`) makes them EQUAL (both
+        // declarators are file-scope nodes), so it's correctly kept. Complements the
+        // path-based isGeneratedFile() check, which can't catch content-minified
+        // bundles.
+        //
+        // Declarator node types are per-grammar; a file only contains its own
+        // language's nodes, so matching all of them in one switch is safe.
+        if (this.tree) {
+            const declCounts = new Map();
+            const bump = (nameNode) => {
+                // `simple_identifier` is Kotlin's name node (a property declarator's name).
+                if (nameNode && (nameNode.type === 'identifier' || nameNode.type === 'simple_identifier')) {
+                    const nm = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+                    if (targets.has(nm))
+                        declCounts.set(nm, (declCounts.get(nm) ?? 0) + 1);
+                }
+            };
+            const dstack = [this.tree.rootNode];
+            let dvisited = 0;
+            while (dstack.length > 0 && dvisited < TreeSitterExtractor.MAX_VALUE_REF_NODES) {
+                const n = dstack.pop();
+                dvisited++;
+                switch (n.type) {
+                    case 'variable_declarator': // TS/JS/tsx
+                    case 'const_spec': // Go  `const X = …`
+                    case 'var_spec': // Go  `var X = …`
+                        bump(n.namedChild(0));
+                        break;
+                    case 'const_item': // Rust  `const X: T = …`
+                    case 'static_item': // Rust  `static X: T = …`
+                        bump((0, tree_sitter_helpers_1.getChildByField)(n, 'name'));
+                        break;
+                    case 'let_declaration': // Rust  `let x = …` (locals — the shadow source)
+                    case 'short_var_declaration': // Go    `x, Y := …`
+                    case 'assignment': { // Python `X = …` / `X: T = …` / `A, B = …`
+                        const left = (0, tree_sitter_helpers_1.getChildByField)(n, 'left') ?? (0, tree_sitter_helpers_1.getChildByField)(n, 'pattern') ?? n.namedChild(0);
+                        if (left?.type === 'identifier')
+                            bump(left);
+                        else if (left)
+                            for (const c of left.namedChildren)
+                                bump(c);
+                        break;
+                    }
+                    case 'init_declarator': // C  `T X = …` (file-scope const AND the local that shadows it)
+                        bump(cDeclaratorIdentifier(n));
+                        break;
+                    case 'val_definition': // Scala  `val X = …` (object/top-level const AND a method-local that shadows it)
+                    case 'var_definition': { // Scala  `var X = …`
+                        const pat = (0, tree_sitter_helpers_1.getChildByField)(n, 'pattern');
+                        if (pat?.type === 'identifier')
+                            bump(pat);
+                        break;
+                    }
+                    case 'static_final_declaration': // Dart  top-level/`static` `const`/`final` (the target itself)
+                    case 'initialized_identifier': // Dart  instance field / `var`
+                    case 'initialized_variable_definition': { // Dart  a method-local `const`/`final`/`var` that shadows a const
+                        const id = n.namedChildren.find((c) => c.type === 'identifier');
+                        if (id)
+                            bump(id);
+                        break;
+                    }
+                    case 'declConst': // Pascal  unit/class `const` (the target itself) AND a function-local `const` that shadows it
+                    case 'declVar': { // Pascal  a function-local `var` that shadows a const
+                        bump((0, tree_sitter_helpers_1.getChildByField)(n, 'name'));
+                        break;
+                    }
+                    case 'property_declaration': { // Kotlin / Swift  `val`/`let X = …` (object/static const AND a method-local that shadows it)
+                        // Kotlin: variable_declaration → simple_identifier; Swift: a `pattern`
+                        // (`<name>` field) → simple_identifier. Resolve either shape.
+                        const vd = n.namedChildren.find((c) => c.type === 'variable_declaration');
+                        const id = vd
+                            ? vd.namedChildren.find((c) => c.type === 'simple_identifier')
+                            : firstSimpleIdentifier((0, tree_sitter_helpers_1.getChildByField)(n, 'name') ??
+                                n.namedChildren.find((c) => c.type === 'value_binding_pattern' || c.type === 'pattern') ??
+                                null);
+                        if (id)
+                            bump(id);
+                        break;
+                    }
+                }
+                for (let i = 0; i < n.namedChildCount; i++) {
+                    const c = n.namedChild(i);
+                    if (c)
+                        dstack.push(c);
+                }
+            }
+            for (const [nm, c] of declCounts)
+                if (c > (fileScopeCounts.get(nm) ?? 1))
+                    targets.delete(nm);
+            if (targets.size === 0)
+                return;
+        }
+        for (const scope of scopes) {
+            const seen = new Set();
+            const stack = [scope.node];
+            // Dart and Pascal attach a function/method BODY as a *next sibling* of the
+            // signature node that is stored as the reader scope (Dart `method_signature`
+            // ← `function_body`; Pascal `declProc` ← `block`, both under a `defProc`),
+            // not as a child — so the scope subtree is just the signature and the reads
+            // live in the sibling. Pull it in. (A body as a next sibling of the scope
+            // node is unique to Dart/Pascal among the value-ref languages — every other
+            // grammar nests the body inside the function node — so this is inert
+            // elsewhere.)
+            const sib = scope.node.nextNamedSibling;
+            if (sib && (sib.type === 'function_body' || sib.type === 'block'))
+                stack.push(sib);
+            let visited = 0;
+            while (stack.length > 0 && visited < TreeSitterExtractor.MAX_VALUE_REF_NODES) {
+                const n = stack.pop();
+                visited++;
+                // `constant` covers Ruby, where both a constant's definition and its
+                // references are `constant`-typed nodes, not `identifier`. `name` covers
+                // PHP, where a constant reference — bare `MAX_ITEMS` or the const half of
+                // `self::MAX_ITEMS` / `Foo::MAX_ITEMS` — is a `name` node (a `$var` local
+                // is a `variable_name`, a different namespace, so it can never shadow a
+                // bare constant — no prune wiring needed). `simple_identifier` covers
+                // Kotlin, whose every name reference (a const read included) is that
+                // node type. Safe across languages: a file only holds its own grammar's
+                // nodes; `name` is PHP-only and `simple_identifier` is Kotlin-only here.
+                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);
+                    // 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.
+                    if (targetId && targetId !== scope.id && refName !== scope.name && !seen.has(targetId)) {
+                        seen.add(targetId);
+                        this.edges.push({
+                            source: scope.id,
+                            target: targetId,
+                            kind: 'references',
+                            metadata: { valueRef: true },
+                        });
+                    }
+                }
+                for (let i = 0; i < n.namedChildCount; i++) {
+                    const c = n.namedChild(i);
+                    if (c)
+                        stack.push(c);
+                }
+            }
+        }
+    }
     /**
      * Visit a node and extract information
      */
@@ -652,8 +961,13 @@ class TreeSitterExtractor {
             skipChildren = true;
         }
         // Check for variable declarations (const, let, var, etc.)
-        // Only extract top-level variables (not inside functions/methods)
-        else if (this.extractor.variableTypes.includes(nodeType) && !this.isInsideClassLikeNode()) {
+        // Only extract top-level variables (not inside functions/methods) — plus
+        // class/module-scope CONSTANTS, which Ruby (and other const-in-class
+        // languages) keep almost exclusively inside a class/module. A Ruby `CONST =
+        // …` has a `constant`-typed LHS; other languages don't put one here, so this
+        // is effectively Ruby-only and doesn't disturb their class-internal locals.
+        else if (this.extractor.variableTypes.includes(nodeType) &&
+            (!this.isInsideClassLikeNode() || this.isClassScopeConstantAssignment(node))) {
             this.extractVariable(node);
             // extractVariable doesn't walk every initializer shape (object literals
             // are deliberately skipped; Python/Ruby don't walk at all), so scan the
@@ -675,6 +989,20 @@ class TreeSitterExtractor {
             nodeType === 'property_declaration' &&
             this.isInsideClassLikeNode()) {
             const ownerId = this.nodeStack[this.nodeStack.length - 1];
+            // A `static let`/`static var` member is a SHARED constant of the type
+            // (Swift's `static`-namespacing idiom, esp. in `enum`/`struct`) — extract
+            // it as `constant`/`variable` so value-reference edges can target it. An
+            // instance stored property stays a `field` (per-instance; Swift instance
+            // properties otherwise aren't own nodes — that's unchanged). A *computed*
+            // property (getter, no stored value) is never a constant — skip the node.
+            const { nameNode, isLet, isComputed } = swiftPropertyInfo(node, this.source);
+            if (nameNode && !isComputed) {
+                const isStatic = this.extractor.isStatic?.(node) ?? false;
+                this.createNode(isStatic ? (isLet ? 'constant' : 'variable') : 'field', (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source), node, {
+                    visibility: this.extractor.getVisibility?.(node),
+                    isStatic,
+                });
+            }
             if (ownerId) {
                 this.extractDecoratorsFor(node, ownerId);
                 this.extractVariableTypeAnnotation(node, ownerId);
@@ -732,6 +1060,22 @@ class TreeSitterExtractor {
             if (parentId)
                 this.emitReExportRefs(node, parentId);
         }
+        // Vuex MODULE default export — `export default { namespaced, actions: {…},
+        // mutations: {…} }` (the canonical Vuex module shape). Object-literal methods
+        // aren't otherwise extracted, so scan the config's actions/mutations/getters
+        // collections and extract their methods as nodes. Store-file gated (the
+        // ≥2-signal heuristic) so a plain default-exported object is untouched; skip
+        // the subtree afterward (the collection methods are now handled).
+        else if (nodeType === 'export_statement' &&
+            (this.language === 'typescript' || this.language === 'tsx' ||
+                this.language === 'javascript' || this.language === 'jsx') &&
+            this.looksLikeVueStoreFile()) {
+            const exported = (0, tree_sitter_helpers_1.getChildByField)(node, 'value');
+            if (exported && (exported.type === 'object' || exported.type === 'object_expression')) {
+                this.extractStoreCollectionMethods(exported);
+                skipChildren = true;
+            }
+        }
         // Check for function calls
         else if (this.extractor.callTypes.includes(nodeType)) {
             this.extractCall(node);
@@ -843,6 +1187,8 @@ class TreeSitterExtractor {
                 });
             }
         }
+        if (this.valueRefsEnabled)
+            this.captureValueRefScope(kind, name, id, node);
         return newNode;
     }
     /**
@@ -938,6 +1284,18 @@ class TreeSitterExtractor {
             parentNode.kind === 'enum' ||
             parentNode.kind === 'module');
     }
+    /**
+     * Ruby `CONST = …` assignment whose LHS is a `constant` node — a class/module
+     * (or top-level) constant worth extracting as a symbol even inside a class.
+     * Other languages don't give an assignment a `constant`-typed LHS, so this
+     * gate is effectively Ruby-only.
+     */
+    isClassScopeConstantAssignment(node) {
+        if (node.type !== 'assignment')
+            return false;
+        const left = (0, tree_sitter_helpers_1.getChildByField)(node, 'left') ?? node.namedChild(0);
+        return left?.type === 'constant';
+    }
     /**
      * Extract a function
      */
@@ -1026,6 +1384,70 @@ class TreeSitterExtractor {
         }
         this.nodeStack.pop();
     }
+    /**
+     * Detect a React component declared via an HOC wrapper whose result is itself a
+     * component: `forwardRef(...)`, `memo(...)`, `React.forwardRef/memo(...)`, and
+     * styled-components / emotion `styled.tag\`…\`` / `styled(Base)\`…\``. These
+     * initializers are a call / tagged-template (not a bare arrow), so the const is
+     * otherwise classified `constant` — and a constant is skipped by both the
+     * JSX-render edge synthesizer and component resolution, so `<Button/>` usages
+     * get no edge and callers/impact silently return empty (#841).
+     *
+     * Returns `{ inner }` — the inline render function to extract as the component
+     * body, or `null` when the wrapper has no inline function (`memo(Imported)`,
+     * `styled.button\`…\``) and only a bodyless component node is minted — or
+     * `undefined` when this initializer is not a recognized component wrapper.
+     */
+    reactComponentHoc(valueNode) {
+        if (valueNode.type !== 'call_expression')
+            return undefined;
+        const callee = (0, tree_sitter_helpers_1.getChildByField)(valueNode, 'function');
+        if (!callee)
+            return undefined;
+        const calleeText = (0, tree_sitter_helpers_1.getNodeText)(callee, this.source);
+        // styled-components / emotion: `styled.button\`…\`` / `styled(Base)\`…\``.
+        // tree-sitter models these tagged templates as a call_expression whose callee
+        // is the `styled.x` / `styled(Base)` tag (\b avoids matching `styledFoo`).
+        // No inline render fn — the argument is the CSS template.
+        if (/^styled\b/.test(calleeText))
+            return { inner: null };
+        // React HOCs: `forwardRef`/`memo`/`React.forwardRef`/`React.memo`.
+        if (!REACT_COMPONENT_HOCS.has(calleeText))
+            return undefined;
+        // The first arrow / function-expression argument is the render fn (if inline;
+        // `memo(Imported)` passes a bare identifier and has none).
+        const args = (0, tree_sitter_helpers_1.getChildByField)(valueNode, 'arguments');
+        let inner = null;
+        if (args) {
+            for (let i = 0; i < args.namedChildCount; i++) {
+                const a = args.namedChild(i);
+                if (a && (a.type === 'arrow_function' || a.type === 'function_expression')) {
+                    inner = a;
+                    break;
+                }
+            }
+        }
+        return { inner };
+    }
+    /**
+     * Emit a `component` node for an HOC-wrapped React component declaration (see
+     * reactComponentHoc). Named by the declarator (`Button`) and located at it so
+     * the node range spans the body. When the wrapper has an inline render
+     * function, its body is walked so the component's callees (hooks, helpers) are
+     * captured under the component node — matching how a plain
+     * `const Foo = () => …` arrow component already behaves.
+     */
+    extractReactComponentNode(name, declarator, innerFn, extra) {
+        const compNode = this.createNode('component', name, declarator, extra);
+        if (!compNode || !innerFn || !this.extractor)
+            return;
+        this.nodeStack.push(compNode.id);
+        const body = this.extractor.resolveBody?.(innerFn, this.extractor.bodyField)
+            ?? (0, tree_sitter_helpers_1.getChildByField)(innerFn, this.extractor.bodyField);
+        if (body)
+            this.visitFunctionBody(body, compNode.id);
+        this.nodeStack.pop();
+    }
     /**
      * Extract a class
      */
@@ -1062,6 +1484,12 @@ class TreeSitterExtractor {
                 this.visitNode(child);
             }
         }
+        // Synthesize compile-time-generated members (Lombok accessors, #912). Runs
+        // after the body so the hook can dedup against hand-written members, and
+        // while the class is still on the stack so containment/QNs attach.
+        if (this.extractor.synthesizeMembers) {
+            this.extractor.synthesizeMembers(node, this.makeExtractorContext());
+        }
         this.nodeStack.pop();
     }
     /**
@@ -1350,6 +1778,15 @@ class TreeSitterExtractor {
         const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         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`
+        // / `static readonly`) is extracted as `constant` kind, not `field`, so
+        // value-reference edges treat it as a target (the gate accepts
+        // constant/variable, not field). Scoped to languages whose `isConst`
+        // predicate is field-shaped — other languages' fields stay `field`.
+        const fieldKind = (this.language === 'java' || this.language === 'csharp') &&
+            (this.extractor.isConst?.(node) ?? false)
+            ? 'constant'
+            : 'field';
         // Java field_declaration: "private final String name = value;" → variable_declarator(s) are direct children
         // C# field_declaration: wraps in variable_declaration → variable_declarator(s)
         let declarators = node.namedChildren.filter(c => c.type === 'variable_declarator');
@@ -1402,7 +1839,7 @@ class TreeSitterExtractor {
                     continue;
                 const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                 const signature = typeText ? `${typeText} ${name}` : name;
-                const fieldNode = this.createNode('field', name, decl, {
+                const fieldNode = this.createNode(fieldKind, name, decl, {
                     docstring,
                     signature,
                     visibility,
@@ -1427,7 +1864,7 @@ class TreeSitterExtractor {
                 || node.namedChildren.find(c => c.type === 'identifier');
             if (nameNode) {
                 const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
-                this.createNode('field', name, node, {
+                this.createNode(fieldKind, name, node, {
                     docstring,
                     visibility,
                     isStatic,
@@ -1543,6 +1980,317 @@ class TreeSitterExtractor {
         }
         return null;
     }
+    /**
+     * RTK Query: from a `createApi({ ..., endpoints: build => ({...}) })` or a
+     * `baseApi.injectEndpoints({ endpoints: build => ({...}) })` call initializer,
+     * return the object literal of endpoint definitions (the object the `endpoints`
+     * arrow returns). Returns null for any other call — the common case — so this
+     * stays cheap and silent. Keyed on the RTK entry-point names (`createApi` /
+     * `injectEndpoints`) like the framework extractors key on their library APIs.
+     */
+    findRtkEndpointsObject(callNode) {
+        const callee = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'function');
+        if (!callee)
+            return null;
+        const calleeName = callee.type === 'identifier'
+            ? (0, tree_sitter_helpers_1.getNodeText)(callee, this.source)
+            : callee.type === 'member_expression'
+                ? (0, tree_sitter_helpers_1.getNodeText)((0, tree_sitter_helpers_1.getChildByField)(callee, 'property') ?? callee, this.source)
+                : '';
+        if (calleeName !== 'createApi' && calleeName !== 'injectEndpoints')
+            return null;
+        const args = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'arguments');
+        if (!args)
+            return null;
+        for (let i = 0; i < args.namedChildCount; i++) {
+            const arg = args.namedChild(i);
+            if (arg?.type !== 'object' && arg?.type !== 'object_expression')
+                continue;
+            for (let j = 0; j < arg.namedChildCount; j++) {
+                const member = arg.namedChild(j);
+                // Two equally-common spellings: `endpoints: build => ({...})` (pair with an
+                // arrow value) and `endpoints(build) { return {...} }` (method shorthand).
+                if (member?.type === 'pair') {
+                    const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'key');
+                    if (!key || (0, tree_sitter_helpers_1.getNodeText)(key, this.source) !== 'endpoints')
+                        continue;
+                    const value = (0, tree_sitter_helpers_1.getChildByField)(member, 'value');
+                    if (value && (value.type === 'arrow_function' || value.type === 'function_expression')) {
+                        return this.functionReturnedObject(value);
+                    }
+                }
+                else if (member?.type === 'method_definition') {
+                    const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'name');
+                    if (!key || (0, tree_sitter_helpers_1.getNodeText)(key, this.source) !== 'endpoints')
+                        continue;
+                    return this.functionReturnedObject(member);
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract each RTK Query endpoint (`getX: build.query({...})` / `build.mutation`)
+     * as a function node named by the endpoint key, spanning its primary handler
+     * (the `queryFn`/`query` arrow) so the fetch logic's calls attribute to the
+     * endpoint. Without this an endpoint exists only as an object-literal property —
+     * never a node — so the generated `useXQuery` hook can't be bridged to it.
+     */
+    extractRtkEndpoints(obj) {
+        for (let i = 0; i < obj.namedChildCount; i++) {
+            const member = obj.namedChild(i);
+            if (member?.type !== 'pair')
+                continue;
+            const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'key');
+            const value = (0, tree_sitter_helpers_1.getChildByField)(member, 'value');
+            if (!key || value?.type !== 'call_expression')
+                continue;
+            // The value must be a builder dispatch `<builder>.query|mutation(...)`.
+            const callee = (0, tree_sitter_helpers_1.getChildByField)(value, 'function');
+            if (callee?.type !== 'member_expression')
+                continue;
+            const method = (0, tree_sitter_helpers_1.getNodeText)((0, tree_sitter_helpers_1.getChildByField)(callee, 'property') ?? callee, this.source);
+            if (method !== 'query' && method !== 'mutation' && method !== 'infiniteQuery')
+                continue;
+            const handler = this.rtkEndpointHandler(value);
+            if (handler) {
+                this.extractFunction(handler, this.objectKeyName(key));
+            }
+            else {
+                // Factory / config-only handler (`queryFn: makeQueryFn(url)`): no function
+                // literal to name. Mint a bare endpoint node spanning the builder call so
+                // the generated hook still bridges to it, and walk the call so its handler
+                // factory (and any inline transform) is captured as an outgoing edge.
+                const epNode = this.createNode('function', this.objectKeyName(key), value, {
+                    signature: (0, tree_sitter_helpers_1.getNodeText)(value, this.source).slice(0, 80),
+                });
+                if (epNode) {
+                    this.nodeStack.push(epNode.id);
+                    this.visitFunctionBody(value, epNode.id);
+                    this.nodeStack.pop();
+                }
+            }
+        }
+    }
+    /**
+     * The primary handler arrow of a `build.query({ queryFn|query: (…) => … })`
+     * endpoint — prefers `queryFn`, then `query`, else the first function-valued
+     * property. Returns null when the endpoint is config-only (no handler arrow).
+     */
+    rtkEndpointHandler(callNode) {
+        const args = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'arguments');
+        if (!args)
+            return null;
+        for (let i = 0; i < args.namedChildCount; i++) {
+            const arg = args.namedChild(i);
+            if (arg?.type !== 'object' && arg?.type !== 'object_expression')
+                continue;
+            let queryFn = null;
+            let query = null;
+            let firstFn = null;
+            for (let j = 0; j < arg.namedChildCount; j++) {
+                const member = arg.namedChild(j);
+                // The handler may be `queryFn: () => …` / `query: () => …` (pair) or the
+                // method-shorthand `query(arg) { … }` / `queryFn(arg) { … }`.
+                let fn = null;
+                let kn = '';
+                if (member?.type === 'pair') {
+                    const v = (0, tree_sitter_helpers_1.getChildByField)(member, 'value');
+                    if (v?.type === 'arrow_function' || v?.type === 'function_expression') {
+                        fn = v;
+                        const k = (0, tree_sitter_helpers_1.getChildByField)(member, 'key');
+                        kn = k ? (0, tree_sitter_helpers_1.getNodeText)(k, this.source) : '';
+                    }
+                }
+                else if (member?.type === 'method_definition') {
+                    fn = member;
+                    const k = (0, tree_sitter_helpers_1.getChildByField)(member, 'name');
+                    kn = k ? (0, tree_sitter_helpers_1.getNodeText)(k, this.source) : '';
+                }
+                if (!fn)
+                    continue;
+                if (kn === 'queryFn')
+                    queryFn = fn;
+                else if (kn === 'query')
+                    query = fn;
+                if (!firstFn)
+                    firstFn = fn;
+            }
+            if (queryFn)
+                return queryFn;
+            if (query)
+                return query;
+            if (firstFn)
+                return firstFn;
+        }
+        return null;
+    }
+    /**
+     * RTK Query generated-hook bindings. `export const { useGetXQuery,
+     * useUpdateYMutation } = someApi` destructures the hooks RTK generates per
+     * endpoint off a createApi result. They are real exported symbols that
+     * components import, but destructured bindings aren't otherwise extracted —
+     * mint a function node per binding matching the RTK hook convention so the hook
+     * resolves and the synthesizer can bridge it to its endpoint. Gated tight by the
+     * caller (object-pattern off a bare identifier) + the name convention here, so
+     * ordinary destructures stay unextracted.
+     */
+    extractRtkHookBindings(pattern, isExported) {
+        for (let i = 0; i < pattern.namedChildCount; i++) {
+            const binding = pattern.namedChild(i);
+            if (binding?.type !== 'shorthand_property_identifier_pattern')
+                continue;
+            const name = (0, tree_sitter_helpers_1.getNodeText)(binding, this.source);
+            if (!RTK_HOOK_NAME_RE.test(name))
+                continue;
+            this.createNode('function', name, binding, {
+                isExported,
+                signature: '= RTK Query generated hook',
+            });
+        }
+    }
+    /** Cheap per-file heuristic: the file carries ≥2 distinct Vue-store signals
+     *  (defineStore/createStore/Vuex, or the actions/mutations/getters/namespaced
+     *  vocabulary). Gates the non-exported `const actions = {…}` Vuex-module form so
+     *  a stray `const actions` in unrelated code is never mistaken for a store. */
+    looksLikeVueStoreFile() {
+        if (this.vueStoreFile !== null)
+            return this.vueStoreFile;
+        const seen = new Set();
+        VUE_STORE_FILE_SIGNAL.lastIndex = 0;
+        let m;
+        while ((m = VUE_STORE_FILE_SIGNAL.exec(this.source))) {
+            seen.add(m[0]);
+            if (seen.size >= 2)
+                break;
+        }
+        this.vueStoreFile = seen.size >= 2;
+        return this.vueStoreFile;
+    }
+    /** True if an object literal has ≥1 inline function member (`key: () => …` /
+     *  `method(){}`) — distinguishes an inline action map (zustand/SvelteKit form
+     *  actions) from a Pinia SETUP store's all-shorthand `return { foo, bar }`
+     *  (whose functions are body-local consts, walked normally instead). */
+    objectHasInlineFunctions(obj) {
+        for (let i = 0; i < obj.namedChildCount; i++) {
+            const member = obj.namedChild(i);
+            if (member?.type === 'method_definition')
+                return true;
+            if (member?.type === 'pair') {
+                const v = (0, tree_sitter_helpers_1.getChildByField)(member, 'value');
+                if (v?.type === 'arrow_function' || v?.type === 'function_expression')
+                    return true;
+            }
+        }
+        return false;
+    }
+    /** Vue store action/mutation/getter collections defined INLINE in a store call:
+     *  `defineStore({ actions: {…}, getters: {…} })` (Pinia options form),
+     *  `defineStore('id', { actions: {…} })`, `createStore({ mutations: {…} })`,
+     *  `new Vuex.Store({ actions: {…} })`. Returns the object literals under those
+     *  keys so their methods become nodes. Gated on the store-factory callee. */
+    findVueStoreCollectionObjects(callNode) {
+        const callee = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'function') ?? (0, tree_sitter_helpers_1.getChildByField)(callNode, 'constructor');
+        if (!callee)
+            return [];
+        const calleeName = callee.type === 'identifier'
+            ? (0, tree_sitter_helpers_1.getNodeText)(callee, this.source)
+            : callee.type === 'member_expression'
+                ? (0, tree_sitter_helpers_1.getNodeText)((0, tree_sitter_helpers_1.getChildByField)(callee, 'property') ?? callee, this.source)
+                : '';
+        if (!VUE_STORE_FACTORY_CALLEES.has(calleeName) && calleeName !== 'Store')
+            return [];
+        const args = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'arguments');
+        if (!args)
+            return [];
+        const objects = [];
+        for (let i = 0; i < args.namedChildCount; i++) {
+            const arg = args.namedChild(i);
+            if (arg?.type !== 'object' && arg?.type !== 'object_expression')
+                continue;
+            for (let j = 0; j < arg.namedChildCount; j++) {
+                const member = arg.namedChild(j);
+                if (member?.type !== 'pair')
+                    continue;
+                const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'key');
+                if (!key || !VUE_STORE_COLLECTION_NAMES.has((0, tree_sitter_helpers_1.getNodeText)(key, this.source)))
+                    continue;
+                const value = (0, tree_sitter_helpers_1.getChildByField)(member, 'value');
+                if (value && (value.type === 'object' || value.type === 'object_expression')) {
+                    objects.push(value);
+                }
+            }
+        }
+        return objects;
+    }
+    /** Extract the methods of a store-config object's `actions`/`mutations`/`getters`
+     *  properties. Used for the canonical Vuex MODULE shape `export default {
+     *  namespaced, actions: {…}, mutations: {…} }` — object-literal methods aren't
+     *  otherwise extracted, so the actions/mutations would never be nodes. */
+    extractStoreCollectionMethods(configObj) {
+        for (let j = 0; j < configObj.namedChildCount; j++) {
+            const member = configObj.namedChild(j);
+            if (member?.type !== 'pair')
+                continue;
+            const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'key');
+            if (!key || !VUE_STORE_COLLECTION_NAMES.has((0, tree_sitter_helpers_1.getNodeText)(key, this.source)))
+                continue;
+            const value = (0, tree_sitter_helpers_1.getChildByField)(member, 'value');
+            if (value && (value.type === 'object' || value.type === 'object_expression')) {
+                this.extractObjectLiteralFunctions(value);
+            }
+        }
+    }
+    /** The SETUP function of a Pinia setup store (`defineStore('id', () => {…})`)
+     *  — an arrow/function arg with a block body. Returns null for the options form
+     *  (`defineStore({…})`) and for any non-defineStore call. The setup body's local
+     *  function consts are the store's actions; the generic body walk doesn't reach
+     *  them (nested functions are separate scopes), so they're extracted explicitly. */
+    findPiniaSetupFn(callNode) {
+        const callee = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'function');
+        if (!callee || callee.type !== 'identifier' || (0, tree_sitter_helpers_1.getNodeText)(callee, this.source) !== 'defineStore')
+            return null;
+        const args = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'arguments');
+        if (!args)
+            return null;
+        for (let i = 0; i < args.namedChildCount; i++) {
+            const arg = args.namedChild(i);
+            if (arg?.type !== 'arrow_function' && arg?.type !== 'function_expression')
+                continue;
+            const body = (0, tree_sitter_helpers_1.getChildByField)(arg, 'body');
+            if (body?.type === 'statement_block')
+                return arg; // block body ⇒ setup form
+        }
+        return null;
+    }
+    /** Extract a Pinia setup store's actions: the body-local `const foo = () => …`
+     *  / `function foo(){}` declarations, named by the binding. (State refs and other
+     *  consts are left to the normal value-extraction; only the functions matter as
+     *  the store's callable surface.) */
+    extractPiniaSetupBody(setupFn) {
+        const body = (0, tree_sitter_helpers_1.getChildByField)(setupFn, 'body');
+        if (!body || body.type !== 'statement_block')
+            return;
+        for (let i = 0; i < body.namedChildCount; i++) {
+            const stmt = body.namedChild(i);
+            if (!stmt)
+                continue;
+            if (stmt.type === 'function_declaration') {
+                this.extractFunction(stmt);
+            }
+            else if (this.extractor.variableTypes.includes(stmt.type)) {
+                for (let j = 0; j < stmt.namedChildCount; j++) {
+                    const decl = stmt.namedChild(j);
+                    if (decl?.type !== 'variable_declarator')
+                        continue;
+                    const v = (0, tree_sitter_helpers_1.getChildByField)(decl, 'value');
+                    if (v?.type === 'arrow_function' || v?.type === 'function_expression') {
+                        this.extractFunction(v); // name resolved from the parent declarator
+                    }
+                }
+            }
+        }
+    }
     /**
      * Extract a variable declaration (const, let, var, etc.)
      *
@@ -1572,8 +2320,15 @@ class TreeSitterExtractor {
                     const valueNode = (0, tree_sitter_helpers_1.getChildByField)(child, 'value');
                     if (nameNode) {
                         // Skip destructured patterns (e.g., `let { x, y } = $props()` in Svelte)
-                        // These produce ugly multi-line names like "{ class: className }"
+                        // These produce ugly multi-line names like "{ class: className }".
+                        // EXCEPT `export const { useGetXQuery } = someApi` — the RTK Query
+                        // generated hooks: real exported symbols destructured off a createApi
+                        // result. Mint a node per binding matching the hook convention (gated
+                        // on a bare-identifier RHS so ordinary destructures stay skipped).
                         if (nameNode.type === 'object_pattern' || nameNode.type === 'array_pattern') {
+                            if (nameNode.type === 'object_pattern' && valueNode?.type === 'identifier') {
+                                this.extractRtkHookBindings(nameNode, isExported);
+                            }
                             continue;
                         }
                         const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
@@ -1585,6 +2340,25 @@ class TreeSitterExtractor {
                         // Capture first 100 chars of initializer for context (stored in signature for searchability)
                         const initValue = valueNode ? (0, tree_sitter_helpers_1.getNodeText)(valueNode, this.source).slice(0, 100) : undefined;
                         const initSignature = initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined;
+                        // React HOC-wrapped components (`forwardRef`/`memo`/`styled`) — see
+                        // reactComponentHoc. The initializer is a call / tagged-template (not
+                        // a bare arrow), so without this the const is a plain `constant`,
+                        // which the JSX-render synthesizer and component resolution both skip
+                        // → `<Button/>` usages get no edge and callers/impact return empty
+                        // (the whole shadcn/ui design-system pattern, #841). PascalCase-gated
+                        // to the component naming convention so a memoization util
+                        // (`const cache = memo(fn)`) stays a constant.
+                        if (valueNode && /^[A-Z]/.test(name)) {
+                            const hoc = this.reactComponentHoc(valueNode);
+                            if (hoc) {
+                                this.extractReactComponentNode(name, child, hoc.inner, {
+                                    docstring,
+                                    signature: initSignature,
+                                    isExported,
+                                });
+                                continue;
+                            }
+                        }
                         const varNode = this.createNode(kind, name, child, {
                             docstring,
                             signature: initSignature,
@@ -1615,21 +2389,65 @@ class TreeSitterExtractor {
                             : valueNode?.type === 'call_expression'
                                 ? this.findInitializerReturnedObject(valueNode)
                                 : null;
-                        const extractObjectMethods = isExported && !!objectOfFns;
+                        // Only treat as an inline object-of-functions when the object actually
+                        // HAS inline functions. A Pinia SETUP store `defineStore('id', () => {
+                        // const foo = …; return { foo } })` returns an ALL-SHORTHAND object
+                        // 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;
+                        // 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
+                        // object-of-functions path above nor the normal walk extracts them.
+                        // Extract each endpoint as a function node (named by its key), and skip
+                        // walking the createApi call body (its handler arrows are extracted
+                        // individually below, exactly like the store-factory case).
+                        const rtkEndpoints = valueNode?.type === 'call_expression' ? this.findRtkEndpointsObject(valueNode) : null;
+                        // Pinia SETUP store: `defineStore('id', () => { const foo = …; return {…} })`.
+                        // Its actions are body-local consts the generic walk can't reach.
+                        const piniaSetup = valueNode?.type === 'call_expression' ? this.findPiniaSetupFn(valueNode) : null;
+                        // Vue store collections — make `actions`/`mutations`/`getters` findable
+                        // function nodes (the foundation under any later dispatch-bridge synth).
+                        // Two positions: INLINE in a store call (`defineStore({ actions: {…} })`
+                        // / `createStore` / `new Vuex.Store`), and the non-exported Vuex-MODULE
+                        // form (`const actions = {…}` at a store file's top level, wired via a
+                        // `export default { actions }`). The Pinia SETUP form is handled by the
+                        // body walk above (its actions are local consts).
+                        const storeCollections = [];
+                        if (valueNode?.type === 'call_expression' || valueNode?.type === 'new_expression') {
+                            storeCollections.push(...this.findVueStoreCollectionObjects(valueNode));
+                        }
+                        if (objectOfFns && !extractObjectMethods &&
+                            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
-                        // call whose returned object 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/module scope).
+                        // / 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')) {
+                            !(extractObjectMethods && valueNode.type === 'call_expression') &&
+                            !rtkEndpoints &&
+                            !piniaSetup &&
+                            storeCollections.length === 0) {
                             this.visitFunctionBody(valueNode, '');
                         }
                         if (extractObjectMethods && objectOfFns) {
                             this.extractObjectLiteralFunctions(objectOfFns);
                         }
+                        if (rtkEndpoints) {
+                            this.extractRtkEndpoints(rtkEndpoints);
+                        }
+                        if (piniaSetup) {
+                            this.extractPiniaSetupBody(piniaSetup);
+                        }
+                        for (const coll of storeCollections) {
+                            this.extractObjectLiteralFunctions(coll);
+                        }
                     }
                 }
             }
@@ -1638,7 +2456,9 @@ class TreeSitterExtractor {
             // Python/Ruby assignment: left = right
             const left = (0, tree_sitter_helpers_1.getChildByField)(node, 'left') || node.namedChild(0);
             const right = (0, tree_sitter_helpers_1.getChildByField)(node, 'right') || node.namedChild(1);
-            if (left && left.type === 'identifier') {
+            // Ruby constant assignments (`MAX = 3`) have a `constant`-typed LHS, not
+            // `identifier`; without this they were never extracted as symbols at all.
+            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
@@ -1725,6 +2545,65 @@ class TreeSitterExtractor {
                 this.createNode(kind, name, nameNode, { docstring, signature: initSignature, isExported });
             });
         }
+        else if (this.language === 'c') {
+            // C: a `declaration` node's name nests inside the `declarator` field —
+            // `init_declarator` (with value) or bare/pointer/array declarators (no
+            // value); a `function_declarator` is a prototype, not a variable. The
+            // generic fallback below only finds a *direct* identifier child, which C
+            // never has, so file-scope consts/globals went unextracted entirely (and
+            // so had no impact-radius edges). Only file-scope declarations are tracked
+            // — locals inside a function body are skipped (a `static const` table read
+            // by same-file functions is the value the impact graph wants, not every
+            // block-local). C allows several declarators per declaration
+            // (`int a = 1, b = 2;`), so iterate them.
+            if (!hasFunctionAncestor(node)) {
+                for (let i = 0; i < node.namedChildCount; i++) {
+                    const child = node.namedChild(i);
+                    if (!child)
+                        continue;
+                    // Accept only `init_declarator` (has a value) and pointer/array
+                    // declarators. A *bare* `identifier` declarator is deliberately
+                    // skipped: an unknown leading macro (`CURL_EXTERN`, `XXH_PUBLIC_API`)
+                    // makes tree-sitter-c misparse a prototype `MACRO RetType fn(args);`
+                    // as a declaration whose "variable" is the bare return-type
+                    // identifier, splitting `fn(args)` off as a bogus expression — minting
+                    // a spurious type-named global for every macro-prefixed prototype in a
+                    // header. Those misparses are always bare identifiers; real
+                    // consts/tables always carry an initializer. The only legit loss is
+                    // uninitialized scalar globals (`static int g;`).
+                    if (child.type !== 'init_declarator' &&
+                        child.type !== 'pointer_declarator' &&
+                        child.type !== 'array_declarator') {
+                        continue;
+                    }
+                    const nameNode = cDeclaratorIdentifier(child);
+                    if (!nameNode)
+                        continue;
+                    const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+                    if (!name)
+                        continue;
+                    const valueNode = child.type === 'init_declarator' ? (0, tree_sitter_helpers_1.getChildByField)(child, 'value') : null;
+                    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, child, { docstring, signature: initSignature, isExported });
+                }
+            }
+        }
+        else if (this.language === 'swift') {
+            // Swift top-level property (`let X = …` / `var Y = …`). The name nests in
+            // a `pattern`, which the generic fallback can't read, so top-level Swift
+            // constants/globals went unextracted. A top-level `let`→`constant`,
+            // `var`→`variable`; a computed property (getter, no value) is skipped.
+            const { nameNode, isLet, isComputed } = swiftPropertyInfo(node, this.source);
+            if (nameNode && !isComputed) {
+                this.createNode(isLet ? 'constant' : 'variable', (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source), node, {
+                    docstring,
+                    isExported,
+                });
+            }
+        }
         else {
             // Generic fallback for other languages
             // Try to find identifier children