@colbymchenry/codegraph 0.9.9 → 1.0.1

package/dist/extraction/function-ref.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Function-as-value capture (#756) — registration-linking for callbacks.
+ *
+ * A function name used as a VALUE — passed as a call argument
+ * (`register_handler(target_cb)`, `signal(SIGINT, handler)`), assigned to a
+ * field or function pointer (`o->cb = target_cb`, `OnFire := TargetCb`),
+ * placed in a struct/object initializer (`{ .recv_cb = my_cb }`,
+ * `{ recv: targetCb }`, `Ops{Cb: targetCb}`), or listed in a function table
+ * (`static cb_t table[] = { cb_a, cb_b }`) — is a real dependency that static
+ * call extraction misses entirely: `callers(target_cb)` showed nothing but
+ * direct calls, so every callback looked dead and its registration sites were
+ * invisible to impact analysis.
+ *
+ * This module captures those value positions during the AST walk as
+ * `function_ref` candidates. Capture is table-driven per language (the value
+ * positions and wrapper forms differ per grammar — `&fn` in C, `Main::fn` in
+ * Java, `::fn` in Kotlin, `#selector(fn)` in Swift, `@TargetCb` in Pascal,
+ * `method(:fn)` in Ruby). Candidates are GATED at end-of-file extraction
+ * (see `TreeSitterExtractor.flushFnRefCandidates`): only names matching a
+ * same-file function/method or an imported binding survive, which bounds
+ * volume and keeps precision high. Resolution then matches survivors against
+ * function/method nodes ONLY (`matchFunctionRef` in
+ * `src/resolution/name-matcher.ts`) and persists them as `references` edges,
+ * which `callers`/`impact` already traverse.
+ *
+ * Deliberately NOT covered (resolving the *dispatch* — `o->cb(x)` → the
+ * registered function — needs data-flow through struct fields; a wrong edge
+ * is worse than none): indirect-call resolution and `obj.method` member
+ * values where `obj` isn't `this`/`self` (the receiver's type is statically
+ * unknowable without local data-flow).
+ */
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+export interface FnRefCandidate {
+    name: string;
+    line: number;
+    column: number;
+    /** Which capture position produced this candidate (gate policy keys on it). */
+    mode: CaptureMode;
+    /**
+     * True when the value was an explicit reference form (`&fn`, `&Cls::m`,
+     * `::fn`, `#selector`, `method(:sym)`) rather than a bare identifier —
+     * C++'s flush policy keys on it.
+     */
+    explicitRef: boolean;
+    /**
+     * Skip the same-file/import name gate for this candidate. Set for PHP
+     * string callables in known HOF positions: PHP global functions are
+     * referenced cross-file WITHOUT imports (global namespace), so the gate
+     * can't see them — the strong positional prior (a string argument to
+     * `usort`/`array_map`/…) plus resolution's unique-or-drop rule carry the
+     * precision instead.
+     */
+    skipGate?: boolean;
+}
+/** How to pull candidate value nodes out of a dispatched container node. */
+type CaptureMode = 'args' | 'rhs' | 'value' | 'list' | 'varinit';
+interface CaptureRule {
+    mode: CaptureMode;
+    /** Field holding the value for rhs/value/varinit (defaults per mode). */
+    field?: string;
+}
+export interface FnRefSpec {
+    /** Bare identifier node types that can act as a function value. */
+    idTypes: Set<string>;
+    /** Container node type → how to extract candidate values from it. */
+    dispatch: Map<string, CaptureRule>;
+    /**
+     * Transparent wrapper layers between a container and its values
+     * (`argument`, `value_argument`, `literal_element`, `expression_list`…).
+     * Value: the field to descend into, or null for "named children".
+     * `expression_list` fans out to ALL named children (Go multi-assign).
+     */
+    layers?: Map<string, string | null>;
+    /**
+     * Unary wrappers whose operand is the function value — C/C++ `&fn`
+     * (pointer_expression), Pascal `@Fn` (exprUnary), Scala eta `fn _`
+     * (postfix_expression). Value: operand field, or null for first named child.
+     */
+    unwrap?: Map<string, string | null>;
+    /**
+     * Whole-node reference forms needing bespoke name extraction —
+     * `method_reference` (Java), `callable_reference` / `navigation_expression`
+     * (Kotlin), `selector_expression` (Swift `#selector` / ObjC `@selector`),
+     * Ruby `method(:sym)` calls, and `this.method` member forms.
+     */
+    special?: Set<string>;
+    /**
+     * Capture modes whose candidates skip the same-file/import gate and rely on
+     * resolution's unique-or-drop rule instead. C-family only: an initializer
+     * value, function-pointer assignment RHS, or table element is a
+     * function-pointer position by construction, and C has no symbol imports —
+     * the dominant repo-scale pattern (`server.c`'s command table naming
+     * handlers defined across files) would otherwise be invisible. Call
+     * arguments stay gated everywhere (locals passed as args dwarf callbacks).
+     */
+    ungatedModes?: Set<CaptureMode>;
+    /**
+     * C++ only: in args/rhs/varinit positions, accept ONLY explicit reference
+     * forms (`&fn`, `&Cls::method`) — never bare identifiers. C++ codebases are
+     * dense with generic free-function/accessor names (`begin`, `end`, `out`,
+     * `size`, `data`) that collide with parameters and locals, and out-of-line
+     * member definitions extract as function-kind nodes — bare-id matching on
+     * fmt was mostly wrong edges. File-scope initializer tables (value/list)
+     * still accept bare identifiers, same as C.
+     */
+    addressOfOnly?: boolean;
+}
+/**
+ * Capture specs by language.
+ */
+export declare const FN_REF_SPECS: Record<string, FnRefSpec | undefined>;
+/**
+ * Extract candidate names from a dispatched container node. Returns the
+ * (name, position) pairs of every function-value-shaped expression found.
+ */
+export declare function captureFnRefCandidates(container: SyntaxNode, rule: CaptureRule, spec: FnRefSpec, source: string): FnRefCandidate[];
+export {};
+//# sourceMappingURL=function-ref.d.ts.map

package/dist/extraction/grammars.d.ts

@@ -7,7 +7,7 @@
  */
 import { Parser } from 'web-tree-sitter';
 import { Language } from '../types';
-export type GrammarLanguage = Exclude<Language, 'svelte' | 'vue' | 'liquid' | 'yaml' | 'twig' | 'xml' | 'properties' | 'unknown'>;
+export type GrammarLanguage = Exclude<Language, 'svelte' | 'vue' | 'astro' | 'liquid' | 'razor' | 'yaml' | 'twig' | 'xml' | 'properties' | 'unknown'>;
 /**
  * File extension to Language mapping
  */
@@ -18,6 +18,12 @@ export declare const EXTENSION_MAP: Record<string, Language>;
  * from EXTENSION_MAP so parser support and indexing selection never drift.
  */
 export declare function isSourceFile(filePath: string): boolean;
+/**
+ * Shopify OS 2.0 JSON template (`templates/*.json`) or section group
+ * (`sections/*.json`) — these reference sections by `"type"`, so the Liquid
+ * extractor links them. (config/ + locales/ JSON have no section refs.)
+ */
+export declare function isShopifyLiquidJson(filePath: string): boolean;
 /**
  * Play Framework routes file: the extensionless `conf/routes` (and included
  * `conf/*.routes`). No grammar — route extraction is done by the Play framework

package/dist/extraction/index.d.ts

@@ -53,6 +53,40 @@ export declare function hashContent(content: string): string;
  * it project code; the explicit `.gitignore` negation is the only opt-in).
  */
 export declare function buildDefaultIgnore(rootDir: string): Ignore;
+/**
+ * Workspace-scope ignore matcher. Ordinary paths get the root's matcher
+ * (built-in defaults + root `.gitignore`); paths inside an EMBEDDED repo get
+ * that repo's own matcher (defaults + its root `.gitignore`) — the parent's
+ * `.gitignore` hides a child repo from git, not from the index (#514). A
+ * directory path (trailing slash) that is an ANCESTOR of an embedded root is
+ * never ignored, so directory-pruning callers (the Linux per-directory
+ * watcher) still descend to reach the embedded repos.
+ *
+ * Single source of truth for indexer and watcher scope — they must not diverge.
+ */
+export declare class ScopeIgnore {
+    private rootMatcher;
+    private embedded;
+    private defaults;
+    constructor(rootMatcher: Ignore, embedded: Array<{
+        root: string;
+        matcher: Ignore;
+    }>);
+    ignores(rel: string): boolean;
+}
+/**
+ * Build the workspace-scope matcher. When the caller already knows the
+ * embedded roots (the scanner discovers them during collection), pass them to
+ * skip rediscovery; otherwise they're discovered here (the watcher path).
+ */
+export declare function buildScopeIgnore(rootDir: string, embeddedRoots?: Iterable<string>): ScopeIgnore;
+/**
+ * Standalone discovery of every embedded repo root under `rootDir` (relative,
+ * trailing-slashed) — both the untracked kind (#193) and the gitignored kind
+ * (#514), recursively (an embedded repo can embed further repos). Returns []
+ * for non-git roots: the filesystem walk handles nested repos there already.
+ */
+export declare function discoverEmbeddedRepoRoots(rootDir: string): string[];
 /**
  * Recursively scan a directory for source files.
  *

package/dist/extraction/languages/c-cpp.d.ts

@@ -1,4 +1,12 @@
 import type { LanguageExtractor } from '../tree-sitter-types';
+/**
+ * Normalize a C++ return type to the bare class name a method could be called
+ * on. Unwraps smart-pointer / optional wrappers to their element type
+ * (`std::unique_ptr<Widget>` → `Widget`) so a factory's `->method()` resolves on
+ * the pointee. Strips cv-qualifiers, `&`/`*`, namespace qualifiers, and other
+ * template args. Returns undefined for primitives / void / `auto` / empty.
+ */
+export declare function normalizeCppReturnType(raw: string): string | undefined;
 export declare const cExtractor: LanguageExtractor;
 export declare const cppExtractor: LanguageExtractor;
 //# sourceMappingURL=c-cpp.d.ts.map

package/dist/extraction/languages/csharp.d.ts

@@ -1,3 +1,25 @@
 import type { LanguageExtractor } from '../tree-sitter-types';
+/**
+ * Blank C# conditional-compilation directive lines (`#if` / `#elif` / `#else` /
+ * `#endif`) before parsing. The vendored tree-sitter-c-sharp grammar mis-parses
+ * a `#if` that appears *inside an enum member list* — the canonical
+ * multi-targeting shape:
+ *
+ *   enum ReadType {
+ *   #if HAVE_DATE_TIME_OFFSET
+ *       ReadAsDateTimeOffset,
+ *   #endif
+ *       ReadAsDouble,
+ *   }
+ *
+ * It emits an ERROR that, for a nested enum, detaches the *enclosing class's*
+ * member list, so most of the class's methods drop out of the index. Removing
+ * the directive lines (keeping the guarded code) sidesteps it. Both branches of
+ * an `#if/#else` are kept — the same behaviour the previous grammar produced,
+ * and the right default for a code graph (index every symbol regardless of
+ * build flags). Replacement preserves byte offsets (directive text → spaces,
+ * newlines kept) so every symbol's line/column stays exact. (#237)
+ */
+export declare function blankCsharpPreprocessorDirectives(source: string): string;
 export declare const csharpExtractor: LanguageExtractor;
 //# sourceMappingURL=csharp.d.ts.map

package/dist/extraction/languages/r.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const rExtractor: LanguageExtractor;
+//# sourceMappingURL=r.d.ts.map

package/dist/extraction/languages/typescript.d.ts

@@ -1,3 +1,16 @@
 import type { LanguageExtractor } from '../tree-sitter-types';
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+/**
+ * A TS/JS class field (`public_field_definition` / `field_definition`) is a
+ * METHOD only when its value is callable — an arrow function, a function
+ * expression, or a HOF call wrapping one (`onScroll = throttle(() => {…})`),
+ * exactly mirroring what `resolveBody` below knows how to walk. Everything
+ * else (`public fonts: Fonts;`, `count = 0`, `static defaults = {…}`) is a
+ * PROPERTY. Previously every field extracted as method-kind (#808), which
+ * misrepresented class shape and defeated kind-based filtering — the reason
+ * #756's function-ref resolution had to restrict TS/JS bare identifiers to
+ * function targets.
+ */
+export declare function classifyTsClassMember(node: SyntaxNode): 'method' | 'property';
 export declare const typescriptExtractor: LanguageExtractor;
 //# sourceMappingURL=typescript.d.ts.map

package/dist/extraction/liquid-extractor.d.ts

@@ -24,6 +24,13 @@ export declare class LiquidExtractor {
      * Create a file node for the Liquid template
      */
     private createFileNode;
+    /**
+     * Shopify OS 2.0 JSON template / section group. Both have a `sections` object
+     * mapping an id → `{ "type": "<section-name>", ... }`; the `type` names a
+     * `sections/<type>.liquid` file. Emit a `references` edge to each, so a section
+     * used only from a JSON template (the OS 2.0 norm) is no longer orphaned.
+     */
+    private extractShopifyJsonSections;
     /**
      * Extract {% render 'snippet' %} and {% include 'snippet' %} references
      */

package/dist/extraction/razor-extractor.d.ts

@@ -0,0 +1,42 @@
+import { ExtractionResult } from '../types';
+export declare class RazorExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private edges;
+    private unresolvedReferences;
+    private errors;
+    constructor(filePath: string, source: string);
+    extract(): ExtractionResult;
+    private createComponentNode;
+    /** Last `.`-segment (`App.ViewModels.RegisterModel` → `RegisterModel`). */
+    private lastSegment;
+    /**
+     * Split a type expression into the capitalized type names it contains — base
+     * type plus any generic arguments (`Bar<Foo, Baz>` → `Bar`, `Foo`, `Baz`),
+     * each reduced to its last namespace segment. Lowercase/keyword tokens drop out.
+     */
+    private typeNames;
+    private pushRef;
+    private extractDirectives;
+    private extractComponentTags;
+    /**
+     * Find the matching `}` for the `{` at `openIdx`, skipping string literals and
+     * comments so a brace inside `"{"` / `// }` doesn't throw off the count.
+     * Returns the index of the closing brace, or -1 if unbalanced.
+     */
+    private matchBrace;
+    /** `@code { … }` / `@functions { … }` (Blazor) and `@{ … }` (Razor) C# blocks. */
+    private extractCodeBlocks;
+    /**
+     * Delegate each `@code`/`@functions`/`@{` block's C# to the tree-sitter C#
+     * extractor and attribute the block's external references (service/DTO calls,
+     * `new X()`, type uses) to the component. The block is wrapped in a synthetic
+     * class so tree-sitter parses the component's fields/methods in a class context
+     * (a Blazor `@code` body compiles into the component's partial class). We keep
+     * only the dependency references — coverage just needs the edges to external
+     * types, not per-member nodes. Degrades gracefully if the C# grammar isn't loaded.
+     */
+    private processCodeBlocks;
+}
+//# sourceMappingURL=razor-extractor.d.ts.map

package/dist/extraction/tree-sitter-types.d.ts

@@ -69,6 +69,15 @@ export interface ExtractorContext {
  * language-specific details like signatures, visibility, and imports.
  */
 export interface LanguageExtractor {
+    /**
+     * Optional source transform applied immediately before the grammar parses the
+     * file. Used to work around grammar gaps that would otherwise corrupt the
+     * parse tree (e.g. C# blanks conditional-compilation directive lines the
+     * grammar mis-parses inside enum bodies). MUST preserve byte offsets (replace
+     * removed text with spaces, keep newlines) so node positions and getNodeText
+     * stay correct; the returned string is used for both parsing and extraction.
+     */
+    preParse?: (source: string) => string;
     /** Node types that represent functions */
     functionTypes: string[];
     /** Node types that represent classes */
@@ -119,6 +128,14 @@ export interface LanguageExtractor {
     isStatic?: (node: SyntaxNode) => boolean;
     /** Check if variable declaration is a constant (const vs let/var) */
     isConst?: (node: SyntaxNode) => boolean;
+    /**
+     * Extract extra symbol-level modifier keywords to persist on the node's
+     * `decorators` list (e.g. Kotlin `expect`/`actual` multiplatform markers).
+     * Called generically for every created node; return undefined/[] when none.
+     * Used by the resolver to link `expect` declarations to their `actual`
+     * implementations across source sets.
+     */
+    extractModifiers?: (node: SyntaxNode) => string[] | undefined;
     /** Additional node types to treat as class declarations (e.g. Dart: 'mixin_declaration') */
     extraClassNodeTypes?: string[];
     /** Whether methods can be top-level without enclosing class (Go: true) */
@@ -135,6 +152,14 @@ export interface LanguageExtractor {
      * for multiple concepts (e.g. Swift uses class_declaration for classes, structs, and enums).
      */
     classifyClassNode?: (node: SyntaxNode) => 'class' | 'struct' | 'enum' | 'interface' | 'trait';
+    /**
+     * Classify a methodTypes node when the grammar reuses one node type for
+     * both callable and data members (#808): TS/JS class FIELDS
+     * (`public_field_definition` / `field_definition`) are methods only when
+     * their value is callable (`onClick = () => {}`); a plain field
+     * (`public fonts: Fonts;`, `count = 0`) is a property. Default: 'method'.
+     */
+    classifyMethodNode?: (node: SyntaxNode) => 'method' | 'property';
     /**
      * Resolve the body node for a function/method/class when it's not a child field.
      * (e.g. Dart puts function_body as a sibling, not a child.)
@@ -156,6 +181,14 @@ export interface LanguageExtractor {
      * When present, the receiver type is included in the qualified name for better searchability.
      */
     getReceiverType?: (node: SyntaxNode, source: string) => string | undefined;
+    /**
+     * Extract a function/method's normalized return type name (bare class name,
+     * smart-pointer pointee unwrapped), stored on the node as `returnType`. Used
+     * by C/C++ so resolution can infer a chained receiver's type from what the
+     * inner call returns (`Foo::instance().bar()` → resolve `bar` on `Foo`,
+     * issue #645). Return undefined for primitives / void / constructors.
+     */
+    getReturnType?: (node: SyntaxNode, source: string) => string | undefined;
     /**
      * Resolve the actual node kind for a type alias declaration.
      * Used by Go where `type_spec` is the named declaration wrapper for structs/interfaces:

package/dist/extraction/tree-sitter.d.ts

@@ -20,11 +20,45 @@ export declare class TreeSitterExtractor {
     private extractor;
     private nodeStack;
     private methodIndex;
+    private fnRefSpec;
+    private fnRefCandidates;
     constructor(filePath: string, source: string, language?: Language);
     /**
      * Parse and extract from the source code
      */
     extract(): ExtractionResult;
+    /**
+     * 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).
+     */
+    private maybeCaptureFnRefs;
+    /**
+     * 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.
+     */
+    private scanFnRefSubtree;
+    /**
+     * 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.
+     */
+    private flushFnRefCandidates;
     /**
      * Visit a node and extract information
      */
@@ -137,6 +171,14 @@ export declare class TreeSitterExtractor {
      * Returns true if children should be skipped (struct/interface handled body visiting).
      */
     private extractTypeAlias;
+    /**
+     * 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.
+     */
+    private extractGoInterfaceMethods;
     /**
      * Surface the members of a TypeScript `type X = { ... }` (or intersection
      * thereof) as `property` / `method` nodes under the type-alias node. Only
@@ -145,6 +187,34 @@ export declare class TreeSitterExtractor {
      * don't produce phantom members.
      */
     private extractTsTypeAliasMembers;
+    /**
+     * 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.
+     */
+    private extractTsTupleContractNames;
     /**
      * `foo: () => T` → property_signature whose type_annotation contains a
      * `function_type`. Treat that as a method-shaped contract member, since
@@ -158,6 +228,83 @@ export declare class TreeSitterExtractor {
      * Also creates unresolved references for resolution purposes.
      */
     private extractImport;
+    /**
+     * 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.
+     */
+    private emitImportBindingRefs;
+    /**
+     * 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.
+     */
+    private emitReExportRefs;
+    /**
+     * 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.
+     */
+    private emitRustUseBindingRefs;
+    /**
+     * 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.
+     */
+    private emitPhpUseRefs;
+    /**
+     * 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.
+     */
+    private emitRubyRequireRefs;
+    /** Convert a PHP FQN `Foo\Bar\Baz` to the stored `Foo\Bar::Baz` and emit an `imports` ref. */
+    private pushPhpUseRef;
+    /**
+     * 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.
+     */
+    private emitPyFromImportRefs;
     /**
      * Extract a function call
      */
@@ -172,6 +319,18 @@ export declare class TreeSitterExtractor {
      * arguments (`new Foo(bar())`) get their own `calls` references.
      */
     private extractInstantiation;
+    /**
+     * 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).
+     */
+    private extractStaticMemberRef;
+    private pushStaticMemberRef;
     /**
      * Find a `class_body` child of an `object_creation_expression` — the
      * marker for an anonymous class (`new T() { ... }`). Returns the body
@@ -216,6 +375,19 @@ export declare 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).
+     */
+    private extractRustRouteMacro;
     private visitFunctionBody;
     /**
      * Extract inheritance relationships
@@ -234,6 +406,11 @@ export declare class TreeSitterExtractor {
      * Languages that support type annotations (TypeScript, etc.)
      */
     private readonly TYPE_ANNOTATION_LANGUAGES;
+    /**
+     * PHP pseudo-types and `self`/`static`/`parent` that aren't project symbols.
+     * (Scalar primitives parse as `primitive_type` and are skipped structurally.)
+     */
+    private readonly PHP_PSEUDO_TYPES;
     /**
      * Built-in/primitive type names that shouldn't create references
      */
@@ -256,12 +433,35 @@ export declare class TreeSitterExtractor {
      * `tuple_type`, …) — none of which are `type_identifier`. Closes #381.
      */
     private extractCsharpTypeRefs;
+    /**
+     * 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)
+     */
+    private extractCsharpPrimaryCtorParamRefs;
     /**
      * Walk a C# subtree that is KNOWN to be in a type position
      * (return type, parameter type, property type, field type, generic
      * argument). Identifiers here are type names, not parameter names.
      */
     private walkCsharpTypePosition;
+    /**
+     * 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.
+     */
+    private extractPhpTypeRefs;
+    /** Walk a PHP subtree KNOWN to be in a type position; emit class/interface refs. */
+    private walkPhpTypePosition;
     /**
      * Extract type references from a variable's type annotation.
      */
@@ -301,6 +501,17 @@ export declare class TreeSitterExtractor {
      * Extract function calls from a Pascal expression
      */
     private extractPascalCall;
+    /**
+     * 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.)
+     */
+    private extractPascalParenlessCall;
     /**
      * Recursively visit a Pascal block/statement tree for call expressions
      */