@aroman22/codegraph-vba 1.5.1 → 1.6.0

package/dist/extraction/grammars.d.ts

@@ -28,6 +28,15 @@ export declare function isSourceFile(filePath: string, overrides?: Record<string
  * extractor links them. (config/ + locales/ JSON have no section refs.)
  */
 export declare function isShopifyLiquidJson(filePath: string): boolean;
+/**
+ * OTP application resource file: `<app>.app.src` (checked into every rebar3/
+ * erlang.mk app) or its compiled `<app>.app`. Erlang TERMS, not forms — the
+ * grammar parses them as top-level expressions, and the Erlang extractor's
+ * application-tuple handler turns `{mod, {Mod, _}}` and `{applications, […]}`
+ * into entry-module and dependency edges. Routed by full suffix because the
+ * last-dot extension (`.src`) is far too generic for EXTENSION_MAP.
+ */
+export declare function isErlangAppFile(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
@@ -54,12 +63,27 @@ export declare function detectVbaFormFile(filePath: string): boolean;
  * Idempotent — safe to call multiple times.
  */
 export declare function initGrammars(): Promise<void>;
+/**
+ * Pre-read the grammar WASM bytes for an index set, keyed by language. The
+ * orchestrator reads each grammar ONCE and hands the bytes to every parse
+ * worker via its `load-grammars` message, so worker spawns/respawns load
+ * grammars from memory instead of re-reading them from disk — on slow storage
+ * (HDD, issue #1231) each respawn's grammar re-read otherwise amplifies the
+ * I/O contention that caused the respawn. Best-effort: a language whose WASM
+ * can't be read here is simply omitted, and the worker falls back to its own
+ * disk load (which surfaces the real error/warning path).
+ */
+export declare function readGrammarWasmBytes(languages: Language[]): Promise<Record<string, Uint8Array>>;
 /**
  * Load grammar WASM files for specific languages only.
  * Skips languages that are already loaded or have no WASM grammar.
  * Must be called after initGrammars().
+ *
+ * `wasmBytes` (optional) holds pre-read grammar bytes keyed by language (from
+ * {@link readGrammarWasmBytes}, forwarded through the parse pool); when a
+ * language's bytes are present they're loaded from memory instead of disk.
  */
-export declare function loadGrammarsForLanguages(languages: Language[]): Promise<void>;
+export declare function loadGrammarsForLanguages(languages: Language[], wasmBytes?: Record<string, Uint8Array>): Promise<void>;
 /**
  * Load ALL grammar WASM files. Convenience function for tests and
  * backward compatibility. Prefer loadGrammarsForLanguages() in production.

package/dist/extraction/index.d.ts

@@ -24,6 +24,14 @@ export interface IndexResult {
     filesIndexed: number;
     filesSkipped: number;
     filesErrored: number;
+    /**
+     * How many indexable files the scan discovered — the ground truth the
+     * indexed/skipped/errored tallies must add up to. A shortfall means files
+     * were silently dropped mid-pipeline (e.g. a killed worker under load) and
+     * the index is PARTIAL; callers surface that rather than trusting the
+     * counts. Only set by full-index runs (indexAll), not indexFiles/sync.
+     */
+    filesDiscovered?: number;
     nodesCreated: number;
     edgesCreated: number;
     errors: ExtractionError[];
@@ -72,6 +80,17 @@ export declare class ScopeIgnore {
      * exclude applies even to tracked files and even inside embedded repos.
      */
     private exclude;
+    /**
+     * Project `codegraph.json` `include` patterns — first-party source forced
+     * INTO the index despite `.gitignore`. When a path matches, it is NOT
+     * ignored (so the watcher watches it), overriding `.gitignore`/`rootMatcher`
+     * — but never `exclude` (checked first) and never a built-in default-ignored
+     * dir. `includeRoots` are the static prefixes so a gitignored ANCESTOR
+     * directory of an included subtree still isn't pruned by the directory
+     * walker/watcher.
+     */
+    private include;
+    private includeRoots;
     private embedded;
     private defaults;
     constructor(rootMatcher: Ignore, embedded: Array<{
@@ -83,7 +102,17 @@ export declare class ScopeIgnore {
      * full root-relative path. Wins over everything else — an explicit user
      * exclude applies even to tracked files and even inside embedded repos.
      */
-    exclude?: Ignore | null);
+    exclude?: Ignore | null, 
+    /**
+     * Project `codegraph.json` `include` patterns — first-party source forced
+     * INTO the index despite `.gitignore`. When a path matches, it is NOT
+     * ignored (so the watcher watches it), overriding `.gitignore`/`rootMatcher`
+     * — but never `exclude` (checked first) and never a built-in default-ignored
+     * dir. `includeRoots` are the static prefixes so a gitignored ANCESTOR
+     * directory of an included subtree still isn't pruned by the directory
+     * walker/watcher.
+     */
+    include?: Ignore | null, includeRoots?: string[]);
     ignores(rel: string): boolean;
 }
 /**
@@ -102,6 +131,22 @@ export declare function buildScopeIgnore(rootDir: string, embeddedRoots?: Iterab
  * there already.
  */
 export declare function discoverEmbeddedRepoRoots(rootDir: string): string[];
+/**
+ * The INVERSE of the gitignored side of {@link discoverEmbeddedRepoRoots}:
+ * nested git repositories under a gitignored directory that the project has NOT
+ * opted into via `codegraph.json` `includeIgnored`. These are real repos the
+ * default `init`/`index` deliberately skips because `.gitignore` excludes them
+ * (#970, #976) — most visibly the "super-repo `.gitignore`s its child repos"
+ * layout (#1156), where `init` at the parent correctly indexes ~nothing while
+ * `init` inside each child works. The CLI uses this to turn that silent empty
+ * index into an actionable hint: it names the skipped repos and offers to opt
+ * them in. Paths are `rootDir`-relative and trailing-slashed (valid
+ * `includeIgnored` patterns as-is). Returns `[]` for a non-git root (a
+ * filesystem walk already descends into nested repos there), skips built-in
+ * default-ignored dirs (`node_modules`, …), and is bounded so it never stalls
+ * on a giant ignored tree.
+ */
+export declare function findUnindexedIgnoredRepos(rootDir: string): string[];
 /**
  * Recursively scan a directory for source files.
  *
@@ -145,7 +190,7 @@ export declare class ExtractionOrchestrator {
     /**
      * Index all files in the project
      */
-    indexAll(onProgress?: (progress: IndexProgress) => void, signal?: AbortSignal, verbose?: boolean): Promise<IndexResult>;
+    indexAll(onProgress?: (progress: IndexProgress) => void, signal?: AbortSignal, verbose?: boolean, walBackpressure?: () => Promise<void> | null): Promise<IndexResult>;
     /**
      * Index specific files
      */

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

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

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

@@ -7,6 +7,104 @@ import type { LanguageExtractor } from '../tree-sitter-types';
  * template args. Returns undefined for primitives / void / `auto` / empty.
  */
 export declare function normalizeCppReturnType(raw: string): string | undefined;
+/**
+ * Strip C++ template arguments from a base-type reference name so it matches the
+ * bare class/struct the template was DEFINED as. `template<typename T> class
+ * Base { … }` is indexed as a node named `Base`, but a derived class
+ * `class D : public Base<int>` records its base as the full `Base<int>` (and
+ * `class Q : public ns::Tpl<int>` as `ns::Tpl<int>`) — neither name-matches
+ * `Base` / `ns::Tpl`, so the `extends` edge never resolves and the derived class
+ * looks like it inherits from nothing (#1043).
+ *
+ * Removes every balanced `<…>` group regardless of nesting or position, so
+ * `Base<int>` → `Base`, `ns::Tpl<Foo<int>>` → `ns::Tpl`, and the rare
+ * `Outer<int>::Inner` → `Outer::Inner`. The remaining qualified head is exactly
+ * what the non-templated base case already produces, so resolution treats them
+ * identically. A name with no template args passes through unchanged.
+ */
+export declare function stripCppTemplateArgs(name: string): string;
 export declare const cExtractor: LanguageExtractor;
+/**
+ * Blank an export/visibility macro in a `class/struct EXPORT_MACRO Name …`
+ * *definition* header before parsing. Not knowing the macro, tree-sitter reads
+ * `class EXPORT_MACRO` as an elaborated type specifier and the rest as a
+ * function, so the whole class — its name, base clause, and members — drops out
+ * of the index (#946 catches the resulting phantom function but can't recover
+ * the class), which silently breaks type-hierarchy / inheritance-impact queries
+ * for effectively every Unreal-Engine (`*_API`), Qt/Boost (`*_EXPORT`), LLVM
+ * (`*_ABI`), … class. Replacing the macro with equal-length spaces preserves
+ * every byte offset (and thus line/column), so the declaration then parses as a
+ * normal class_specifier and the existing extraction emits the node, members,
+ * and `extends` edge. (#1061, follow-up to #946.)
+ *
+ * Matched tightly so it can't touch the same macro used as an ordinary value
+ * elsewhere (`int x = SOME_API;`): the macro is the ALL-CAPS token sitting
+ * *between* `class`/`struct` and the type name, and the trailing `[:{]`
+ * definition-guard fires only when a base clause or body follows — the only
+ * shape that misparses. That guard also leaves elaborated-type variable
+ * declarations (`struct FOO var;`, `class FOO obj = …`) untouched, since those
+ * end in `;` / `=` / `[`, never `:` / `{`. C++-only (wired into cppExtractor),
+ * so C's heavier use of `struct TAG var;` never reaches it.
+ */
+export declare function blankCppExportMacros(source: string): string;
+export declare function blankCppInlineMacros(source: string): string;
+/**
+ * Universal fallback (any macro, no list) for a C/C++ function name still mangled
+ * because a macro we don't blank sat in front of the return type: `MACRO Ret
+ * name(…)` / `Ret MACRO name(…)` misparse so the return type is glued onto the
+ * name ("Ret name", "char_t* to_str(double v)"). Recover the real identifier —
+ * the token immediately before the parameter list (or the last token). This runs
+ * AFTER the curated pre-parse blank, so it only ever sees the residual tail that
+ * blanking didn't already fix cleanly (which also recovers the return type).
+ *
+ * Safe by construction: only touches an ALREADY-mangled name — one with an
+ * internal space that isn't a legit `operator …`/destructor — so a well-formed
+ * name is returned unchanged. Guarded against the two ways it could mis-pick:
+ * the `Ret (name)` parenthesized-name idiom (left as-is, ambiguous), and a token
+ * that is a bare primitive/keyword rather than a real identifier.
+ */
+export declare function recoverMangledCppName(name: string): string;
+export declare function blankMetalAttributes(source: string): string;
+/**
+ * Blank annotation-style macro invocations that decorate a declaration but carry
+ * NO terminating semicolon — the pervasive Unreal-Engine reflection markup
+ * (`UPROPERTY(...)`, `UFUNCTION(...)`, `UCLASS(...)`, `GENERATED_BODY()`,
+ * `UE_DEPRECATED_FORGAME(...)`, `DECLARE_DELEGATE_*(...)`, …) that sits on its
+ * own line right before a member/type. tree-sitter's C++ grammar doesn't know
+ * these are macros, so each one drops into error recovery; in a big reflected
+ * class (`CharacterMovementComponent.h` has ~240 of them) the errors accumulate
+ * until the enclosing `class_specifier` can't close and collapses into an ERROR
+ * node — the whole class definition, its members, and its `extends` edges vanish
+ * from the graph. Neither `blankCppExportMacros` (class-header export macros) nor
+ * `blankCppInlineMacros` (return-type inline specifiers) touches these in-body
+ * markup macros. Replacing each with equal-length spaces preserves every byte
+ * offset (so line/column stay exact) and the class then parses normally.
+ *
+ * Deliberately name-list-FREE — UE alone has hundreds of such macros and projects
+ * add their own — so it keys on structure, not a curated list, matched tightly to
+ * avoid touching legitimate C++:
+ *  - the macro must be the FIRST non-whitespace token on its line (`^[ \t]*`),
+ *    which is where declaration markup lives — so a macro used inside an
+ *    expression or condition (`if (CHECK(x))`, `x = MACRO(a) + b`) is never
+ *    matched (it isn't line-leading);
+ *  - the name must be ALL-CAPS (`[A-Z][A-Z0-9_]{2,}`), since ordinary
+ *    function/type names called at line start are lower/mixed case;
+ *  - the char after the balanced `(...)` must START A DECLARATION — a letter,
+ *    `_`, `~` (destructor), or `#` (a following directive). Declaration markup is
+ *    always followed by the thing it decorates (`UPROPERTY(...)\n float X;`,
+ *    `UE_DEPRECATED(...) UPROPERTY(...)`), whereas a statement call is followed by
+ *    `;` (`FOO(x);`), an init-list item by `,`/`{`, and an expression fragment by
+ *    an operator (`MAKE(a) + 1`) — all rejected. String/char literals inside the
+ *    args are skipped so an embedded `)` can't mis-close the balance.
+ *
+ * C++-only (wired into cppExtractor). A blanked macro inside a block comment is
+ * harmless (comments don't parse), and the rare line-leading no-semicolon
+ * ALL-CAPS call that isn't markup only loses that one annotation, never a whole
+ * class.
+ */
+export declare function blankCppAnnotationMacroCalls(source: string): string;
+export declare function blankCppApiPrefixMacros(source: string): string;
+export declare function blankCppInlineAnnotationMacros(source: string): string;
+export declare function blankCudaConstructs(source: string): string;
 export declare const cppExtractor: LanguageExtractor;
 //# sourceMappingURL=c-cpp.d.ts.map

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

@@ -0,0 +1,12 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+/**
+ * `<cfquery>` SQL bodies: `#hash#` expressions inside the SQL text are real
+ * CFML expressions (tree-sitter-cfml's `cfquery` grammar parses them
+ * structurally — `call_expression`/`member_expression`, same shape as
+ * cfscript's), so a call like `#getCurrentUser().getId()#` embedded in a
+ * WHERE clause is a genuine call edge. The surrounding SQL keywords/
+ * identifiers aren't symbols CodeGraph models — only `call_expression` is
+ * mapped, so extraction yields call references and nothing else.
+ */
+export declare const cfqueryExtractor: LanguageExtractor;
+//# sourceMappingURL=cfquery.d.ts.map

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * COBOL Language Extractor
+ *
+ * COBOL's AST (vendored, patched build of yutaro-sakamoto/tree-sitter-cobol)
+ * is fundamentally different from block-structured languages, so extraction
+ * runs almost entirely through the custom visitNode hook (the Pascal pattern):
+ *
+ * - A program (PROGRAM-ID) becomes a `module` node.
+ * - PROCEDURE DIVISION sections and paragraphs become `function` nodes. The
+ *   grammar emits them FLAT — a section_header/paragraph_header followed by
+ *   sibling statements — so extents are reconstructed here: a paragraph runs
+ *   from its header to the next header, a section to the next section header.
+ * - PERFORM (including THRU ranges), GO TO, and CALL 'literal' become `calls`
+ *   references. A dynamic CALL through a data name is skipped — announce,
+ *   don't guess. EXEC CICS LINK/XCTL PROGRAM('X') with a literal target also
+ *   becomes a `calls` reference; EXEC SQL INCLUDE X becomes an `imports`
+ *   reference (DB2's COPY).
+ * - COPY statements become `import` nodes + `imports` references.
+ * - DATA DIVISION entries become `variable` (01/77 levels), `field` (nested
+ *   levels, contained in their group item), or `constant` (88-level condition
+ *   names) nodes, so impact queries on working-storage names work.
+ * - Standalone copybooks (.cpy) parse via the grammar's copybook_fragment
+ *   entry point: data copybooks yield their record structure, procedure
+ *   copybooks yield paragraphs.
+ *
+ * The grammar is fixed-format (code area columns 8-72). preParse detects a
+ * free-format file (division header or level number starting before column 8)
+ * and indents every line by 7 spaces: line numbers are preserved, columns
+ * drift by 7 — acceptable for line-oriented consumers.
+ */
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const cobolExtractor: LanguageExtractor;
+//# sourceMappingURL=cobol.d.ts.map

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+/**
+ * The vendored VB.NET grammar has no true end-of-file token (its `_eof` rule is
+ * a literal-`$` placeholder that never matches real input), so a file whose
+ * last line lacks a trailing newline ends every parse with a MISSING-newline
+ * error on the final statement. Appending a newline is offset-preserving for
+ * all existing content.
+ */
+export declare function ensureTrailingNewline(source: string): string;
+export declare const vbnetExtractor: LanguageExtractor;
+//# sourceMappingURL=vbnet.d.ts.map

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/parse-pool.d.ts

@@ -47,6 +47,7 @@ export interface ParseTask {
     content: string;
     language: Language;
     frameworkNames?: string[];
+    vbaTargets?: Record<string, boolean>;
 }
 /**
  * Resolve the pool size from the `CODEGRAPH_PARSE_WORKERS` override and the
@@ -56,6 +57,12 @@ export interface ParseTask {
  *   - unset / blank / non-numeric → `clamp(cores - 1, 1, 8)` (leave a core for
  *     the main thread + UI; never zero — parsing always needs a worker).
  */
+/**
+ * Resolve the base per-parse timeout from the `CODEGRAPH_PARSE_TIMEOUT_MS`
+ * override. Slow storage (HDD, network folders) can need a larger budget; a
+ * non-numeric / non-positive value falls back to the default (10s).
+ */
+export declare function resolveParseTimeoutMs(envVal: string | undefined): number;
 export declare function resolveParsePoolSize(envVal: string | undefined, cpuCount: number): number;
 export interface ParseWorkerPoolOptions {
     /** Languages to load grammars for in every worker at spawn. */
@@ -72,6 +79,15 @@ export interface ParseWorkerPoolOptions {
     createWorker?: () => ParsePoolWorker;
     /** Optional verbose logger (the orchestrator's `[worker] …` logger). */
     log?: (msg: string) => void;
+    /**
+     * Pre-read grammar WASM bytes keyed by language, forwarded to every worker's
+     * `load-grammars` message so a spawn/respawn loads grammars from memory
+     * instead of re-reading them from disk — on slow storage each respawn's
+     * grammar re-read otherwise amplifies the very I/O contention that caused
+     * the respawn (issue #1231). Best-effort: a missing language falls back to
+     * the worker's own disk read.
+     */
+    grammarBuffers?: Record<string, Uint8Array>;
 }
 export declare class ParseWorkerPool {
     private idle;
@@ -89,6 +105,7 @@ export declare class ParseWorkerPool {
     private readonly parseTimeoutMs;
     private readonly createWorker;
     private readonly log;
+    private readonly grammarBuffers?;
     constructor(opts: ParseWorkerPoolOptions);
     /** Pool size cap (for logging). */
     get size(): number;
@@ -99,7 +116,7 @@ export declare class ParseWorkerPool {
     /**
      * Parse one file on the pool. Resolves with the extraction result, or REJECTS
      * if the parse times out or its worker crashes — the caller records the error
-     * and (for worker-exit/OOM rejections) re-attempts in its retry pass.
+     * and (for worker-exit/OOM/timeout rejections) re-attempts in its retry pass.
      */
     requestParse(task: ParseTask): Promise<ExtractionResult>;
     private spawnOne;
@@ -112,7 +129,17 @@ export declare class ParseWorkerPool {
     private recycle;
     private removeWorker;
     private dispatch;
+    /**
+     * The base timer fired with no result processed yet. Do NOT kill or settle:
+     * the timer firing doesn't prove the parse is still running — after a long
+     * synchronous main-thread stretch Node services the timers phase before the
+     * poll phase, so an already-delivered `parse-result` is still queued behind
+     * this callback. Mark the job late (onMessage accepts a result that shows up)
+     * and arm the hard-kill backstop for workers that are genuinely hung.
+     */
     private onTimeout;
+    /** No result after the full hard-kill window — the worker really is hung. */
+    private onHardTimeout;
     private drain;
     private settle;
     /**

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 */
@@ -114,6 +116,15 @@ export interface LanguageExtractor {
     returnField?: string;
     /** Override symbol name extraction (e.g. ObjC multi-part selectors). */
     resolveName?: (node: SyntaxNode, source: string) => string | undefined;
+    /**
+     * Post-process an already-extracted name to recover a real identifier from a
+     * name still mangled by a macro the pre-parse didn't blank (C/C++:
+     * `MACRO Ret name(` misparses to the name "Ret name"). Applied to every name
+     * this extractor produces, so it MUST be a no-op on a well-formed name — only
+     * C/C++ set it, because a mangled name there is unambiguous (an internal space),
+     * whereas e.g. Kotlin/Scala backtick identifiers legitimately contain spaces.
+     */
+    recoverMangledName?: (name: string) => string;
     /** Extract property name when the generic name walk fails (e.g. ObjC @property). */
     extractPropertyName?: (node: SyntaxNode, source: string) => string | null;
     /** Extract signature from node */
@@ -140,6 +151,14 @@ export interface LanguageExtractor {
     extraClassNodeTypes?: string[];
     /** Whether methods can be top-level without enclosing class (Go: true) */
     methodsAreTopLevel?: boolean;
+    /**
+     * Skip a bodiless class node as a forward declaration / elaborated type,
+     * mirroring the bodiless-struct/enum skip. Set only for languages where a
+     * bodiless `class` specifier is NOT a complete definition — C/C++
+     * (`class Foo;` is a forward decl). Leave unset for languages where a
+     * bodiless class IS complete (Kotlin `class Empty`, Scala `case object`). (#1093)
+     */
+    skipBodilessClass?: boolean;
     /** NodeKind to use for interface-like declarations (Rust: 'trait'). Default: 'interface' */
     interfaceKind?: NodeKind;
     /**

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,7 +458,37 @@ 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
+     * that invokes a constructor — `Calculator calc(0)` (direct-init) or
+     * `Widget w{1, 2}` (brace-init) — as opposed to a plain variable or a
+     * function declaration? Used to emit an `instantiates` edge for the
+     * call-less construction syntax (#1035); heap `new T(...)` is handled
+     * separately by INSTANTIATION_KINDS.
+     *
+     * Two signals, both required:
+     *  - the `type` field is a class-like NAMED type (`type_identifier`,
+     *    `template_type`, or `qualified_identifier`). Primitives (`int x(0)`),
+     *    `auto` (`placeholder_type_specifier` — that form always carries a real
+     *    `call_expression`, already handled), and sized specifiers are excluded —
+     *    they construct no class; and
+     *  - a declarator carries constructor arguments: an `init_declarator` whose
+     *    `value` is an `argument_list` (`(args)`) or `initializer_list` (`{args}`).
+     *    This skips default construction `Calculator c;` (no value) and the
+     *    most-vexing-parse `Calculator c();` (a bodyless `function_declarator`,
+     *    a function decl — not a construction).
+     */
+    private isCppStackConstruction;
     /**
      * 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
@@ -507,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
@@ -643,5 +702,5 @@ export declare class TreeSitterExtractor {
  * those names and the file's language are run after the tree-sitter pass.
  * Their nodes/references/errors are merged into the returned result.
  */
-export declare function extractFromSource(filePath: string, source: string, language?: Language, frameworkNames?: string[]): ExtractionResult;
+export declare function extractFromSource(filePath: string, source: string, language?: Language, frameworkNames?: string[], vbaTargets?: Record<string, boolean>): ExtractionResult;
 //# sourceMappingURL=tree-sitter.d.ts.map

package/dist/extraction/vba/call-sweep.d.ts

@@ -0,0 +1,3 @@
+import { VbaExtractorContext } from './context';
+export declare function sweepCallsAndSql(ctx: VbaExtractorContext, src: string): void;
+//# sourceMappingURL=call-sweep.d.ts.map