@aroman22/codegraph-vba 1.3.3

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

@@ -0,0 +1,394 @@
+import { ExtractionResult } from '../types';
+export declare class VbaExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private edges;
+    private errors;
+    private unresolvedReferences;
+    private moduleOrClassNode;
+    /**
+     * 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` (e.g. `DoThing`), preserving
+     * the pre-hueco-5 behavior and every existing qualifiedName-based
+     * assertion in `extraction-vba.test.ts`.
+     *
+     * Resolved once per `extract()` from `isCls` + `vbName` (both already
+     * computed for `createModuleOrClassNode`); `sweepProcedures` reads it
+     * to set `ProcInfo.qualifiedName` and the function node's qualifiedName.
+     */
+    private classNamePrefix;
+    /**
+     * 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`. Audit W6
+     * (June 2026): the previous Map<string, ProcInfo> kept only the last
+     * accessor, breaking same-file call resolution and emitting the wrong
+     * `findFunctionNodeByName` match.
+     */
+    private localProcs;
+    /**
+     * Cache: procedure name → first matching function node emitted for that
+     * name. Audit S2 (June 2026): the previous implementation did an O(n)
+     * linear scan of all nodes for every call site; with W6's multimap
+     * the same-name collision can return multiple matches but bare-name
+     * call resolution only needs the first.
+     */
+    private functionNodeByName;
+    /**
+     * Cache: startLine → function node emitted for that line. Used by Fix 1
+     * (June 2026): when Property Get/Let/Set share a name, we need to find
+     * the SPECIFIC accessor's node by its declaration line rather than relying
+     * on `functionNodeByName` which only stores the first accessor.
+     */
+    private functionNodeByStartLine;
+    constructor(filePath: string, source: string);
+    extract(): ExtractionResult;
+    private result;
+    private isFormOrReportFile;
+    private createFileNode;
+    private detectVbName;
+    private createModuleOrClassNode;
+    /** Sub/Function/Property regex — captures visibility prefix, kind, and name. */
+    private static readonly PROC_RE;
+    /**
+     * Walk the (uncommented, line-joined) source and emit one `function` node
+     * per `Sub` / `Function` / `Property` declaration. Also records the proc
+     * in `localProcs` so call-site resolution can distinguish same-file from
+     * cross-module calls.
+     */
+    private sweepProcedures;
+    /** Implements regex. */
+    private static readonly IMPLEMENTS_RE;
+    /** Edges whose source needs to be set to the module/class id once it exists. */
+    private pendingModuleOrClassSource;
+    private sweepImplements;
+    /**
+     * Check that a line is a variable declaration and NOT a Sub/Function/
+     * Property/Const/WithEvents header (those have their own sweeps).
+     * Fix 1+3 (Issues #1,#3): replaced the old single-match DIM_QUAL_RE /
+     * DIM_UNQUAL_RE pair with a prefix-check + global scan that handles
+     * `As New <Type>`, multi-variable `Dim a As Foo, b As Bar`, and all
+     * visibility keywords in one pass.
+     */
+    private static readonly DIM_DECL_PREFIX_RE;
+    /**
+     * Globally scan all `identifier As [New] TypePart1[.TypePart2]` on a
+     * variable declaration line. Run with /g after confirming DIM_DECL_PREFIX_RE.
+     *
+     * Groups: (1) variable name, (2) type outer part, (3) type inner part (if qualified).
+     * `(?:New\s+)?` consumes the VBA auto-instantiation keyword so it is
+     * never captured as the type name (Fix 1).
+     */
+    private static readonly DIM_ALL_VARS_RE;
+    /**
+     * 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.
+     */
+    private static readonly PRIMITIVE_TYPES;
+    /** `WithEvents m_X As Form_Foo` — Dim/Private/Public prefix is optional. */
+    private static readonly WITHEVENTS_RE;
+    private sweepDimsAndWithEvents;
+    /** `[visibility] Enum <Name>` — opens an enum block. */
+    private static readonly ENUM_START_RE;
+    /** `End Enum` — closes the current enum block. */
+    private static readonly ENUM_END_RE;
+    /**
+     * An enum member line: a leading identifier optionally followed by `=
+     * <value>`. Runs only inside an open Enum block, on the (already
+     * comment-stripped) source, so a trailing `'comment` never reaches here.
+     * `\p{L}` covers accented member names (e.g. `Sí`).
+     */
+    private static readonly ENUM_MEMBER_RE;
+    /** `[visibility] Const <decls>` — captures visibility (1) and the rest (2). */
+    private static readonly CONST_DECL_RE;
+    /**
+     * One declared name inside a `Const` body. A name sits at a declaration
+     * boundary (start-of-body or after a comma), optionally followed by
+     * `As <Type>`, then `=`. Run with /g over the CONST_DECL_RE group 2 so
+     * multi-name lines (`Const A = 1, B = 2`) emit one node per name.
+     */
+    private static readonly CONST_NAME_RE;
+    /**
+     * 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).
+     */
+    private static foldVisibility;
+    /**
+     * 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`.
+     */
+    private sweepEnumsAndConsts;
+    /**
+     * 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.
+     */
+    private pushContainsFromModule;
+    /**
+     * Walk the (uncommented) source per line. For each line:
+     *  - If it starts a `Sub`/`Function`/`Property`, push the proc onto a stack.
+     *  - If it ends one (`End Sub` / `End Function` / `End Property`), pop.
+     *  - While inside a procedure, scan the line for call-site patterns and
+     *    SQL-wrapper patterns.
+     *
+     * Call-site regex: `(?<!\w)([A-Za-z_]\w*)(?:\.([A-Za-z_]\w*))?\s*\(` —
+     * captures either `Name(...)` (same-file candidate) or `Receiver.Member(...)`
+     * (qualified — emit a synthetic node + heuristic edge).
+     */
+    private static readonly CALL_RE;
+    /** SQL wrapper helpers — order matters because `db.Execute` is a suffix of others. */
+    private static readonly SQL_WRAPPERS;
+    /**
+     * `DoCmd.OpenForm "<FormName>"` modelling regex — B4 (hueco 6).
+     *
+     * Real VBA idiom (matches both forms):
+     *   `DoCmd.OpenForm "MyForm"`
+     *   `DoCmd.OpenForm "MyForm", acNormal, , , acFormEdit`
+     *
+     * Captures the form NAME (group 1) so the extractor can synthesize an
+     * `opens-form` heuristic edge from the calling Sub to a stub for the
+     * target form. The trailing positional args (`acNormal`, `acFormEdit`,
+     * etc.) are intentionally NOT captured — the orchestrator's scope decision
+     * was to cover ONLY `OpenForm` for this commit; `OpenReport`, `OpenQuery`,
+     * `OpenTable`, … are flagged in the commit body as follow-up work.
+     *
+     * Why a separate dispatch: `DoCmd` is in `RUNTIME_RECEIVER_BLACKLIST`
+     * (R4 invariant), so `DoCmd.OpenForm` is intentionally SKIPPED by the
+     * generic `CALL_RE` path that would otherwise emit a junk `calls` edge
+     * to a synthetic `function` node for `DoCmd.OpenForm`. This regex
+     * matches BEFORE the call-site scan and uses its own dispatch to emit
+     * the `opens-form` edge instead — sharing no logic with CALL_RE.
+     */
+    private static readonly OPEN_FORM_RE;
+    /** SQL assigned to a local variable, e.g. `m_SQL = "SELECT ..." & ...`. */
+    private static readonly SQL_VAR_ASSIGN_RE;
+    /** SQL wrapper called with a variable, e.g. `getdb().Execute m_SQL`. */
+    private static readonly SQL_VAR_EXEC_RE;
+    /** SQL table-name regex scoped to FROM / INTO / UPDATE. */
+    private static readonly SQL_TABLE_RE;
+    /**
+     * `Me.<ControlName>` reference capture — hole 1 of VBA control-modeling.
+     *
+     * Real VBA idiom:
+     *   `Me.lblTitulo.Caption = "Hello"`            ← property assignment
+     *   `Me.txtDescripcion.Value = "World"`          ← property assignment
+     *   `Me.ComandoGrabar.Enabled = True`           ← property assignment
+     *   `If Nz(Me.MotivoBorrado, "") = "" Then`      ← read in expression
+     *
+     * The existing call-site scanner (CALL_RE) only fires on `Name(`
+     * (paren form) and `Me` is in its keyword blacklist anyway, so
+     * `Me.<Control>` references are silently invisible. This regex matches
+     * the FIRST identifier after `Me.` regardless of what follows (a
+     * property, an index, an assignment, a call argument, etc.) so the
+     * form → control binding is surfaced as an UnresolvedReference for the
+     * resolver to pick up later. Subsequent segments (`.Caption`, `.Value`,
+     * `.Enabled`) are intentionally NOT captured — they are properties of
+     * the control, not new symbols.
+     *
+     * Provenance: `metadata.synthesizedBy = 'vba-me-control'`. Mirrors the
+     * `vba-form-binding` (form→sibling-`.cls`) and `vba-name-resolution`
+     * (qualified Dim) patterns already documented on `UnresolvedReference.metadata`
+     * in `src/types.ts`.
+     */
+    private static readonly ME_CONTROL_RE;
+    /** Keywords we never want to match as call receivers. */
+    private static readonly CALL_KEYWORD_BLACKLIST;
+    /**
+     * 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.
+     */
+    private static readonly RUNTIME_RECEIVER_BLACKLIST;
+    /**
+     * 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.
+     */
+    private static maskStringContent;
+    /**
+     * 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.
+     */
+    private isLocalProjectClassVar;
+    private sweepCallsAndSql;
+    private scanCallSites;
+    /** Cache so we don't re-emit the same proc function node per call site. */
+    private procNodeIdCache;
+    private callDedupe;
+    private synthFunctionNodeIds;
+    /**
+     * B4 (hueco 6): cache of stub `form-layout` node ids we've already emitted
+     * for a given target form name in this file. Avoids emitting duplicate
+     * stubs when `DoCmd.OpenForm "FormTest"` shows up N times across N calls.
+     * Keyed by the lowercased form name so `FormTest` / `formtest` collapse.
+     */
+    private opensFormStubIdsByName;
+    /**
+     * Hueco 1: scan a line for `Me.<ControlName>` patterns and emit one
+     * UnresolvedReference per occurrence, tagged
+     * `metadata.synthesizedBy: 'vba-me-control'`.
+     *
+     * Operates on the masked `callScanLine` (string-literal content already
+     * replaced with spaces) so `Me.X` inside a string literal is not falsely
+     * captured. Per-site emission — every `Me.lblTitulo` reference site
+     * produces its own UnresolvedReference carrying the line/column; the
+     * resolver fans them out into multiple `references` edges at index time
+     * once the matching `form-instance-control` node exists.
+     *
+     * `fromNodeId` is the current procedure's function node — that's the
+     * "owner" of the reference (the Sub body that wrote `Me.lblTitulo = …`).
+     */
+    private scanMeControlReferences;
+    private findOrCreateFunctionNodeId;
+    private findFunctionNodeByName;
+    /**
+     * H1: detect a statement-form Sub call.
+     *
+     * Real VBA idioms:
+     *   `MySub`                           — bare no-argument statement call
+     *   `MySub arg1, Nz(x, 0)`            — bare statement call
+     *   `Call MySub arg1, Nz(x, 0)`       — Call keyword, no parens around call
+     *   `MySub(arg1, arg2)`               — parens call (handled by CALL_RE)
+     *   `Call MySub(arg1, arg2)`          — Call keyword + parens (also CALL_RE)
+     *
+     * Returns the called proc name if the line matches the statement form
+     * AND the proc name is in localProcs (same-file resolution). Returns
+     * null for declarations, assignments, comments, keyword lines, etc.
+     *
+     * The `Call` keyword form is handled by stripping `Call ` and
+     * running the same logic on the remainder — they're structurally the
+     * same call after the keyword.
+     */
+    private detectStatementCall;
+    /**
+     * H1: emit a same-file `calls` edge for a statement-form Sub call.
+     * `caller` is the current procedure (from the stack); `procName` is
+     * the called procedure name. Emits a plain `calls` edge to the
+     * already-emitted function node.
+     */
+    private emitStatementCallEdge;
+    /**
+     * Fix 7: detect a qualified statement-form call — `Receiver.Member <args>`
+     * where `Receiver.Member` is NOT followed by `(`.
+     *
+     * Real VBA idioms this covers:
+     *   `m_NCOp.Registrar m_ARAlInicio, p_Error`
+     *   `m_Obj.Init`
+     *
+     * These are distinct from the paren form (`m_NCOp.Registrar(...)`) which is
+     * already handled by `CALL_RE`. Returns `{receiver, member}` or `null`.
+     *
+     * Property assignments (`Receiver.Prop = value`) are excluded via the `=`
+     * guard — consistent with `detectStatementCall`'s same-file assignment skip.
+     * Blacklisted receivers (runtime objects, keywords) are excluded too.
+     */
+    private detectQualifiedStatementCall;
+    /**
+     * 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 for de-duplication so a
+     * paren and non-paren form on the same line don't create duplicate edges.
+     */
+    private emitQualifiedStatementCallEdge;
+    /**
+     * B4 (hueco 6): scan one line of VBA source for `DoCmd.OpenForm "X"`
+     * calls. For each match, emit:
+     *  - a stub `form-layout` node for the target form (cached by name so
+     *    the same form referenced from N sites emits exactly ONE stub),
+     *  - an `opens-form` heuristic edge from the calling Sub to that stub.
+     *
+     * Both endpoints are pushed into `this.nodes` / `this.edges`, so the
+     * per-file edge filter at `index.ts:insertedIds.has(source) &&
+     * insertedIds.has(target)` passes the edge naturally without any
+     * exemption to the filter.
+     *
+     * Why a stub and not a direct lookup: the target form lives in a
+     * DIFFERENT file (its own `.form.txt`), and the extractor doesn't have
+     * DB access at parse time. The stub's synthetic file path
+     * (`synthetic:opensFormStub/<FormName>.form.txt`) guarantees a
+     * deterministic node id so re-indexes collapse to the same stub.
+     * When the consumer's `.form.txt` is later indexed, the real
+     * `form-layout` node carries a different id (it uses the real file
+     * path); the stub and the real coexist harmlessly. The orchestrator
+     * flagged this as acceptable for B4 — only `OpenForm` is in scope.
+     * `OpenReport`, `OpenQuery`, `OpenTable`, … are follow-up work.
+     *
+     * Scope note: this regex matches ONLY the literal-string form
+     * `DoCmd.OpenForm "X"`. Variable-form calls like
+     * `DoCmd.OpenForm m_FormName` are intentionally NOT captured here
+     * because resolving the variable to a concrete form name would
+     * require data-flow analysis that is out of scope.
+     */
+    private scanOpenFormCalls;
+    /**
+     * B4 (hueco 6): emit a stub `form-layout` node for `targetFormName`
+     * (cached so duplicates collapse) and an `opens-form` heuristic edge
+     * from `caller` to that stub.
+     *
+     * The edge carries:
+     *  - `kind: 'opens-form'`                — new cross-file edge kind
+     *  - `provenance: 'heuristic'`           — synthesized, not parsed
+     *  - `metadata.targetFormName`           — the captured literal
+     *  - `metadata.synthesizedBy: 'vba-opens-form'` — distinguishes this
+     *    synthesis from the dim/sql/event-handler families
+     *
+     * The stub's `metadata.stub: true` flag lets downstream UI render
+     * unresolved references distinctly (e.g. with a dashed border) and
+     * gives later re-resolution pass a hook for collapse. The stub is
+     * line-independent (`line = 0`) so re-indexes produce identical ids.
+     */
+    private emitOpensFormEdge;
+    private scanSqlInLine;
+    private trackSqlVariableAssignment;
+    private collectStringLiteralText;
+    private emitSqlTableReferences;
+    /**
+     * Emit a `references` edge from the file's module/class node to a synthetic
+     * node named `targetName`. Used by Dim, WithEvents, Implements, and SQL.
+     */
+    private emitReference;
+    private synthClassNodeIds;
+    /**
+     * Fix 2 (Issue #2): maps `variableName.toLowerCase()` → declared type info.
+     * Built by `sweepDimsAndWithEvents`; consulted by `sweepCallsAndSql` to gate
+     * qualified statement-form calls — only receivers that are file-local variables
+     * typed as a SIMPLE (non-qualified, non-primitive) identifier emit edges.
+     */
+    private localVarTypeMap;
+}
+//# sourceMappingURL=vba-extractor.d.ts.map

package/dist/extraction/vba-form-extractor.d.ts

@@ -0,0 +1,89 @@
+import { ExtractionResult } from '../types';
+export declare class VbaFormExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private edges;
+    private errors;
+    private unresolvedReferences;
+    constructor(filePath: string, source: string);
+    extract(): ExtractionResult;
+    private createFileNode;
+    /**
+     * Strip the two-segment extension (`.form.txt`, `.report.txt`) or the
+     * fallback single-segment extension. Returns the file basename without
+     * its extension — used as the sibling `.cls` name when `VB_Name` is
+     * absent and as the default module name.
+     */
+    private basenameWithoutExtension;
+    private detectVbName;
+    /**
+     * Build the per-file node for a `.form.txt` / `.report.txt` source.
+     * Emits `kind: 'form-layout'` (B2 hueco 4), replacing the historical
+     * `kind: 'module'` so consumers can dispatch on a UI-specific kind.
+     *
+     * The deterministic id formula `generateNodeId(filePath, 'form-layout',
+     * name, 1)` is preserved so cross-extractor stubs (e.g. event-handler
+     * synthesis on the `.cls` side) can produce a matching id when needed
+     * — though the immediate use case is the `module` → `form-layout`
+     * rename. `metadata.containerKind` keeps the historical `'module'`
+     * label as a back-compat marker; consumers should prefer `node.kind`.
+     */
+    private createFormLayoutNode;
+    /**
+     * Match each `Begin <ControlType>` declaration line and emit one `property`
+     * node per match. The control type is the second token after `Begin`.
+     *
+     * The Dysflow SaveAsText format uses:
+     *   Begin TextBox
+     *       Name = "txtFoo"
+     *   End
+     *
+     * We do not try to balance `Begin`/`End` blocks — each `Begin <Type>` on
+     * its own line is a control. Form/report files are shallow enough that
+     * the extra `Begin`/`End` for the form's root block are matched but
+     * filtered by the control-type blacklist (see below).
+     */
+    private static readonly BEGIN_RE;
+    /**
+     * `Name = "..."` attribute line — emits the Access control instance name
+     * (e.g. `lblTitulo`, `ComandoAltaPM`). Capture group 1 is the name.
+     * The Dysflow SaveAsText format always wraps the value in double quotes
+     * — even when the name is a simple identifier — so we anchor on `"…"`
+     * without trying to handle unquoted forms.
+     */
+    private static readonly NAME_RE;
+    /**
+     * Control type tokens that are NOT user-visible Access controls and must be
+     * filtered out so they don't appear as `property` nodes.
+     *
+     * - `Form`    — the form's own root `Begin Form` / `End` container.
+     * - `Section` — Access section containers (Header / Detail / Footer).
+     *
+     * `Rectangle` and `Image` are real Access controls and must NOT appear here.
+     */
+    private static readonly NON_CONTROL_TYPES;
+    /**
+     * Maximum scan window for the `Name = "..."` attribute after a
+     * `Begin <Type>` line. Real Dysflow exports have at most a handful of
+     * whitespace-only lines and the `Name` line within the first 3–6 lines
+     * of the block. 16 is a generous bound; if `Name` is missing within
+     * that window, the control is treated as a nameless container and only
+     * the legacy `property` node is emitted (preserves REQ-FORM-2 for
+     * pre-Name `.form.txt` files exported by older Dysflow versions).
+     */
+    private static readonly NAME_SCAN_WINDOW;
+    private sweepControls;
+    /**
+     * Scan ahead from a `Begin <Type>` line for the first `Name = "…"`
+     * attribute. Returns the captured name and the line number where it
+     * was found, or `{ name: '', nameLine: 0 }` when no Name is present
+     * within the scan window (e.g. the `Begin Form` root block which has
+     * `Caption = "..."` but no `Name`, or pre-Name legacy exports).
+     *
+     * Stops at the next `Begin` or `End` boundary so a misaligned scan
+     * never crosses into a sibling control's attribute block.
+     */
+    private findControlName;
+}
+//# sourceMappingURL=vba-form-extractor.d.ts.map

package/dist/extraction/vba-preprocess.d.ts

@@ -0,0 +1,81 @@
+/**
+ * VBA pre-processing pipeline.
+ *
+ * Pure helpers used by `VbaExtractor` before and during regex extraction:
+ *
+ *   1. joinLineContinuations(src)
+ *      VBA uses a trailing ` _` (space + underscore) at the end of a line to
+ *      mark line continuation. We collapse these into single logical lines so
+ *      the regex sweeps downstream see one statement per regex match.
+ *
+ *   2. stripVbaComments(src)
+ *      VBA has two comment forms:
+ *        - apostrophe `'` — anything from the apostrophe to end-of-line
+ *        - `Rem ` (case-insensitive keyword, with trailing space) — the legacy
+ *          alternative to `'`
+ *      Both are STRIPPED only when outside double-quoted strings. We walk
+ *      character-by-character so a `'` inside `"..."` is preserved.
+ *
+ *   3. extractStringLiterals(src)
+ *      Used by SQL-variable tracking to read literal fragments from assignments
+ *      such as `m_SQL = "SELECT ..." & ...`. It returns every `"..."` span
+ *      with its 1-based line and 0-based column. VBA doubles `"` inside literals
+ *      (`""`) as the escape for a single `"` — the escape is consumed, the
+ *      literal is returned without the doubling.
+ *
+ * Each helper is < 50 LOC, pure, and tested in isolation in
+ * `__tests__/extraction-vba-preprocess.test.ts`.
+ *
+ * Source unchanged guarantee: every helper treats `src` as read-only.
+ */
+/**
+ * Collapse VBA line continuations: any line whose last non-newline character is
+ * `_` (preceded by exactly one space, per VBA convention) is joined to the
+ * next line. A single space replaces the joined boundary.
+ *
+ * - Input  : multi-line source
+ * - Output : source with continuation lines merged into the previous line
+ *
+ * Does NOT inspect string literals — VBA's continuation convention is line-
+ * physical (the underscore must be the last non-space char on the line), so a
+ * `"` followed by `_` inside a string is still a line continuation. In real
+ * Dysflow-exported code this never happens (continuations are syntactic, not
+ * inside string content), so we skip the cost of tracking string state.
+ */
+export declare function joinLineContinuations(src: string): string;
+/**
+ * Strip VBA comments from source. Walks character-by-character:
+ *  - inside a double-quoted string: skip until the closing `"` (handling the
+ *    `""` doubled-quote escape so it doesn't terminate the string early)
+ *  - outside a string:
+ *      * `'` to EOL → drop the rest of the line
+ *      * line-start `Rem ` (case-insensitive) → drop the whole line
+ *      * mid-line ` Rem ` (case-insensitive, with surrounding whitespace) →
+ *        drop the rest of the line
+ *      * `Option <word>` directive lines → drop the whole line
+ *      * newline → end-of-line marker for the apostrophe rule
+ *
+ * The trailing whitespace of each stripped line is trimmed so a `code ' comment`
+ * becomes `code` (not `code `), keeping downstream regex anchored patterns
+ * from drifting on whitespace artifacts.
+ *
+ * Source is treated as read-only.
+ */
+export declare function stripVbaComments(src: string): string;
+export interface StringLiteralSpan {
+    /** The literal content (no surrounding quotes; `""` collapsed to `"`). */
+    text: string;
+    /** 1-based line number where the opening quote sits. */
+    line: number;
+    /** 0-based column where the opening quote sits. */
+    column: number;
+}
+/**
+ * Walk source and record every double-quoted string literal with its 1-based
+ * line and 0-based column. VBA's `""` escape is collapsed to a single `"` in
+ * the recorded `text`.
+ *
+ * The source is NOT mutated.
+ */
+export declare function extractStringLiterals(src: string): StringLiteralSpan[];
+//# sourceMappingURL=vba-preprocess.d.ts.map

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

@@ -0,0 +1,51 @@
+import { ExtractionResult } from '../types';
+/**
+ * VueExtractor - Extracts code relationships from Vue Single-File Component files
+ *
+ * Vue SFCs are multi-language (script + template + style). Rather than
+ * parsing the full Vue grammar, we extract the <script> block content
+ * and delegate it to the TypeScript/JavaScript TreeSitterExtractor.
+ *
+ * Every .vue file produces a component node (Vue components are always importable).
+ */
+export declare class VueExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private edges;
+    private unresolvedReferences;
+    private errors;
+    constructor(filePath: string, source: string);
+    /**
+     * Extract from Vue source
+     */
+    extract(): ExtractionResult;
+    /**
+     * Create a component node for the .vue file
+     */
+    private createComponentNode;
+    /**
+     * Extract <script> and <script setup> blocks from the Vue source
+     */
+    private extractScriptBlocks;
+    /**
+     * Process a script block by delegating to TreeSitterExtractor
+     */
+    private processScriptBlock;
+    /**
+     * Extract component usages from the Vue `<template>`.
+     *
+     * PascalCase tags (`<Modal>`, `<Button />`) and kebab-case tags
+     * (`<my-button>`) both represent component instantiations — analogous to
+     * function calls in imperative code. Capturing them creates parent→child
+     * component edges and lets `callers` / `impact` see a component that is
+     * only ever used in markup. Vue's extractor previously parsed only the
+     * `<script>` block, so these usages produced no edge at all (#629).
+     *
+     * HTML elements (lowercase, no hyphen) and Vue built-ins are skipped.
+     * Unmatched names create no edge during resolution, so converting
+     * kebab-case is safe even for native custom elements.
+     */
+    private extractTemplateComponents;
+}
+//# sourceMappingURL=vue-extractor.d.ts.map

package/dist/extraction/wasm-runtime-flags.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The V8 flag(s) that keep tree-sitter grammar compilation off the turboshaft
+ * optimizing tier. Single source of truth: the relaunch guard and the test
+ * suite both read this (a test asserts each is a real flag on the running
+ * runtime, so a rename can't silently regress the fix).
+ */
+export declare const WASM_RUNTIME_FLAGS: readonly string[];
+/**
+ * Env var carrying the *host* PID (the relauncher's own parent) across the
+ * re-exec. Without `--liftoff-only` the CLI re-execs itself once, inserting an
+ * intermediate process between the MCP host and the server. That intermediate
+ * stays alive (blocked in spawnSync) even after the host is killed, so the
+ * server's PPID watchdog can't detect the host's death by watching its own
+ * `process.ppid`. Passing the host PID through lets the watchdog poll it
+ * directly. Unset on the no-re-exec path (bundled launcher / flag already
+ * present), where the server is already a direct child of the host. See
+ * src/mcp/index.ts (#277).
+ */
+export declare const HOST_PPID_ENV = "CODEGRAPH_HOST_PPID";
+/** True when every required WASM runtime flag is already present in `execArgv`. */
+export declare function processHasWasmRuntimeFlags(execArgv?: readonly string[]): boolean;
+/**
+ * Build the argv for re-execing node with the WASM runtime flags: our flags
+ * first, then any node flags already in `execArgv` (deduped), then the script
+ * and its args. Pure — exported for unit testing.
+ */
+export declare function buildRelaunchArgv(scriptPath: string, scriptArgs: readonly string[], execArgv?: readonly string[]): string[];
+/**
+ * If the current process is missing the WASM runtime flags, re-exec it once
+ * with them and exit with the child's status. No-op when the flags are already
+ * present (the normal bundled-launcher path), when already relaunched, or when
+ * disabled via CODEGRAPH_NO_RELAUNCH.
+ *
+ * On spawn failure, returns so the caller runs in-process anyway — risking the
+ * OOM is still better than refusing to start.
+ */
+export declare function relaunchWithWasmRuntimeFlagsIfNeeded(scriptPath: string): void;
+//# sourceMappingURL=wasm-runtime-flags.d.ts.map

package/dist/graph/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Graph Module
+ *
+ * Provides graph traversal and query functionality for the code knowledge graph.
+ */
+export { GraphTraverser } from './traversal';
+export { GraphQueryManager } from './queries';
+//# sourceMappingURL=index.d.ts.map