@aroman22/codegraph-vba 1.5.2 → 1.6.1

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

package/dist/extraction/vba/calls.d.ts

@@ -0,0 +1,55 @@
+import { VbaExtractorContext, ProcInfo } from './context';
+export declare function scanRaiseEvents(ctx: VbaExtractorContext, line: string, from: ProcInfo, lineNum: number): void;
+export declare function scanCallSites(ctx: VbaExtractorContext, line: string, from: ProcInfo, lineNum: number): void;
+/**
+ * Issue #45: split a single-line VBA `If <cond> Then <body>` into one or
+ * more statement-clause fragments the statement-call detectors can process
+ * (`If x Then Foo Else Bar`, colon-separated `If x Then DoA: DoB`). When the
+ * line is not a single-line `If … Then` shape, returns `[<line>]` so
+ * block-form `If` still works through the per-line scan. `GoTo`/`Exit`/
+ * `Resume` clauses are filtered out. `line` is the string-literal-masked
+ * scan line, which makes global `:`/`Else` splitting safe.
+ */
+export declare function splitSingleLineIfClauses(line: string): string[];
+/**
+ * H1: detect a statement-form Sub call (`MySub`, `MySub arg1, x`,
+ * `Call MySub arg1`). Returns the called proc name, or null for
+ * declarations, assignments, comments, keyword lines, and the paren form
+ * (handled by CALL_RE).
+ */
+export declare function detectStatementCall(line: string): string | null;
+/**
+ * H1: emit a same-file `calls` edge for a statement-form Sub call to the
+ * already-emitted function node named `procName`.
+ */
+export declare function emitStatementCallEdge(ctx: VbaExtractorContext, caller: ProcInfo, procName: string, lineNum: number): void;
+/**
+ * Fix 7: detect a qualified statement-form call — `Receiver.Member <args>`
+ * where `Receiver.Member` is NOT followed by `(`. Distinct from the paren
+ * form (handled by CALL_RE). Property assignments and blacklisted
+ * receivers/members are excluded. Returns `{receiver, member}` or null.
+ */
+export declare function detectQualifiedStatementCall(line: string): {
+    receiver: string;
+    member: string;
+} | null;
+/**
+ * Fix 7: emit a heuristic `calls` edge for a qualified statement-form call.
+ * Same shape as the qualified-paren path in `scanCallSites` — reuses the
+ * same `callDedupe` / `synthFunctionNodeIds` sets so a paren and non-paren
+ * form on the same line don't create duplicate edges.
+ */
+export declare function emitQualifiedStatementCallEdge(ctx: VbaExtractorContext, caller: ProcInfo, receiver: string, member: string, lineNum: number): void;
+/**
+ * Issue #43: normalize the receiver of a `With <expr>` block to a bare
+ * identifier, or null when it is a keyword / runtime object / unparseable.
+ */
+export declare function normalizeWithReceiver(expr: string): string | null;
+/**
+ * Issue #43: detect a `.Member` call inside a `With` block (leading-dot
+ * member reference that is a call, not a property assignment).
+ */
+export declare function detectWithMemberCall(line: string): {
+    member: string;
+} | null;
+//# sourceMappingURL=calls.d.ts.map

package/dist/extraction/vba/constants.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared regexes and lookup sets used by more than one VBA extraction pass.
+ * Kept in a leaf module so the per-concern pass modules can import them
+ * without depending on each other or on the orchestrator.
+ */
+/** Sub/Function/Property regex — captures visibility prefix, kind, and name. */
+export declare const PROC_RE: RegExp;
+/**
+ * Issue #52: shared `End Sub` / `End Function` / `End Property` marker.
+ * Promoted from a local regex in `sweepCallsAndSql` so `sweepEnumsAndConsts`
+ * can walk the same proc boundaries and decide Const scope per line.
+ * The `(?:^|:\s*)` prefix tolerates colon-separated single-line procs
+ * (`Public Sub X(): ... : End Sub`) so the proc stack pops on the same
+ * physical line.
+ */
+export declare const PROCEDURE_END_RE: RegExp;
+/**
+ * VBA primitive type names — skipped when emitted as Dim targets so
+ * we don't pollute the graph with `As Long` / `As String` references.
+ * Fix 4: all entries are LOWERCASE and the lookup lowercases the
+ * captured type name so `As long`, `As LONG`, `As Long` all match.
+ * Fix 1 (Issue #1): added `'new'` as a backstop so that if the `As New`
+ * pattern is ever captured as a type name it is silently skipped.
+ */
+export declare const PRIMITIVE_TYPES: Set<string>;
+/** Keywords we never want to match as call receivers. */
+export declare const CALL_KEYWORD_BLACKLIST: Set<string>;
+/**
+ * Access runtime objects and singletons. Calls on these receivers are
+ * real VBA calls but the targets are NOT user-defined modules or
+ * classes — they're Access/DAO/ADO runtime types. Synthesizing a
+ * `function` node for each would pollute the graph with ~20+ junk
+ * nodes per real-world file (audit W4, June 2026). Skip synthesis
+ * for any receiver or member in this set.
+ *
+ * Note: `DoCmd.RunSQL`, `DoCmd.OpenForm`, etc. still get SQL/edge
+ * tracking via the dedicated `SQL_WRAPPERS` regex path (REQ-CODE-8),
+ * which fires BEFORE this scan and uses its own dispatch — so
+ * blacklisting DoCmd here doesn't lose the SQL-flow edges.
+ */
+export declare const RUNTIME_RECEIVER_BLACKLIST: Set<string>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/extraction/vba/context.d.ts

@@ -0,0 +1,175 @@
+/**
+ * VbaExtractorContext — the shared state + shared helpers threaded through
+ * every VBA extraction pass.
+ *
+ * It owns the node/edge/reference accumulators, the per-file lookup maps
+ * (`localProcs`, `functionNodeByName`, `localVarTypeMap`, `localConstants`,
+ * `localEvents`), the lazily-created module/class node, and the de-dup caches.
+ * The per-concern sweeps under `src/extraction/vba/*` are free functions that
+ * take a `VbaExtractorContext` and read/write this shared state; the handful
+ * of helpers that more than one sweep needs (`emitReference`,
+ * `pushContainsFromModule`, `findOrCreateFunctionNodeId`, the qualified-call
+ * gates, and the per-scope Const lookup) live here as methods.
+ */
+import { Node, Edge, ExtractionError, UnresolvedReference } from '../../types';
+export interface ProcInfo {
+    name: string;
+    qualifiedName: string;
+    kind: 'sub' | 'function' | 'property';
+    visibility: 'public' | 'private' | 'protected' | 'internal';
+    startLine: number;
+}
+export declare class VbaExtractorContext {
+    filePath: string;
+    nodes: Node[];
+    edges: Edge[];
+    errors: ExtractionError[];
+    unresolvedReferences: UnresolvedReference[];
+    moduleOrClassNode: Node | null;
+    /**
+     * Class-name prefix for `qualifiedName` composition.
+     *
+     * B3 (hueco 5): for `.cls` files every function node's `qualifiedName`
+     * is composed as `${className}.${procName}` (e.g. `Form_TestForm.Form_Load`)
+     * so cross-class callers can disambiguate which form each `Form_Load`
+     * belongs to. For `.bas` files this is `null` — module-scoped procs keep
+     * their bare-name `qualifiedName`. Resolved once per `extract()` from
+     * `isCls` + `vbName`; `sweepProcedures` reads it.
+     */
+    classNamePrefix: string | null;
+    /**
+     * Map of procedure name (within this file) → list of ProcInfo. The list
+     * (rather than a single value) is needed because VBA allows multiple
+     * Property accessors with the same name: `Property Get Foo`, `Property
+     * Let Foo`, and `Property Set Foo` all share the name `Foo`.
+     */
+    localProcs: Map<string, ProcInfo[]>;
+    /**
+     * Cache: procedure name → first matching function node emitted for that
+     * name (audit S2 — O(1) same-file call resolution).
+     */
+    functionNodeByName: Map<string, Node>;
+    /**
+     * Cache: startLine → function node emitted for that line. When Property
+     * Get/Let/Set share a name, we find the SPECIFIC accessor's node by its
+     * declaration line (Fix 1).
+     */
+    functionNodeByStartLine: Map<number, Node>;
+    /** Edges whose source needs to be set to the module/class id once it exists. */
+    pendingModuleOrClassSource: Edge[];
+    /** Cache so we don't re-emit the same proc function node per call site. */
+    procNodeIdCache: Map<string, string>;
+    callDedupe: Set<string>;
+    synthFunctionNodeIds: Set<string>;
+    /**
+     * B4 (hueco 6) extended by Issue #48: cache of stub node ids we've already
+     * emitted for a given (method, target name) pair in this file. Keyed by
+     * `${cacheKey}:${lowerName}` so the OpenForm and OpenReport de-dup buckets
+     * stay disjoint.
+     */
+    opensStubIdsByKey: Map<string, string>;
+    synthClassNodeIds: Set<string>;
+    /**
+     * Issue #50: TempVars placeholder-node de-dup cache. Keys are the
+     * deterministic node ids produced by `emitTempVarReference` — those ids
+     * intentionally use a synthetic `synthetic:tempvar/<key>` path so the SAME
+     * key referenced from Form_A.cls AND Form_B.cls collapses to ONE node.
+     */
+    synthTempVarNodeIds: Set<string>;
+    /**
+     * Maps `variableName.toLowerCase()` → declared type info.
+     * Built by `sweepDimsAndWithEvents`; consulted by the unified qualified-call
+     * gate (`shouldProcessQualifiedCall`) so declared project-class locals emit
+     * edges, declared primitive/external locals stay silent, and undeclared
+     * receivers remain module-name candidates for the resolver (Fix 2 / Issue #2).
+     */
+    localVarTypeMap: Map<string, {
+        outer: string;
+        qualified: boolean;
+        withEvents?: boolean;
+        variableName?: string;
+        assignedWithSet?: boolean;
+    }>;
+    /**
+     * Issue #52: Const resolution buckets, scoped per procedure. Key is
+     * `'module'` for module-level Consts, or the procedure's `startLine`
+     * (stringified) for proc-local Consts. Each bucket maps the lowercase
+     * constant name to its simple-literal value (used by `DoCmd.OpenForm` /
+     * `OpenReport` / `OpenQuery` argument resolution via `resolveLocalConst`).
+     */
+    localConstants: Map<'module' | string, Map<string, string>>;
+    /**
+     * Issue #52: the current Const-lookup scope. `'module'` when no procedure
+     * is open, otherwise the top-of-stack proc's `startLine` as a string. Both
+     * `sweepEnumsAndConsts` and `sweepCallsAndSql` keep this in sync with their
+     * per-line stack walk.
+     */
+    currentProcKey: 'module' | string;
+    /**
+     * Issue #52: per-extraction proc-stack shared between `sweepEnumsAndConsts`
+     * and `sweepCallsAndSql`. Each sweep clears it at the start so the file's
+     * mid-proc structural state never leaks across sweeps. Holds the `startLine`
+     * of every procedure whose `End` marker the sweep has not yet seen.
+     */
+    procStack: number[];
+    /** Local event name (lowercase) → event node for `RaiseEvent` edge emission. */
+    localEvents: Map<string, Node>;
+    constructor(filePath: string);
+    /**
+     * Emit a `contains` edge from the (lazily-created) module/class node to
+     * `targetId`. Mirrors the pending-source pattern the procedure and
+     * implements sweeps use: the module node doesn't exist yet, so the edge's
+     * source is rewritten once `extract()` creates it.
+     */
+    pushContainsFromModule(targetId: string): void;
+    /**
+     * Fix 2 (Issue #2): return true iff `receiverName` is a file-local variable
+     * (appears in `localVarTypeMap`) whose declared type is a SIMPLE (non-
+     * qualified, non-primitive) identifier — a candidate project-defined class.
+     * Qualified types (e.g. `DAO.Recordset`) and primitives (`String`, `Long`)
+     * return false so runtime/DAO calls are suppressed. Brackets are stripped
+     * from the lookup key defensively (Issue #54).
+     */
+    isLocalProjectClassVar(receiverName: string): boolean;
+    /**
+     * Qualified-call eligibility is intentionally shared by paren-form
+     * (`Receiver.Member(...)`) and statement-form (`Receiver.Member args`) scans:
+     * project-class locals are processed after type resolution, declared
+     * primitive/external locals are silent, and undeclared receivers remain
+     * candidate module names.
+     */
+    shouldProcessQualifiedCall(receiverName: string): boolean;
+    /**
+     * #12a: resolve the "receiver type" used to build a qualified call-stub's
+     * name/qualifiedName. When `receiverName` is a file-local variable typed
+     * as a candidate project class (`isLocalProjectClassVar`), returns the
+     * RESOLVED CLASS NAME from `localVarTypeMap` (e.g. `m_NCOp As NCOperaciones`
+     * → `'NCOperaciones'`) so the stub matches the real `.cls` method's
+     * `${className}.${proc}` shape. Otherwise returns `receiverName` unchanged
+     * (the `.bas`-qualified module call case).
+     */
+    resolveReceiverType(receiverName: string): string;
+    findOrCreateFunctionNodeId(proc: ProcInfo): string;
+    findFunctionNodeByName(name: string): Node | undefined;
+    /**
+     * Emit a `references` edge from the file's module/class node to a synthetic
+     * node named `targetName`. Used by Dim, WithEvents, Set-New, and SQL sweeps.
+     * Fix 5: the synthetic node id is keyed on (filePath, kind, name) WITHOUT
+     * lineNum so the same type/table referenced on N lines produces ONE node.
+     */
+    emitReference(targetName: string, lineNum: number, column: number, synthesizedBy: string): void;
+    /**
+     * Issue #52: shared lookup helper for `scanDoCmdOpenCalls` and
+     * `scanDoCmdOpenQuery`. The current scope is the procedure whose
+     * `startLine` is on top of `procStack` (or `'module'` when empty).
+     * Per-proc bucket first; module bucket is the fallback.
+     */
+    resolveLocalConst(name: string): string | undefined;
+    /**
+     * Issue #52: shared writer. `scopeKey` is `'module'` or the procedure's
+     * startLine-as-string. Creates the bucket lazily. Returns the bucket the
+     * value was written to (mostly useful for tests).
+     */
+    setLocalConstInScope(scopeKey: 'module' | string, name: string, value: string): Map<string, string>;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/extraction/vba/controls.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Control-reference sweeps: `Me.<Control>` / `Me!<Control>` (hueco 1, issue
+ * #44) and cross-form `Forms!<Form>` / `Forms("<Form>")!<Ctl>` bang refs
+ * (issue #44). Both emit `UnresolvedReference`s (no synthetic `function`
+ * node) the resolver later binds to the form's controls.
+ */
+import { VbaExtractorContext, ProcInfo } from './context';
+/**
+ * Hueco 1: scan a line for `Me.<ControlName>` / `Me!<ControlName>`
+ * patterns and emit one UnresolvedReference per occurrence, tagged
+ * `metadata.synthesizedBy: 'vba-me-control'`. Operates on the masked
+ * `callScanLine`. The +3 column offset skips the 3-char `Me.` / `Me!`
+ * prefix (both are 3 chars).
+ */
+export declare function scanMeControlReferences(ctx: VbaExtractorContext, line: string, from: ProcInfo, lineNum: number): void;
+/**
+ * Issue #44: scan a line for cross-form bang references
+ * (`Forms!<FormName>[!<Ctl>]` and `Forms("<FormName>")!<Ctl>`) and
+ * emit ONE UnresolvedReference per match with `metadata.synthesizedBy
+ * = 'vba-forms-bang'`. Operates on the ORIGINAL (unmasked) line. The form
+ * identifier is unwrapped of surrounding `"` quotes and `[…]` brackets.
+ */
+export declare function scanFormsBang(ctx: VbaExtractorContext, line: string, from: ProcInfo, lineNum: number): void;
+//# sourceMappingURL=controls.d.ts.map

package/dist/extraction/vba/declarations.d.ts

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

package/dist/extraction/vba/dims.d.ts

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

package/dist/extraction/vba/docmd.d.ts

@@ -0,0 +1,16 @@
+import { VbaExtractorContext, ProcInfo } from './context';
+/**
+ * B4 (hueco 6) extended by Issue #48: scan one line of VBA source for
+ * `DoCmd.OpenX "Target"` calls where X ∈ {Form, Report}. For each match emit
+ * a cached stub node (form-layout / report-layout) and an
+ * `opens-form` / `opens-report` heuristic edge from the calling Sub.
+ */
+export declare function scanDoCmdOpenCalls(ctx: VbaExtractorContext, line: string, caller: ProcInfo, lineNum: number): void;
+/**
+ * Issue #48: scan one line of VBA source for `DoCmd.OpenQuery "X"` calls.
+ * Each match emits ONE `UnresolvedReference` (NOT a stub + edge) so the
+ * resolver binds to the REAL `query` node that `SqlQueryExtractor`
+ * produces for `queries/<Name>.sql`, tagged `synthesizedBy: 'vba-opens-query'`.
+ */
+export declare function scanDoCmdOpenQuery(ctx: VbaExtractorContext, line: string, caller: ProcInfo, lineNum: number): void;
+//# sourceMappingURL=docmd.d.ts.map

package/dist/extraction/vba/enums-consts.d.ts

@@ -0,0 +1,15 @@
+import { VbaExtractorContext } from './context';
+/**
+ * Walk the (uncommented, line-joined) source and emit:
+ *  - one `enum` node per `Enum <Name>` block, with one `enum_member` node
+ *    per member and a `contains` edge enum→member;
+ *  - one `constant` node per name declared on a `Const` line (multi-name
+ *    lines emit one node per name);
+ *  - a `contains` edge from the module/class node to each enum and constant
+ *    (held in `pendingModuleOrClassSource` until the module node exists).
+ *
+ * Returns the number of top-level symbols (enums + constants) emitted so
+ * the caller can flip `hasAnySymbols`.
+ */
+export declare function sweepEnumsAndConsts(ctx: VbaExtractorContext, src: string): number;
+//# sourceMappingURL=enums-consts.d.ts.map

package/dist/extraction/vba/implements.d.ts

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

package/dist/extraction/vba/procedures.d.ts

@@ -0,0 +1,3 @@
+import { VbaExtractorContext, ProcInfo } from './context';
+export declare function sweepProcedures(ctx: VbaExtractorContext, src: string): ProcInfo[];
+//# sourceMappingURL=procedures.d.ts.map

package/dist/extraction/vba/sql-wrapper.d.ts

@@ -0,0 +1,17 @@
+import { VbaExtractorContext } from './context';
+export declare function scanSqlInLine(ctx: VbaExtractorContext, line: string, lineNum: number, dedupe: Set<string>, sqlVariables: Map<string, string>): void;
+/**
+ * #13 fix: `sql = sql & "..."` (self-referential concatenation) must
+ * ACCUMULATE the new fragment onto whatever was already tracked for
+ * `varName`, not overwrite it. Overwriting silently dropped earlier
+ * fragments' tables — typically the initial `FROM <table>` in
+ * `sql = "SELECT * FROM tblA"` followed by `sql = sql & " WHERE x=1"`.
+ *
+ * Detection: the RHS (`m[2]`, trimmed) starts with `<varName> &`,
+ * case-insensitively — matching VBA's case-insensitive identifiers (`Sql`
+ * and `sql` are the same variable). A genuine fresh assignment (RHS does
+ * NOT start with the self-reference) still RESETS tracking — that
+ * behavior is unchanged.
+ */
+export declare function trackSqlVariableAssignment(lines: string[], lineIndex: number, sqlVariables: Map<string, string>): void;
+//# sourceMappingURL=sql-wrapper.d.ts.map

package/dist/extraction/vba/tempvars.d.ts

@@ -0,0 +1,10 @@
+import { VbaExtractorContext, ProcInfo } from './context';
+/**
+ * Issue #50: scan one line of VBA source for TempVars access sites and
+ * emit one `references` edge per site. Bang form scans the MASKED line,
+ * paren + Add forms scan the ORIGINAL line. Access is classified by the
+ * line suffix after the match: a bare `=` next non-whitespace char is a
+ * write (VBA has no `==`).
+ */
+export declare function sweepTempVars(ctx: VbaExtractorContext, maskedLine: string, originalLine: string, lineNum: number, caller: ProcInfo | undefined): void;
+//# sourceMappingURL=tempvars.d.ts.map

package/dist/extraction/vba/text-utils.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Pure text helpers shared across the VBA extraction passes. None of these
+ * touch extractor state — they are deterministic string transforms lifted
+ * out of `VbaExtractor` verbatim so each pass module can import what it needs
+ * without pulling in the orchestrator.
+ */
+/**
+ * Fold a VBA visibility keyword to the canonical lowercase enum, matching
+ * the procedure convention: `Private` → 'private'; `Public`, `Global`,
+ * `Friend`, or none → 'public' (VBA's default module-level `Const`/`Enum`
+ * is Private, but we follow the same broader-than-private fold the proc
+ * sweep uses so visibility is consistent across symbol kinds).
+ */
+export declare function foldVisibility(raw: string): 'public' | 'private';
+/**
+ * Fix 2 (Issue #2): replace string-literal content with spaces so that
+ * call-site patterns inside `"..."` spans are invisible to CALL_RE and
+ * the statement-form detectors.  Column positions are preserved (each
+ * character is replaced 1-for-1) so any col-based metadata stays correct.
+ */
+export declare function maskStringContent(line: string): string;
+/**
+ * #13 helper: escape a variable name for safe interpolation into the
+ * self-reference RegExp built by `trackSqlVariableAssignment`. VBA
+ * identifiers are alphanumeric+underscore only, so in practice nothing here
+ * ever needs escaping — this guards against regex metacharacters anyway
+ * rather than assume the input is always well-formed.
+ */
+export declare function escapeRegExpLiteral(value: string): string;
+export declare function parseConstDeclarations(body: string): Array<{
+    name: string;
+    value: string | null;
+}>;
+export declare function splitOutsideVbaStrings(value: string, separator: string): string[];
+/**
+ * Issue #50 helper: return true iff `line.charAt(fromIndex..)` (after the
+ * matched TempVars site, including any trailing whitespace) holds an `=`
+ * (write-assignment) and not a `==` (VBA has no `==` operator, so a bare
+ * check for `=` is safe). Used by `sweepTempVars` to classify a `TempVars`
+ * access as read vs write from the local line context.
+ *
+ * We skip over trailing whitespace only — `.`, `(`, `<`, `>`, `*`, `+`
+ * etc. all mean "this isn't an assignment target", and bare `=`
+ * is the only access-suffix shape VBA syntax allows here. A line like
+ * `TempVars!x = 1` (write) or `Debug.Print TempVars!x` (read) land in
+ * the right bucket without further analysis.
+ *
+ * Strings should already be masked out of `line` (`maskStringContent`)
+ * when this is called for the bang form (no string in scope anyway);
+ * the paren form passes the ORIGINAL line — but for THAT form the
+ * captured match ends at the closing `"` of the literal, so any `=`
+ * that follows is unambiguously outside the string.
+ */
+export declare function detectAssignmentSuffix(line: string, fromIndex: number): boolean;
+export declare function unwrapVbaStringLiteral(raw: string): string;
+/**
+ * Hueco 3 helper: parse an Access event-handler Sub name into its
+ * `<ControlName>_<EventName>` components. Returns null when the name does
+ * not match the convention, when the split yields an empty segment, or
+ * when the control name is `Form` (form-level events are NOT control
+ * handlers — `Form_Load` is the form's own lifecycle event, not a
+ * command-button click).
+ *
+ * Splitting on the LAST underscore (rather than the first) lets
+ * multi-word event names parse correctly: `ComandoAltaPM_BeforeDelConfirm`
+ * yields control=`ComandoAltaPM`, event=`BeforeDelConfirm`, not
+ * control=`ComandoAlta`, event=`PM_BeforeDelConfirm`.
+ */
+export declare function parseEventHandlerName(name: string): {
+    controlName: string;
+    eventName: string;
+} | null;
+//# sourceMappingURL=text-utils.d.ts.map