@davesheffer/hunch 1.45.2 → 1.47.0

package/dist/extractors/languages.d.ts

@@ -1,43 +1,49 @@
 import type { Edge } from "../core/types.js";
 export type ParsedSymbolKind = "function" | "method" | "class" | "interface" | "trait" | "enum" | "type" | "variable" | "file";
 export interface LanguageSpec {
-    /** Stable id, also used as the grammar-bundle cache key by parse.ts. */
+    /** Stable language id (`typescript`, `python`, `go`, `php`, `yaml`). */
     id: string;
+    /** File suffixes, leading dot included, that this spec handles. */
     extensions: string[];
-    /** Cache key parse.ts's bundleFor() uses (one grammar+query pair may serve
-     *  several extensions, e.g. tsx serves both .tsx and .jsx). */
+    /** Memoization key for the parser+query bundle. One grammar can serve several
+     *  extensions, and two specs may share an `id` yet differ here (TS vs TSX). */
     grammarKey: string;
-    /** Lazily returns the tree-sitter Language object for this spec. */
+    /** Lazily returns the tree-sitter Language object. */
     loadGrammar(): unknown;
-    /** Tree-sitter query source capturing every construct this language cares about. */
+    /** Tree-sitter query source capturing every construct of interest. */
     query: string;
-    /** Node types ascendToDef() walks up to when resolving a name capture's enclosing def. */
+    /** Node types the parser climbs to when attaching a name capture to its definition. */
     defNodeTypes: Set<string>;
-    /** Query capture-name (ending in ".def") -> the ParsedSymbolKind it represents. */
+    /** Symbol kind for each capture name ending in `.def`. */
     defKindOf: Record<string, ParsedSymbolKind>;
-    /** Query capture-name (ending in ".name") -> the matching ".def" capture-name. */
+    /** Maps each `.name` capture to the `.def` capture it belongs to. */
     nameToDef: Record<string, string>;
+    /** Optional query binding a local name to an imported module, run with
+     *  matches() so captures pair up: @bind.src (module specifier), @bind.local
+     *  (local name), @bind.name (an imported member, `from X import name`). Feeds
+     *  qualified calls (`ns.fn()`), resolved only inside the bound module's files. */
+    bindingQuery?: string;
+    /** Local name an import binds when @bind.local is absent (Go `"a/geo"` -> geo). */
+    defaultBindingLocal?(src: string): string | null;
+    /** Module path of `from <src> import <name>` when name is itself a submodule. */
+    joinSubmodule?(src: string, name: string): string;
     /** Optional semantic relationship captures. The generic parser/indexer emit
      * these through the normal graph path; languages only describe syntax. */
     relationKindOf?: Record<string, {
         edgeType: Edge["type"];
         label: string;
     }>;
-    /** Common builtin/stdlib method names. Member calls to these (e.g. `arr.map(...)`)
-     *  must NOT create call edges to unrelated repo symbols that happen to share the
-     *  name (DESIGN: keep the graph clean). */
+    /** Common builtin/stdlib method names. A member call whose property is in this
+     *  set never produces a call edge to a same-named repo symbol. */
     builtinMethods: Set<string>;
     /** Direct-call builtins for languages such as PHP. These never become repo
      * call edges merely because a project symbol shares the runtime name. */
     builtinFunctions?: Set<string>;
-    /** Edge type emitted for this language's calls-list entries (e.g. YAML's
-     *  alias->anchor references aren't function calls). Defaults to "calls"
-     *  when omitted — every language before YAML. */
+    /** Edge type emitted for this language's call-list entries; defaults to
+     *  `"calls"`. YAML sets it because alias-to-anchor links are references. */
     referenceEdgeType?: Edge["type"];
-    /** Fallback name for a ".def" capture with no paired ".name" capture (e.g.
-     *  a whole-file root symbol with no natural identifier of its own). Omit
-     *  for a language where every ".def" always has a name capture — parse.ts
-     *  then keeps dropping unnamed defs, the current behavior for TS/Python. */
+    /** Name for a `.def` capture that has no paired `.name` capture (a whole-file
+     *  root symbol, say). When omitted, unnamed defs are dropped. */
     fallbackDefName?: (file: string) => string;
     /** Ancestor shapes in which an ERROR node is a known limitation of THIS grammar
      *  rather than a real syntax error. parse.ts forgives an error only when some
@@ -55,30 +61,24 @@ export interface LanguageSpec {
      *  every captured value from the original source at the tree's unchanged
      *  offsets. Keep replacements syntax-equivalent outside the grammar defect. */
     parseErrorRecovery?: (source: string) => string;
-    /** Patterns whose presence anywhere in the source mean "this isn't actually
-     *  {id} text yet — it's a template that renders to {id} later" (Go/Jinja/Helm
-     *  delimiters in a .yaml file, e.g.). parse.ts still runs the real parse — a
-     *  genuine anchor/symbol elsewhere in the file is still extracted, same as any
-     *  other {id} file — but no longer lets the resulting ERROR nodes fail-close
-     *  the whole-repo scan completeness gate the way toleratedErrorScopes protects
-     *  narrower, per-grammar false positives (issue #33). Keep these narrow: a
-     *  pattern that also matches ordinary, always-valid {id} syntax (e.g. GitHub
-     *  Actions' `${{ }}` expressions) would silently disable the fail-closed
-     *  guarantee for files that were never templated at all. */
+    /** Patterns whose presence anywhere in a file's text means the file is a
+     *  template that renders into this language later (Go/Jinja/Helm delimiters in
+     *  YAML). The real parse still runs, but the resulting error nodes must not make
+     *  the file unparseable, so the whole-repo completeness gate does not fail
+     *  closed. Keep patterns narrow so they never match always-valid syntax such as
+     *  GitHub Actions `${{ }}` expressions. */
     templatingMarkers?: readonly RegExp[];
-    /** Extensions within this language where EVERY file is inherently a template
-     *  regardless of content — unlike templatingMarkers, this never content-sniffs.
-     *  The extension alone means "this file is a template, parseable must never
-     *  become false for it," matching Helm's `_helpers.tpl` convention where the
-     *  file may be pure Go-template text with no YAML structure of its own at all. */
+    /** Extensions where every file is a template regardless of content, with no
+     *  sniffing (Helm's `_helpers.tpl` convention). Such files are never reported
+     *  unparseable. */
     alwaysTemplatedExtensions?: readonly string[];
 }
 export declare const LANGUAGES: LanguageSpec[];
+/** Every registered extension, de-duplicated, in registry order. */
 export declare const CODE_EXTENSIONS: string[];
+/** First spec (registry order) with an extension the file name ends with. */
 export declare function languageFor(file: string): LanguageSpec | null;
-/** Prose formats worth drafting a decision from even though no LanguageSpec parses
- *  them — no grammar, no symbols/edges, just eligible input to synthesis (issue #12). */
+/** Prose formats eligible as synthesis input but never parsed. */
 export declare const PROSE_EXTENSIONS: string[];
-/** Broader than languageFor: "is this worth reasoning about" (synthesis input)
- *  rather than "can tree-sitter parse this" (symbol/dependency extraction). */
+/** True for parseable code or prose. Deliberately broader than parseability. */
 export declare function isSubstantive(file: string): boolean;

package/dist/extractors/languages.js

@@ -1,9 +1,8 @@
 /**
- * Language registry: one LanguageSpec per supported language, consumed by
- * parse.ts (tree-sitter grammar/query dispatch), indexer.ts / diff.ts /
- * synthesize.ts ("is this a code file?"). Adding a language is a new entry
- * here (+ a new tree-sitter-* dependency), not edits scattered across those
- * four files.
+ * The single language registry: one `LanguageSpec` per supported language. The
+ * parser reads grammar and query data from here, and the indexer, diff analysis
+ * and synthesis ask it "is this a code file?". Adding a language means adding an
+ * entry here plus a grammar dependency.
  */
 import { basename } from "node:path";
 import { loadNativeTreeSitter } from "./nativeTreeSitter.js";
@@ -17,7 +16,14 @@ const TS_QUERY = `
   (variable_declarator
      name: (identifier) @arrow.name
      value: [(arrow_function) (function_expression)]) @arrow.def
+  ;; Class-field arrows (\`handler = () => {}\`) are methods in every way that matters.
+  (public_field_definition
+     name: (property_identifier) @method.name
+     value: [(arrow_function) (function_expression)]) @method.def
   (import_statement source: (string) @import.src)
+  ;; require("./x") and dynamic import("./x") are imports too, when the specifier is literal.
+  (call_expression function: (identifier) @_require arguments: (arguments . (string) @import.src .) (#eq? @_require "require"))
+  (call_expression function: (import) arguments: (arguments . (string) @import.src .))
   (call_expression function: (identifier) @call.id)
   (call_expression function: (member_expression property: (property_identifier) @call.member))
   ;; Construction IS a call. Without these, \`new Foo()\` produced no edge at all, so
@@ -27,24 +33,56 @@ const TS_QUERY = `
   (new_expression constructor: (identifier) @call.id)
   (new_expression constructor: (member_expression property: (property_identifier) @call.member))
 `;
+/** Rendering a component IS a call; lowercase tags are intrinsic elements, not symbols. */
+const TSX_QUERY = `${TS_QUERY}
+  (jsx_opening_element name: (identifier) @call.id (#match? @call.id "^[A-Z]"))
+  (jsx_self_closing_element name: (identifier) @call.id (#match? @call.id "^[A-Z]"))
+  (jsx_opening_element name: (member_expression property: (property_identifier) @call.member))
+  (jsx_self_closing_element name: (member_expression property: (property_identifier) @call.member))
+`;
+/** Module-object bindings: \`import * as ns\`, \`const m = require()\`, \`const m = await import()\`. */
+const TS_BINDING_QUERY = `
+  (import_statement (import_clause (namespace_import (identifier) @bind.local)) source: (string) @bind.src)
+  (variable_declarator
+     name: (identifier) @bind.local
+     value: (call_expression function: (identifier) @_require arguments: (arguments . (string) @bind.src .))
+     (#eq? @_require "require"))
+  (variable_declarator
+     name: (identifier) @bind.local
+     value: (await_expression (call_expression function: (import) arguments: (arguments . (string) @bind.src .))))
+`;
 const TS_BUILTIN_METHODS = new Set([
+    // arrays
     "map", "filter", "forEach", "reduce", "find", "findIndex", "some", "every", "includes",
-    "push", "pop", "shift", "unshift", "slice", "splice", "concat", "join", "split", "flat", "flatMap",
-    "indexOf", "lastIndexOf", "keys", "values", "entries", "sort", "reverse", "fill", "at",
+    "push", "pop", "shift", "unshift", "slice", "splice", "concat", "join", "split", "flat",
+    "flatMap", "indexOf", "lastIndexOf", "keys", "values", "entries", "sort", "reverse", "fill", "at",
+    // Map / Set
     "get", "set", "has", "add", "delete", "clear",
+    // Promise
     "then", "catch", "finally", "all", "race", "resolve", "reject",
+    // object basics
     "toString", "valueOf", "toJSON", "hasOwnProperty",
-    "replace", "replaceAll", "trim", "trimStart", "trimEnd", "padStart", "padEnd", "startsWith", "endsWith",
-    "toLowerCase", "toUpperCase", "charAt", "charCodeAt", "substring", "substr", "repeat", "match", "matchAll",
+    // strings
+    "replace", "replaceAll", "trim", "trimStart", "trimEnd", "padStart", "padEnd", "startsWith",
+    "endsWith", "toLowerCase", "toUpperCase", "charAt", "charCodeAt", "substring", "substr",
+    "repeat", "match", "matchAll",
+    // Function / RegExp / JSON / Date / Array / Object statics
     "call", "apply", "bind", "test", "exec", "now", "parse", "stringify", "from", "of", "isArray", "assign",
+    // console
     "log", "error", "warn", "info", "debug",
 ]);
 const TS_SHARED = {
     id: "typescript",
     query: TS_QUERY,
     defNodeTypes: new Set([
-        "function_declaration", "generator_function_declaration", "method_definition",
-        "class_declaration", "interface_declaration", "type_alias_declaration", "variable_declarator",
+        "function_declaration",
+        "generator_function_declaration",
+        "method_definition",
+        "class_declaration",
+        "interface_declaration",
+        "type_alias_declaration",
+        "variable_declarator",
+        "public_field_definition",
     ]),
     defKindOf: {
         "fn.def": "function", "method.def": "method", "class.def": "class",
@@ -55,6 +93,7 @@ const TS_SHARED = {
         "iface.name": "iface.def", "type.name": "type.def", "arrow.name": "arrow.def",
     },
     builtinMethods: TS_BUILTIN_METHODS,
+    bindingQuery: TS_BINDING_QUERY,
     // ES2018 relaxed template literals: an INVALID escape (`\x` with no hex, `\u`
     // short, `\u{` unterminated) is legal inside a TAGGED template — the cooked
     // value is undefined and the raw text survives, which is the entire point of
@@ -72,15 +111,15 @@ const TYPESCRIPT = {
     grammarKey: "ts",
     loadGrammar: () => loadNativeTreeSitter().typescript,
 };
-/** .tsx/.jsx use the TSX grammar variant; everything else in the TS spec uses
- *  the plain typescript grammar. Both share the same query/def maps/builtins,
- *  so this is a second LanguageSpec entry with a distinct grammarKey/loadGrammar
- *  only — not a second `id` (languageFor callers only care about extension match). */
+/** TSX is a second entry that differs from TYPESCRIPT only in grammar and cache
+ *  key (the `id` is shared). It also overrides the query with TSX_QUERY, widens
+ *  the tolerated error scopes and adds a recovery pass. */
 const TSX = {
     ...TS_SHARED,
     extensions: [".tsx", ".jsx"],
     grammarKey: "tsx",
     loadGrammar: () => loadNativeTreeSitter().tsx,
+    query: TSX_QUERY,
     // tree-sitter-javascript rejects a bare ampersand in JSX text even though JSX
     // accepts it (tree-sitter-javascript#366). The ERROR is a direct jsx_element
     // child and its text begins at the ampersand. Require both facts plus text that
@@ -96,13 +135,15 @@ const TSX = {
     parseErrorRecovery: (source) => source.replaceAll("&", "|"),
 };
 const PY_QUERY = `
+  ;; A class whose body directly holds a def (plain or decorated): the nested def is
+  ;; a method. parse.ts keeps the first classification per node, so the generic
+  ;; function pattern below does not reclassify it.
   (class_definition
-    name: (identifier) @class.name
-    body: (block
-      [
-        (function_definition name: (identifier) @method.name) @method.def
-        (decorated_definition definition: (function_definition name: (identifier) @method.name) @method.def)
-      ])) @class.def
+     name: (identifier) @class.name
+     body: (block [
+       (function_definition name: (identifier) @method.name) @method.def
+       (decorated_definition definition: (function_definition name: (identifier) @method.name) @method.def)
+     ])) @class.def
   ;; Every class, including one with no directly-nested def: dataclasses, Exception
   ;; subclasses, Enums, TypedDicts and pydantic models are method-less by design and
   ;; were invisible to the entire graph (no symbol, no component, no edges), so
@@ -113,20 +154,18 @@ const PY_QUERY = `
   (function_definition name: (identifier) @fn.name) @fn.def
   (import_statement name: (dotted_name) @import.src)
   (import_statement name: (aliased_import name: (dotted_name) @import.src))
-  (import_from_statement module_name: (dotted_name) @import.src)
-  (import_from_statement module_name: (relative_import) @import.src)
+  (import_from_statement module_name: [(dotted_name) (relative_import)] @import.src)
   (call function: (identifier) @call.id)
   (call function: (attribute attribute: (identifier) @call.member))
 `;
 const PY_BUILTIN_METHODS = new Set([
-    "get", "set", "keys", "values", "items", "pop", "popitem", "update", "setdefault", "copy", "clear",
-    "append", "extend", "insert", "remove", "reverse", "sort", "count", "index",
-    "add", "discard", "union", "intersection", "difference",
-    "format", "join", "split", "rsplit", "splitlines", "strip", "lstrip", "rstrip",
-    "startswith", "endswith", "replace", "find", "rfind", "lower", "upper", "title", "capitalize",
-    "encode", "decode", "isdigit", "isalpha", "isalnum", "isspace",
-    "read", "write", "close", "open", "readline", "readlines",
-    "run", "wait", "poll", "communicate",
+    "get", "set", "keys", "values", "items", "pop", "popitem", "update", "setdefault", "copy",
+    "clear", "append", "extend", "insert", "remove", "reverse", "sort", "count", "index", "add",
+    "discard", "union", "intersection", "difference", "format", "join", "split", "rsplit",
+    "splitlines", "strip", "lstrip", "rstrip", "startswith", "endswith", "replace", "find",
+    "rfind", "lower", "upper", "title", "capitalize", "encode", "decode", "isdigit", "isalpha",
+    "isalnum", "isspace", "read", "write", "close", "open", "readline", "readlines", "run",
+    "wait", "poll", "communicate",
 ]);
 const PYTHON = {
     id: "python",
@@ -254,7 +293,9 @@ const PHP = {
 const YAML_QUERY = `
   (block_node (anchor (anchor_name) @anchor.name)) @anchor.def
   (flow_node (anchor (anchor_name) @anchor.name)) @anchor.def
+  ;; An alias is a reference to its anchor.
   (alias (alias_name) @call.id)
+  ;; The whole document gets a root symbol (named via fallbackDefName).
   (stream) @doc.def
 `;
 const YAML = {
@@ -263,42 +304,30 @@ const YAML = {
     grammarKey: "yaml",
     loadGrammar: () => loadNativeTreeSitter().yaml,
     query: YAML_QUERY,
-    // Both block-style (`key: &x\n  ...`) and flow-style (`key: &x {...}`) anchors
-    // wrap only the sigil+name; ascendToDef climbs from anchor_name -> anchor ->
-    // this enclosing node to find the def whose byte range covers the full value.
     defNodeTypes: new Set(["block_node", "flow_node"]),
     defKindOf: { "anchor.def": "variable", "doc.def": "file" },
     nameToDef: { "anchor.name": "anchor.def" },
     builtinMethods: new Set(),
-    // Alias references aren't calls; label the edge accordingly (Task 5).
     referenceEdgeType: "references",
-    // Most aliases reference an anchor from OUTSIDE that anchor's own byte range
-    // (a sibling key, not a nested value) — without a whole-file fallback symbol,
-    // attributeCalls's containment check would silently drop them. See Task 4.
+    // Most aliases sit outside their anchor's byte range, so without a root symbol
+    // call attribution would drop them. The file's own name is the root.
     fallbackDefName: (file) => basename(file),
-    // Helm charts / templated CI configs are common .yaml content that only
-    // becomes valid YAML after a render step (issue #33). The negative lookbehind
-    // on "{{" excludes GitHub Actions' `${{ expression }}` syntax, which is
-    // ordinary, always-valid YAML — every workflow file in this repo uses it, so
-    // treating it as a templating marker would blanket-disable the fail-closed
-    // gate for .github/workflows/**.
-    templatingMarkers: [/(?<!\$)\{\{/, /\{%/],
+    // Go/Jinja/Helm delimiters make a file invalid YAML until rendered. A `{{` not
+    // preceded by `$` (GitHub Actions `${{ }}` is plain valid YAML) and a Jinja `{%`.
+    templatingMarkers: [/(?<!\$)\{\{/u, /\{%/u],
+    // `.tpl` files (Helm `_helpers.tpl`) are templates by convention, whatever they hold.
     alwaysTemplatedExtensions: [".tpl"],
 };
 export const LANGUAGES = [TYPESCRIPT, TSX, PYTHON, GO, PHP, YAML];
+/** Every registered extension, de-duplicated, in registry order. */
 export const CODE_EXTENSIONS = [...new Set(LANGUAGES.flatMap((l) => l.extensions))];
+/** First spec (registry order) with an extension the file name ends with. */
 export function languageFor(file) {
-    for (const lang of LANGUAGES) {
-        if (lang.extensions.some((ext) => file.endsWith(ext)))
-            return lang;
-    }
-    return null;
+    return LANGUAGES.find((l) => l.extensions.some((ext) => file.endsWith(ext))) ?? null;
 }
-/** Prose formats worth drafting a decision from even though no LanguageSpec parses
- *  them — no grammar, no symbols/edges, just eligible input to synthesis (issue #12). */
+/** Prose formats eligible as synthesis input but never parsed. */
 export const PROSE_EXTENSIONS = [".md"];
-/** Broader than languageFor: "is this worth reasoning about" (synthesis input)
- *  rather than "can tree-sitter parse this" (symbol/dependency extraction). */
+/** True for parseable code or prose. Deliberately broader than parseability. */
 export function isSubstantive(file) {
     return languageFor(file) !== null || PROSE_EXTENSIONS.some((ext) => file.endsWith(ext));
 }

package/dist/extractors/nativeTreeSitter.d.ts

@@ -32,10 +32,10 @@ export declare class NativeTreeSitterLoadError extends Error {
  *  a worker/IPC boundary keeps only its plain properties. The name check
  *  survives both. */
 export declare function isParserLoadError(e: unknown): boolean;
-/** Load all native tree-sitter addons (the parser runtime + every grammar) from
+/** Loads every native tree-sitter addon (the parser runtime and each grammar) from
  * content-addressed copies in a per-user temp cache — never from the installed
  * package. Windows keeps loaded `.node` files locked for the
- * process lifetime; redirecting the upstream loaders means npm can replace the
- * installed package during an active MCP session without killing that session
- * or falling back to a stale binary. */
+ * lifetime of the process, so pointing the upstream loaders at copies lets npm
+ * replace the installed package during a live MCP session without killing it and
+ * without ever loading a stale binary. */
 export declare function loadNativeTreeSitter(): NativeTreeSitterRuntime;

package/dist/extractors/nativeTreeSitter.js

@@ -10,13 +10,14 @@ const COPY_PREFIX = "hunch-tree-sitter-";
 const CACHE_PREFIX = "hunch-tree-sitter-cache-";
 /** A hash dir no process has used for this long is pruned. */
 const CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+/** npm packages whose native addons are loaded from isolated copies. */
 const NATIVE_PACKAGES = [
     "tree-sitter",
     "tree-sitter-typescript",
     "tree-sitter-python",
     "tree-sitter-go",
     "tree-sitter-php",
-    "@tree-sitter-grammars/tree-sitter-yaml",
+    "tree-sitter-yaml",
 ];
 let runtime = null;
 /** The parser runtime itself is unavailable — the addons could not be copied or
@@ -87,8 +88,11 @@ function removeStaleCopies() {
         }
     }
 }
+/** node-gyp-build keys the redirect on the package's own `name`, not the
+ *  specifier it was required by — the two differ for an npm alias. */
 function environmentKey(packageName) {
-    return `${packageName.toUpperCase().replaceAll("-", "_")}_PREBUILD`;
+    const { name } = runtimeRequire(`${packageName}/package.json`);
+    return `${name.toUpperCase().replaceAll("-", "_")}_PREBUILD`;
 }
 /** The per-user copy cache. A binary copied to a fresh path costs a first-load
  *  assessment (macOS checks every never-seen dylib: ~2s per addon, six addons)
@@ -197,12 +201,12 @@ function pruneCache(root, keep) {
         catch { /* in use or already gone */ }
     }
 }
-/** Load all native tree-sitter addons (the parser runtime + every grammar) from
+/** Loads every native tree-sitter addon (the parser runtime and each grammar) from
  * content-addressed copies in a per-user temp cache — never from the installed
  * package. Windows keeps loaded `.node` files locked for the
- * process lifetime; redirecting the upstream loaders means npm can replace the
- * installed package during an active MCP session without killing that session
- * or falling back to a stale binary. */
+ * lifetime of the process, so pointing the upstream loaders at copies lets npm
+ * replace the installed package during a live MCP session without killing it and
+ * without ever loading a stale binary. */
 export function loadNativeTreeSitter() {
     if (runtime)
         return runtime;
@@ -219,13 +223,12 @@ export function loadNativeTreeSitter() {
     }
 }
 function loadRuntime() {
-    // Three binding spellings: prebuilds ship as tree-sitter[-typescript|-python].node
-    // or, for a scoped package like @tree-sitter-grammars/tree-sitter-yaml, as
-    // @scope+name.node; from-source builds are named after the binding.gyp target
-    // with underscores (tree_sitter_runtime_binding.node, tree_sitter_python_binding.node,
-    // tree_sitter_yaml_binding.node, …). Missing the underscore names let an
-    // already-loaded source-built addon slip past this guard and defeat the
-    // file-lock isolation entirely (issue #52).
+    // Recognised addon file names: the prebuilt names of the runtime and of each
+    // grammar package, the `@scope+name` spelling that scoped packages use inside
+    // their prebuilds, and from-source builds, which are named after the
+    // binding.gyp target with underscores and end in `_binding`. Missing the
+    // underscore form once let an already-loaded source build slip past isolation
+    // (issue #52).
     const preloaded = Object.keys(runtimeRequire.cache).filter((path) => /(?:tree-sitter(?:-typescript|-python|-go|-php|-yaml)?|tree_sitter(?:_[a-z]+)*_binding)\.node$/.test(path)
         && !new RegExp(`(?:^|[\\\\/])(?:${COPY_PREFIX}\\d+-|${CACHE_PREFIX})`).test(path));
     if (preloaded.length) {
@@ -260,7 +263,7 @@ function loadRuntime() {
         const python = runtimeRequire("tree-sitter-python");
         const go = runtimeRequire("tree-sitter-go");
         const php = runtimeRequire("tree-sitter-php");
-        const yaml = runtimeRequire("@tree-sitter-grammars/tree-sitter-yaml");
+        const yaml = runtimeRequire("tree-sitter-yaml");
         runtime = { Parser, typescript: languages.typescript, tsx: languages.tsx, python, go, php: php.php, yaml };
     }
     finally {

package/dist/extractors/parse.d.ts

@@ -15,6 +15,20 @@ export interface ParsedCall {
     endByte: number;
     /** true for `x.foo()` (property access), false for a direct `foo()` call. */
     member: boolean;
+    /** For a member call on a plain identifier (`x.foo()`), that identifier. */
+    qualifier?: string;
+}
+/** A local name bound by an import: a module object (`imported` null — `import *
+ *  as ns`, `require()`, Go package alias) or one aliased member of a module. */
+export interface ParsedBinding {
+    local: string;
+    module: string;
+    imported: string | null;
+}
+/** A call whose target is pinned to one imported module (`ns.fn()`, aliased `g()`). */
+export interface QualifiedCall {
+    callee: string;
+    module: string;
 }
 export interface ParsedRelation {
     target: string;
@@ -28,28 +42,28 @@ export interface ParsedFile {
     imports: string[];
     calls: ParsedCall[];
     relations: ParsedRelation[];
+    bindings: ParsedBinding[];
     namespace: string | null;
     parseable: boolean;
 }
-/** Cap on a stored symbol's bodyText — large enough for review context, small
- *  enough that a huge function/file doesn't bloat every JSON symbol record. */
+/** Cap on stored symbol body text: enough context for review without bloating JSON records. */
 export declare const MAX_BODY_TEXT_CHARS = 4000;
 export declare function parseSource(file: string, source: string, opts?: {
     throwOnParseError?: boolean;
 }): ParsedFile | null;
 /** Map each call site to the innermost symbol whose byte-range contains it.
- *  Keyed by the symbol's position (index) in `parsed.symbols` — NOT its
- *  startByte, which is not a reliable per-symbol identity: a language whose
- *  extractor merges a synthetic whole-file symbol with independently-derived
- *  symbols (e.g. YAML's fallback-root synthetic symbol alongside Helm's
- *  regex-derived `define` blocks) can produce two distinct symbols that both
- *  start at byte 0. Indexing by array position is unique by construction,
- *  regardless of byte overlap — the caller must consume the exact same
- *  `parsed.symbols` array (or an equivalently-ordered copy) to look up a
- *  symbol by the index this function returns. The value maps callee name ->
- *  `memberOnly` (true iff every occurrence was a `x.foo()` member call, never
- *  a direct `foo()`), so the indexer can resolve member calls conservatively. */
+ *  The result is keyed by the symbol's INDEX in `parsed.symbols`, not its start
+ *  byte: two distinct symbols can share a start byte (a synthetic whole-file root
+ *  beside others starting at byte 0), so callers must look symbols up in the same
+ *  array order. Each value maps callee name -> memberOnly, true iff every
+ *  occurrence of that callee inside the symbol was a member call, so the indexer
+ *  can resolve member calls conservatively. */
 export declare function attributeCalls(parsed: ParsedFile): Map<number, Map<string, boolean>>;
+/** Map each call bound to an imported module — `ns.fn()` through a module-object
+ *  binding, or `g()` through an aliased member import — to the innermost symbol
+ *  containing it (same index identity as attributeCalls). A local bound to two
+ *  different modules is ambiguous and dropped: never guess a binding. */
+export declare function attributeQualifiedCalls(parsed: ParsedFile): Map<number, QualifiedCall[]>;
 /** Map static semantic relationships (extends/implements/trait use) to the
  * innermost enclosing declaration using the same stable symbol-index identity
  * as call attribution. */