@colbymchenry/codegraph-darwin-x64 0.9.8 → 1.0.0

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

@@ -43,9 +43,13 @@ exports.extractFromSource = extractFromSource;
 const path = __importStar(require("path"));
 const grammars_1 = require("./grammars");
 const tree_sitter_helpers_1 = require("./tree-sitter-helpers");
+const function_ref_1 = require("./function-ref");
+const generated_detection_1 = require("./generated-detection");
 const languages_1 = require("./languages");
 const liquid_extractor_1 = require("./liquid-extractor");
+const razor_extractor_1 = require("./razor-extractor");
 const svelte_extractor_1 = require("./svelte-extractor");
+const astro_extractor_1 = require("./astro-extractor");
 const dfm_extractor_1 = require("./dfm-extractor");
 const vue_extractor_1 = require("./vue-extractor");
 const mybatis_extractor_1 = require("./mybatis-extractor");
@@ -130,6 +134,78 @@ function extractName(node, source, extractor) {
     }
     return '<anonymous>';
 }
+/**
+ * Resolve a Scala type node to its base type NAME for name-matching — unwrapping
+ * `generic_type` (`Monoid[Int]` → `Monoid`), taking the last segment of a
+ * qualified `stable_type_identifier` (`cats.Functor` → `Functor`), and falling
+ * back to a descendant `type_identifier`. Returns null for non-type nodes.
+ * Shared by Scala inheritance and type-reference extraction.
+ */
+function scalaBaseTypeName(node, source) {
+    if (!node)
+        return null;
+    switch (node.type) {
+        case 'type_identifier':
+        case 'identifier':
+            return (0, tree_sitter_helpers_1.getNodeText)(node, source);
+        case 'generic_type':
+            // `<base> type_arguments` — the base type is the first named child.
+            return scalaBaseTypeName(node.namedChild(0), source);
+        case 'stable_type_identifier':
+        case 'stable_identifier': {
+            // Qualified `a.b.C` — match on the simple (last) segment.
+            const ids = node.namedChildren.filter((c) => c.type === 'type_identifier' || c.type === 'identifier');
+            const last = ids[ids.length - 1];
+            return last ? (0, tree_sitter_helpers_1.getNodeText)(last, source) : null;
+        }
+        default: {
+            const id = node.namedChildren.find((c) => c.type === 'type_identifier');
+            return id ? (0, tree_sitter_helpers_1.getNodeText)(id, source) : null;
+        }
+    }
+}
+/**
+ * PHP type-position wrapper node kinds (a type-hint is `named_type`,
+ * `?Foo` is `optional_type`, `A|B` is `union_type`, `A&B` is
+ * `intersection_type`). Used to find the type subtree inside a parameter /
+ * property / return position before walking it for class references.
+ */
+const PHP_TYPE_NODES = new Set([
+    'named_type', 'optional_type', 'nullable_type',
+    'union_type', 'intersection_type', 'disjunctive_normal_form_type',
+    'primitive_type',
+]);
+/**
+ * Member-access node kinds whose receiver, when it's a capitalized
+ * type/enum/class name, is a real dependency — `Enum.value`, `Type.CONST`,
+ * `Foo::BAR`. These VALUE reads (as opposed to `Type.method()` calls, already
+ * handled) produced no edge, so a type used only via a static member or enum
+ * value looked like nothing depended on it. See {@link extractStaticMemberRef}.
+ */
+const MEMBER_ACCESS_TYPES = new Set([
+    'field_access', // java (`Foo.BAR`)
+    'member_access_expression', // c#  (`Foo.Bar`)
+    'navigation_expression', // kotlin / swift (`Foo.bar`)
+    'field_expression', // scala (`Foo.bar`)
+    'class_constant_access_expression', // php (`Foo::CONST`, `Foo::class`)
+    'scoped_property_access_expression', // php (`Foo::$bar`)
+    'qualified_identifier', // c++ (`Foo::bar`)
+]);
+/**
+ * Languages whose types are Capitalized by convention, so a capitalized
+ * member-access receiver is reliably a type (not a local/variable). The
+ * static-member/value-read pass is gated to these — the ones where it was the
+ * confirmed residual frontier (enum-value / static-field reads). TS/JS/Python
+ * are deliberately excluded, and a measured A/B confirms the call: extending the
+ * pass to them adds ZERO coverage — in import-based languages you must `import` a
+ * type before any `Type.MEMBER` read, so the import edge already covers it (the
+ * static read is pure duplication) — while adding real graph noise (+1813 edges /
+ * +2448 `references` on excalidraw, the retrieval-perf benchmark, all pointing at
+ * already-covered types). Don't re-add `member_expression`/`attribute` here.
+ */
+const STATIC_MEMBER_LANGS = new Set([
+    'java', 'csharp', 'kotlin', 'swift', 'scala', 'dart', 'php', 'cpp',
+]);
 /**
  * Tree-sitter node kinds that represent constructor invocations
  * (`new Foo()` and friends). Used by extractInstantiation to emit
@@ -139,6 +215,9 @@ const INSTANTIATION_KINDS = new Set([
     'new_expression', // typescript / javascript / tsx / jsx
     'object_creation_expression', // java / c#
     'instance_creation_expression', // some grammars
+    'composite_literal', // go — `Widget{...}` / `pkga.Widget{...}`
+    'struct_expression', // rust — `Widget { n: 1 }` / `m::Widget { .. }`
+    'instance_expression', // scala — `new Monoid[Int] { ... }`
 ]);
 /**
  * TreeSitterExtractor - Main extraction class
@@ -155,11 +234,17 @@ class TreeSitterExtractor {
     extractor = null;
     nodeStack = []; // Stack of parent node IDs
     methodIndex = null; // lookup key → node ID for Pascal defProc lookup
+    // Function-as-value capture (#756): per-language spec + candidates collected
+    // during the walk, gated & flushed into unresolvedReferences at end-of-file
+    // (see flushFnRefCandidates).
+    fnRefSpec;
+    fnRefCandidates = [];
     constructor(filePath, source, language) {
         this.filePath = filePath;
         this.source = source;
         this.language = language || (0, grammars_1.detectLanguage)(filePath, source);
         this.extractor = languages_1.EXTRACTORS[this.language] || null;
+        this.fnRefSpec = function_ref_1.FN_REF_SPECS[this.language];
     }
     /**
      * Parse and extract from the source code
@@ -200,6 +285,14 @@ class TreeSitterExtractor {
             };
         }
         try {
+            // Optional pre-parse source transform (offset-preserving) to work around
+            // grammar gaps — e.g. C# blanks conditional-compilation directive lines
+            // the grammar mis-parses inside enum bodies (#237). We reassign
+            // this.source so downstream getNodeText reads the same bytes the parser
+            // saw (identical outside the blanked directive lines).
+            if (this.extractor?.preParse) {
+                this.source = this.extractor.preParse(this.source);
+            }
             this.tree = parser.parse(this.source) ?? null;
             if (!this.tree) {
                 throw new Error('Parser returned null tree');
@@ -230,6 +323,9 @@ class TreeSitterExtractor {
             if (packageNodeId)
                 this.nodeStack.push(packageNodeId);
             this.visitNode(this.tree.rootNode);
+            // 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();
             if (packageNodeId)
                 this.nodeStack.pop();
             this.nodeStack.pop();
@@ -267,6 +363,157 @@ class TreeSitterExtractor {
             durationMs: Date.now() - startTime,
         };
     }
+    /**
+     * Function-as-value capture (#756): if this node is one of the language's
+     * value-position containers (call arguments, assignment RHS, struct/object
+     * initializer, array/table literal), collect candidate function names from
+     * it. Candidates are gated & flushed at end-of-file (flushFnRefCandidates).
+     */
+    maybeCaptureFnRefs(node, nodeType) {
+        const spec = this.fnRefSpec;
+        if (!spec)
+            return;
+        const rule = spec.dispatch.get(nodeType);
+        if (!rule || this.nodeStack.length === 0)
+            return;
+        const fromNodeId = this.nodeStack[this.nodeStack.length - 1];
+        if (!fromNodeId)
+            return;
+        for (const cand of (0, function_ref_1.captureFnRefCandidates)(node, rule, spec, this.source)) {
+            this.fnRefCandidates.push({ ...cand, fromNodeId });
+        }
+    }
+    /**
+     * Candidates-only scan of a subtree the main walkers won't traverse
+     * (top-level variable initializers). No extraction side effects. Halts at
+     * nested function definitions: their bodies are walked — and their
+     * candidates attributed — by extractFunction's own body walk.
+     */
+    scanFnRefSubtree(node, depth) {
+        if (!this.fnRefSpec || depth > 12)
+            return;
+        const nodeType = node.type;
+        if (depth > 0 && (this.extractor?.functionTypes.includes(nodeType) ||
+            nodeType === 'arrow_function' ||
+            nodeType === 'function_expression' ||
+            nodeType === 'lambda_literal' ||
+            nodeType === 'lambda_expression')) {
+            return;
+        }
+        this.maybeCaptureFnRefs(node, nodeType);
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child)
+                this.scanFnRefSubtree(child, depth + 1);
+        }
+    }
+    /**
+     * Gate captured function-as-value candidates and push survivors as
+     * `function_ref` unresolved references.
+     *
+     * The gate bounds volume and protects precision: a candidate survives only
+     * if its name matches a function/method DEFINED IN THIS FILE or a name this
+     * file imports/references. Everything else (locals, params, fields passed
+     * as arguments) is dropped before it ever reaches the database. Resolution
+     * then matches survivors against function/method nodes only
+     * (matchFunctionRef) and emits `references` edges — which callers/impact
+     * already traverse.
+     *
+     * Known v1 limit, deliberate: a C/C++ callback registered in a DIFFERENT
+     * translation unit than its definition (extern, no symbol imports to match)
+     * is not captured. Same-file registration — the dominant C pattern (static
+     * callback + same-file ops struct) — is.
+     */
+    flushFnRefCandidates() {
+        if (this.fnRefCandidates.length === 0)
+            return;
+        const candidates = this.fnRefCandidates;
+        this.fnRefCandidates = [];
+        // Generated/minified files (vendored jquery.min.js and friends): their
+        // function-as-value edges are noise — single-letter minified symbols
+        // resolve everywhere. Same policy as the callback synthesizer.
+        if ((0, generated_detection_1.isGeneratedFile)(this.filePath))
+            return;
+        const definedHere = new Set();
+        for (const n of this.nodes) {
+            if (n.kind === 'function' || n.kind === 'method')
+                definedHere.add(n.name);
+        }
+        // Import-binding names only (all binding emitters push kind 'imports').
+        // Deliberately NOT 'references': those carry type-annotation and
+        // interface-member names, which let local variables that share a type
+        // member's name slip through the gate (excalidraw A/B finding). A dotted
+        // import (JVM `import com.example.OtherClass`) also contributes its LAST
+        // segment — the simple name Java/Kotlin code uses in `OtherClass::method`
+        // references.
+        const SIMPLE_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+        // JVM imports are dotted (`com.example.OtherClass`); PHP `use` imports
+        // are backslashed (`App\Services\Mailer`). Both contribute their last
+        // segment — the simple name code uses to reference them.
+        const QUALIFIED_IMPORT = /^[A-Za-z_$][A-Za-z0-9_$.\\]*[.\\]([A-Za-z_$][A-Za-z0-9_$]*)$/;
+        const importedNames = new Set();
+        for (const r of this.unresolvedReferences) {
+            if (r.referenceKind !== 'imports')
+                continue;
+            if (SIMPLE_NAME.test(r.referenceName)) {
+                importedNames.add(r.referenceName);
+            }
+            else {
+                const qualified = r.referenceName.match(QUALIFIED_IMPORT);
+                if (qualified)
+                    importedNames.add(qualified[1]);
+            }
+        }
+        const ungated = this.fnRefSpec?.ungatedModes;
+        const addressOfOnly = this.fnRefSpec?.addressOfOnly === true;
+        const seen = new Set();
+        for (const c of candidates) {
+            const atFileScope = c.fromNodeId.startsWith('file:');
+            // C++ (addressOfOnly): a BARE identifier qualifies only inside a
+            // file-scope initializer table. Everywhere else — args, assignments,
+            // local braced-init lists like `{begin, size}` — only explicit `&`
+            // forms count (fmt A/B finding: generic names `begin`/`out`/`size`
+            // collide with locals and members).
+            if (addressOfOnly &&
+                !c.explicitRef &&
+                !(atFileScope && (c.mode === 'value' || c.mode === 'list'))) {
+                continue;
+            }
+            // Gate policy by candidate shape:
+            //  - `this.<member>`: ALWAYS flush — the member may be inherited from a
+            //    class in another file (definedHere can't see it), volume is
+            //    naturally bounded by real `this.X` expressions, and resolution is
+            //    strictly class-scoped (own members or the validated supertype
+            //    pass), so nothing fuzzy can leak.
+            //  - `Scope::member` (C++ member-pointers, Java/Kotlin type-qualified
+            //    method refs, PHP `'Cls::m'`): ALWAYS flush — the explicit-ref
+            //    syntax is self-selecting, the referenced type often needs NO
+            //    import (Java/Kotlin same-package, Kotlin companions), and
+            //    resolution is scope-suffix-anchored + unique-or-drop, so a
+            //    same-named member on another class can't match.
+            //  - C-family file-scope initializers skip the gate entirely
+            //    (constant-expression context — see FnRefSpec.ungatedModes).
+            //  - everything else: name ∈ same-file functions/methods ∪ imports.
+            if (!c.name.startsWith('this.') && !c.name.includes('::')) {
+                const skipGate = (ungated?.has(c.mode) === true && atFileScope) ||
+                    c.skipGate === true; // PHP HOF-position string callables (see FnRefCandidate.skipGate)
+                if (!skipGate && !definedHere.has(c.name) && !importedNames.has(c.name)) {
+                    continue;
+                }
+            }
+            const key = `${c.fromNodeId}|${c.name}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            this.unresolvedReferences.push({
+                fromNodeId: c.fromNodeId,
+                referenceName: c.name,
+                referenceKind: 'function_ref',
+                line: c.line,
+                column: c.column,
+            });
+        }
+    }
     /**
      * Visit a node and extract information
      */
@@ -279,8 +526,14 @@ class TreeSitterExtractor {
         if (this.extractor.visitNode) {
             const ctx = this.makeExtractorContext();
             const handled = this.extractor.visitNode(node, ctx);
-            if (handled)
+            if (handled) {
+                // The hook consumed this subtree, so the walkers below never descend
+                // into it — scan it for function-as-value candidates (#756). Scala's
+                // hook handles val/var definitions (`val table = Seq(targetCb)`), for
+                // example. The scan is capture-only and halts at nested functions.
+                this.scanFnRefSubtree(node, 0);
                 return;
+            }
         }
         // Pascal-specific AST handling
         if (this.language === 'pascal') {
@@ -288,6 +541,10 @@ class TreeSitterExtractor {
             if (skipChildren)
                 return;
         }
+        // Function-as-value capture (#756) — independent of the dispatch ladder
+        // below (the captured container types have no other handler there), so it
+        // can never shadow or be shadowed by an extraction branch.
+        this.maybeCaptureFnRefs(node, nodeType);
         // Check for function declarations
         // For Python/Ruby, function_definition inside a class should be treated as method
         if (this.extractor.functionTypes.includes(nodeType)) {
@@ -329,8 +586,31 @@ class TreeSitterExtractor {
         }
         // Check for method declarations (only if not already handled by functionTypes)
         else if (this.extractor.methodTypes.includes(nodeType)) {
-            this.extractMethod(node);
-            skipChildren = true; // extractMethod visits children via visitFunctionBody
+            // 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') {
+                const propNode = this.extractProperty(node);
+                // Walk the initializer so its calls/instantiations attribute to the
+                // property (`history = createHistory()` → history calls
+                // createHistory). The old field-as-method path never walked these
+                // (resolveBody only resolves function bodies), so this is additive.
+                const valueNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'value');
+                if (propNode && valueNode) {
+                    this.nodeStack.push(propNode.id);
+                    this.visitFunctionBody(valueNode, '');
+                    this.nodeStack.pop();
+                }
+                // A field initializer can also register callbacks
+                // (`static handlers = { click: onClick }`) — scan it for
+                // function-as-value candidates (capture-only, halts at functions).
+                this.scanFnRefSubtree(node, 0);
+                skipChildren = true;
+            }
+            else {
+                this.extractMethod(node);
+                skipChildren = true; // extractMethod visits children via visitFunctionBody
+            }
         }
         // Check for interface/protocol/trait declarations
         else if (this.extractor.interfaceTypes.includes(nodeType)) {
@@ -356,19 +636,70 @@ class TreeSitterExtractor {
         // Check for class properties (e.g. C# property_declaration)
         else if (this.extractor.propertyTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {
             this.extractProperty(node);
+            // Property initializers aren't walked — scan for function-as-value
+            // candidates (#756): Scala `val table = Seq(targetCb)` in an object,
+            // Kotlin `val cb = ::handler` class properties.
+            this.scanFnRefSubtree(node, 0);
             skipChildren = true;
         }
         // Check for class fields (e.g. Java field_declaration, C# field_declaration)
         else if (this.extractor.fieldTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {
             this.extractField(node);
+            // Field initializers aren't walked — scan for function-as-value
+            // candidates (#756): Java `List<IntConsumer> table = List.of(Main::cb)`,
+            // C# `List<Action<int>> table = new() { TargetCb }`.
+            this.scanFnRefSubtree(node, 0);
             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()) {
             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
+            // declaration subtree for function-as-value candidates — `const routes =
+            // { home: renderHome }`, `handlers = {"recv": target_cb}`. The scan halts
+            // at nested function definitions (their bodies are walked — and
+            // attributed — separately) and flush-time dedup absorbs any overlap with
+            // initializers extractVariable DOES walk.
+            this.scanFnRefSubtree(node, 0);
             skipChildren = true; // extractVariable handles children
         }
+        // Swift stored properties inside a type. Swift instance properties aren't
+        // extracted as their own nodes, but a property's PROPERTY WRAPPER
+        // (`@Argument`/`@Published`/`@State`/custom) and declared type ARE
+        // dependencies — attribute them to the enclosing type so the wrapper/type
+        // files get dependents. Don't skipChildren: an initializer's calls still
+        // matter. (Other languages extract properties via property/field types.)
+        else if (this.language === 'swift' &&
+            nodeType === 'property_declaration' &&
+            this.isInsideClassLikeNode()) {
+            const ownerId = this.nodeStack[this.nodeStack.length - 1];
+            if (ownerId) {
+                this.extractDecoratorsFor(node, ownerId);
+                this.extractVariableTypeAnnotation(node, ownerId);
+                // Fluent / SwiftUI property-wrapper attributes often reference a model or
+                // type by metatype in their ARGUMENTS — `@Siblings(through: Pivot.self,
+                // …)`, `@Group(…)`. extractDecoratorsFor captures the wrapper type
+                // (`Siblings`); this pulls the TYPE out of the argument expressions
+                // (`Pivot.self` → a dependency on Pivot), so a model reached ONLY through
+                // a relationship (a many-to-many pivot/join model) isn't left orphaned.
+                // extractStaticMemberRef self-filters to `Type.member` navigation, so the
+                // `\.$keypath` arguments and the wrapper `user_type` are skipped.
+                const modifiers = node.namedChildren.find((c) => c.type === 'modifiers');
+                if (modifiers) {
+                    const walkAttrArgs = (n) => {
+                        this.extractStaticMemberRef(n);
+                        for (let i = 0; i < n.namedChildCount; i++) {
+                            const c = n.namedChild(i);
+                            if (c)
+                                walkAttrArgs(c);
+                        }
+                    };
+                    walkAttrArgs(modifiers);
+                }
+            }
+        }
         // `export_statement` itself is not extracted — the walker descends
         // into children, where the inner declaration (lexical_declaration,
         // function_declaration, class_declaration, etc.) is dispatched to
@@ -386,6 +717,21 @@ class TreeSitterExtractor {
         else if (this.extractor.importTypes.includes(nodeType)) {
             this.extractImport(node);
         }
+        // Re-export from another module — `export { X } from './y'` (TS/JS). A
+        // re-export is a dependency on the source module just like an import, but
+        // the export_statement is otherwise only descended into (no declaration to
+        // extract), so a barrel that ONLY re-exports produced zero edges and showed
+        // 0 dependents. Link each re-exported name to its definition. Children are
+        // still visited (a non-re-export `export const X = …` has no `source` and
+        // falls through to its normal declaration extraction).
+        else if (nodeType === 'export_statement' &&
+            (this.language === 'typescript' || this.language === 'tsx' ||
+                this.language === 'javascript' || this.language === 'jsx') &&
+            (0, tree_sitter_helpers_1.getChildByField)(node, 'source')) {
+            const parentId = this.nodeStack[this.nodeStack.length - 1];
+            if (parentId)
+                this.emitReExportRefs(node, parentId);
+        }
         // Check for function calls
         else if (this.extractor.callTypes.includes(nodeType)) {
             this.extractCall(node);
@@ -477,6 +823,14 @@ class TreeSitterExtractor {
             updatedAt: Date.now(),
             ...extra,
         };
+        // Persist extra symbol-level modifiers (e.g. Kotlin `expect`/`actual`) onto
+        // the node's decorators list so the resolver can pair multiplatform
+        // declarations with their implementations. Merged, not overwritten, so a
+        // language that also captures real annotations keeps both.
+        const mods = this.extractor?.extractModifiers?.(node);
+        if (mods && mods.length > 0) {
+            newNode.decorators = [...(newNode.decorators ?? []), ...mods];
+        }
         this.nodes.push(newNode);
         // Add containment edge from parent
         if (this.nodeStack.length > 0) {
@@ -616,8 +970,19 @@ class TreeSitterExtractor {
                 }
             }
         }
-        if (name === '<anonymous>')
-            return; // Skip anonymous functions
+        if (name === '<anonymous>') {
+            // Don't emit a node for the anonymous wrapper itself, but still visit its
+            // body: AMD/RequireJS and CommonJS module wrappers (`define([], function(){…})`,
+            // `(function(){…})()`) hold named inner functions and calls that would
+            // otherwise be lost — the dispatcher set skipChildren, so nothing else
+            // descends into this subtree. (#528)
+            const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+                ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+            if (body) {
+                this.visitFunctionBody(body, '');
+            }
+            return;
+        }
         // Check for misparse artifacts (e.g. C++ macros causing "namespace detail" functions)
         // Skip the node but still visit the body for calls and structural nodes
         if (this.extractor.isMisparsedFunction?.(name, node)) {
@@ -634,6 +999,7 @@ class TreeSitterExtractor {
         const isExported = 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);
         const funcNode = this.createNode('function', name, node, {
             docstring,
             signature,
@@ -641,6 +1007,7 @@ class TreeSitterExtractor {
             isExported,
             isAsync,
             isStatic,
+            returnType,
         });
         if (!funcNode)
             return;
@@ -678,6 +1045,8 @@ class TreeSitterExtractor {
             return;
         // Extract extends/implements
         this.extractInheritance(node, classNode.id);
+        // C# primary-constructor parameter dependencies (`class Svc(IRepo r, …)`).
+        this.extractCsharpPrimaryCtorParamRefs(node, classNode.id);
         // Extract decorators applied to the class (`@Foo class X {}`).
         this.extractDecoratorsFor(node, classNode.id);
         // Push to stack and visit body
@@ -738,12 +1107,14 @@ class TreeSitterExtractor {
         const visibility = this.extractor.getVisibility?.(node);
         const isAsync = this.extractor.isAsync?.(node);
         const isStatic = this.extractor.isStatic?.(node);
+        const returnType = this.extractor.getReturnType?.(node, this.source);
         const extraProps = {
             docstring,
             signature,
             visibility,
             isAsync,
             isStatic,
+            returnType,
         };
         if (receiverType) {
             extraProps.qualifiedName = `${receiverType}::${name}`;
@@ -817,8 +1188,10 @@ class TreeSitterExtractor {
         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)
         const body = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
-        if (!body)
+        if (!body && node.type !== 'record_declaration')
             return;
         const name = extractName(node, this.source, this.extractor);
         const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
@@ -833,15 +1206,21 @@ class TreeSitterExtractor {
             return;
         // Extract inheritance (e.g. Swift: struct HTTPMethod: RawRepresentable)
         this.extractInheritance(node, structNode.id);
-        // Push to stack for field extraction
-        this.nodeStack.push(structNode.id);
-        for (let i = 0; i < body.namedChildCount; i++) {
-            const child = body.namedChild(i);
-            if (child) {
-                this.visitNode(child);
+        // 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);
+        // Push to stack for field extraction (bodiless positional records have
+        // no members to visit)
+        if (body) {
+            this.nodeStack.push(structNode.id);
+            for (let i = 0; i < body.namedChildCount; i++) {
+                const child = body.namedChild(i);
+                if (child) {
+                    this.visitNode(child);
+                }
             }
+            this.nodeStack.pop();
         }
-        this.nodeStack.pop();
     }
     /**
      * Extract an enum
@@ -914,22 +1293,35 @@ class TreeSitterExtractor {
      */
     extractProperty(node) {
         if (!this.extractor)
-            return;
+            return null;
         const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
         const isStatic = this.extractor.isStatic?.(node) ?? false;
         const hookName = this.extractor.extractPropertyName?.(node, this.source);
+        // JS `field_definition` names its key the `property` field (TS uses
+        // `name`) — try both before the generic identifier scan (#808).
         const nameNode = hookName
             ? null
-            : (0, tree_sitter_helpers_1.getChildByField)(node, 'name') || node.namedChildren.find(c => c.type === 'identifier');
+            : (0, tree_sitter_helpers_1.getChildByField)(node, 'name') ||
+                (0, tree_sitter_helpers_1.getChildByField)(node, 'property') ||
+                node.namedChildren.find(c => c.type === 'identifier');
         const name = hookName ?? (nameNode ? (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source) : null);
         if (!name)
-            return;
-        // Get property type from the type child (first named child that isn't modifier or identifier)
-        const typeNode = node.namedChildren.find(c => c.type !== 'modifier' && c.type !== 'modifiers'
-            && c.type !== 'identifier' && c.type !== 'accessor_list'
-            && c.type !== 'accessors' && c.type !== 'equals_value_clause');
-        const typeText = typeNode ? (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source) : undefined;
+            return null;
+        // Get property type. TS/JS field definitions carry an explicit `type`
+        // field (a `type_annotation`); their other named children are the name
+        // 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';
+        const typeNode = isTsJsField
+            ? (0, tree_sitter_helpers_1.getChildByField)(node, 'type')
+            : node.namedChildren.find(c => c.type !== 'modifier' && c.type !== 'modifiers'
+                && c.type !== 'identifier' && c.type !== 'accessor_list'
+                && c.type !== 'accessors' && c.type !== 'equals_value_clause');
+        const typeText = typeNode
+            ? (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source).replace(/^:\s*/, '')
+            : undefined;
         const signature = typeText ? `${typeText} ${name}` : name;
         const propNode = this.createNode('property', name, node, {
             docstring,
@@ -946,6 +1338,7 @@ class TreeSitterExtractor {
             // `type_annotation` children; the C# branch walks the `type` field.
             this.extractTypeAnnotations(node, propNode.id);
         }
+        return propNode;
     }
     /**
      * Extract a class field declaration (e.g. Java field_declaration, C# field_declaration).
@@ -1042,6 +1435,114 @@ class TreeSitterExtractor {
             }
         }
     }
+    /**
+     * Extract function-valued properties of an object literal as named function
+     * nodes (named by their property key). Shared by the two object-of-functions
+     * shapes in extractVariable: the object as a direct const value, and the
+     * object returned by a store-initializer call. Handles both `key: () => {}` /
+     * `key: function() {}` pairs and method shorthand `key() {}`.
+     */
+    extractObjectLiteralFunctions(obj) {
+        for (let i = 0; i < obj.namedChildCount; i++) {
+            const member = obj.namedChild(i);
+            if (!member)
+                continue;
+            if (member.type === 'pair') {
+                const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'key');
+                const value = (0, tree_sitter_helpers_1.getChildByField)(member, 'value');
+                if (key && value && (value.type === 'arrow_function' || value.type === 'function_expression')) {
+                    this.extractFunction(value, this.objectKeyName(key));
+                }
+            }
+            else if (member.type === 'method_definition') {
+                // Method shorthand: `{ fetchUser() {...} }`. extractMethod deliberately
+                // skips object-literal methods, so route through extractFunction with an
+                // explicit name (method_definition exposes a `body` field, so resolveBody
+                // falls through to it and the node spans the full method).
+                const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'name');
+                if (key)
+                    this.extractFunction(member, this.objectKeyName(key));
+            }
+        }
+    }
+    /** Property-key text with surrounding quotes stripped (`'foo'` → `foo`). */
+    objectKeyName(key) {
+        return (0, tree_sitter_helpers_1.getNodeText)(key, this.source).replace(/^['"`]|['"`]$/g, '');
+    }
+    /**
+     * Given a `call_expression` initializer (`create((set, get) => ({...}))`),
+     * find the object literal RETURNED by a function argument — descending through
+     * nested call_expression arguments so middleware wrappers are unwrapped
+     * (`create(persist((set, get) => ({...}), {...}))`, devtools, immer,
+     * subscribeWithSelector). Returns null when no such object is found — the
+     * common case for ordinary call initializers — so this stays cheap and silent
+     * rather than guessing. Keyed purely on AST shape; no library names.
+     */
+    findInitializerReturnedObject(callNode, depth = 0) {
+        if (depth > 4)
+            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)
+                continue;
+            if (arg.type === 'arrow_function' || arg.type === 'function_expression') {
+                const obj = this.functionReturnedObject(arg);
+                if (obj)
+                    return obj;
+            }
+            else if (arg.type === 'call_expression') {
+                const obj = this.findInitializerReturnedObject(arg, depth + 1);
+                if (obj)
+                    return obj;
+            }
+        }
+        return null;
+    }
+    /**
+     * The object literal a function expression returns — either the `=> ({...})`
+     * arrow form (a parenthesized_expression wrapping an object) or a
+     * `=> { return {...} }` block. Returns null for any other body shape.
+     */
+    functionReturnedObject(fnNode) {
+        const body = (0, tree_sitter_helpers_1.getChildByField)(fnNode, 'body');
+        if (!body)
+            return null;
+        const asObject = (n) => {
+            if (!n)
+                return null;
+            if (n.type === 'object' || n.type === 'object_expression')
+                return n;
+            if (n.type === 'parenthesized_expression') {
+                for (let i = 0; i < n.namedChildCount; i++) {
+                    const inner = asObject(n.namedChild(i));
+                    if (inner)
+                        return inner;
+                }
+            }
+            return null;
+        };
+        // `(set, get) => ({...})` — body is the (parenthesized) object directly.
+        const direct = asObject(body);
+        if (direct)
+            return direct;
+        // `(set, get) => { return {...} }` — scan top-level return statements.
+        if (body.type === 'statement_block') {
+            for (let i = 0; i < body.namedChildCount; i++) {
+                const stmt = body.namedChild(i);
+                if (stmt?.type !== 'return_statement')
+                    continue;
+                for (let j = 0; j < stmt.namedChildCount; j++) {
+                    const obj = asObject(stmt.namedChild(j));
+                    if (obj)
+                        return obj;
+                }
+            }
+        }
+        return null;
+    }
     /**
      * Extract a variable declaration (const, let, var, etc.)
      *
@@ -1093,29 +1594,41 @@ class TreeSitterExtractor {
                         if (varNode) {
                             this.extractVariableTypeAnnotation(child, varNode.id);
                         }
+                        // Exported const object-of-functions — extract each function-valued
+                        // property as a function named by its key + walk its body so its
+                        // calls are captured. Two shapes, both keyed on AST shape (not on any
+                        // library name):
+                        //   `export const actions = { default: async () => {} }` — object is
+                        //     the DIRECT value (SvelteKit form actions / handler maps / route
+                        //     tables).
+                        //   `export const useStore = create((set, get) => ({ fetchUser:
+                        //     async () => {} }))` — object is RETURNED by an initializer call,
+                        //     possibly through middleware wrappers (persist/devtools/immer).
+                        //     Covers Zustand/Redux/Pinia/MobX stores generically. Without
+                        //     this, store actions exist only as object-literal properties —
+                        //     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.
+                        const objectOfFns = valueNode && (valueNode.type === 'object' || valueNode.type === 'object_expression')
+                            ? valueNode
+                            : valueNode?.type === 'call_expression'
+                                ? this.findInitializerReturnedObject(valueNode)
+                                : null;
+                        const extractObjectMethods = isExported && !!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).
                         if (valueNode &&
                             valueNode.type !== 'object' &&
-                            valueNode.type !== 'object_expression') {
+                            valueNode.type !== 'object_expression' &&
+                            !(extractObjectMethods && valueNode.type === 'call_expression')) {
                             this.visitFunctionBody(valueNode, '');
                         }
-                        // Exported const object-of-functions: `export const actions =
-                        // { default: async () => {} }` (SvelteKit form actions / handler maps
-                        // / route tables). Extract each function-valued property as a function
-                        // named by its key + walk its body so its calls (e.g. api.post) are
-                        // captured. Scoped to EXPORTED consts to exclude the inline-object
-                        // noise (`ctx.set({...})`) the object-method skip deliberately avoids.
-                        if (isExported && valueNode &&
-                            (valueNode.type === 'object' || valueNode.type === 'object_expression')) {
-                            for (let j = 0; j < valueNode.namedChildCount; j++) {
-                                const pair = valueNode.namedChild(j);
-                                if (pair?.type !== 'pair')
-                                    continue;
-                                const v = (0, tree_sitter_helpers_1.getChildByField)(pair, 'value');
-                                const k = (0, tree_sitter_helpers_1.getChildByField)(pair, 'key');
-                                if (k && v && (v.type === 'arrow_function' || v.type === 'function_expression')) {
-                                    this.extractFunction(v, (0, tree_sitter_helpers_1.getNodeText)(k, this.source).replace(/^['"`]|['"`]$/g, ''));
-                                }
-                            }
+                        if (extractObjectMethods && objectOfFns) {
+                            this.extractObjectLiteralFunctions(objectOfFns);
                         }
                     }
                 }
@@ -1143,16 +1656,34 @@ class TreeSitterExtractor {
             const specs = node.namedChildren.filter(c => c.type === 'var_spec' || c.type === 'const_spec');
             for (const spec of specs) {
                 const nameNode = spec.namedChild(0);
+                let varNode = null;
                 if (nameNode && nameNode.type === 'identifier') {
                     const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                     const valueNode = spec.namedChildCount > 1 ? spec.namedChild(spec.namedChildCount - 1) : 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(node.type === 'const_declaration' ? 'constant' : 'variable', name, spec, {
+                    varNode = this.createNode(node.type === 'const_declaration' ? 'constant' : 'variable', name, spec, {
                         docstring,
                         signature: initSignature,
                     });
                 }
+                // Walk the initializer so composite literals and calls in a
+                // package-level `var Query Binding = queryBinding{}` (a registry of
+                // implementations) or `var c = pkg.New()` are extracted as
+                // instantiates/calls dependencies — the body walker only covers
+                // initializers inside functions, not these top-level declarations.
+                // Scope the walk to the declared symbol so a call inside an anonymous
+                // func_literal initializer — a cobra `RunE: func(){…}` handler, a
+                // goroutine or callback closure — attributes to the var instead of
+                // leaking to the file node (which reads as "no caller"), issue #693.
+                const valueField = (0, tree_sitter_helpers_1.getChildByField)(spec, 'value');
+                if (valueField) {
+                    if (varNode)
+                        this.nodeStack.push(varNode.id);
+                    this.visitFunctionBody(valueField, varNode?.id ?? '');
+                    if (varNode)
+                        this.nodeStack.pop();
+                }
             }
             // Handle short_var_declaration (:=)
             if (node.type === 'short_var_declaration') {
@@ -1290,6 +1821,13 @@ class TreeSitterExtractor {
             const typeChild = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
             if (typeChild)
                 this.extractInheritance(typeChild, interfaceNode.id);
+            // Go: extract the interface's method specs as `method` nodes so implicit
+            // interface satisfaction (a struct's method set ⊇ the interface's) and
+            // impl-navigation can see the contract. Go has no `implements` keyword, so
+            // without the interface's method set there's nothing to match against.
+            if (this.language === 'go' && typeChild) {
+                this.extractGoInterfaceMethods(typeChild, interfaceNode.id);
+            }
             return true;
         }
         const typeAliasNode = this.createNode('type_alias', name, node, {
@@ -1309,11 +1847,39 @@ class TreeSitterExtractor {
                 // an unrelated class method picked by path-proximity (#359).
                 if (this.language === 'typescript' || this.language === 'tsx') {
                     this.extractTsTypeAliasMembers(value, typeAliasNode);
+                    // `type List = [ Service<'name', Req, Resp>, … ]` — surface each
+                    // entry's string-literal name as a searchable member (issue #634).
+                    this.extractTsTupleContractNames(value, typeAliasNode);
                 }
             }
         }
         return false;
     }
+    /**
+     * Extract the method specs of a Go `interface_type` body as `method` nodes
+     * contained by the interface (e.g. `Marshal`, `Unmarshal` of a `Core`
+     * interface). tree-sitter-go names these `method_elem` (newer) or
+     * `method_spec` (older). Embedded interfaces (`Reader` inside `ReadWriter`)
+     * are `type_identifier`s, not methods, and are left to inheritance extraction.
+     */
+    extractGoInterfaceMethods(interfaceType, ifaceId) {
+        this.nodeStack.push(ifaceId);
+        for (let i = 0; i < interfaceType.namedChildCount; i++) {
+            const m = interfaceType.namedChild(i);
+            if (!m || (m.type !== 'method_elem' && m.type !== 'method_spec'))
+                continue;
+            const nameNode = (0, tree_sitter_helpers_1.getChildByField)(m, 'name') ?? m.namedChild(0);
+            if (!nameNode)
+                continue;
+            const mname = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+            if (mname) {
+                this.createNode('method', mname, m, {
+                    signature: this.extractor?.getSignature?.(m, this.source),
+                });
+            }
+        }
+        this.nodeStack.pop();
+    }
     /**
      * Surface the members of a TypeScript `type X = { ... }` (or intersection
      * thereof) as `property` / `method` nodes under the type-alias node. Only
@@ -1370,6 +1936,82 @@ class TreeSitterExtractor {
         }
         this.nodeStack.pop();
     }
+    /**
+     * Surface the string-literal "names" of a TypeScript service/contract
+     * registry written as a tuple of generic instantiations:
+     *
+     *   type MyServiceList = [
+     *     Service<'query_apply_record', Req, Resp>,
+     *     Service<'apply_confirm', Req, Resp>,
+     *   ];
+     *
+     * Each `Service<'name', …>` tags an entry with a string-literal name that a
+     * dynamic factory (`createService<MyServiceList>()`) turns into a callable
+     * property (`api.query_apply_record(…)`). Static extraction otherwise never
+     * sees that name — it's a type argument, not a declaration — so
+     * `codegraph query query_apply_record` returned nothing (issue #634). We emit
+     * each name as a `method` node under the type alias (qualifiedName
+     * `MyServiceList::query_apply_record`) so it's searchable and resolvable as a
+     * symbol. (A call through the proxy, `api.query_apply_record(…)`, still
+     * resolves to the imported `api` binding — the receiver's type isn't known —
+     * so this fixes discoverability, not the per-method call edge.)
+     *
+     * Scope is deliberately narrow to avoid noise: only a string literal that is
+     * a DIRECT type argument of a `generic_type` that is itself a DIRECT element
+     * of a `tuple_type`. This excludes utility types (`Pick`/`Omit`/`Record` are
+     * never written as tuples) and string args nested deeper
+     * (`Service<'a', Pick<U, 'id'>>` yields only `a`, never `id`). Names must be
+     * valid identifiers, which also rules out route paths / arbitrary strings.
+     */
+    extractTsTupleContractNames(value, typeAliasNode) {
+        const tuples = [];
+        const collectTuples = (n, depth) => {
+            if (depth > 6)
+                return; // a type expression is shallow; cap defensively
+            if (n.type === 'tuple_type')
+                tuples.push(n);
+            for (let i = 0; i < n.namedChildCount; i++) {
+                const c = n.namedChild(i);
+                if (c)
+                    collectTuples(c, depth + 1);
+            }
+        };
+        collectTuples(value, 0);
+        if (tuples.length === 0)
+            return;
+        this.nodeStack.push(typeAliasNode.id);
+        for (const tuple of tuples) {
+            for (let i = 0; i < tuple.namedChildCount; i++) {
+                const entry = tuple.namedChild(i);
+                if (!entry || entry.type !== 'generic_type')
+                    continue;
+                const typeArgs = (0, tree_sitter_helpers_1.getChildByField)(entry, 'type_arguments');
+                if (!typeArgs)
+                    continue;
+                for (let j = 0; j < typeArgs.namedChildCount; j++) {
+                    const arg = typeArgs.namedChild(j);
+                    if (!arg || arg.type !== 'literal_type')
+                        continue;
+                    // literal_type wraps the actual literal; only a string is a name.
+                    const strNode = arg.namedChild(0);
+                    if (!strNode || strNode.type !== 'string')
+                        continue;
+                    const name = (0, tree_sitter_helpers_1.getNodeText)(strNode, this.source)
+                        .trim()
+                        .replace(/^['"`]/, '')
+                        .replace(/['"`]$/, '');
+                    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name))
+                        continue;
+                    const signature = (0, tree_sitter_helpers_1.getNodeText)(entry, this.source).replace(/\s+/g, ' ').trim().slice(0, 120);
+                    this.createNode('method', name, entry, {
+                        signature,
+                        qualifiedName: `${typeAliasNode.name}::${name}`,
+                    });
+                }
+            }
+        }
+        this.nodeStack.pop();
+    }
     /**
      * `foo: () => T` → property_signature whose type_annotation contains a
      * `function_type`. Treat that as a method-shaped contract member, since
@@ -1421,6 +2063,48 @@ class TreeSitterExtractor {
                         });
                     }
                 }
+                // Link each imported binding to its definition so imported-but-not-
+                // called/typed symbols still record a cross-file dependency (TS/JS only).
+                if (this.language === 'typescript' || this.language === 'tsx' ||
+                    this.language === 'javascript' || this.language === 'jsx') {
+                    const parentId = this.nodeStack[this.nodeStack.length - 1];
+                    if (parentId)
+                        this.emitImportBindingRefs(node, parentId);
+                }
+                // Python `from module import X, Y` — link each imported name to its
+                // definition (covers `__init__.py` re-export barrels, which are just
+                // `from .sub import X`). Same recall gap as TS: a name imported and
+                // used in a non-call position created no dependency edge.
+                if (this.language === 'python' && node.type === 'import_from_statement') {
+                    const parentId = this.nodeStack[this.nodeStack.length - 1];
+                    if (parentId)
+                        this.emitPyFromImportRefs(node, parentId);
+                }
+                // Rust `use crate::m::Item;` / `pub use self::sub::Item;` — link each
+                // imported leaf to its definition. Covers `pub use` re-export hubs
+                // (a `mod.rs` re-exporting submodule items, e.g. tokio's `fs/mod.rs`)
+                // and items imported but used in non-call/non-type positions.
+                if (this.language === 'rust' && node.type === 'use_declaration') {
+                    const parentId = this.nodeStack[this.nodeStack.length - 1];
+                    if (parentId)
+                        this.emitRustUseBindingRefs(node, parentId);
+                }
+                // PHP `use Foo\Bar\Baz;` — link to the namespace-qualified definition so
+                // an imported-but-DI-injected contract (Laravel's pattern) records a
+                // cross-file dependency. Grouped imports are handled in their own branch.
+                if (this.language === 'php' && node.type === 'namespace_use_declaration') {
+                    const parentId = this.nodeStack[this.nodeStack.length - 1];
+                    if (parentId)
+                        this.emitPhpUseRefs(node, parentId);
+                }
+                // Ruby `require "lib/foo"` / `require_relative "../foo"` — resolve to the
+                // required FILE so a file pulled in only by `require` (config-loaded
+                // components, gems that don't autoload) records a cross-file dependency.
+                if (this.language === 'ruby' && node.type === 'call') {
+                    const parentId = this.nodeStack[this.nodeStack.length - 1];
+                    if (parentId)
+                        this.emitRubyRequireRefs(node, parentId);
+                }
                 return;
             }
             // Hook returned null — fall through to multi-import inline handlers only
@@ -1430,12 +2114,31 @@ class TreeSitterExtractor {
         // Multi-import cases that create multiple nodes (can't be expressed with single-return hook)
         // Python import_statement: import os, sys (creates one import per module)
         if (this.language === 'python' && node.type === 'import_statement') {
+            const importParentId = this.nodeStack[this.nodeStack.length - 1];
+            // A bare `import a.b.c` of an internal module (the standard Django
+            // `AppConfig.ready(): import myapp.signals` registration pattern, and any
+            // `import pkg.mod` used for its side effects) had no edge to the module
+            // file — only `from x import y` was linked. Push an `imports` ref (like
+            // Go) so the resolver maps the dotted path to its file. Stdlib/external
+            // modules naturally don't resolve (no `os.py` file node in the repo).
+            const pushModuleRef = (dotted) => {
+                if (!importParentId)
+                    return;
+                this.unresolvedReferences.push({
+                    fromNodeId: importParentId,
+                    referenceName: (0, tree_sitter_helpers_1.getNodeText)(dotted, this.source),
+                    referenceKind: 'imports',
+                    line: dotted.startPosition.row + 1,
+                    column: dotted.startPosition.column,
+                });
+            };
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
                 if (child?.type === 'dotted_name') {
                     this.createNode('import', (0, tree_sitter_helpers_1.getNodeText)(child, this.source), node, {
                         signature: importText,
                     });
+                    pushModuleRef(child);
                 }
                 else if (child?.type === 'aliased_import') {
                     const dottedName = child.namedChildren.find(c => c.type === 'dotted_name');
@@ -1443,6 +2146,7 @@ class TreeSitterExtractor {
                         this.createNode('import', (0, tree_sitter_helpers_1.getNodeText)(dottedName, this.source), node, {
                             signature: importText,
                         });
+                        pushModuleRef(dottedName);
                     }
                 }
             }
@@ -1503,6 +2207,9 @@ class TreeSitterExtractor {
                         this.createNode('import', fullPath, node, {
                             signature: importText,
                         });
+                        const parentId = this.nodeStack[this.nodeStack.length - 1];
+                        if (parentId)
+                            this.pushPhpUseRef(fullPath, parentId, node);
                     }
                 }
                 return;
@@ -1516,6 +2223,285 @@ class TreeSitterExtractor {
             signature: importText,
         });
     }
+    /**
+     * Emit one `imports` reference per named/default import binding (TS/JS family),
+     * attributed to the file node — so the resolver links each imported symbol to
+     * the file that DEFINES it.
+     *
+     * Importing a symbol IS a dependency, but extraction only emits references for
+     * calls, instantiations, type annotations, and inheritance. A symbol that's
+     * imported and then only re-exported (`export { X } from './x'`), placed in a
+     * registry array (`[expressResolver, …]`), passed as an argument, or used in
+     * JSX produced NO cross-file edge at all — so the providing file showed a
+     * false "0 dependents" and was invisible to blast-radius / `affected`. The
+     * resolver maps the local name (alias-aware) to the provider's definition and
+     * creates a cross-file `imports` edge; `getFileDependents` picks it up, while
+     * `getImpactRadius` keeps it as a bounded leaf (the importing file node).
+     *
+     * Namespace imports (`import * as NS`) bind a whole module: `NS.member` calls
+     * resolve on their own, but a namespace used ONLY via a value-member read
+     * (`NS.SOME_CONST`) would leave no edge — so we also emit the namespace local
+     * name, which the resolver links to the module FILE as a dependency backstop.
+     */
+    emitImportBindingRefs(node, fromNodeId) {
+        const clause = node.namedChildren.find((c) => c.type === 'import_clause');
+        if (!clause)
+            return; // side-effect import (`import './x'`) — no bindings
+        const pushRef = (nameNode) => {
+            if (!nameNode)
+                return;
+            const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+            if (!name)
+                return;
+            this.unresolvedReferences.push({
+                fromNodeId,
+                referenceName: name,
+                referenceKind: 'imports',
+                line: nameNode.startPosition.row + 1,
+                column: nameNode.startPosition.column,
+            });
+        };
+        for (const child of clause.namedChildren) {
+            if (child.type === 'identifier') {
+                // default import: `import Foo from './x'`
+                pushRef(child);
+            }
+            else if (child.type === 'named_imports') {
+                // `import { A, B as C } from './x'` — link the LOCAL name (alias if any)
+                for (const spec of child.namedChildren) {
+                    if (spec.type !== 'import_specifier')
+                        continue;
+                    pushRef((0, tree_sitter_helpers_1.getChildByField)(spec, 'alias') ?? (0, tree_sitter_helpers_1.getChildByField)(spec, 'name') ?? spec.namedChild(0));
+                }
+            }
+            else if (child.type === 'namespace_import') {
+                // `import * as NS from './x'` — emit NS so the module-import backstop can
+                // record the file dependency even if NS is only used by value-member read.
+                pushRef(child.namedChildren.find((c) => c.type === 'identifier') ?? child.namedChild(0));
+            }
+        }
+    }
+    /**
+     * Emit one `imports` reference per re-exported binding of a
+     * `export { A, B as C } from './y'` statement, attributed to the file node —
+     * so a barrel that re-exports from another module records a dependency on it.
+     *
+     * Links the SOURCE-side name (`A`, the `name` field — not the local alias
+     * `C`), since that is what the source module defines. `export * from './y'`
+     * has no named bindings to attribute and `export { default as X }` can't be
+     * name-matched, so both are skipped.
+     */
+    emitReExportRefs(node, fromNodeId) {
+        const clause = node.namedChildren.find((c) => c.type === 'export_clause');
+        if (!clause)
+            return; // `export * from './y'` — no named bindings
+        for (const spec of clause.namedChildren) {
+            if (spec.type !== 'export_specifier')
+                continue;
+            const nameNode = (0, tree_sitter_helpers_1.getChildByField)(spec, 'name') ?? spec.namedChild(0);
+            if (!nameNode)
+                continue;
+            const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+            if (!name || name === 'default')
+                continue;
+            this.unresolvedReferences.push({
+                fromNodeId,
+                referenceName: name,
+                referenceKind: 'imports',
+                line: nameNode.startPosition.row + 1,
+                column: nameNode.startPosition.column,
+            });
+        }
+    }
+    /**
+     * Emit one `imports` reference per binding of a Rust `use` declaration —
+     * `use crate::m::Item`, `use crate::m::{A, B as C}`, `pub use self::sub::Item`.
+     * Emits the FULL path (e.g. `self::sub::Item`, not just `Item`) so the resolver
+     * can resolve the module prefix to a file and find the leaf symbol there —
+     * disambiguating common-name re-exports (`pub use self::read::read`, where the
+     * leaf `read` collides with many same-named symbols). Falls back to name-match
+     * on the leaf when the path can't be resolved. `use ...::*` has no leaf binding.
+     */
+    emitRustUseBindingRefs(node, fromNodeId) {
+        const paths = [];
+        const join = (prefix, seg) => (prefix ? `${prefix}::${seg}` : seg);
+        const collect = (n, prefix) => {
+            switch (n.type) {
+                case 'identifier':
+                    paths.push({ text: join(prefix, (0, tree_sitter_helpers_1.getNodeText)(n, this.source)), node: n });
+                    break;
+                case 'scoped_identifier': {
+                    // Full scoped path (`a::b::C`); combine with any outer group prefix.
+                    const full = (0, tree_sitter_helpers_1.getNodeText)(n, this.source).trim();
+                    paths.push({ text: prefix ? `${prefix}::${full}` : full, node: n });
+                    break;
+                }
+                case 'scoped_use_list': {
+                    // `path::{ ... }` — the group's path becomes the prefix for each item.
+                    const pathNode = (0, tree_sitter_helpers_1.getChildByField)(n, 'path');
+                    const seg = pathNode ? (0, tree_sitter_helpers_1.getNodeText)(pathNode, this.source).trim() : '';
+                    const newPrefix = seg ? join(prefix, seg) : prefix;
+                    const list = (0, tree_sitter_helpers_1.getChildByField)(n, 'list') ?? n.namedChildren.find((c) => c.type === 'use_list');
+                    if (list)
+                        collect(list, newPrefix);
+                    break;
+                }
+                case 'use_list':
+                    for (let i = 0; i < n.namedChildCount; i++) {
+                        const c = n.namedChild(i);
+                        if (c)
+                            collect(c, prefix);
+                    }
+                    break;
+                case 'use_as_clause': {
+                    // `Path as Alias` → link the source path (the definition), not the alias.
+                    const p = (0, tree_sitter_helpers_1.getChildByField)(n, 'path') ?? n.namedChild(0);
+                    if (p)
+                        collect(p, prefix);
+                    break;
+                }
+                // use_wildcard → no specific binding to link.
+            }
+        };
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c)
+                collect(c, '');
+        }
+        for (const p of paths) {
+            // The leaf must be a real name (skip a path that is only `self`/`super`/`crate`).
+            const leaf = p.text.split('::').pop();
+            if (!leaf || leaf === 'self' || leaf === 'super' || leaf === 'crate' || leaf === '*')
+                continue;
+            this.unresolvedReferences.push({
+                fromNodeId,
+                referenceName: p.text,
+                referenceKind: 'imports',
+                line: p.node.startPosition.row + 1,
+                column: p.node.startPosition.column,
+            });
+        }
+    }
+    /**
+     * Emit an `imports` reference for a single PHP `use Foo\Bar\Baz;` (grouped
+     * imports `use Foo\{A, B}` are handled where their per-item nodes are created).
+     * The reference targets the namespace-qualified `Foo\Bar::Baz` form classes are
+     * stored under (see the PHP `namespace` capture), so it resolves to the RIGHT
+     * definition — Laravel has many same-named contracts (`Factory`, `Dispatcher`,
+     * `Guard`) across namespaces that a bare-name match can't disambiguate.
+     */
+    emitPhpUseRefs(node, fromNodeId) {
+        const clause = node.namedChildren.find((c) => c.type === 'namespace_use_clause');
+        if (!clause)
+            return;
+        const qn = clause.namedChildren.find((c) => c.type === 'qualified_name')
+            ?? clause.namedChildren.find((c) => c.type === 'name');
+        if (qn)
+            this.pushPhpUseRef((0, tree_sitter_helpers_1.getNodeText)(qn, this.source), fromNodeId, node);
+    }
+    /**
+     * Ruby `require`/`require_relative` → an `imports` ref to the required FILE.
+     * `require "sidekiq/fetch"` is load-path-relative (matched by file-path suffix
+     * via {@link matchByFilePath}); `require_relative "../foo"` is resolved against
+     * this file's directory. Bare gem/stdlib requires (`require "json"`, no slash)
+     * are skipped — they're external. The path form (a `/` + `.rb`) makes the ref
+     * resolve to the file node, so a file pulled in only by `require` — not by a
+     * resolved constant/call — still records a cross-file dependency.
+     */
+    emitRubyRequireRefs(node, fromNodeId) {
+        const method = node.namedChildren.find((c) => c.type === 'identifier');
+        const mname = method ? (0, tree_sitter_helpers_1.getNodeText)(method, this.source) : '';
+        if (mname !== 'require' && mname !== 'require_relative')
+            return;
+        const argList = node.namedChildren.find((c) => c.type === 'argument_list');
+        const str = argList?.namedChildren.find((c) => c.type === 'string');
+        const content = str?.namedChildren.find((c) => c.type === 'string_content');
+        if (!content)
+            return;
+        const req = (0, tree_sitter_helpers_1.getNodeText)(content, this.source).trim();
+        if (!req)
+            return;
+        let refPath;
+        if (mname === 'require_relative') {
+            const slash = this.filePath.lastIndexOf('/');
+            const dir = slash >= 0 ? this.filePath.slice(0, slash) : '';
+            refPath = path.posix.normalize(dir ? `${dir}/${req}` : req);
+        }
+        else {
+            refPath = req; // load-path require — suffix-matched against the file path
+        }
+        if (!refPath.includes('/'))
+            return; // bare gem/stdlib require — external
+        if (!refPath.endsWith('.rb'))
+            refPath += '.rb';
+        this.unresolvedReferences.push({
+            fromNodeId,
+            referenceName: refPath,
+            referenceKind: 'imports',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+        });
+    }
+    /** Convert a PHP FQN `Foo\Bar\Baz` to the stored `Foo\Bar::Baz` and emit an `imports` ref. */
+    pushPhpUseRef(fqn, fromNodeId, node) {
+        const clean = fqn.replace(/^\\/, '');
+        const lastSep = clean.lastIndexOf('\\');
+        if (lastSep < 0)
+            return; // global-namespace class — already matches by simple name
+        this.unresolvedReferences.push({
+            fromNodeId,
+            referenceName: `${clean.slice(0, lastSep)}::${clean.slice(lastSep + 1)}`,
+            referenceKind: 'imports',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+        });
+    }
+    /**
+     * Emit one `imports` reference per name imported in a Python
+     * `from module import A, B as C` statement, attributed to the file node — so
+     * the resolver links each imported name to the module that DEFINES it.
+     *
+     * Same recall gap as TS: extraction only emitted references for calls,
+     * instantiations, and inheritance, so a name imported and then used in a
+     * non-call position (a list/dict literal, a default argument, a decorator
+     * target, or simply re-exported through an `__init__.py` barrel) produced no
+     * cross-file edge — the providing module showed a false "0 dependents". Links
+     * the LOCAL name (alias when present, since that's what the resolver's import
+     * mapping keys on); `from module import *` has no names to attribute.
+     */
+    emitPyFromImportRefs(node, fromNodeId) {
+        const moduleNameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'module_name');
+        for (const child of node.namedChildren) {
+            // Skip the `from <module>` part itself and `import *`.
+            if (moduleNameNode &&
+                child.startIndex === moduleNameNode.startIndex &&
+                child.endIndex === moduleNameNode.endIndex)
+                continue;
+            if (child.type === 'wildcard_import')
+                continue;
+            let nameNode = null;
+            if (child.type === 'aliased_import') {
+                nameNode = (0, tree_sitter_helpers_1.getChildByField)(child, 'alias') ?? (0, tree_sitter_helpers_1.getChildByField)(child, 'name') ?? child.namedChild(0);
+            }
+            else if (child.type === 'dotted_name') {
+                nameNode = child;
+            }
+            if (!nameNode)
+                continue;
+            const raw = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+            // Imported names are simple identifiers; defensively take the last segment.
+            const local = raw.includes('.') ? raw.split('.').pop() : raw;
+            if (!local)
+                continue;
+            this.unresolvedReferences.push({
+                fromNodeId,
+                referenceName: local,
+                referenceKind: 'imports',
+                line: nameNode.startPosition.row + 1,
+                column: nameNode.startPosition.column,
+            });
+        }
+    }
     /**
      * Extract a function call
      */
@@ -1539,6 +2525,57 @@ class TreeSitterExtractor {
             // single-dot receiver regex fails. Pull out the immediate field after `this.`
             // so the receiver is the field name (`userbo`), which the resolver can then
             // look up in the enclosing class's field declarations.
+            // PHP static-factory fluent chain: `Cls::for($x)->method()` — the receiver
+            // is itself a static call, so resolution must infer the method's class
+            // from what `Cls::for` RETURNS (its `: self` / `: static` / `: Type`),
+            // #608 (mirrors the C++ chain fix in #645). Encode `<Cls::factory>().<method>`;
+            // the `().` marker lets the PHP resolver split it. The receiver text
+            // (`Cls::for('x')`) carries the args, so without this it degrades to an
+            // unresolvable string and the call edge is dropped.
+            if (methodName && this.language === 'php' && objectField.type === 'scoped_call_expression') {
+                const innerScope = (0, tree_sitter_helpers_1.getChildByField)(objectField, 'scope');
+                const innerName = (0, tree_sitter_helpers_1.getChildByField)(objectField, 'name');
+                if (innerScope && innerName) {
+                    calleeName = `${(0, tree_sitter_helpers_1.getNodeText)(innerScope, this.source)}::${(0, tree_sitter_helpers_1.getNodeText)(innerName, this.source)}().${methodName}`;
+                }
+                else {
+                    calleeName = methodName;
+                }
+                if (calleeName) {
+                    this.unresolvedReferences.push({
+                        fromNodeId: callerId,
+                        referenceName: calleeName,
+                        referenceKind: 'calls',
+                        line: node.startPosition.row + 1,
+                        column: node.startPosition.column,
+                    });
+                }
+                return;
+            }
+            // Java static-factory / fluent chain: `Foo.getInstance().bar()` — the
+            // receiver is itself a method call, so resolution must infer bar's class
+            // from what `Foo.getInstance` RETURNS (its declared return type), the
+            // #645/#608 mechanism. Encode `<inner-receiver>.<inner-method>().<method>`;
+            // the `().` marker lets the Java chain resolver split it, and normalizing to
+            // empty parens drops any factory args (`Foo.create(cfg).bar()`) that would
+            // otherwise leave a `(cfg)` in the receiver text and break the split.
+            if (methodName &&
+                this.language === 'java' &&
+                objectField.type === 'method_invocation') {
+                const innerObj = (0, tree_sitter_helpers_1.getChildByField)(objectField, 'object');
+                const innerName = (0, tree_sitter_helpers_1.getChildByField)(objectField, 'name');
+                if (innerObj && innerName) {
+                    calleeName = `${(0, tree_sitter_helpers_1.getNodeText)(innerObj, this.source)}.${(0, tree_sitter_helpers_1.getNodeText)(innerName, this.source)}().${methodName}`;
+                    this.unresolvedReferences.push({
+                        fromNodeId: callerId,
+                        referenceName: calleeName,
+                        referenceKind: 'calls',
+                        line: node.startPosition.row + 1,
+                        column: node.startPosition.column,
+                    });
+                    return;
+                }
+            }
             let receiverName;
             if (objectField.type === 'field_access') {
                 const inner = (0, tree_sitter_helpers_1.getChildByField)(objectField, 'object');
@@ -1584,15 +2621,77 @@ class TreeSitterExtractor {
                 }
             }
             if (methodKeywords.length > 0) {
-                const methodName = methodKeywords.length === 1
-                    ? methodKeywords[0]
-                    : methodKeywords.map((k) => `${k}:`).join('');
+                // A selector keyword takes a `:` when it has an argument. A SINGLE
+                // keyword can be unary (`[c reset]` → `reset`) OR take one argument
+                // (`[c storeImage:k]` → `storeImage:`) — distinguished by whether the
+                // message has a `:` token. Without this, every single-argument message
+                // (the most common form: `addObject:`, `storeImage:`, …) was named
+                // without the colon and never matched its `storeImage:` method.
+                let hasColon = false;
+                for (let i = 0; i < node.childCount; i++) {
+                    if (node.child(i)?.type === ':') {
+                        hasColon = true;
+                        break;
+                    }
+                }
+                const methodName = hasColon
+                    ? methodKeywords.map((k) => `${k}:`).join('')
+                    : methodKeywords[0];
                 const receiverField = (0, tree_sitter_helpers_1.getChildByField)(node, 'receiver');
                 const SKIP_RECEIVERS = new Set(['self', 'super']);
                 if (receiverField && receiverField.type !== 'message_expression') {
                     const receiverName = (0, tree_sitter_helpers_1.getNodeText)(receiverField, this.source);
                     if (receiverName && !SKIP_RECEIVERS.has(receiverName)) {
                         calleeName = `${receiverName}.${methodName}`;
+                        // A CLASS-message receiver (`[SDImageCache alloc]`,
+                        // `[SDImageCache sharedCache]`) is a capitalized class name. The
+                        // call resolves the method (`alloc`/`sharedCache`), but the CLASS
+                        // itself — whose @interface lives in the header — would otherwise
+                        // never be referenced. Emit a `references` edge to it so a class
+                        // used only via class messages (alloc/init, singletons, factories)
+                        // and its header record a dependent.
+                        if (/^[A-Z][A-Za-z0-9_]*$/.test(receiverName)) {
+                            this.unresolvedReferences.push({
+                                fromNodeId: callerId,
+                                referenceName: receiverName,
+                                referenceKind: 'references',
+                                line: receiverField.startPosition.row + 1,
+                                column: receiverField.startPosition.column,
+                            });
+                        }
+                    }
+                    else {
+                        calleeName = methodName;
+                    }
+                }
+                else if (receiverField && receiverField.type === 'message_expression' && /^\w+$/.test(methodName)) {
+                    // Chained message send `[[Foo create] doIt]` — the receiver is itself a
+                    // class message. Recover the inner `Class.selector` and encode
+                    // `Class.selector().doIt` so resolution infers doIt's class from what
+                    // `Class.selector` RETURNS (#645/#608). Only a CLASS-factory chain
+                    // (capitalized inner receiver); a unary outer selector is required
+                    // because the chain resolver's method part is `\w+` (no `:`). An
+                    // instance chain (`[[obj foo] bar]`, lowercase inner) stays bare.
+                    const innerRecv = (0, tree_sitter_helpers_1.getChildByField)(receiverField, 'receiver');
+                    const innerRecvName = innerRecv ? (0, tree_sitter_helpers_1.getNodeText)(innerRecv, this.source) : '';
+                    if (innerRecv?.type === 'identifier' && /^[A-Z]/.test(innerRecvName)) {
+                        const innerKw = [];
+                        for (let i = 0; i < receiverField.namedChildCount; i++) {
+                            if (receiverField.fieldNameForNamedChild(i) === 'method') {
+                                const kw = receiverField.namedChild(i);
+                                if (kw)
+                                    innerKw.push((0, tree_sitter_helpers_1.getNodeText)(kw, this.source));
+                            }
+                        }
+                        let innerColon = false;
+                        for (let i = 0; i < receiverField.childCount; i++) {
+                            if (receiverField.child(i)?.type === ':') {
+                                innerColon = true;
+                                break;
+                            }
+                        }
+                        const innerSelector = innerColon ? innerKw.map((k) => `${k}:`).join('') : innerKw[0];
+                        calleeName = innerSelector ? `${innerRecvName}.${innerSelector}().${methodName}` : methodName;
                     }
                     else {
                         calleeName = methodName;
@@ -1642,6 +2741,67 @@ class TreeSitterExtractor {
                                 calleeName = methodName;
                             }
                         }
+                        else if ((this.language === 'cpp' ||
+                            this.language === 'c' ||
+                            this.language === 'kotlin' ||
+                            this.language === 'swift' ||
+                            this.language === 'rust' ||
+                            this.language === 'go' ||
+                            this.language === 'scala') &&
+                            receiver &&
+                            receiver.type === 'call_expression') {
+                            // Receiver that is itself a call — `Foo::instance().bar()`,
+                            // `openSession()->run()`, `mgr.view().render()` (C/C++),
+                            // `Foo.getInstance().bar()` (Kotlin) / `Foo.make().draw()` (Swift),
+                            // `Foo::new().bar()` (Rust), or `New().Method()` (Go). Keep the inner
+                            // call so resolution can infer bar()'s class from what the inner call
+                            // RETURNS (#645/#608). Encode as `<innerCallee>().<method>`; the `().`
+                            // marker never appears in an ordinary ref, so the resolver can detect
+                            // and split it. Other languages keep the bare-name behavior below.
+                            let innerCallee;
+                            let reencode;
+                            if (this.language === 'kotlin' || this.language === 'swift') {
+                                // tree-sitter-kotlin/swift expose the inner callee as the
+                                // call_expression's first named child (a navigation_expression
+                                // `Foo.getInstance`, or a bare identifier for a free/constructor call).
+                                const innerNav = receiver.namedChild(0);
+                                innerCallee = innerNav ? (0, tree_sitter_helpers_1.getNodeText)(innerNav, this.source).replace(/\s+/g, '') : '';
+                                // Only re-encode a CLASS / companion-factory / constructor chain,
+                                // whose receiver chain starts with a capitalized type
+                                // (`Foo.getInstance().bar()`, `Foo().bar()`). An instance chain
+                                // (`list.filter{}.map{}`) has a lowercase receiver whose type we
+                                // can't recover here — re-encoding it would only drop the edge (no
+                                // chain resolution, no bare-name fallback), regressing recall in
+                                // fluent codebases. Leave those to the bare-name path.
+                                reencode = /^[A-Z]/.test(innerCallee);
+                            }
+                            else {
+                                const innerFn = (0, tree_sitter_helpers_1.getChildByField)(receiver, 'function');
+                                innerCallee = innerFn
+                                    ? (0, tree_sitter_helpers_1.getNodeText)(innerFn, this.source).replace(/->/g, '.').replace(/\s+/g, '')
+                                    : '';
+                                // Rust: only re-encode an associated-function chain
+                                // (`Foo::new().bar()`), whose inner callee is a path/`scoped_identifier`.
+                                // Go: only a bare package-level factory chain (`New().Method()`),
+                                // whose inner callee is an `identifier`. An instance chain
+                                // (`x.foo().bar()` Rust, `obj.Method().Other()` Go) keeps bare-name —
+                                // the resolver can't recover a variable's type, so re-encoding would
+                                // only drop the edge. C/C++ re-encode any inner.
+                                if (this.language === 'rust')
+                                    reencode = innerFn?.type === 'scoped_identifier';
+                                else if (this.language === 'go')
+                                    reencode = innerFn?.type === 'identifier';
+                                // Scala: only a companion-factory / case-class-apply chain whose
+                                // receiver chain starts with a capitalized type (`Foo.create().bar()`,
+                                // `Foo(args).bar()`). An instance chain (`list.map().filter()`) has a
+                                // lowercase receiver whose type we can't recover — leave it bare.
+                                else if (this.language === 'scala')
+                                    reencode = /^[A-Z]/.test(innerCallee);
+                                else
+                                    reencode = !!innerCallee;
+                            }
+                            calleeName = reencode ? `${innerCallee}().${methodName}` : methodName;
+                        }
                         else {
                             calleeName = methodName;
                         }
@@ -1651,11 +2811,39 @@ class TreeSitterExtractor {
                     // Scoped call: Module::function()
                     calleeName = (0, tree_sitter_helpers_1.getNodeText)(func, this.source);
                 }
+                else if (this.language === 'csharp' && func.type === 'member_access_expression') {
+                    // C# member call `recv.Method(...)`. When the receiver is itself a call
+                    // — a chained factory `Foo.Create(args).Bar()` — encode `inner().Bar`
+                    // with normalized empty parens so resolution can infer Bar's class from
+                    // what `Foo.Create` RETURNS (#645/#608). A non-call receiver keeps the
+                    // full member-access text (the existing `recv.Method` behavior).
+                    const recv = (0, tree_sitter_helpers_1.getChildByField)(func, 'expression');
+                    const nameNode = (0, tree_sitter_helpers_1.getChildByField)(func, 'name');
+                    const methodName = nameNode ? (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source) : '';
+                    if (recv && recv.type === 'invocation_expression' && methodName) {
+                        const innerFunc = (0, tree_sitter_helpers_1.getChildByField)(recv, 'function');
+                        const innerCallee = innerFunc ? (0, tree_sitter_helpers_1.getNodeText)(innerFunc, this.source).replace(/\s+/g, '') : '';
+                        calleeName = innerCallee ? `${innerCallee}().${methodName}` : methodName;
+                    }
+                    else {
+                        calleeName = (0, tree_sitter_helpers_1.getNodeText)(func, this.source);
+                    }
+                }
                 else {
                     calleeName = (0, tree_sitter_helpers_1.getNodeText)(func, this.source);
                 }
             }
         }
+        // Parenthesized type conversions — Go `(*T)(x)` / `(T)(x)` (and a
+        // parenthesized callee generally) parse as a call whose "function" is a
+        // parenthesized type/expression, so the callee text is the un-resolvable
+        // literal `(*T)`. Normalize to the inner name so it resolves to `T` (a real
+        // dependency on the converted-to type) instead of dropping on the floor.
+        if (calleeName) {
+            const conv = calleeName.match(/^\(\s*\*?\s*([A-Za-z_][\w.]*)\s*\)$/);
+            if (conv && conv[1])
+                calleeName = conv[1];
+        }
         if (calleeName) {
             this.unresolvedReferences.push({
                 fromNodeId: callerId,
@@ -1689,6 +2877,46 @@ class TreeSitterExtractor {
             node.namedChild(0);
         if (!ctor)
             return;
+        // Go composite literals: `Widget{...}` (same package) and `pkga.Widget{...}`
+        // (cross-package). Only a directly-named struct type is a meaningful
+        // instantiation target — skip slice/map/array literals (`[]T{}`,
+        // `map[K]V{}`) whose `type` field is a composite type, not a named type.
+        // Unlike `new ns.Foo()`, KEEP the package qualifier (`pkga.Widget`) so the
+        // Go cross-package resolver can disambiguate it to the right package's type.
+        if (node.type === 'composite_literal') {
+            if (ctor.type !== 'type_identifier' && ctor.type !== 'qualified_type')
+                return;
+            let goType = (0, tree_sitter_helpers_1.getNodeText)(ctor, this.source).trim();
+            const brIdx = goType.indexOf('['); // strip Go generic args: `Box[T]{}` -> `Box`
+            if (brIdx > 0)
+                goType = goType.slice(0, brIdx).trim();
+            if (goType) {
+                this.unresolvedReferences.push({
+                    fromNodeId: fromId,
+                    referenceName: goType,
+                    referenceKind: 'instantiates',
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                });
+            }
+            return;
+        }
+        // Scala: `new Monoid[Int] { ... }` — the constructor is a `generic_type`
+        // (or qualified `stable_type_identifier`) using `[...]` type args, which the
+        // generic `<...>` strip below misses. Unwrap to the base type name.
+        if (node.type === 'instance_expression') {
+            const name = scalaBaseTypeName(ctor, this.source);
+            if (name) {
+                this.unresolvedReferences.push({
+                    fromNodeId: fromId,
+                    referenceName: name,
+                    referenceKind: 'instantiates',
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                });
+            }
+            return;
+        }
         let className = (0, tree_sitter_helpers_1.getNodeText)(ctor, this.source);
         // Strip type-argument suffix first: `new Map<K, V>()` would
         // otherwise produce className 'Map<K, V>' (the constructor
@@ -1714,6 +2942,75 @@ class TreeSitterExtractor {
             });
         }
     }
+    /**
+     * Static-member / value-read pass. A type/enum/class used only via a member
+     * VALUE — `Enum.value`, `Type.CONST`, `Colors.red`, `Foo::BAR` — recorded no
+     * edge, because the body walker only handled CALLS (`Type.method()`). So a
+     * type referenced only by an enum value or a static field looked like nothing
+     * depended on it (the residual frontier across Dart/Java/C#/Swift/Kotlin/PHP).
+     * Emit a `references` edge to the capitalized receiver. Gated to languages
+     * where types are Capitalized by convention, and skipped when the access is a
+     * call's callee (the call extractor already links the method).
+     */
+    extractStaticMemberRef(node) {
+        if (!STATIC_MEMBER_LANGS.has(this.language))
+            return;
+        if (this.nodeStack.length === 0)
+            return;
+        const ownerId = this.nodeStack[this.nodeStack.length - 1];
+        if (!ownerId)
+            return;
+        // Dart structures member access as an `identifier` + a sibling `selector`,
+        // not a single node. A value-read selector (no `argument_part`) whose
+        // previous sibling is a capitalized identifier is `Enum.value`.
+        if (this.language === 'dart') {
+            if (node.type !== 'selector')
+                return;
+            if (node.namedChildren.some((c) => c.type === 'argument_part'))
+                return;
+            const prev = node.previousNamedSibling;
+            if (prev?.type === 'identifier' && /^[A-Z][A-Za-z0-9_]*$/.test(prev.text)) {
+                this.pushStaticMemberRef(prev.text, ownerId, prev);
+            }
+            return;
+        }
+        if (!MEMBER_ACCESS_TYPES.has(node.type))
+            return;
+        // Skip `Type.method()` — the access is the callee of a call, already linked.
+        const parent = node.parent;
+        if (parent && this.extractor.callTypes.includes(parent.type)) {
+            const callee = (0, tree_sitter_helpers_1.getChildByField)(parent, 'function') ??
+                (0, tree_sitter_helpers_1.getChildByField)(parent, 'method') ??
+                parent.namedChild(0);
+            if (callee && callee.startIndex === node.startIndex)
+                return;
+        }
+        // The receiver must be a SIMPLE capitalized identifier — `Type.X`, not the
+        // nested `a.B.c` (whose own head member-access is visited separately) nor a
+        // lowercase `obj.field` / `pkg.func`.
+        const recv = (0, tree_sitter_helpers_1.getChildByField)(node, 'object') ??
+            (0, tree_sitter_helpers_1.getChildByField)(node, 'expression') ??
+            (0, tree_sitter_helpers_1.getChildByField)(node, 'scope') ??
+            node.namedChild(0);
+        if (!recv)
+            return;
+        const t = recv.type;
+        if (t === 'identifier' || t === 'type_identifier' || t === 'simple_identifier' ||
+            t === 'name' || t === 'scoped_type_identifier') {
+            const text = (0, tree_sitter_helpers_1.getNodeText)(recv, this.source);
+            if (/^[A-Z][A-Za-z0-9_]*$/.test(text))
+                this.pushStaticMemberRef(text, ownerId, recv);
+        }
+    }
+    pushStaticMemberRef(name, ownerId, node) {
+        this.unresolvedReferences.push({
+            fromNodeId: ownerId,
+            referenceName: name,
+            referenceKind: 'references',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+        });
+    }
     /**
      * Find a `class_body` child of an `object_creation_expression` — the
      * marker for an anonymous class (`new T() { ... }`). Returns the body
@@ -1804,11 +3101,13 @@ class TreeSitterExtractor {
             if (!n)
                 return;
             // `marker_annotation` is Java's grammar for arg-less annotations
-            // (`@Override`, `@Deprecated`); without including it, every
-            // such Java annotation would be silently skipped.
+            // (`@Override`, `@Deprecated`); `attribute` is Swift's grammar for
+            // attributes and PROPERTY WRAPPERS (`@objc`, `@Argument`, `@Published`,
+            // `@State`). Without these, those usages would be silently skipped.
             if (n.type !== 'decorator' &&
                 n.type !== 'annotation' &&
-                n.type !== 'marker_annotation') {
+                n.type !== 'marker_annotation' &&
+                n.type !== 'attribute') {
                 return;
             }
             // Find the leading identifier: skip the `@` punct, unwrap
@@ -1828,7 +3127,9 @@ class TreeSitterExtractor {
                 if (child.type === 'identifier' ||
                     child.type === 'member_expression' ||
                     child.type === 'scoped_identifier' ||
-                    child.type === 'navigation_expression') {
+                    child.type === 'navigation_expression' ||
+                    child.type === 'user_type' || // swift attribute → user_type (`@Argument`)
+                    child.type === 'type_identifier') {
                     target = child;
                     break;
                 }
@@ -1836,9 +3137,13 @@ class TreeSitterExtractor {
             if (!target)
                 return;
             let name = (0, tree_sitter_helpers_1.getNodeText)(target, this.source);
+            const lt = name.indexOf('<'); // strip generic args: `@Argument<T>` → `Argument`
+            if (lt > 0)
+                name = name.slice(0, lt);
             const lastDot = Math.max(name.lastIndexOf('.'), name.lastIndexOf('::'));
             if (lastDot >= 0)
                 name = name.slice(lastDot + 1).replace(/^[:.]/, '');
+            name = name.trim();
             if (!name)
                 return;
             this.unresolvedReferences.push({
@@ -1852,7 +3157,17 @@ class TreeSitterExtractor {
         // 1. Decorators that are direct children of the declaration
         //    (method/property style, also some grammars for class).
         for (let i = 0; i < declNode.namedChildCount; i++) {
-            consider(declNode.namedChild(i));
+            const child = declNode.namedChild(i);
+            consider(child);
+            // Java/Kotlin/C# put annotations INSIDE a `modifiers` node
+            // (`@MyAnno public class X` → class_declaration → modifiers → annotation),
+            // so descend into it — otherwise every annotation usage is silently
+            // dropped and annotation types show zero dependents.
+            if (child && child.type === 'modifiers') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    consider(child.namedChild(j));
+                }
+            }
         }
         // 2. Decorators that are PRECEDING siblings of the declaration
         //    inside the parent's children (TypeScript class style).
@@ -1900,11 +3215,80 @@ class TreeSitterExtractor {
      *      tree-sitter to interpret the namespace block as a function_definition,
      *      hiding real class/struct/enum nodes inside the "function body".
      */
+    /**
+     * Rocket route-registration macros — `routes![a::b::handler, c::d::other]`
+     * and `catchers![not_found]`. Tree-sitter leaves a macro body as a flat
+     * `token_tree` of raw tokens (`identifier`, `::`, `,`), so the handler paths
+     * are never seen as references and each handler fn looks like it has no caller
+     * — it's mounted by Rocket at runtime, not called by in-repo code, so its file
+     * shows 0 dependents. Walk the token tree, reconstruct each comma-separated
+     * path, and emit a `references` edge; the Rust path resolver
+     * (`resolveRustPathReference`) then links it to the handler fn. The handler
+     * names are explicit in source, so this is precise static extraction, not a
+     * heuristic — no false edges (resolution still validates each path).
+     */
+    extractRustRouteMacro(node) {
+        if (this.language !== 'rust')
+            return;
+        const macroName = node.namedChild(0);
+        if (!macroName)
+            return;
+        const name = (0, tree_sitter_helpers_1.getNodeText)(macroName, this.source);
+        if (name !== 'routes' && name !== 'catchers')
+            return;
+        const tokenTree = node.namedChildren.find((c) => c.type === 'token_tree');
+        if (!tokenTree)
+            return;
+        const fromId = this.nodeStack[this.nodeStack.length - 1];
+        if (!fromId)
+            return;
+        // The token tree is a flat stream: `[ id :: id :: id , id … ]`. Group runs
+        // of `identifier` tokens (the `::` joiners are anonymous) into one path; a
+        // `,` (or the closing `]`) ends a path.
+        let parts = [];
+        let line = 0;
+        let column = 0;
+        const flush = () => {
+            if (parts.length > 0) {
+                this.unresolvedReferences.push({
+                    fromNodeId: fromId,
+                    referenceName: parts.join('::'),
+                    referenceKind: 'references',
+                    line,
+                    column,
+                });
+                parts = [];
+            }
+        };
+        for (let i = 0; i < tokenTree.childCount; i++) {
+            const t = tokenTree.child(i);
+            if (!t)
+                continue;
+            if (t.type === 'identifier') {
+                if (parts.length === 0) {
+                    line = t.startPosition.row + 1;
+                    column = t.startPosition.column;
+                }
+                parts.push((0, tree_sitter_helpers_1.getNodeText)(t, this.source));
+            }
+            else if (t.type === ',') {
+                flush();
+            }
+        }
+        flush();
+    }
     visitFunctionBody(body, _functionId) {
         if (!this.extractor)
             return;
         const visitForCallsAndStructure = (node) => {
             const nodeType = node.type;
+            // 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);
+            // Rocket route-registration macros (`routes![…]` / `catchers![…]`): the
+            // handler paths live in a raw token tree the call walker can't see.
+            if (nodeType === 'macro_invocation')
+                this.extractRustRouteMacro(node);
             if (this.extractor.callTypes.includes(nodeType)) {
                 this.extractCall(node);
             }
@@ -1938,6 +3322,24 @@ class TreeSitterExtractor {
                     }
                 }
             }
+            // Static-member / value-read: `Enum.value`, `Type.CONST`, `Foo::BAR`.
+            this.extractStaticMemberRef(node);
+            // Local variable type annotations inside a body — `const items: Foo[] = []`,
+            // `const x: SomeType = svc.load()`. We deliberately do NOT create nodes for
+            // locals (that would explode the graph — the data-flow frontier we leave
+            // uncovered), but the TYPE a local is annotated with is a real dependency of
+            // the enclosing function, so attribute a `references` edge to it. Without
+            // this, a function that uses a type ONLY in its body (very common — e.g. a
+            // resolver building `const nodes: Node[] = []`) produced no edge to that
+            // type, so impact / `affected` missed the dependency entirely. We fall
+            // through to the default recursion below so the initializer's calls (and any
+            // nested declarators) are still walked.
+            if (nodeType === 'variable_declarator' &&
+                this.TYPE_ANNOTATION_LANGUAGES.has(this.language)) {
+                const ownerId = this.nodeStack[this.nodeStack.length - 1];
+                if (ownerId)
+                    this.extractVariableTypeAnnotation(node, ownerId);
+            }
             // Nested NAMED functions inside a body — function declarations and named
             // function expressions like `.on('mount', function onmount(){})` — become
             // their own nodes so the graph can link to them (callback handlers, local
@@ -2039,6 +3441,62 @@ class TreeSitterExtractor {
                 child.type === 'base_clause' || // PHP class extends
                 child.type === 'extends_interfaces' // Java interface extends
             ) {
+                // Scala: `extends A[X] with B with C` packs EVERY supertype into the
+                // one extends_clause (separated by `with`), each a `generic_type` /
+                // `type_identifier` / `stable_type_identifier`. The generic path below
+                // takes only namedChild(0) and keeps the full text (`A[X]`), so a
+                // parameterized supertype — every typeclass in cats/algebra — never
+                // matched and `with`-mixed traits past the first were dropped. Iterate
+                // all supertypes and unwrap each to its base type name.
+                if (this.language === 'scala') {
+                    for (const target of child.namedChildren) {
+                        const name = scalaBaseTypeName(target, this.source);
+                        if (name) {
+                            this.unresolvedReferences.push({
+                                fromNodeId: classId,
+                                referenceName: name,
+                                referenceKind: 'extends',
+                                line: target.startPosition.row + 1,
+                                column: target.startPosition.column,
+                            });
+                        }
+                    }
+                    continue;
+                }
+                // Dart: `class C extends Base with M1, M2` — the `superclass` node holds
+                // the extends type as a direct `type_identifier` AND a `mixins` child
+                // listing the `with` mixins (and `class C with M` has ONLY mixins, no
+                // extends type). The generic `namedChild(0)` path would read the
+                // `mixins` node itself as the superclass and drop every mixin — yet
+                // mixins are Dart's core composition mechanism (Flutter is built on
+                // them). Emit `extends` for the base and `implements` for each mixin.
+                if (this.language === 'dart' && child.type === 'superclass') {
+                    for (const t of child.namedChildren) {
+                        if (t.type === 'mixins') {
+                            for (const m of t.namedChildren) {
+                                if (m.type === 'type_identifier') {
+                                    this.unresolvedReferences.push({
+                                        fromNodeId: classId,
+                                        referenceName: (0, tree_sitter_helpers_1.getNodeText)(m, this.source),
+                                        referenceKind: 'implements',
+                                        line: m.startPosition.row + 1,
+                                        column: m.startPosition.column,
+                                    });
+                                }
+                            }
+                        }
+                        else if (t.type === 'type_identifier') {
+                            this.unresolvedReferences.push({
+                                fromNodeId: classId,
+                                referenceName: (0, tree_sitter_helpers_1.getNodeText)(t, this.source),
+                                referenceKind: 'extends',
+                                line: t.startPosition.row + 1,
+                                column: t.startPosition.column,
+                            });
+                        }
+                    }
+                    continue;
+                }
                 // Extract parent class/interface names
                 // Java uses type_list wrapper: superclass -> type_identifier, extends_interfaces -> type_list -> type_identifier
                 const typeList = child.namedChildren.find((c) => c.type === 'type_list');
@@ -2318,7 +3776,15 @@ class TreeSitterExtractor {
      * Languages that support type annotations (TypeScript, etc.)
      */
     TYPE_ANNOTATION_LANGUAGES = new Set([
-        'typescript', 'tsx', 'dart', 'kotlin', 'swift', 'rust', 'go', 'java', 'csharp',
+        'typescript', 'tsx', 'dart', 'kotlin', 'swift', 'rust', 'go', 'java', 'csharp', 'scala', 'php',
+    ]);
+    /**
+     * PHP pseudo-types and `self`/`static`/`parent` that aren't project symbols.
+     * (Scalar primitives parse as `primitive_type` and are skipped structurally.)
+     */
+    PHP_PSEUDO_TYPES = new Set([
+        'self', 'static', 'parent', 'mixed', 'object', 'iterable', 'callable', 'void',
+        'null', 'false', 'true', 'never', 'array', 'int', 'float', 'string', 'bool',
     ]);
     /**
      * Built-in/primitive type names that shouldn't create references
@@ -2334,6 +3800,9 @@ class TreeSitterExtractor {
         // Go
         'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64',
         'float32', 'float64', 'complex64', 'complex128', 'rune', 'error',
+        // Scala (capitalized primitives + ubiquitous stdlib aliases)
+        'Int', 'Long', 'Short', 'Byte', 'Float', 'Double', 'Boolean', 'Char', 'Unit',
+        'String', 'Any', 'AnyRef', 'AnyVal', 'Nothing', 'Null',
     ]);
     /**
      * Extract type references from type annotations on a function/method/field node.
@@ -2354,16 +3823,67 @@ class TreeSitterExtractor {
             this.extractCsharpTypeRefs(node, nodeId);
             return;
         }
-        // Extract parameter type annotations
-        const params = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.paramsField || 'parameters');
-        if (params) {
-            this.extractTypeRefsFromSubtree(params, nodeId);
+        // PHP type-hints are `named_type`/`optional_type`/`union_type` wrapping a
+        // `name`/`qualified_name` — never `type_identifier` — so the generic walker
+        // below emits nothing for them. Dispatch to a PHP-aware path that walks only
+        // type positions (parameter / return / property types), so type-hinted
+        // dependencies (the constructor-injected contracts that dominate Laravel) are
+        // recorded and a `variable_name` like `$events` never mis-emits as a ref.
+        if (this.language === 'php') {
+            this.extractPhpTypeRefs(node, nodeId);
+            return;
+        }
+        // Dart: a `method_signature` wraps the real `function_signature` (where the
+        // params and return type live), and the return type is a bare
+        // `type_identifier` child, not a `type` field — so getChildByField below
+        // finds neither. Walk the inner signature: param names / the method name are
+        // `identifier` (not `type_identifier`), so only types surface.
+        if (this.language === 'dart') {
+            let sig = node;
+            if (node.type === 'method_signature') {
+                sig = node.namedChildren.find((c) => c.type === 'function_signature' ||
+                    c.type === 'getter_signature' ||
+                    c.type === 'setter_signature' ||
+                    c.type === 'constructor_signature' ||
+                    c.type === 'factory_constructor_signature') ?? node;
+            }
+            this.extractTypeRefsFromSubtree(sig, nodeId);
+            return;
+        }
+        // Extract parameter type annotations. Scala curries — `def f(a)(implicit
+        // M: TC)` has MULTIPLE `parameters` siblings, and the typeclass is almost
+        // always in the trailing implicit list — so walk every parameter list, not
+        // just getChildByField's first match.
+        if (this.language === 'scala') {
+            for (const pc of node.namedChildren) {
+                if (pc.type === 'parameters')
+                    this.extractTypeRefsFromSubtree(pc, nodeId);
+            }
+        }
+        else {
+            const params = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.paramsField || 'parameters');
+            if (params) {
+                this.extractTypeRefsFromSubtree(params, nodeId);
+            }
         }
         // Extract return type annotation
         const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.returnField || 'return_type');
         if (returnType) {
             this.extractTypeRefsFromSubtree(returnType, nodeId);
         }
+        // Scala context bounds / type-parameter bounds: `def f[A: Monoid]`,
+        // `[F[_]: Monad]`, `[A <: Foo]` carry the bound type inside `type_parameters`.
+        // This is THE pervasive way a typeclass is required in Scala, yet the bound
+        // never appears in the value parameters. Param NAMES are `identifier` (not
+        // `type_identifier`), so only the bound types surface. Scala-only: in other
+        // languages a `type_parameters` child holds declaration names as
+        // `type_identifier` (TS `<T>`), which would wrongly surface as refs.
+        if (this.language === 'scala') {
+            const typeParams = node.namedChildren.find((c) => c.type === 'type_parameters');
+            if (typeParams) {
+                this.extractTypeRefsFromSubtree(typeParams, nodeId);
+            }
+        }
         // Extract direct type annotation (for class fields like `model: ITextModel`)
         const typeAnnotation = node.namedChildren.find((c) => c.type === 'type_annotation');
         if (typeAnnotation) {
@@ -2383,8 +3903,11 @@ class TreeSitterExtractor {
      * `tuple_type`, …) — none of which are `type_identifier`. Closes #381.
      */
     extractCsharpTypeRefs(node, nodeId) {
-        // Return type / property type — the field is named `type`.
-        const directType = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+        // A property's type is under the `type` field; a method/constructor's RETURN
+        // type is under `returns` (tree-sitter-c-sharp 0.23.x — older builds used
+        // `type` for both). A node carries only one of the two, so checking both
+        // covers return types and property types without conflating them.
+        const directType = (0, tree_sitter_helpers_1.getChildByField)(node, 'type') ?? (0, tree_sitter_helpers_1.getChildByField)(node, 'returns');
         if (directType)
             this.walkCsharpTypePosition(directType, nodeId);
         // Field declarations wrap declarators in a `variable_declaration`
@@ -2414,6 +3937,32 @@ class TreeSitterExtractor {
             }
         }
     }
+    /**
+     * Record the dependencies declared by a C# PRIMARY CONSTRUCTOR
+     * (`class Svc(IRepo repo, [FromKeyedServices("k")] ICache cache) { … }`,
+     * C# 12+). The parameter list hangs off the class/struct/record declaration
+     * as an unnamed-field `parameter_list` child (not the `parameters` field a
+     * method uses), so it's found by node type. Each parameter's declared type
+     * becomes a `references` edge from the owning type — these are exactly the
+     * services a DI-registered type depends on, so impact/blast-radius and
+     * "who depends on this contract" now see them. No-op when there's no primary
+     * constructor. (#237)
+     */
+    extractCsharpPrimaryCtorParamRefs(node, ownerId) {
+        if (this.language !== 'csharp')
+            return;
+        const paramList = node.namedChildren.find((c) => c.type === 'parameter_list');
+        if (!paramList)
+            return;
+        for (let i = 0; i < paramList.namedChildCount; i++) {
+            const param = paramList.namedChild(i);
+            if (!param || param.type !== 'parameter')
+                continue;
+            const paramType = (0, tree_sitter_helpers_1.getChildByField)(param, 'type');
+            if (paramType)
+                this.walkCsharpTypePosition(paramType, ownerId);
+        }
+    }
     /**
      * Walk a C# subtree that is KNOWN to be in a type position
      * (return type, parameter type, property type, field type, generic
@@ -2476,6 +4025,65 @@ class TreeSitterExtractor {
                 this.walkCsharpTypePosition(child, fromNodeId);
         }
     }
+    /**
+     * Extract PHP type references from a method/function/property declaration.
+     * Walks ONLY type positions: each parameter's type child (inside
+     * `formal_parameters`), the return type, and a property's type — all
+     * `named_type` / `optional_type` / `union_type` / … direct children. Parameter
+     * and property NAMES are `variable_name` (`$x`), never type nodes, so they
+     * can't be mis-emitted.
+     */
+    extractPhpTypeRefs(node, nodeId) {
+        const params = node.namedChildren.find((c) => c.type === 'formal_parameters');
+        if (params) {
+            for (const p of params.namedChildren) {
+                // simple_parameter / property_promotion_parameter / variadic_parameter
+                for (const c of p.namedChildren) {
+                    if (PHP_TYPE_NODES.has(c.type))
+                        this.walkPhpTypePosition(c, nodeId);
+                }
+            }
+        }
+        // Return type (method/function) and property type are TYPE nodes that are
+        // DIRECT children of the declaration.
+        for (const c of node.namedChildren) {
+            if (PHP_TYPE_NODES.has(c.type))
+                this.walkPhpTypePosition(c, nodeId);
+        }
+    }
+    /** Walk a PHP subtree KNOWN to be in a type position; emit class/interface refs. */
+    walkPhpTypePosition(node, fromNodeId) {
+        if (node.type === 'primitive_type')
+            return; // int/string/void/…
+        if (node.type === 'name') {
+            const name = (0, tree_sitter_helpers_1.getNodeText)(node, this.source);
+            if (name && !this.PHP_PSEUDO_TYPES.has(name)) {
+                this.unresolvedReferences.push({
+                    fromNodeId, referenceName: name, referenceKind: 'references',
+                    line: node.startPosition.row + 1, column: node.startPosition.column,
+                });
+            }
+            return;
+        }
+        if (node.type === 'qualified_name') {
+            // `App\Contracts\Logger` → match on the trailing simple name (what the
+            // class node is stored as, and what a `use` import brings into scope).
+            const last = (0, tree_sitter_helpers_1.getNodeText)(node, this.source).split('\\').pop() ?? '';
+            if (last && !this.PHP_PSEUDO_TYPES.has(last)) {
+                this.unresolvedReferences.push({
+                    fromNodeId, referenceName: last, referenceKind: 'references',
+                    line: node.startPosition.row + 1, column: node.startPosition.column,
+                });
+            }
+            return;
+        }
+        // optional_type / nullable_type / union_type / intersection_type / named_type → recurse
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child)
+                this.walkPhpTypePosition(child, fromNodeId);
+        }
+    }
     /**
      * Extract type references from a variable's type annotation.
      */
@@ -2807,9 +4415,29 @@ class TreeSitterExtractor {
                 }
             }
         }
-        const parentId = this.methodIndex.get(fullNameKey) ||
-            this.methodIndex.get(shortNameKey) ||
-            this.nodeStack[this.nodeStack.length - 1];
+        let parentId = this.methodIndex.get(fullNameKey) ||
+            this.methodIndex.get(shortNameKey);
+        // No existing node? This is an implementation-only **free** procedure/function
+        // (`procedure Helper; begin … end;` with no interface declaration and not a
+        // class method). Create a function node so its body's calls attribute to it,
+        // not to the enclosing file/module. A method (`TClass.Method`, a dotted name)
+        // always has a node from its class declaration, so this only fires for free
+        // routines — and the methodIndex lookup above already covers interface-declared
+        // free routines, so there's no duplicate.
+        if (!parentId && !fullName.includes('.')) {
+            const fnNode = this.createNode('function', fullName, declProc, {
+                signature: this.extractor?.getSignature?.(declProc, this.source),
+                visibility: this.extractor?.getVisibility?.(declProc),
+            });
+            if (fnNode) {
+                parentId = fnNode.id;
+                this.methodIndex.set(fullNameKey, fnNode.id);
+                if (!this.methodIndex.has(shortNameKey))
+                    this.methodIndex.set(shortNameKey, fnNode.id);
+            }
+        }
+        if (!parentId)
+            parentId = this.nodeStack[this.nodeStack.length - 1];
         if (!parentId)
             return;
         // Visit the block for calls
@@ -2835,10 +4463,41 @@ class TreeSitterExtractor {
             return;
         let calleeName = '';
         if (firstChild.type === 'exprDot') {
-            // Qualified call: Obj.Method(...)
-            const identifiers = firstChild.namedChildren.filter((c) => c.type === 'identifier');
-            if (identifiers.length > 0) {
-                calleeName = identifiers.map((id) => (0, tree_sitter_helpers_1.getNodeText)(id, this.source)).join('.');
+            // Chained static-factory call: `TFoo.GetInstance().DoIt()` — the exprDot's
+            // receiver is itself an `exprCall`, so the bare identifier list would
+            // collapse to just `DoIt` and mis-resolve to a same-named method on an
+            // unrelated class. Encode `TFoo.GetInstance().DoIt` so resolution infers
+            // DoIt's class from what `TFoo.GetInstance` RETURNS (#645/#608). Only a
+            // capitalized class-factory chain; a unary outer method.
+            const innerCall = firstChild.namedChildren.find((c) => c.type === 'exprCall');
+            const outerId = firstChild.namedChildren.filter((c) => c.type === 'identifier').pop();
+            const method = outerId ? (0, tree_sitter_helpers_1.getNodeText)(outerId, this.source) : '';
+            if (innerCall && method && /^\w+$/.test(method)) {
+                const innerFirst = innerCall.namedChild(0);
+                let innerCallee = '';
+                if (innerFirst?.type === 'exprDot') {
+                    innerCallee = innerFirst.namedChildren
+                        .filter((c) => c.type === 'identifier')
+                        .map((id) => (0, tree_sitter_helpers_1.getNodeText)(id, this.source))
+                        .join('.');
+                }
+                else if (innerFirst?.type === 'identifier') {
+                    innerCallee = (0, tree_sitter_helpers_1.getNodeText)(innerFirst, this.source);
+                }
+                // Gate on the Delphi type-naming convention — `TFoo` classes / `IFoo`
+                // interfaces — so a class-factory chain re-encodes but a capitalized
+                // VARIABLE/parameter chain (Pascal capitalizes locals too: `Curve.X().Y()`,
+                // `Self.X().Y()`) stays bare and keeps its existing bare-name resolution.
+                calleeName = innerCallee && /^[TI][A-Z]/.test(innerCallee)
+                    ? `${innerCallee}().${method}`
+                    : method;
+            }
+            else {
+                // Qualified call: Obj.Method(...)
+                const identifiers = firstChild.namedChildren.filter((c) => c.type === 'identifier');
+                if (identifiers.length > 0) {
+                    calleeName = identifiers.map((id) => (0, tree_sitter_helpers_1.getNodeText)(id, this.source)).join('.');
+                }
             }
         }
         else if (firstChild.type === 'identifier') {
@@ -2859,6 +4518,72 @@ class TreeSitterExtractor {
             this.visitPascalBlock(args);
         }
     }
+    /**
+     * Extract a PAREN-LESS Pascal method/procedure call (`Obj.Method;`,
+     * `TFoo.GetInstance.DoIt;`). Pascal lets a no-arg method drop its parens, so it
+     * parses as a bare `exprDot` (not an `exprCall`). A bare `exprDot` is
+     * syntactically identical to a field/property access, so this is only ever
+     * called for a STATEMENT-level exprDot (caller-gated): a bare `Obj.Field;`
+     * statement is a no-op, so a statement-level dot expression is a call. (An
+     * exprDot in assignment LHS/RHS or a condition is left alone — there it really
+     * can be a field/property read.)
+     */
+    extractPascalParenlessCall(node) {
+        if (this.nodeStack.length === 0)
+            return;
+        const callerId = this.nodeStack[this.nodeStack.length - 1];
+        if (!callerId)
+            return;
+        const receiver = node.namedChild(0);
+        const outerId = node.namedChildren.filter((c) => c.type === 'identifier').pop();
+        const method = outerId ? (0, tree_sitter_helpers_1.getNodeText)(outerId, this.source) : '';
+        if (!method)
+            return;
+        let calleeName = '';
+        // Chained: the receiver is itself a call — a paren-less `TFoo.GetInstance` (an
+        // inner exprDot) or a paren'd `TFoo.GetInstance()` (an exprCall). Encode the
+        // chain `TFoo.GetInstance().DoIt` so resolution infers DoIt's class from what
+        // the factory RETURNS (#645/#608), gated on the Delphi `TFoo`/`IFoo` type
+        // convention; a capitalized VARIABLE chain stays a bare method name.
+        if ((receiver?.type === 'exprDot' || receiver?.type === 'exprCall') && /^\w+$/.test(method)) {
+            const innerCalleeNode = receiver.type === 'exprCall' ? receiver.namedChild(0) : receiver;
+            const innerCallee = !innerCalleeNode
+                ? ''
+                : innerCalleeNode.type === 'identifier'
+                    ? (0, tree_sitter_helpers_1.getNodeText)(innerCalleeNode, this.source)
+                    : innerCalleeNode.namedChildren
+                        .filter((c) => c.type === 'identifier')
+                        .map((id) => (0, tree_sitter_helpers_1.getNodeText)(id, this.source))
+                        .join('.');
+            if (innerCallee && /^[TI][A-Z]/.test(innerCallee)) {
+                calleeName = `${innerCallee}().${method}`;
+                // The T/I-prefixed inner is itself a real call — record it too.
+                if (receiver.type === 'exprCall')
+                    this.extractPascalCall(receiver);
+                else
+                    this.extractPascalParenlessCall(receiver);
+            }
+            else {
+                calleeName = method; // non-class receiver: a bare method ref (no field-access ref)
+            }
+        }
+        else {
+            // Simple: `Obj.Method` → the dotted name (resolves via the receiver / bare name).
+            calleeName = node.namedChildren
+                .filter((c) => c.type === 'identifier')
+                .map((id) => (0, tree_sitter_helpers_1.getNodeText)(id, this.source))
+                .join('.');
+        }
+        if (calleeName) {
+            this.unresolvedReferences.push({
+                fromNodeId: callerId,
+                referenceName: calleeName,
+                referenceKind: 'calls',
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column,
+            });
+        }
+    }
     /**
      * Recursively visit a Pascal block/statement tree for call expressions
      */
@@ -2867,15 +4592,32 @@ class TreeSitterExtractor {
             const child = node.namedChild(i);
             if (!child)
                 continue;
+            // Function-as-value capture (#756): Pascal bodies are walked here, not
+            // in visitNode/visitForCallsAndStructure, so the capture hook fires here
+            // — assignment RHS is the Delphi event-wiring idiom (`OnFire := Handler`).
+            this.maybeCaptureFnRefs(child, child.type);
             if (child.type === 'exprCall') {
                 this.extractPascalCall(child);
+                // The walker doesn't descend into a call's arguments — dispatch the
+                // argument container directly (`RegisterHandler(TargetCb)` / `(@Cb)`).
+                const args = child.namedChildren.find((c) => c.type === 'exprArgs');
+                if (args)
+                    this.maybeCaptureFnRefs(args, 'exprArgs');
             }
             else if (child.type === 'exprDot') {
-                // Check if exprDot contains an exprCall
-                for (let j = 0; j < child.namedChildCount; j++) {
-                    const grandchild = child.namedChild(j);
-                    if (grandchild?.type === 'exprCall') {
-                        this.extractPascalCall(grandchild);
+                // A STATEMENT-level bare exprDot is a paren-less call (`Obj.Free;`,
+                // `TFoo.GetInstance.DoIt;`). Anywhere else (assignment side, condition,
+                // expression) a bare exprDot is ambiguous with a field/property access,
+                // so there we only descend for paren'd inner calls.
+                if (node.type === 'statement') {
+                    this.extractPascalParenlessCall(child);
+                }
+                else {
+                    for (let j = 0; j < child.namedChildCount; j++) {
+                        const grandchild = child.namedChild(j);
+                        if (grandchild?.type === 'exprCall') {
+                            this.extractPascalCall(grandchild);
+                        }
                     }
                 }
             }
@@ -2907,11 +4649,21 @@ function extractFromSource(filePath, source, language, frameworkNames) {
         const extractor = new vue_extractor_1.VueExtractor(filePath, source);
         result = extractor.extract();
     }
+    else if (detectedLanguage === 'astro') {
+        // Use custom extractor for Astro (frontmatter + template delegation)
+        const extractor = new astro_extractor_1.AstroExtractor(filePath, source);
+        result = extractor.extract();
+    }
     else if (detectedLanguage === 'liquid') {
         // Use custom extractor for Liquid
         const extractor = new liquid_extractor_1.LiquidExtractor(filePath, source);
         result = extractor.extract();
     }
+    else if (detectedLanguage === 'razor') {
+        // Use custom extractor for ASP.NET Razor (.cshtml) / Blazor (.razor) markup
+        const extractor = new razor_extractor_1.RazorExtractor(filePath, source);
+        result = extractor.extract();
+    }
     else if (detectedLanguage === 'xml') {
         // Custom extractor for MyBatis mapper XML. Non-mapper XML returns just a
         // file node so the watcher tracks it without emitting symbols.