@aroman22/codegraph-vba 1.10.0 → 1.11.0

package/dist/db/queries.d.ts

@@ -354,6 +354,43 @@ export declare class QueryBuilder {
      * a second stub edge onto the same real target (F1 duplicate-collapse).
      */
     edgeExists(source: string, target: string, kind: EdgeKind): boolean;
+    /**
+     * Issue #150 — return every `references` edge whose metadata was
+     * stamped by the given `synthesizedBy` key. Used by the
+     * event-handler synthesis pass to find every `WithEvents` binding
+     * in the project. The `metadata LIKE` filter is a cheap index-free
+     * pre-filter (a `synthesizedBy` value can appear as a substring of
+     * another); callers must still exact-check the parsed JSON
+     * `metadata.synthesizedBy` field.
+     *
+     * Returns the raw rows (id, source, target, metadata JSON). Callers
+     * join against `getNodeById` to materialize the source/target Node
+     * values. The `references` edges this returns are the
+     * `resolveVbaReferenceStubs`-repointed ones (target is the real
+     * class node, not the synthetic stub), so the binding lookup
+     * survives the resolver.
+     */
+    getReferencesBySynthesizedBy(synthesizedBy: string): Array<{
+        id: number;
+        source: string;
+        target: string;
+        metadata: string | null;
+    }>;
+    /**
+     * Issue #150 — return every `raises-event` edge in the DB. Used by
+     * the event-handler synthesis pass to walk every `RaiseEvent`
+     * statement and connect it to its `m_<var>_<EventName>` handler
+     * Sub. Returns the raw rows; callers parse the metadata to pull
+     * the `eventName` for downstream edge construction.
+     */
+    getRaisesEventEdges(): Array<{
+        id: number;
+        source: string;
+        target: string;
+        line: number | null;
+        col: number | null;
+        metadata: string | null;
+    }>;
     /**
      * Find all edges where both source and target are in the given node set.
      * Useful for recovering inter-node connectivity after BFS.

package/dist/extraction/frameworks/dysflow-export.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Dysflow-export framework resolver (issue #154).
+ *
+ * The 3 Dysflow-specific extractors ÔÇö form/report SaveAsText UI, test
+ * manifests, and test sequences ÔÇö used to be hard-coded into
+ * `extractFromSource` as a `detectedLanguage === 'vba' && <isFoo> (filePath)`
+ * ladder. They are now lifted into this `FrameworkResolver`-shaped module
+ * so they can be:
+ *   1. Reached through the standard framework registry (the same path every
+ *      other framework ÔÇö Express, React, Spring ÔÇö flows through).
+ *   2. Opted out at the project level via `codegraph.json`'s
+ *      `vba.dysflowExport: false` ÔÇö useful for projects that carry legacy
+ *      `.form.txt`/`.report.txt` files (or test manifests from a different
+ *      system) and want them tracked as just a `file` node instead of
+ *      being expanded into the graph.
+ *
+ * Architecture: the underlying `VbaFormExtractor` / `VbaTestManifestExtractor`
+ * / `VbaTestSequenceExtractor` classes are the single source of truth for
+ * the per-file extraction logic. This module:
+ *   - decides WHICH sub-extractor applies to a file (path shape);
+ *   - delegates the actual `extract()` to that sub-extractor;
+ *   - exposes the `FrameworkResolver` shape (`detect` / `extract` /
+ *     `resolve` / `claimsReference`) so the rest of the codebase can treat
+ *     "Dysflow export" as a regular framework on top of the base VBA
+ *     language.
+ *
+ * Behavior contract: with `dysflowExport: true` (the default), the emitted
+ * nodes/edges/references are byte-identical to the pre-refactor paths in
+ * `tree-sitter.ts`. With `dysflowExport: false`, the framework's `detect()`
+ * returns `false` so it's never in the per-project detected list ÔÇö meaning
+ * its `extract()` is never called and the form/report/manifest/sequence
+ * files fall through to a `file`-only node via the language-specific
+ * dispatch in `tree-sitter.ts`.
+ */
+import { FrameworkResolver } from '../../resolution/types';
+export declare const dysflowExportResolver: FrameworkResolver;
+//# sourceMappingURL=dysflow-export.d.ts.map

package/dist/extraction/frameworks/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Extraction-side framework resolvers.
+ *
+ * `src/extraction/frameworks/` is the home for `FrameworkResolver`s whose
+ * primary contribution is per-file extraction (nodes + references), as
+ * opposed to `src/resolution/frameworks/` whose resolvers are primarily
+ * reference resolvers. The two registries are kept separate so a future
+ * "extraction-only" framework (e.g. another format-specific generator)
+ * doesn't drag in the full resolution pipeline, and so the namespacing
+ * matches the layer the resolver actually plugs into.
+ *
+ * Currently only the Dysflow export resolver lives here ÔÇö the 3
+ * Dysflow-specific extractors (form/report, test manifest, test
+ * sequence) were lifted out of `tree-sitter.ts` into this `FrameworkResolver`
+ * shape so the project can opt out via `codegraph.json`
+ * (`vba.dysflowExport: false`, issue #154). New extraction-side frameworks
+ * (e.g. a future "terraform state" generator) should be added here.
+ */
+export { dysflowExportResolver } from './dysflow-export';
+//# sourceMappingURL=index.d.ts.map

package/dist/extraction/parse-pool.d.ts

@@ -48,6 +48,16 @@ export interface ParseTask {
     language: Language;
     frameworkNames?: string[];
     vbaTargets?: Record<string, boolean>;
+    /** Issue #152: per-file fanout cap for `RaiseEvent` edges (VBA only). */
+    maxRaiseFanout?: number;
+    /**
+     * Issue #154 — gate the 3 Dysflow-specific VBA sub-extractors. `true`
+     * (the default) keeps the pre-refactor behavior; `false` opts out so
+     * form/report/manifest/sequence files are tracked as just a `file`
+     * node. Threaded through the worker so the same flag is honored on
+     * either side of the pool boundary.
+     */
+    dysflowExport?: boolean;
 }
 /**
  * Resolve the pool size from the `CODEGRAPH_PARSE_WORKERS` override and the

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

@@ -701,6 +701,14 @@ export declare class TreeSitterExtractor {
  * If `frameworkNames` is provided, framework-specific extractors matching
  * those names and the file's language are run after the tree-sitter pass.
  * Their nodes/references/errors are merged into the returned result.
+ *
+ * `dysflowExport` (issue #154) gates the 3 Dysflow-specific VBA
+ * sub-extractors (form/report SaveAsText, test manifests, test sequences).
+ * `true` (the default) preserves the pre-refactor behavior; `false` opts
+ * out so `.form.txt`/`.report.txt`/manifest/sequence files are tracked as
+ * just a `file` node. Read from `codegraph.json` via
+ * `loadDysflowExportConfig(rootDir)` at the call site and threaded in here
+ * so this function stays project-config-agnostic.
  */
-export declare function extractFromSource(filePath: string, source: string, language?: Language, frameworkNames?: string[], vbaTargets?: Record<string, boolean>): ExtractionResult;
+export declare function extractFromSource(filePath: string, source: string, language?: Language, frameworkNames?: string[], vbaTargets?: Record<string, boolean>, maxRaiseFanout?: number, dysflowExport?: boolean): ExtractionResult;
 //# sourceMappingURL=tree-sitter.d.ts.map

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

@@ -1,9 +1,52 @@
 import { VbaExtractorContext, VbaClassifier } from './context';
+import { VbaExtractionRule } from './rules';
+/**
+ * Issue #153: the declarative rule table for the calls/SQL concern.
+ *
+ * Of the call-sweep's full machinery, only the per-line *patterns*
+ * fit the declarative shape. The procedural scanners
+ * (`scanRaiseEvents`, `scanCallSites`, `scanMeControlReferences`,
+ * `scanSqlInLine`, `scanDoCmdOpenCalls`, `scanDoCmdOpenQuery`,
+ * `scanFormsBang`, `sweepTempVars`, statement/qualified call
+ * detection) walk the masked line scanning for call shapes that
+ * don't reduce to a single regex — they stay inside the factory's
+ * `classifyLine` (acknowledged in the Issue #153 spec: "The
+ * inter-line state machines (procedure stack, with stack,
+ * sqlVariables) NEED a class, not a pure rule.").
+ *
+ * Four rules, all driven by the masked line (the call site / Set
+ * patterns must not match inside string literals):
+ *
+ *  - `set-new`    — `Set <var> = New <Type>[.<Inner>]`; registers the
+ *                   receiver in `localVarTypeMap` and emits a
+ *                   `vba-set-new` `references` edge.
+ *  - `set-call`   — `Set <var> = <Factory>(...)`; types the receiver
+ *                   from a same-file function's project-class return
+ *                   type so a later `x.Method` resolves to the
+ *                   factory's class. Emits a `vba-factory-return`
+ *                   `references` edge.
+ *  - `with-start` — `With <receiver>`; normalizes the receiver and
+ *                   pushes it onto `ctx.vbaWithStack` (replaces the
+ *                   pre-#153 per-factory closure variable).
+ *  - `with-end`   — `End With`; pops the matching `ctx.vbaWithStack`
+ *                   entry.
+ *
+ * The `set-new` rule's emit function is a "pure" (match, ctx, line)
+ * consumer — it reads/writes only `ctx` and the unmasked/ masked
+ * line, with no closure references. Same for the other three.
+ */
+export declare const RULES: readonly VbaExtractionRule<unknown>[];
 /**
  * Issue #83: factory for the calls/SQL classifier. The factory takes the
  * pre-split `lines` array (so `trackSqlVariableAssignment` can do its
  * multi-line look-ahead for `&`-accumulate semantics) and closes over the
  * per-file state the legacy `sweepCallsAndSql` declared locally.
+ *
+ * Issue #153: the per-line pattern matching has been extracted into
+ * the `RULES` table. The factory body is now a thin shell that
+ * dispatches `RULES` and runs the procedural scanners (call sites,
+ * raise events, SQL, DoCmd, TempVars, etc.) that don't reduce to a
+ * single regex.
  */
 export declare function createCallsAndSqlClassifier(lines: readonly string[]): VbaClassifier;
 /**

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

@@ -143,8 +143,58 @@ export declare class VbaExtractorContext {
      * of every procedure whose `End` marker the sweep has not yet seen.
      */
     procStack: number[];
+    /**
+     * Issue #153: per-extraction state for the events/types/declares
+     * classifier's `Type <Name> ... End Type` block tracking. The
+     * `currentTypeBlock` is set when a `type-start` rule fires and
+     * cleared when the matching `type-end` rule fires. Lives on `ctx`
+     * (instead of the factory's closure) so the declarative RULES
+     * table's `emit` functions can read/write it without taking a
+     * closure-captured mutable reference. `null` means "outside any
+     * type block right now". Reset implicitly per-extraction (a fresh
+     * `VbaExtractorContext` is constructed every `extract()` call).
+     */
+    vbaDeclTypeBlock: {
+        id: string;
+        name: string;
+    } | null;
+    /**
+     * Issue #153: per-extraction state for the enum/consts classifier's
+     * `Enum <Name> ... End Enum` block tracking. Same shape and
+     * rationale as `vbaDeclTypeBlock`: lives on `ctx` so the
+     * declarative RULES table's `emit` functions can read/write it
+     * without taking a closure-captured mutable reference.
+     * `null` means "outside any enum block right now".
+     */
+    vbaEnumBlock: {
+        id: string;
+        name: string;
+    } | null;
+    /**
+     * Issue #153: per-extraction state for the calls/SQL classifier's
+     * `With <receiver> ... End With` block tracking. The with-receiver
+     * stack mirrors the textual nesting of `With` blocks inside a
+     * procedure body — the top of the stack is the active receiver
+     * for `.Member` and `.Member(args)` statement-form calls. Reset
+     * implicitly per-extraction (a fresh `VbaExtractorContext` is
+     * constructed every `extract()` call). Replaces the per-factory
+     * closure variable that lived in `sweepCallsAndSql` before the
+     * Issue #153 RULES-table refactor.
+     */
+    vbaWithStack: string[];
     /** Local event name (lowercase) → event node for `RaiseEvent` edge emission. */
     localEvents: Map<string, Node>;
+    /**
+     * Issue #152: per-event counter for `RaiseEvent <EventName>` sites. Keyed
+     * by event node id (so two different events that share a name across
+     * files don't collide — the gate is per-file). The count is incremented
+     * in `scanRaiseEvents` BEFORE the edge is pushed, so the count equals
+     * the number of raise sites regardless of the gate decision downstream.
+     * The orchestrator's fanout-gate pass reads this map to decide which
+     * event nodes to flag `metadata.highFanout: true` and which `raises-event`
+     * edges to drop.
+     */
+    raiseEventCounts: Map<string, number>;
     /**
      * Same-file function/property return types, keyed by lowercase proc name →
      * declared return type. ONLY non-primitive (project-class) return types are
@@ -156,7 +206,34 @@ export declare class VbaExtractorContext {
      * time) — that stays the resolver's frontier.
      */
     functionReturnTypes: Map<string, string>;
+    /**
+     * Issue #156: per-stage timings, lazily allocated ONLY when
+     * `CODEGRAPH_VBA_TIMING=1|2` is set. The default path (env var unset)
+     * keeps this `null` so `recordStage` is a single null-check and we
+     * pay zero Map-allocation cost in the hot path. Stage names are
+     * dot-separated: `preprocess.stripVbaComments`,
+     * `preprocess.cc.lexer+parser`, `walk.procedures`, `walk.main`,
+     * `classifier.<name>`. Counters are in milliseconds (float).
+     */
+    timings: Map<string, number> | null;
+    /**
+     * Issue #156: how many times each classifier's `classifyLine` was
+     * invoked. Only allocated together with `timings` so the default path
+     * pays no cost.
+     */
+    classifierInvokeCounts: Map<string, number> | null;
     constructor(filePath: string);
+    /**
+     * Issue #156: ensure the timings Maps exist. Called once per
+     * `extract()` by the orchestrator right after it reads the env var.
+     * No-op when already allocated.
+     */
+    ensureTimings(): void;
+    /**
+     * Issue #156: add `ms` to the stage named `name`. No-op when
+     * `timings` is null (default path).
+     */
+    recordStage(name: string, ms: number): void;
     /**
      * Emit a `contains` edge from the (lazily-created) module/class node to
      * `targetId`. Mirrors the pending-source pattern the procedure and
@@ -193,6 +270,27 @@ export declare class VbaExtractorContext {
     resolveReceiverType(receiverName: string): string;
     findOrCreateFunctionNodeId(proc: ProcInfo): string;
     findFunctionNodeByName(name: string): Node | undefined;
+    /**
+     * Issue #152: apply the per-file `RaiseEvent` fanout gate. For every
+     * event whose `raiseEventCounts` value exceeds `maxFanout`:
+     *   1. Stamp the event node's `metadata.highFanout = true` and
+     *      `metadata.raiseCount = <count>` so consumers (codegraph_explore,
+     *      vba-event-tracer) can recognize a high-fanout event.
+     *   2. Drop every `raises-event` edge targeting that event id from
+     *      `edges`. The event node itself stays — declaration site, handler
+     *      linkage via `subscribes-event`, and metadata are all preserved.
+     *
+     * Events with `<= maxFanout` raise sites are untouched (no flag, edges
+     * stay). When `maxFanout` is undefined, the gate is disabled and the
+     * method is a no-op. Mirrors the upstream `EVENT_FANOUT_CAP` discipline
+     * in `src/resolution/callback-synthesizer.ts:43` (this side suppresses
+     * the producer side, the upstream side suppresses the synthesized
+     * cross-file dispatcher/handler edges).
+     *
+     * Returns the number of `raises-event` edges dropped (zero when the
+     * gate is disabled or no event exceeds the cap — useful for tests).
+     */
+    applyRaiseFanoutGate(maxFanout: number | undefined): number;
     /**
      * 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.
@@ -206,8 +304,18 @@ export declare class VbaExtractorContext {
      * TempVars sweep already emits (`emitTempVarReference`). Omitted for
      * structural references (Dim/WithEvents/Set-New) where the direction is not
      * meaningful.
+     *
+     * `extras` (optional): additional metadata fields to merge into the
+     * emitted edge's `metadata` object. Used by the WithEvents sweep to
+     * stamp `variableName` (issue #150) so the post-extraction
+     * event-handler synthesis pass can find the `m_<var>_<event>`
+     * handler Sub even after `resolveVbaReferenceStubs` CASCADE-deletes
+     * the companion `subscribes-event` edge along with the synthetic
+     * class stub. Fields here are merged AFTER the standard
+     * `{ synthesizedBy [, access] }` shape, so callers can override
+     * (rarely useful) but not accidentally drop the stamp.
      */
-    emitReference(targetName: string, lineNum: number, column: number, synthesizedBy: string, access?: 'read' | 'write'): void;
+    emitReference(targetName: string, lineNum: number, column: number, synthesizedBy: string, access?: 'read' | 'write', extras?: Record<string, unknown>): void;
     /**
      * Issue #52: shared lookup helper for `scanDoCmdOpenCalls` and
      * `scanDoCmdOpenQuery`. The current scope is the procedure whose

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

@@ -1,7 +1,43 @@
 import { VbaExtractorContext, VbaClassifier } from './context';
+import { VbaExtractionRule } from './rules';
 /**
- * Issue #83: factory for the events/types/declares classifier. Closure
- * state: `currentType` (the open `Type ... End Type` block).
+ * Issue #153: the declarative rule table for the events/types/declares
+ * concern. Five rules, partitioned by where they fire:
+ *
+ *  - `event-decl`   (outside-type-block) — match an `Event <Name>` decl
+ *  - `type-start`   (outside-type-block) — match a `Type <Name>` header;
+ *                  sets `ctx.vbaDeclTypeBlock` on a successful match
+ *  - `type-end`     (inside-type-block)  — match `End Type`; clears
+ *                  `ctx.vbaDeclTypeBlock` on a successful match
+ *  - `type-member`  (inside-type-block)  — match `<Member> As <Type>`
+ *                  inside an open type block
+ *  - `dll-declare`  (outside-type-block) — match a `[Private|Public]
+ *                  Declare [PtrSafe] Sub|Function <Name> Lib "<dll>"
+ *                  [Alias "<x>"]` Win32 API declaration
+ *
+ * The `requires` field encodes the type-block precondition. The
+ * dispatcher (the factory's `classifyLine`) filters rules whose
+ * precondition does not hold, so an `End Type` line never
+ * accidentally re-enters the `event-decl` / `dll-declare` paths.
+ *
+ * Inter-line state lives on `ctx.vbaDeclTypeBlock` (replaces the
+ * pre-#153 factory closure variable) so the emit functions can
+ * read/write it without taking a mutable closure reference.
+ */
+export declare const RULES: readonly VbaExtractionRule<unknown>[];
+/**
+ * Issue #83: factory for the events/types/declares classifier.
+ *
+ * Inter-line state (`ctx.vbaDeclTypeBlock`) lives on `ctx` — the
+ * declarative RULES table's `emit` functions read/write it directly.
+ * The dispatcher below honours each rule's `requires` precondition
+ * so the per-line dispatch mirrors the legacy cascade exactly:
+ *
+ *   if (currentType) {
+ *     try type-end, then type-member; return early
+ *   } else {
+ *     try event-decl, type-start, dll-declare
+ *   }
  */
 export declare function createEventsTypesDeclaresClassifier(): VbaClassifier;
 /**

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

@@ -1,6 +1,40 @@
 import { VbaExtractorContext, VbaClassifier } from './context';
+import { VbaExtractionRule } from './rules';
 /**
- * Issue #83: factory for the Dim / WithEvents classifier. Stateless per-line.
+ * Issue #153: the declarative rule table for the Dim / WithEvents
+ * concern. Two rules:
+ *
+ *  - `dim-decl`       — match a `Dim|Private|Public|Global|Static
+ *                       <var> [As [New] <TypePart>[.<TypePart>]][, …]`
+ *                       declaration; populate `localVarTypeMap` and
+ *                       emit one `references` edge per non-primitive
+ *                       type (or per qualified outer type).
+ *  - `withevents-decl`— match a `[Dim|Private|Public|Global|Static]
+ *                       WithEvents <var> As <FormType>` declaration;
+ *                       populate `localVarTypeMap` with `withEvents: true`,
+ *                       emit a `references` edge (synthesizedBy:
+ *                       `vba-withevents`) and a `subscribes-event` edge.
+ *
+ * The two rules are dispatched independently and BOTH can fire on the
+ * same line in principle (a `WithEvents` line does NOT match the
+ * `Dim|Private|...` prefix because the negative lookahead excludes it).
+ * The `dim-decl` rule's `count` hook reports the number of
+ * non-primitive `references` edges it emitted, so a multi-variable
+ * `Dim a As Foo, b As Bar` line adds 2 to the classifier count, and a
+ * bare `Dim x` line adds 0 (the bare-Dim path is a `localVarTypeMap`
+ * only side effect, no graph edges).
+ *
+ * No inter-line state — each rule is self-contained.
+ */
+export declare const RULES: readonly VbaExtractionRule<unknown>[];
+/**
+ * Issue #83: factory for the Dim / WithEvents classifier.
+ *
+ * The body walks the declarative `RULES` table (Issue #153). The two
+ * rules are independent: `dim-decl` handles typed declarations
+ * (REJECTED if the line is a `WithEvents` because the prefix
+ * negative-lookahead excludes `WithEvents`), `withevents-decl`
+ * handles WithEvents. No inter-line state.
  */
 export declare function createDimsClassifier(): VbaClassifier;
 /**

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

@@ -1,13 +1,53 @@
 import { VbaExtractorContext, VbaClassifier } from './context';
+import { VbaExtractionRule } from './rules';
 /**
- * Issue #83: factory for the enum / const classifier. Closure state:
- * `currentEnum` (open `Enum ... End Enum` block).
+ * Issue #153: the declarative rule table for the enum / const concern.
+ * Six rules, partitioned by where they fire:
  *
- * Also resets + advances the SHARED `ctx.procStack`/`ctx.currentProcKey`
- * per line — same protocol the pre-#83 sweep followed. The calls-sql
- * classifier runs AFTER this one in the per-line dispatch order and
- * applies the same protocol, so the end-of-line scope state is identical
- * to the legacy sequential-sweep behaviour.
+ *  - `proc-start`      (outside-enum-block) — match a `Sub` /
+ *                      `Function` / `Property` header; push onto
+ *                      `ctx.procStack` and set `ctx.currentProcKey`
+ *                      so subsequent Const writes land in the
+ *                      per-proc resolution bucket.
+ *  - `proc-end`        (outside-enum-block) — match `End Sub` /
+ *                      `End Function` / `End Property`; pop the
+ *                      matching `procStack` entry.
+ *  - `enum-start`      (outside-enum-block) — match `[visibility]
+ *                      Enum <Name>`; emit an `enum` node + `contains`
+ *                      edge and mark `ctx.vbaEnumBlock`.
+ *  - `enum-end`        (inside-enum-block)  — match `End Enum`; clear
+ *                      `ctx.vbaEnumBlock`.
+ *  - `enum-member`     (inside-enum-block)  — match `<MemberName>
+ *                      [= <value>]`; emit an `enum_member` node + a
+ *                      `contains` edge from the open enum.
+ *  - `const-decl`      (outside-enum-block) — match `[visibility]
+ *                      Const <decls>`; always write the per-scope
+ *                      resolution bucket, and emit a `constant` node
+ *                      + `contains` edge ONLY when not inside a proc
+ *                      (proc-local Consts are not module symbols).
+ *
+ * The inter-line `ctx.procStack` / `ctx.currentProcKey` state is
+ * SHARED with the calls/SQL classifier (issue #52 protocol). The
+ * `ctx.vbaEnumBlock` state is local to this concern and lives on
+ * `ctx` for the same RULES-table-friendliness reason as
+ * `vbaDeclTypeBlock`.
+ */
+export declare const RULES: readonly VbaExtractionRule<unknown>[];
+/**
+ * Issue #83: factory for the enum / const classifier.
+ *
+ * The body walks the declarative `RULES` table (Issue #153) and
+ * honours each rule's `requires` precondition. The inter-line
+ * state — `ctx.procStack`, `ctx.currentProcKey`, and
+ * `ctx.vbaEnumBlock` — lives on `ctx` so the RULES table's `emit`
+ * functions can read/write it without taking a closure reference.
+ *
+ * Issue #52: the first invocation also resets the shared proc-stack
+ * + lookup key so leftover state from a previous `extract()` (only
+ * possible in tests that construct a fresh extractor and run twice)
+ * never leaks across sweeps. The walk below updates both every
+ * iteration; `sweepCallsAndSql` resets again at its own start, so
+ * the protocol stays consistent across both classifiers.
  */
 export declare function createEnumsConstsClassifier(): VbaClassifier;
 /**

package/dist/extraction/vba/event-synth.d.ts

@@ -0,0 +1,3 @@
+import { QueryBuilder } from '../../db/queries';
+export declare function synthesizeVbaEventHandlerEdges(queries: QueryBuilder): number;
+//# sourceMappingURL=event-synth.d.ts.map

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

@@ -1,6 +1,22 @@
 import { VbaExtractorContext, VbaClassifier } from './context';
+import { VbaExtractionRule } from './rules';
+/**
+ * Issue #153: the declarative rule table for the implements concern.
+ * One rule — `implements` — matching a leading `Implements <Name>`
+ * declaration. The body has no inter-line state to track, so the
+ * orchestrator walks the table and bumps `this.count` on every
+ * non-null emit. Keeps the inline `classifyLine` below honest: any
+ * branch not represented in this table is dead code.
+ */
+export declare const RULES: readonly VbaExtractionRule<unknown>[];
 /**
  * Issue #83: factory for the `Implements` classifier. Stateless per-line.
+ *
+ * The body walks the declarative `RULES` table — the inline regex
+ * match that lived here before #153 is now a single entry in
+ * `RULES`. This is the canonical pattern every classifier will
+ * converge on as part of the refactor; the legacy "one giant
+ * if/else cascade" is gone.
  */
 export declare function createImplementsClassifier(): VbaClassifier;
 /**

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

@@ -1,7 +1,27 @@
 import { VbaExtractorContext, ProcInfo, VbaClassifier } from './context';
+import { VbaExtractionRule } from './rules';
+/**
+ * Issue #153: the declarative rule table for the procedures concern.
+ * One rule — `procedure` — matches a `Sub` / `Function` /
+ * `Property Get|Let|Set` declaration and emits the function node,
+ * the `localProcs` / `functionNodeByName` / `functionNodeByStartLine`
+ * / `functionReturnTypes` registration, and (for form code-behind)
+ * the synthesized `event-handler` edge.
+ *
+ * The emit body is intentionally not split across multiple rules —
+ * these are 5+ small operations that all fire on the same declaration
+ * line. Splitting them would force the orchestrator to know they
+ * always co-occur, which is more coupling than the original cascade
+ * had. The pattern is the discriminating surface; everything past
+ * `match` is one emit.
+ */
+export declare const RULES: readonly VbaExtractionRule<unknown>[];
 /**
  * Issue #83: factory for the procedures classifier. Closure state: none
  * beyond `count` (the per-concern accumulators live on `ctx`).
+ *
+ * The body walks the declarative `RULES` table (Issue #153). The
+ * inline cascade that used to live here is now one entry in `RULES`.
  */
 export declare function createProceduresClassifier(): VbaClassifier;
 /**

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

@@ -0,0 +1,125 @@
+/**
+ * VbaExtractionRule — the declarative rule shape every VBA classifier
+ * exports as a `RULES: VbaExtractionRule[]` constant. Issue #153.
+ *
+ * Before this refactor the per-concern sweepers under `src/extraction/vba/`
+ * encoded their rules as inline `if (RE.test(line)) { ... }` branches
+ * inside `classifyLine`. Each branch was hard to enumerate, impossible
+ * to unit-test in isolation, and easy to silently drop when refactoring
+ * the body of a sweep. The rule table here promotes the pattern →
+ * emit-mapping to a typed object so:
+ *
+ *   1. Every rule has a stable `id` (used in error messages, logs, and
+ *      as a stable handle for tools that consume the rule table).
+ *   2. The pattern is explicit (single RegExp or RegExp[]) — the
+ *      dispatcher knows exactly what to test, no "branched control flow
+ *      around the regex".
+ *   3. The emit function is the ONLY side effect for the rule — pure
+ *      given (match, ctx, line, lineNum) → T | null. That makes the
+ *      rule trivially testable in isolation.
+ *   4. The `count?` hook lets a rule report "N symbols emitted" without
+ *      sharing an accumulator with the orchestrator (each rule owns
+ *      its own count semantics).
+ *
+ * Inter-line state (procedure stack, With stack, SQL variables) STILL
+ * lives on `VbaExtractorContext` — the rule table is per-line. The
+ * `classifyLine` orchestrator inside each classifier is the "shell"
+ * that maintains the state machine and walks the rule table.
+ */
+import type { VbaExtractorContext } from './context';
+/**
+ * A single per-line rule the orchestrator dispatches.
+ *
+ * @typeParam T - The shape `emit` returns. Most rules return
+ *   `void | null` because they push directly onto `ctx.nodes` /
+ *   `ctx.edges` (the canonical VBA sweep idiom). Rules that
+ *   synthesize a specific symbol can narrow `T` to the symbol's
+ *   shape so `count?` and downstream consumers get a typed handle.
+ *
+ * Fields:
+ *
+ *  - `id`        Stable, human-readable identifier (e.g. `'implements'`,
+ *                `'procedure'`, `'dim'`, `'sql-in-strings'`). The rule
+ *                table's primary key — every id within one file must be
+ *                unique. Used in error messages and in the test suite
+ *                that pins the table's shape.
+ *  - `description` One-line plain-English summary. Surfaced in tooling
+ *                that introspects the table.
+ *  - `pattern`   The regex (or regex alternatives) the dispatcher tests
+ *                against the per-line source. Either a single `RegExp`
+ *                or a non-empty `RegExp[]` (a rule is matched when ANY
+ *                of the alternatives matches). The dispatcher runs
+ *                `.exec()` for single regexes and iterates for arrays.
+ *  - `requires?` Optional structural gate. `'class'` means the rule
+ *                only fires inside a `.cls` file; `'module'` only in
+ *                `.bas`/`.frm`/`.dsr`; `'inside-procedure'` only when
+ *                `ctx.procStack.length > 0`. The orchestrator is
+ *                expected to honour this — keeping the gate declarative
+ *                lets the rule own its own preconditions instead of
+ *                scattering `if` checks into the rule body.
+ *  - `scan?`     `'masked'` = run on the string-literal-masked line
+ *                (so call patterns inside `"..."` are ignored), the
+ *                default. `'unmasked'` = run on the original line (so
+ *                SQL patterns inside `"..."` are caught). `'both'` =
+ *                dispatcher calls the rule twice, once with each line.
+ *  - `emit`      The per-match side effect. Receives the
+ *                `RegExpExecArray` from the pattern, the shared
+ *                `VbaExtractorContext`, the original (or masked) line,
+ *                and the 1-based line number. Returns the symbol it
+ *                emitted (used by `count?`) or `null` when the match
+ *                didn't apply (the caller is expected to skip
+ *                `count?` in that case).
+ *  - `count?`    Optional counter. When the rule emits exactly one
+ *                symbol per successful match the orchestrator can
+ *                treat `1` as the implicit count; the hook is for
+ *                rules whose emit can fan out (e.g. a multi-variable
+ *                `Dim a As Foo, b As Bar` line that produces two
+ *                `references` edges from one match).
+ *
+ * The `count` parameter is typed as `unknown` to keep the
+ * `VbaExtractionRule<T>` shape covariant in `T` — narrowing `T`
+ * (e.g. to `{ edges: number }` for the dim-decl fan-out rule) does
+ * NOT then force `count` to take that narrower type, which would
+ * break the `VbaExtractionRule<unknown>[]` aggregate. Rule
+ * authors cast inside their `count` body.
+ */
+export interface VbaExtractionRule<T = unknown> {
+    readonly id: string;
+    readonly description: string;
+    readonly pattern: RegExp | RegExp[];
+    readonly requires?: 'class' | 'module' | 'inside-procedure' | string;
+    readonly scan?: 'masked' | 'unmasked' | 'both';
+    readonly emit: (match: RegExpMatchArray, ctx: VbaExtractorContext, line: string, lineNum: number) => T | null;
+    readonly count?: (result: unknown) => number;
+}
+/**
+ * Helper to build a `VbaExtractionRule<T>` with a single RegExp.
+ * Most rules are 1-line declarations; this collapses the boilerplate
+ * to one place.
+ */
+export declare function defineRule<T = unknown>(spec: Omit<VbaExtractionRule<T>, 'pattern'> & {
+    pattern: RegExp;
+}): VbaExtractionRule<T>;
+/**
+ * Helper to build a `VbaExtractionRule<T>` whose `pattern` is an array
+ * of alternative regexes. The dispatcher treats the rule as matched
+ * when ANY alternative matches; it runs the alternatives in order and
+ * uses the first match's `RegExpExecArray` for `emit`.
+ */
+export declare function defineRuleAlternatives<T = unknown>(spec: Omit<VbaExtractionRule<T>, 'pattern'> & {
+    pattern: RegExp[];
+}): VbaExtractionRule<T>;
+/**
+ * Run a single rule's `pattern` against `line` and return the first
+ * match's `RegExpMatchArray`, or `null` when no alternative matches.
+ * `pattern` is `RegExp | RegExp[]` (an array means "match any of
+ * these alternatives"); this helper normalizes both into the same
+ * `RegExpMatchArray | null` shape the dispatcher's `emit` expects.
+ *
+ * Every classifier's `classifyLine` walks the declarative `RULES`
+ * table via this helper. Centralizing the RegExp/RegExp[] branching
+ * here keeps the per-classifier dispatcher loops trivial and avoids
+ * each classifier re-implementing the same boilerplate.
+ */
+export declare function matchRule(pattern: RegExp | RegExp[], line: string): RegExpMatchArray | null;
+//# sourceMappingURL=rules.d.ts.map

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

@@ -1,11 +1,87 @@
 import { ExtractionResult } from '../types';
+import type { VbaExtractionRule } from './vba/rules';
+/**
+ * Issue #152: per-file fanout cap for `RaiseEvent <EventName>` edges. An
+ * event raised from more than this many sites in a single file is
+ * flagged `metadata.highFanout: true` and ALL `raises-event` edges to it
+ * are dropped — the gate suppresses graph noise from events with generic
+ * names (`Change`, `Click`, `AfterUpdate`, …) that would otherwise
+ * produce hundreds of edges per file. Mirrors the upstream
+ * `EVENT_FANOUT_CAP` discipline in
+ * `src/resolution/callback-synthesizer.ts:43`. Configurable via
+ * `codegraph.json` → `vba.maxRaiseFanout`. Pass `Number.POSITIVE_INFINITY`
+ * (or any value `>=` the largest expected count) to disable the gate.
+ */
+export declare const DEFAULT_MAX_RAISE_FANOUT = 50;
+/**
+ * Issue #153: the orchestrator's aggregated view of every VBA
+ * classifier's declarative `RULES` table. Each entry is the
+ * `readonly VbaExtractionRule[]` constant exported by the
+ * corresponding classifier file. Exposed at module scope so:
+ *
+ *   1. Tests can pin the table shape and assert that the orchestrator
+ *      still references each table (a deleted import would
+ *      accidentally break a whole concern and the test would catch
+ *      the missing reference).
+ *   2. Tooling can introspect every rule the orchestrator
+ *      dispatches — useful for `codegraph stats` style UIs that
+ *      show "what kinds of VBA symbols does codegraph know about".
+ *   3. The `validateVbaRuleTables` invariant runs on this aggregate
+ *      so a refactor that empties one concern's `RULES` array
+ *      (e.g. by deleting the `defineRule` calls during a partial
+ *      migration) fails loudly at module load instead of silently
+ *      dropping a whole concern.
+ *
+ * The keys are the FILE BASENAMES of the classifier modules (no
+ * `.ts` extension, kebab-case) — the same naming convention the
+ * per-classifier export comments use. Stable identifier for
+ * `validateVbaRuleTables` consumers.
+ */
+export declare const VBA_RULE_TABLES: Readonly<Record<string, readonly VbaExtractionRule[]>>;
+/**
+ * Issue #153: validate that every per-concern rule table the
+ * orchestrator dispatches is non-empty. Called once at module load
+ * (see the IIFE at the bottom of this file) so an accidentally-
+ * emptied `RULES` array fails loudly when the extractor is first
+ * imported, NOT at the first `extract()` call.
+ *
+ * The result is `{ ok, empty }`:
+ *   - `ok: true`  — every required table has at least one rule.
+ *   - `ok: false` — at least one table is empty; `empty` lists the
+ *                   concern keys that need attention.
+ *
+ * The function accepts an optional `tables` argument so the unit
+ * test in `__tests__/extraction-vba-rule-table.test.ts` can verify
+ * the validator's contract independently of the live data.
+ */
+export declare function validateVbaRuleTables(tables?: Readonly<Record<string, readonly VbaExtractionRule[]>>): {
+    ok: boolean;
+    empty: string[];
+};
 export declare class VbaExtractor {
     private filePath;
     private source;
     private ctx;
     private vbaTargets?;
-    constructor(filePath: string, source: string, vbaTargets?: Record<string, boolean>);
+    /**
+     * Issue #152: per-file fanout cap for `RaiseEvent <EventName>` edges.
+     * When a single event is raised more than this many times in one file,
+     * the event node is flagged `metadata.highFanout: true` and ALL
+     * `raises-event` edges to it are dropped. Pass `undefined` to disable
+     * the gate (the legacy, uncapped behaviour). The 50 default lives in
+     * the orchestrator: callers that don't pass a value get the default.
+     */
+    private maxRaiseFanout;
+    constructor(filePath: string, source: string, vbaTargets?: Record<string, boolean>, maxRaiseFanout?: number);
     extract(): ExtractionResult;
+    /**
+     * Issue #156: emit the per-file timing block (mode `1` or `2`) and
+     * — in mode `2` — append the running aggregate. No-op when
+     * `mode === 'off'`. In aggregate mode we flush after every extract()
+     * call so the line is visible per-file even without a graceful
+     * shutdown (crash-on-file-3 still shows files 1-3 in the aggregate).
+     */
+    private maybeEmitTimings;
     private result;
     private isFormOrReportFile;
     private createFileNode;

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

@@ -96,7 +96,17 @@ export declare function stripVbaComments(src: string): string;
  * downstream extraction keeps source-line parity. Unsupported/unsafe
  * expressions evaluate to false rather than throwing.
  */
-export declare function preprocessConditionalCompilation(src: string, customTargets?: Record<string, boolean>): string;
+export declare function preprocessConditionalCompilation(src: string, customTargets?: Record<string, boolean>, 
+/**
+ * Issue #156: optional timing sink for the internal lexer+parser.
+ * When provided, the wall-clock spent inside `evaluateConditionalExpression`
+ * and `evaluateConstRhs` is accumulated under the key
+ * `preprocess.cc.lexer+parser` so the orchestrator can break the
+ * outer `preprocess.conditionalCompilation` stage into its outer +
+ * inner sub-totals. Undefined → no-op, zero cost (just the
+ * `if (timings)` null-check on every CC line).
+ */
+timings?: Map<string, number> | null): string;
 export interface StringLiteralSpan {
     /** The literal content (no surrounding quotes; `""` collapsed to `"`). */
     text: string;

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

@@ -0,0 +1,38 @@
+import { VbaExtractorContext, VbaClassifier } from './vba/context';
+export type TimingMode = 'off' | 'per-file' | 'aggregate';
+/**
+ * Read the timing mode from the env var. Reads are cached per call —
+ * the env var is consulted on every `extract()` but the result is just
+ * a number/string compare.
+ */
+export declare function readTimingMode(): TimingMode;
+/**
+ * Run `fn`, time the wall-clock, and record into `ctx.timings` under
+ * `stageName`. Returns the value `fn` returned. No-op when timings
+ * are disabled (the Map is null) — except the `performance.now()` pair,
+ * which is the irreducible cost of measuring anything.
+ *
+ * `performance.now()` is the right primitive here (monotonic, sub-ms
+ * resolution on every supported Node version). `Date.now()` would round
+ * to whole milliseconds and lose the per-stage signal on small files.
+ */
+export declare function withStage<T>(ctx: VbaExtractorContext, stageName: string, fn: () => T): T;
+/**
+ * Time a single `VbaClassifier.classifyLine` invocation. The accumulated
+ * time is reported under the bucket `classifier.<name>` so the
+ * aggregate stage totals match the per-classifier view.
+ */
+export declare function withClassifier(ctx: VbaExtractorContext, classifier: VbaClassifier, line: string, index: number): void;
+/**
+ * Per-file stderr block. Cheap string-build; the per-extract call cost
+ * is bounded by the small number of stages (~10).
+ */
+export declare function emitPerFileTimings(ctx: VbaExtractorContext, filePath: string): void;
+export declare function recordAggregateTimings(ctx: VbaExtractorContext, _filePath: string): void;
+export declare function flushAggregate(): void;
+/**
+ * Test-only: clear the aggregate between test cases so they do not
+ * pollute each other. Not exported in the public API.
+ */
+export declare function _resetAggregateForTests(): void;
+//# sourceMappingURL=vba-timing.d.ts.map

package/dist/project-config.d.ts

@@ -25,6 +25,27 @@ export interface ProjectConfig {
     exclude?: string[];
     vba?: {
         targets?: Record<string, boolean>;
+        /**
+         * Per-file fanout cap for `RaiseEvent <EventName>` edges (#152). When
+         * a single event (by name) is raised from more than this many sites
+         * in one file, the event node is flagged `metadata.highFanout: true`
+         * and ALL `raises-event` edges to it are dropped — the gate suppresses
+         * graph noise from events with generic names (`Change`, `Click`,
+         * `AfterUpdate`, …) that would otherwise produce hundreds of edges per
+         * file. Defaults to 50 when unset; the event node itself (declaration
+         * site, handler linkage via `subscribes-event`) is preserved.
+         */
+        maxRaiseFanout?: number;
+        /**
+         * Run the Dysflow-specific extractors (form/report SaveAsText, test
+         * manifests, test sequences) on top of the base VBA extractor. Set to
+         * `false` to opt out — useful for projects that carry legacy
+         * `.form.txt`/`.report.txt` files (or test-manifest JSON from a
+         * different system) and want them tracked as just a `file` node
+         * instead of being expanded into the graph (issue #154). Defaults to
+         * `true`.
+         */
+        dysflowExport?: boolean;
     };
     /**
      * Gitignore-style patterns for first-party source to force INTO the index even
@@ -43,7 +64,17 @@ export interface ProjectConfig {
 }
 export declare function loadVbaConfig(rootDir: string): {
     targets?: Record<string, boolean>;
+    maxRaiseFanout?: number;
+    dysflowExport?: boolean;
 };
+/**
+ * Load the validated `vba.dysflowExport` flag for a project, mtime-cached
+ * (issue #154). Returns `true` when the flag is absent — the default keeps
+ * the legacy Dysflow-specific extractors running so existing users see no
+ * behavioral change. `false` opts out, so `.form.txt`/`.report.txt`/test
+ * manifest/sequence files are tracked as just a `file` node.
+ */
+export declare function loadDysflowExportConfig(rootDir: string): boolean;
 /**
  * Load the validated extension overrides for a project, mtime-cached.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aroman22/codegraph-vba",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Local-first code intelligence for AI agents (MCP). Self-contained — bundles its own runtime.",
   "bin": {
     "codegraph-vba": "npm-shim.js"
@@ -15,12 +15,12 @@
     "./package.json": "./package.json"
   },
   "optionalDependencies": {
-    "@aroman22/codegraph-vba-darwin-arm64": "1.10.0",
-    "@aroman22/codegraph-vba-darwin-x64": "1.10.0",
-    "@aroman22/codegraph-vba-linux-arm64": "1.10.0",
-    "@aroman22/codegraph-vba-linux-x64": "1.10.0",
-    "@aroman22/codegraph-vba-win32-arm64": "1.10.0",
-    "@aroman22/codegraph-vba-win32-x64": "1.10.0"
+    "@aroman22/codegraph-vba-darwin-arm64": "1.11.0",
+    "@aroman22/codegraph-vba-darwin-x64": "1.11.0",
+    "@aroman22/codegraph-vba-linux-arm64": "1.11.0",
+    "@aroman22/codegraph-vba-linux-x64": "1.11.0",
+    "@aroman22/codegraph-vba-win32-arm64": "1.11.0",
+    "@aroman22/codegraph-vba-win32-x64": "1.11.0"
   },
   "files": [
     "npm-shim.js",