@colbymchenry/codegraph 1.2.0 → 1.3.0

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

@@ -12,15 +12,21 @@ import { ExtractionResult } from '../types';
  *
  * This extractor emits one method-shaped node per `<select|insert|update|
  * delete>` and per `<sql>` fragment, qualified as `<namespace>::<id>` so the
- * MyBatis framework synthesizer (`src/resolution/frameworks/mybatis.ts`) can
- * link the matching Java method → XML statement by suffix-matching qualified
- * names. `<include refid="...">` inside a statement yields an unresolved
- * reference to the SQL fragment, also keyed by `<namespace>::<refid>`.
+ * MyBatis framework synthesizer can link the matching Java method → XML
+ * statement by suffix-matching qualified names. `<include refid="...">` inside
+ * a statement yields an unresolved reference to the SQL fragment, also keyed
+ * by `<namespace>::<refid>`.
+ *
+ * Both dialects are covered: MyBatis 3 `<mapper namespace="...">` and the
+ * legacy iBatis 2 `<sqlMap>` (namespaced, or namespace-less with `Map.stmt`
+ * ids, plus its extra `<statement>`/`<procedure>` verbs). Attribute values may
+ * use either quote style, and statements commented out with `<!-- ... -->` are
+ * ignored (see the constructor's comment-stripping pre-pass).
  *
  * Non-mapper XML (Maven `pom.xml`, Spring beans XML, `web.xml`, log4j config,
- * etc.) is detected by the absence of a `<mapper namespace="...">` root and
- * returns just a file node — we still need the file row so the watcher can
- * track it, but we emit no symbols.
+ * etc.) is detected by the absence of a `<mapper namespace="...">` /
+ * `<sqlMap>` root and returns just a file node — we still need the file row so
+ * the watcher can track it, but we emit no symbols.
  */
 export declare class MyBatisExtractor {
     private filePath;
@@ -31,16 +37,30 @@ export declare class MyBatisExtractor {
     private errors;
     private lineStarts;
     constructor(filePath: string, source: string);
+    private static stripXmlComments;
     extract(): ExtractionResult;
     private createFileNode;
     /**
-     * Find the `<mapper namespace="X">` opening tag. Returns the namespace and
-     * the byte offsets of the body (between the opening and closing tag) so
-     * statement extraction can be scoped to mapper contents.
+     * Find the mapper root and its dialect. Two shapes are recognized:
+     *   - MyBatis 3: `<mapper namespace="com.foo.Bar">` — namespace required.
+     *   - iBatis 2:  `<sqlMap namespace="Account">`, or a namespace-less
+     *     `<sqlMap>` whose statement ids carry the qualifier as `Map.statement`.
+     * Returns the namespace, the dialect, and the byte offsets of the body
+     * (between the opening and closing tag) so statement extraction is scoped to
+     * the root's contents. Either quote style is accepted for the namespace
+     * (`namespace='X'` is legal XML and common in older mappers).
      */
     private findMapperRoot;
     private extractMapper;
     private buildSignature;
+    /**
+     * Build the `<namespace>::<id>` qualified name the MyBatis synthesizer
+     * suffix-matches against a Java `<Class>::<method>`, and the display name.
+     * For a namespace-less iBatis `<sqlMap>`, the statement id carries the
+     * qualifier as `Map.statement`, so split on the last dot to reach the same
+     * shape (`Account.getById` → `Account::getById`, name `getById`).
+     */
+    private qualifyStatement;
     private previewSql;
     private computeLineStarts;
     private getLineNumber;

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

@@ -76,8 +76,10 @@ export interface LanguageExtractor {
      * 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.
+     * `filePath` lets a transform key off the concrete file extension when one
+     * language id serves several dialects (C++ also parses `.metal` shaders).
      */
-    preParse?: (source: string) => string;
+    preParse?: (source: string, filePath?: string) => string;
     /** Node types that represent functions */
     functionTypes: string[];
     /** Node types that represent classes */

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

@@ -25,6 +25,8 @@ export declare class TreeSitterExtractor {
     private errors;
     private extractor;
     private nodeStack;
+    private namespacePrefix;
+    private cppLocalFnPtrs;
     private methodIndex;
     private fnRefSpec;
     private fnRefCandidates;
@@ -427,6 +429,25 @@ export declare class TreeSitterExtractor {
     /**
      * Extract a function call
      */
+    /**
+     * The module an Erlang gen_server target expression statically names, or
+     * null when it's dynamic (pid/var/tuple form). Static shapes:
+     *   - a bare atom — either this module or another one; OTP's dominant
+     *     registration convention (`{local, ?MODULE}`) names a server process
+     *     after its module, so `gen_server:call(other_mod, …)` reaches
+     *     `other_mod`'s handlers. A registered name that matches no module
+     *     resolves to nothing downstream (the qualified ref just drops).
+     *   - `?MODULE`, or a macro the file defines as `?MODULE`
+     *     (`-define(SERVER, ?MODULE)` — the standard self idiom)
+     *   - a macro the file defines as a bare atom
+     *     (`-define(STORE, kv_store)` — the cross-module variant)
+     * The macro tables are memoized per file (single entry — extraction is
+     * file-sequential).
+     */
+    private erlangServerMacroFile;
+    private erlangSelfMacros;
+    private erlangAtomMacros;
+    private resolveErlangGenServerTarget;
     private extractCall;
     /**
      * `new Foo(...)` / `Foo::new(...)` / object_creation_expression —
@@ -437,6 +458,15 @@ export declare class TreeSitterExtractor {
      * Children are still walked so nested calls inside the constructor
      * arguments (`new Foo(bar())`) get their own `calls` references.
      */
+    /**
+     * VB.NET `New Invoice(1)` is syntactically ambiguous between constructing
+     * Invoice with an argument and allocating an Invoice array of bound 1; the
+     * grammar parses the parenthesized form as array_creation_expression. A
+     * user-defined type with no `{...}` array initializer is overwhelmingly a
+     * constructor call, so treat it as an instantiation. Predefined element
+     * types (`New Byte(1023)`) and brace-initialized forms stay arrays.
+     */
+    private isVbnetConstructorShapedArrayCreation;
     private extractInstantiation;
     /**
      * Is this C++ `declaration` a stack/direct-initialization object construction
@@ -528,6 +558,14 @@ export declare class TreeSitterExtractor {
      * heuristic — no false edges (resolution still validates each path).
      */
     private extractRustRouteMacro;
+    /**
+     * Record a C++ local function-pointer binding (`local = &fn` / `&fn<…>` /
+     * `&ns::fn<…>`) for the CURRENT enclosing symbol, so calls through the local
+     * resolve to the real target (see cppLocalFnPtrs). Only the address-of shape
+     * is accepted — a bare-identifier RHS (`auto x = y;`) is any value copy, and
+     * linking through it would guess.
+     */
+    private recordCppFnPtrBinding;
     private visitFunctionBody;
     /**
      * Extract inheritance relationships

package/dist/index.d.ts

@@ -4,7 +4,7 @@
  * A local-first code intelligence system that builds a semantic
  * knowledge graph from any codebase.
  */
-import { Node, Edge, FileRecord, ExtractionResult, Subgraph, TraversalOptions, SearchOptions, SearchResult, Context, GraphStats, TaskInput, TaskContext, BuildContextOptions, FindRelevantContextOptions } from './types';
+import { Node, Edge, FileRecord, ExtractionResult, Subgraph, TraversalOptions, SearchOptions, SearchResult, SegmentMatch, Context, GraphStats, TaskInput, TaskContext, BuildContextOptions, FindRelevantContextOptions } from './types';
 import { IndexProgress, IndexResult, SyncResult } from './extraction';
 import { ResolutionResult } from './resolution';
 import { WatchOptions, PendingFile } from './sync';
@@ -227,6 +227,16 @@ export declare class CodeGraph {
      * freshness without shelling out to `codegraph status --json`. (#329)
      */
     getLastIndexedAt(): number | null;
+    /**
+     * Completeness of the last full index run. `'complete'` is the only good
+     * state. `'indexing'` after the fact means a run was killed mid-index (OOM,
+     * SIGKILL, liveness watchdog) and the on-disk index is truncated;
+     * `'partial'` means the run finished but silently dropped files
+     * (discovered > indexed+skipped+errored); `'failed'` means it reported
+     * failure. `null` = index predates this marker. Surfaced by
+     * `codegraph status`.
+     */
+    getIndexState(): 'indexing' | 'complete' | 'partial' | 'failed' | null;
     /**
      * Which engine built the current index: the package version + extraction
      * version stamped at the last full `indexAll`. Either field is null for an
@@ -264,6 +274,13 @@ export declare class CodeGraph {
      * Processes chunks of unresolved refs, persisting results after each batch.
      */
     resolveReferencesBatched(onProgress?: (current: number, total: number) => void): Promise<ResolutionResult>;
+    /**
+     * References extracted but not yet resolved into edges. Zero on a healthy
+     * index — a completed resolution pass consumes every row. Non-zero at rest
+     * means a pass was interrupted mid-run (killed indexer, crash — #1187), so
+     * some files' call edges are missing; the next `sync` sweeps them.
+     */
+    getPendingReferenceCount(): number;
     /**
      * Get detected frameworks in the project
      */
@@ -307,10 +324,55 @@ export declare class CodeGraph {
      * definition the caller wants is never dropped below a search cut.
      */
     getNodesByName(name: string): Node[];
+    /** Nodes whose name starts with `prefix` (index range scan, capped). */
+    getNodesByNamePrefix(prefix: string, limit?: number): Node[];
     /**
      * Search nodes by text
      */
     searchNodes(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Graph-derived prompt matching for the front-load hook's MEDIUM tier:
+     * which indexed symbols do these prose words name? "state machine des
+     * commandes" → `OrderStateMachine`, in any human language whose technical
+     * nouns are Latin script — no keyword list involved.
+     *
+     * Precision comes from the repo's own naming statistics, not vocabulary:
+     * - CO-OCCURRENCE: ≥2 words that are segments of the SAME name ("state" +
+     *   "machine" → OrderStateMachine) is strong evidence and always qualifies.
+     * - RARITY: a single matched word qualifies only when its segment is
+     *   discriminative here (≤ {@link SEGMENT_RARITY_CEILING} distinct names) —
+     *   "checkout" in a shop backend yes, "state" in a react app no.
+     * Every candidate is re-verified against `nodes` before being returned
+     * (vocab rows are proposals; deletions leave orphans by design), so a
+     * returned symbol is guaranteed to exist right now.
+     */
+    getSegmentMatches(words: string[], limit?: number): SegmentMatch[];
+    /** A single word ("state") can match hundreds of names in a big repo — that
+     *  is noise, not signal. Ceiling for the single-word tier; co-occurrence is
+     *  exempt because two words on one name is already discriminative. */
+    private static readonly SEGMENT_RARITY_CEILING;
+    /** Which of the prompt's original words match `name`'s segments (via
+     *  variants). Segments are recomputed in JS — a name-keyed vocab lookup
+     *  would scan the (segment, name) primary key. */
+    private wordsMatchingName;
+    /**
+     * One-shot upgrade heal for callers that open the graph WITHOUT syncing —
+     * concretely the prompt hook, whose MEDIUM tier reads the segment
+     * vocabulary: a database migrated from before the vocab table existed
+     * starts with it empty, and the only other backfill lives inside `sync()`,
+     * which such callers never run (#1142). Returns true when the vocab is
+     * usable (already populated — the overwhelmingly common one-SELECT case —
+     * or healed here); false when it isn't (empty graph, or another process
+     * holds the index lock — that process's own sync heals it).
+     */
+    healSegmentVocabIfEmpty(): Promise<boolean>;
+    /**
+     * Rebuild the segment vocabulary from the current graph, batched and
+     * yielding — the upgrade-heal path for indexes built before the vocab table
+     * existed. Runs inside the index mutex/lock (sync and
+     * healSegmentVocabIfEmpty hold them).
+     */
+    private rebuildNameSegmentVocab;
     /**
      * Normalized project-name tokens (go.mod / package.json / repo dir) used to
      * down-weight the non-discriminative project name in search ranking (#720).

package/dist/mcp/daemon.d.ts

@@ -136,9 +136,11 @@ export declare class Daemon {
     /**
      * Defense-in-depth against a daemon that outlives its clients (#692), for the
      * cases the refcount + idle timer miss because a socket close never arrives:
-     *   - **Inactivity backstop:** exit if no inbound traffic for `maxIdleMs` while
-     *     clients are still (nominally) connected. A phantom client sends nothing,
-     *     so it can't pin the daemon past this window.
+     *   - **Inactivity backstop:** after `maxIdleMs` with no inbound traffic, reap
+     *     the daemon — but ONLY if no connected client can be proven alive (see
+     *     {@link backstopShouldExit}). This is the sole phantom class the sweep
+     *     below can't catch: a client whose client-hello never arrived, so we have
+     *     no pid to check.
      *   - **Liveness sweep:** drop any client whose peer process has died (per the
      *     client-hello pids), which re-arms the idle timer once the last real
      *     client is gone. Catches a dead peer within one sweep instead of waiting
@@ -147,6 +149,26 @@ export declare class Daemon {
      * neither should hold it open on its own.
      */
     private startLivenessTimers;
+    /**
+     * Decide whether the inactivity backstop should reap the daemon right now.
+     * Public + `isAlive`-injected for deterministic tests; the timer calls it each
+     * tick with the real liveness probe.
+     *
+     * The backstop exists ONLY to catch a **phantom** client (#692) — one counted
+     * but actually gone, whose socket-close was never delivered. It must never
+     * reap a **live-but-quiet** session (connected, alive peer, just not querying):
+     * doing so silently severed the shared daemon and degraded that session — and
+     * any others sharing it — to an in-process engine. `lastActivityAt` only tracks
+     * inbound query bytes, and MCP has no keepalive, so a genuinely-live session
+     * trips the raw inactivity window after ~30 min of not being queried.
+     *
+     * So: once the inactivity window elapses, drop provably-dead peers (the same
+     * check the periodic sweep runs), then reap the daemon only when NOT ONE
+     * remaining client can be proven alive — i.e. every client left is an
+     * unknown-pid connection the sweep can't verify. A single provably-alive
+     * client keeps the daemon up. Has the sweep's side effect (drops dead peers).
+     */
+    backstopShouldExit(isAlive: (pid: number) => boolean): boolean;
     /**
      * Drop every connected client whose peer process is gone. Returns the count
      * reaped. `isAlive` is injected for testing. Clients with unknown pids (no

package/dist/mcp/early-ppid.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parent-pid baseline captured as early as possible in process life (#1185).
+ *
+ * The PPID watchdog's POSIX signal is "`process.ppid` CHANGED since startup" —
+ * but a launcher killed within the first ~100ms of our boot (an MCP host's
+ * config probe, an instant user cancel, an initialize-timeout teardown) can
+ * reparent this process to init BEFORE the serve/proxy code captured its
+ * baseline. The baseline then reads `1`, never diverges, and the watchdog is
+ * permanently blind — the orphaned-server accumulation reported in #1185.
+ * Reproduced on macOS: SIGKILL the launcher 50ms after spawn while the host
+ * holds the stdio pipes open, and the server survived indefinitely; at 150ms
+ * the old capture had already run and the watchdog reaped it.
+ *
+ * The CLI entry imports this module before anything else, so the capture runs
+ * within the first few ms of JS execution — the earliest a Node process can
+ * observe its parent. A kill landing in the remaining pre-JS window (process
+ * spawn → first require) still captures `1`; that residual case is covered by
+ * the startup-handshake timeout (see ./startup-handshake.ts), which reaps a
+ * server that never receives any MCP traffic.
+ *
+ * Library consumers don't load the CLI entry; for them the capture runs at
+ * first import of the MCP layer — no worse than the previous per-call-site
+ * capture, and identical once the module cache warms.
+ */
+export declare const EARLY_PPID: number;
+//# sourceMappingURL=early-ppid.d.ts.map

package/dist/mcp/startup-handshake.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Never-initialized backstop for `serve --mcp` (#1185).
+ *
+ * Every real MCP host sends `initialize` immediately after spawning a server.
+ * A server that has received NO bytes at all for many minutes is not serving
+ * anyone — it is the residue of an abandoned launch: the host killed the
+ * launcher chain during startup (config probe, instant cancel, initialize
+ * timeout) but kept our stdio pipe fds open, so stdin never EOFs. If the kill
+ * landed before {@link ../mcp/early-ppid} could observe the real parent, the
+ * PPID watchdog is blind too (baseline `1`), and — pre-#1185 — the orphan
+ * lived until the HOST process exited, accumulating one ~30MB node process
+ * per occurrence.
+ *
+ * This backstop closes that last hole: arm a one-shot timer at serve start
+ * and disarm it on the first byte of client traffic. If the timer fires, the
+ * caller shuts the server down. The default is deliberately generous (15
+ * minutes) — hosts initialize within milliseconds, so the only processes this
+ * ever reaps are ones nobody is talking to. It never affects a session that
+ * spoke even once: after the first byte the timer is gone for good (a
+ * quiet-but-live session is the PPID watchdog's / stdin teardown's job).
+ *
+ * IMPORTANT (callers): attaching a `'data'` listener switches the stream into
+ * flowing mode. Arm this AFTER the real stdin consumer is attached, in the
+ * same synchronous block, so no early bytes are emitted while only our
+ * listener exists. The detached daemon must never arm this — its stdin is
+ * `'ignore'` and its lifecycle is refcount/idle-based.
+ *
+ * Tune with `CODEGRAPH_STARTUP_HANDSHAKE_TIMEOUT_MS`; `0` disables.
+ */
+/** Default wait for the first byte of MCP traffic before assuming orphaned. */
+export declare const DEFAULT_STARTUP_HANDSHAKE_TIMEOUT_MS = 900000;
+export declare const STARTUP_HANDSHAKE_TIMEOUT_ENV = "CODEGRAPH_STARTUP_HANDSHAKE_TIMEOUT_MS";
+/**
+ * Parse the timeout env override. Missing/invalid → default; `<= 0` → `0`
+ * (disabled), the same disable convention as `CODEGRAPH_PPID_POLL_MS`.
+ */
+export declare function parseStartupHandshakeTimeoutMs(raw: string | undefined): number;
+/**
+ * Arm the backstop. `onAbandoned` runs at most once, only if no `'data'` event
+ * arrives on `stream` within the timeout. Returns a disarm function (idempotent;
+ * also detaches the listener). `stream`/`timeoutMs` are injectable for tests.
+ */
+export declare function armStartupHandshakeTimeout(onAbandoned: () => void, stream?: NodeJS.ReadableStream, timeoutMs?: number): () => void;
+//# sourceMappingURL=startup-handshake.d.ts.map

package/dist/mcp/tools.d.ts

@@ -25,6 +25,28 @@ export declare class NotIndexedError extends Error {
  */
 export declare class PathRefusalError extends Error {
 }
+/**
+ * Normalize Erlang-native symbol spellings in an explore query into the shapes
+ * the rest of the pipeline already understands. Agents working Erlang code
+ * name symbols the way the language spells them — `mod:fn/3`, `init/2` — and
+ * those tokens previously died in both consumers: the flow-builder's token
+ * filter rejects `:` and `/arity` outright, and the search-side field parser
+ * eats `mod:fn` as an unknown `field:value`. Measured on cowboy: the agent
+ * named `cowboy_stream_h:request_process/3` in two queries, got no body back
+ * either time, and fell back to Read.
+ *
+ *   - `fn/3` → `fn` (arity tail after an identifier; a path segment like
+ *     `src/2fa` doesn't match because the tail must be all digits)
+ *   - `mod:fn` → `mod.fn` (exactly one colon between identifiers, so it rides
+ *     the existing Class.method qualified handling; `::`, URLs, drive letters,
+ *     and times don't match, and the query language's own field prefixes —
+ *     kind:/lang:/language:/path:/name: — are left alone)
+ *
+ * Safe cross-language: Lua's `t:m` spelling maps to the same `t.m` its
+ * qualified names use, and no other supported spelling contains a bare
+ * single-colon identifier pair.
+ */
+export declare function normalizeQuerySpelling(query: string): string;
 /**
  * Calculate the recommended number of codegraph_explore calls based on project size.
  * Larger codebases need more exploration calls to cover their surface area,

package/dist/project-config.d.ts

@@ -23,6 +23,20 @@ export interface ProjectConfig {
      * and your `.gitignore`.
      */
     exclude?: string[];
+    /**
+     * Gitignore-style patterns for first-party source to force INTO the index even
+     * when `.gitignore` would drop it — the general whitelist `includeIgnored`
+     * never was (that one only revives *embedded git repos* inside ignored dirs).
+     * The case this exists for: a project under a second VCS (SVN, Perforce, …)
+     * deliberately `.gitignore`s its own real source so it never lands in Git, yet
+     * that source must still be indexed. Matched against project-root-relative
+     * paths, so `"Tools/"`, a recursive `"Tools/**"` glob, or `"Local/typescript"`
+     * all work.
+     * Built-in default-ignored dirs (`node_modules`, `dist`, …), `.git`, and
+     * CodeGraph's own data dir are never resurfaced; an explicit `exclude` still
+     * wins. Absent/empty (the default) forces nothing in.
+     */
+    include?: string[];
 }
 /**
  * Load the validated extension overrides for a project, mtime-cached.
@@ -51,6 +65,30 @@ export declare function loadIncludeIgnoredPatterns(rootDir: string): string[];
  * the built-in defaults and the project's `.gitignore`.
  */
 export declare function loadExcludePatterns(rootDir: string): string[];
+/**
+ * Load the validated `include` patterns for a project, mtime-cached.
+ *
+ * These name first-party source to force INTO the index even when `.gitignore`
+ * would drop it — the whitelist for SVN/Perforce-only source a project
+ * gitignores out of Git. An empty result — the zero-config default — forces
+ * nothing in. Built-in default-ignored dirs, `.git`, and CodeGraph's data dir
+ * are never resurfaced, and an explicit `exclude` still wins.
+ */
+export declare function loadIncludePatterns(rootDir: string): string[];
 /** Test/maintenance hook: forget cached config (e.g. after rewriting it in a test). */
 export declare function clearProjectConfigCache(): void;
+/**
+ * Add gitignore-style patterns to a project's `codegraph.json` `includeIgnored`
+ * list, creating the file if absent and preserving every other key. Used by the
+ * CLI to opt a "super-repo of gitignored child repos" (#1156) into the index on
+ * the user's say-so. Returns the count of patterns actually ADDED (ones already
+ * present are skipped, so a re-run is idempotent).
+ *
+ * A plain-JSON round-trip: a `codegraph.json` carrying comments (not valid JSON)
+ * already fails to load with a warning, so rather than silently clobber such a
+ * file this throws when an existing config won't parse — the caller falls back
+ * to printing the manual snippet. Invalidates the config cache so a subsequent
+ * index in the same process sees the new patterns.
+ */
+export declare function addIncludeIgnoredPatterns(rootDir: string, patterns: string[]): number;
 //# sourceMappingURL=project-config.d.ts.map

package/dist/resolution/frameworks/cics.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CICS Framework Resolver (COBOL)
+ *
+ * Resolves the pseudo-conversational transaction hop: a program ends with
+ * `EXEC CICS RETURN TRANSID('CB00')` (or START), and CICS re-invokes the
+ * program that OWNS transaction CB00 on the next attention key. The
+ * transaction→program mapping lives in the CICS CSD, which is never in the
+ * repo — but by near-universal convention each program declares its own
+ * transaction id as a working-storage constant:
+ *
+ *     05 WS-TRANID    PIC X(04) VALUE 'CB00'.
+ *
+ * The COBOL extractor emits `cics-transid:CB00` call references for literal
+ * (or same-file-dereferenced) TRANSID options; this resolver maps the id to
+ * the program module whose TRAN*-named data item declares that VALUE. No
+ * match (an id owned by a program outside the repo) stays unresolved.
+ */
+import { FrameworkResolver } from '../types';
+export declare const cicsResolver: FrameworkResolver;
+//# sourceMappingURL=cics.d.ts.map

package/dist/resolution/frameworks/terraform.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Terraform Framework Resolver
+ *
+ * Terraform's scoping rule is narrow and directory-shaped: `var.X`,
+ * `local.X`, `module.M`, and resource/data references resolve ONLY inside
+ * the same module directory as the reference site. The generic name matcher
+ * resolves by qualified-name alone, so a reference to `var.project_id` from
+ * `modules/net-vpc/main.tf` could bind to a `variable "project_id"` declared
+ * in an unrelated module — a wrong cross-module edge that poisons impact
+ * analysis. This resolver enforces the real semantics:
+ *
+ *   1. Same directory as the reference site → resolve (highest confidence).
+ *   2. `.tfvars` files additionally walk UP to the nearest ancestor
+ *      directory declaring the variable (`terraform apply -var-file=envs/prod.tfvars`
+ *      sets ROOT module variables from a subdirectory).
+ *   3. Otherwise: no edge. Terraform cannot reference across sibling module
+ *      directories, so a non-local candidate is never a correct target.
+ *
+ * It also bridges the module boundary through `:`-scoped references that
+ * only this resolver understands (see the extractor's emitModuleWiring):
+ *
+ *   - `module.M:file`       → the entry file of the module's local source
+ *     directory (an `imports` edge, so a module call connects to the code
+ *     it instantiates).
+ *   - `module.M:var.<in>`   → the child module's `variable "<in>"` node —
+ *     the module block sets that variable, so "what depends on the child's
+ *     var.cidr" reaches every caller.
+ *   - `module.M:output.<o>` → the child module's `output "<o>"` node —
+ *     `module.M.o` uses flow through to the output's definition instead of
+ *     dead-ending at the module declaration.
+ *
+ * The module's `source` is re-read from the declaration's file (cached
+ * lines); only local `./`/`../` sources bridge. Registry/git sources stay
+ * unresolved — an out-of-repo module is a visible boundary, never a guess.
+ */
+import type { FrameworkResolver } from '../types';
+export declare const terraformResolver: FrameworkResolver;
+//# sourceMappingURL=terraform.d.ts.map

package/dist/resolution/import-resolver.d.ts

@@ -5,6 +5,7 @@
  */
 import { Language } from '../types';
 import { UnresolvedRef, ResolvedRef, ResolutionContext, ImportMapping, ReExport } from './types';
+export declare function isNixPathImportRef(ref: UnresolvedRef): boolean;
 /**
  * Resolve an import path to an actual file
  */
@@ -37,6 +38,12 @@ export declare function loadCppIncludeDirs(projectRoot: string): string[];
  * to a same-named symbol — so callers must not fall back to the name-matcher.
  */
 export declare function isPhpIncludePathRef(ref: UnresolvedRef): boolean;
+/**
+ * Is this a COBOL COPY / EXEC SQL INCLUDE copybook reference? These resolve
+ * to files only (or stay unresolved for compiler-supplied members) — never
+ * to a same-named symbol via the name-matcher.
+ */
+export declare function isCobolCopybookRef(ref: UnresolvedRef): boolean;
 /**
  * Extract import mappings from a file
  */

package/dist/resolution/index.d.ts

@@ -27,6 +27,9 @@ export declare class ReferenceResolver {
     private nameCache;
     private lowerNameCache;
     private qualifiedNameCache;
+    private fileLinesCache;
+    private methodMatchCache;
+    private nodesByKindCache;
     private knownNames;
     private knownFiles;
     private cachesWarmed;
@@ -58,6 +61,8 @@ export declare class ReferenceResolver {
      * Clear internal caches
      */
     clearCaches(): void;
+    /** `readFile` through the LRU content cache (null = read failed, also cached). */
+    private readFileCached;
     /**
      * Create the resolution context
      */
@@ -105,12 +110,17 @@ export declare class ReferenceResolver {
      */
     resolveChainedCallsViaConformance(): Promise<number>;
     /**
-     * Resolve one batch in smaller sub-chunks, yielding to the event loop between
-     * them so the #850 liveness heartbeat can fire on a slow/dense batch (#1091).
-     * Behaviourally identical to a single `resolveAll(batch)`: `warmCaches()` is
-     * idempotent (guarded) and `resolveOne` is independent per ref, so splitting
-     * and re-merging changes only timing, never which edges get created. Falls
-     * through to a plain `resolveAll` when the batch is already small.
+     * Resolve one batch with a yield checkpoint between EVERY ref so the #850
+     * liveness heartbeat can fire on a slow/dense batch (#1091). The checkpoint
+     * granularity is per-ref — not per-N-refs — because per-ref cost is unbounded
+     * in the worst case (a collision-heavy method name whose candidate set misses
+     * the LRU re-fetches tens of thousands of rows): any fixed N multiplies that
+     * worst case into the watchdog window, which is how v1.2.0 still got killed
+     * at "Resolving refs" on large Java monorepos (#1122). `maybeYield()` is a
+     * ~ns time check when under budget, so per-ref checkpoints cost nothing.
+     * Behaviourally identical to `resolveAll(batch)`: `warmCaches()` is
+     * idempotent (guarded) and `resolveOne` is independent per ref, so yielding
+     * between refs changes only timing, never which edges get created.
      */
     private resolveBatchYielding;
     /**
@@ -161,6 +171,29 @@ export declare class ReferenceResolver {
      * through to name-matching).
      */
     private resolveRazorUsing;
+    /**
+     * Resolve a CFML inheritance reference written as a component path (#1152).
+     * Two forms exist in real code:
+     *
+     * - Dotted: `extends="coldbox.system.web.Controller"` — dots are directory
+     *   separators from the webroot or a CFML mapping. Mappings live in server
+     *   config / Application.cfc, so the leading segments may not exist in the
+     *   repo at all (in the coldbox repo itself the path is `system/web/
+     *   Controller.cfc` — the `coldbox.` root IS the repo). Matched by final
+     *   segment (the class), corroborated right-to-left against the candidate's
+     *   parent directories.
+     * - Relative: `extends="../base"` / `extends="./base"` (the FW/1 style) —
+     *   resolved against the referencing file's own directory.
+     *
+     * Conservative by design: a candidate needs at least one corroborating
+     * directory segment (a dotted path whose only same-named class sits in an
+     * unrelated directory is almost always an out-of-repo library supertype —
+     * mxunit/testbox/coldbox-as-dependency), and a corroboration tie yields no
+     * edge. Directory comparison is case-insensitive (CFML path resolution is);
+     * the class segment itself is matched exactly, which real code satisfies —
+     * dotted paths are written to match the on-disk file name.
+     */
+    private resolveCfmlComponentPath;
     /**
      * Resolve a `this.<member>` function-as-value reference (#756/#808) to the
      * ENCLOSING CLASS's own member — never a same-named symbol elsewhere. The

package/dist/resolution/name-matcher.d.ts

@@ -108,8 +108,5 @@ export declare function matchMethodCall(ref: UnresolvedRef, context: ResolutionC
  * Fuzzy match - last resort with lower confidence
  */
 export declare function matchFuzzy(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
-/**
- * Match all strategies in order of confidence
- */
 export declare function matchReference(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
 //# sourceMappingURL=name-matcher.d.ts.map

package/dist/resolution/strip-comments.d.ts

@@ -22,6 +22,6 @@
  * `path(...)`, `Route::get(...)`, `app.get(...)` style patterns that
  * framework extractors scan for.
  */
-export type CommentLang = 'python' | 'javascript' | 'typescript' | 'php' | 'ruby' | 'java' | 'csharp' | 'swift' | 'go' | 'rust' | 'c' | 'cpp';
+export type CommentLang = 'python' | 'javascript' | 'typescript' | 'php' | 'ruby' | 'java' | 'csharp' | 'swift' | 'go' | 'rust' | 'c' | 'cpp' | 'erlang';
 export declare function stripCommentsForRegex(content: string, lang: CommentLang): string;
 //# sourceMappingURL=strip-comments.d.ts.map

package/dist/resolution/types.d.ts

@@ -70,6 +70,26 @@ export interface ResolutionContext {
     fileExists(filePath: string): boolean;
     /** Read file content */
     readFile(filePath: string): string | null;
+    /**
+     * `readFile(filePath)` split into lines, LRU-cached per file. Receiver-type
+     * inference scans source lines for EVERY `receiver.method()` ref; splitting
+     * the whole file per ref made that O(refs-in-file × file-size) — ~20% of
+     * total index CPU on a Java-heavy repo and a driver of the #1122 watchdog
+     * kill on large ones. Optional so external/test contexts compile without it;
+     * callers fall back to splitting `readFile` themselves.
+     */
+    getFileLines?(filePath: string): string[] | null;
+    /**
+     * The method-definition nodes matching `typeName::methodName` in `language` —
+     * exactly `resolveMethodOnType`'s kind/language/qualifiedName-suffix filter,
+     * LRU-cached per (language, type, method). The uncached path re-fetches every
+     * node sharing the METHOD name (unbounded — tens of thousands on a collision-
+     * heavy Java repo) and re-scans it per ref, the dominant term in the #1122
+     * watchdog kill. Cached entries hold only the small filtered result; per-ref
+     * disambiguation (import FQN, call-site file) stays in the caller so a cached
+     * entry is valid from any call site. Optional for external/test contexts.
+     */
+    getMethodMatches?(typeName: string, methodName: string, language: Language): Node[];
     /** Get project root */
     getProjectRoot(): string;
     /** Get all files */