@aroman22/codegraph-vba 1.15.0 → 1.17.0

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

@@ -1,4 +1,4 @@
-import { VbaExtractorContext, VbaClassifier } from './context';
+import { VbaClassifier } from './context';
 import { VbaExtractionRule } from './rules';
 /**
  * Issue #153: the declarative rule table for the Dim / WithEvents
@@ -34,12 +34,16 @@ export declare const RULES: readonly VbaExtractionRule<unknown>[];
  * 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.
+ * handles WithEvents.
+ *
+ * Issue #205: the classifier maintains a closure-local proc stack
+ * (parallel to the calls-sweep's `ctx.procStack` in
+ * `call-sweep.ts:213`) and writes the top of that stack into
+ * `ctx.currentVarTypeProcKey` so `localVarTypeMap` writes are scoped
+ * to the procedure whose body the `Dim` is inside (or `'module'`
+ * when no procedure is open). The two stacks track the same
+ * `PROC_RE` / `PROCEDURE_END_RE` boundaries so they stay in sync at
+ * every line.
  */
 export declare function createDimsClassifier(): VbaClassifier;
-/**
- * Backward-compat wrapper (see procedures.ts). Returns the classifier's
- * `count` so the orchestrator can decide `hasAnySymbols`.
- */
-export declare function sweepDimsAndWithEvents(ctx: VbaExtractorContext, src: string): number;
 //# sourceMappingURL=dims.d.ts.map

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

@@ -5,12 +5,39 @@ import { VbaExtractorContext, ProcInfo } from './context';
  * 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;
+export declare function scanDoCmdOpenCalls(ctx: VbaExtractorContext, line: string, maskedLine: 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;
+export declare function scanDoCmdOpenQuery(ctx: VbaExtractorContext, line: string, maskedLine: string, caller: ProcInfo, lineNum: number): void;
+/**
+ * Issue #246 (task T4): scan one line of VBA source for
+ * `DoCmd.Close acForm|acReport, "<Name>"`.
+ *
+ * Each match emits ONE `references` edge -- not a new edge kind -- from the
+ * calling procedure to the very same `form-layout` / `report-layout` stub
+ * that `opens-form` / `opens-report` already point at, by reusing
+ * `resolveOpensStubId`'s cache. A form that is both opened and closed
+ * therefore ends up with ONE node carrying two distinct edges.
+ *
+ * The edge carries `synthesizedBy: 'vba-closes-form'` for both object types
+ * (one tag for the whole verb keeps every close edge queryable as a set) and
+ * `targetFormName` as its single name key, for the same reason. If a
+ * first-class `closes-form` edge kind is ever wanted, that tag is the seam.
+ */
+export declare function scanDoCmdCloseCalls(ctx: VbaExtractorContext, line: string, maskedLine: string, caller: ProcInfo, lineNum: number): void;
+/**
+ * Issue #254: scan one line of VBA source for every `DoCmd` verb in
+ * `DOCMD_OBJECT_DISPATCH`. Each match whose object argument resolves to a
+ * static name emits ONE `UnresolvedReference` — no node, ever.
+ *
+ * `maskedLine` has string CONTENT blanked out, so the `docmd` prefix check
+ * rejects a verb name that only appears inside a string literal. The object
+ * name itself lives inside a literal, which is why the split runs on the
+ * original `line`.
+ */
+export declare function scanDoCmdObjectCalls(ctx: VbaExtractorContext, line: string, maskedLine: string, caller: ProcInfo, lineNum: number): void;
 //# sourceMappingURL=docmd.d.ts.map

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

@@ -1,4 +1,4 @@
-import { VbaExtractorContext, VbaClassifier } from './context';
+import { VbaClassifier } from './context';
 import { VbaExtractionRule } from './rules';
 /**
  * Issue #153: the declarative rule table for the enum / const concern.
@@ -26,8 +26,9 @@ import { VbaExtractionRule } from './rules';
  *                      + `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
+ * This classifier exclusively owns the inter-line `ctx.procStack` /
+ * `ctx.currentProcKey` state. The calls/SQL classifier keeps its own
+ * `ProcInfo` stack and only reads the shared current-scope key. The
  * `ctx.vbaEnumBlock` state is local to this concern and lives on
  * `ctx` for the same RULES-table-friendliness reason as
  * `vbaDeclTypeBlock`.
@@ -42,17 +43,9 @@ export declare const RULES: readonly VbaExtractionRule<unknown>[];
  * `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.
+ * A fresh `VbaExtractorContext` owns fresh stack state; classifiers never
+ * lazily reset it. This makes the result independent of whether a procedure
+ * begins on the first or a later physical line.
  */
 export declare function createEnumsConstsClassifier(): VbaClassifier;
-/**
- * Backward-compat wrapper (see procedures.ts). Returns the classifier's
- * `count` so the orchestrator can decide `hasAnySymbols`.
- */
-export declare function sweepEnumsAndConsts(ctx: VbaExtractorContext, src: string): number;
 //# sourceMappingURL=enums-consts.d.ts.map

package/dist/extraction/vba/error-channel.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The channel names used when `codegraph.json` → `vba.errorChannel` is absent.
+ *
+ * `m_Error` / `p_Error` are the private module-variable spellings, `g_Error`
+ * the global one, and `Error` the public field a caller reads off the object
+ * (`m_ObjRiesgoActivo.Error`). Identical to the probe's
+ * `DEFAULT_ERROR_CHANNEL_NAMES` — `scripts/vba-coverage-probe.mjs` measured
+ * the census this task is accepted against, so the two lists must agree.
+ */
+export declare const DEFAULT_ERROR_CHANNEL_NAMES: readonly string[];
+/** A channel entry is a bare VBA identifier — nothing qualified, no regex. */
+export declare const ERROR_CHANNEL_ENTRY_RE: RegExp;
+/**
+ * The per-extractor compiled channel. Built ONCE per `VbaExtractor` and parked
+ * on `VbaExtractorContext`, for the same reason `CompiledSqlWrappers` is: the
+ * name lookup runs per identifier per line, and the write matcher per statement
+ * per line, so neither may be rebuilt inside the line loop.
+ *
+ * NOT structured-cloneable (it holds a `Set` and `RegExp`s) — which is exactly
+ * why `VbaExtractionOptions.errorChannel` carries plain strings across the
+ * worker boundary and the compilation happens on the far side.
+ */
+export interface CompiledErrorChannel {
+    /** The channel names, defaults first, project entries appended. Display form. */
+    readonly names: readonly string[];
+    /** Lowercased `names`, for the per-identifier membership test. VBA is case-insensitive. */
+    readonly lookup: ReadonlySet<string>;
+    /**
+     * One anchored regex per name: the channel in the assignment-TARGET position
+     * of a statement — bare (`p_Error = …`), `Me.`-qualified (`Me.Error = …`) or
+     * object-qualified (`obj.Error = …`).
+     *
+     * Anchoring at the start of the statement is the whole precision of this
+     * matcher: it is what separates a WRITE from a READ, so the house guard
+     * `If m_Error <> "" Then` and the copy `x = m_Error` both correctly miss.
+     * Kept identical to the probe's `buildChannelWriteMatcher`.
+     */
+    readonly writeRes: readonly RegExp[];
+}
+/**
+ * Compile the channel from the plain-string config entries.
+ *
+ * `configured` entries are APPENDED to {@link DEFAULT_ERROR_CHANNEL_NAMES},
+ * never substituted for them — same contract as `vba.sqlWrappers`: a project
+ * that names its own `lastFailure` field must not lose `m_Error` in the trade,
+ * because in a codebase this size the two conventions coexist. Blank, dotted
+ * and otherwise non-identifier entries are dropped here; `project-config.ts`
+ * has already warned about them at load time.
+ */
+export declare function compileErrorChannel(configured?: readonly string[]): CompiledErrorChannel;
+export declare function defaultErrorChannel(): CompiledErrorChannel;
+/**
+ * Is `name` the error channel? A WHOLE-name, case-insensitive test — the
+ * single reason `ErrorCount` does not match `Error`, pinned by a test.
+ */
+export declare function isErrorChannelName(channel: CompiledErrorChannel, name: string): boolean;
+//# sourceMappingURL=error-channel.d.ts.map

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

@@ -0,0 +1,64 @@
+import { VbaClassifier, VbaExtractorContext, VbaErrorPolicyState } from './context';
+import { VbaExtractionRule } from './rules';
+/**
+ * The error-propagation channel this corpus actually uses: a module-level or
+ * object field the failing procedure writes and the caller reads. §2.3 of the
+ * plan measures 3,602 handlers touching it against 16 that re-raise — VBA's
+ * own error mechanism unwinds one frame, the MESSAGE travels through one of
+ * these variables.
+ *
+ * Names only, never substrings, so `ErrorCount` cannot match `Error`.
+ *
+ * Issue #261 (task E4) moved this list — and the write matcher built from it —
+ * into `./error-channel`, so the two consumers can no longer fork: this
+ * classifier asks "is this statement a channel WRITE?", `module-vars.ts` asks
+ * "is this variable the channel?", and both now read one compiled object that
+ * `codegraph.json` → `vba.errorChannel` extends. Re-exported from here because
+ * this module was its home and the probe-agreement suite imports it.
+ */
+export { DEFAULT_ERROR_CHANNEL_NAMES } from './error-channel';
+/**
+ * Calls that make an error visible to a human. `MsgBox` is the form-code
+ * shape, `Debug.Print` the developer-only one; §2.3 counts both as "display",
+ * so this list — identical to the probe's `DEFAULT_DISPLAY_CALLS` — does too.
+ */
+export declare const DEFAULT_DISPLAY_CALLS: readonly string[];
+/** A fresh accumulator for a procedure body opening at `startLine`. */
+export declare function newErrorPolicyState(startLine: number, edgeMark: number, refMark: number): VbaErrorPolicyState;
+/**
+ * Issue #259: the declarative rule table for the error-policy concern. All
+ * four rules are `scan: 'masked'` and `requires: 'inside-procedure'`.
+ *
+ * `masked` is the #209 discipline: `s = "On Error GoTo errores"` is a string
+ * assignment, and a classifier that reads it as a handler would report a
+ * protected procedure that is not protected. `inside-procedure` is what keeps
+ * module-level noise out — there is no error policy without a procedure to
+ * attach it to.
+ *
+ * The three `On Error` rules re-scan their own line globally instead of
+ * acting on the dispatcher's single match, so a colon-separated single-line
+ * procedure carrying two `On Error GoTo` statements counts two.
+ */
+export declare const RULES: readonly VbaExtractionRule<unknown>[];
+/**
+ * Fold the open accumulator into the procedure's `metadata.errorPolicy` and
+ * clear it. `endLine` is the procedure's terminating `End` line — the handler
+ * region's closing boundary.
+ *
+ * Called from three places: the `End Sub` boundary (the normal path), a new
+ * procedure declaration while a body is somehow still open (malformed VBA
+ * with no `End`), and end-of-file. All three converge on the same shape, so a
+ * truncated module still records a policy instead of silently dropping it.
+ */
+export declare function closeErrorPolicy(ctx: VbaExtractorContext, endLine: number): void;
+/**
+ * Issue #259: factory for the error-policy classifier.
+ *
+ * `count` stays at 0 for the life of the classifier, deliberately. The
+ * orchestrator derives `hasAnySymbols` from the sum of every classifier's
+ * `count`, and this one emits no symbols at all — it only annotates nodes the
+ * procedures sweep already created. Letting it count would make a file whose
+ * only content is an `On Error` line look like a file with symbols.
+ */
+export declare function createErrorPolicyClassifier(): VbaClassifier;
+//# sourceMappingURL=errors.d.ts.map

package/dist/extraction/vba/filesystem-statements.d.ts

@@ -0,0 +1,23 @@
+import type { ProcInfo, VbaExtractorContext } from './context';
+export declare const VBA_FILESYSTEM_STATEMENT_SYNTHESIZED_BY: "vba-filesystem-statement";
+export type VbaFilesystemOperation = 'kill' | 'open' | 'close';
+/**
+ * Parse only the intrinsic grammar-shaped statement forms. The input must be a
+ * single string-masked statement clause, so quoted keywords remain opaque while
+ * valid string operands retain their token shape.
+ */
+export declare function detectVbaFilesystemStatement(statement: string): VbaFilesystemOperation | null;
+/**
+ * The shared provenance gate used by both resolution and runtime
+ * classification. Name, kind, language, family, and operation must agree; a
+ * copied or partially forged metadata stamp is rejected.
+ */
+export declare function isExactVbaFilesystemStatementReference(ref: {
+    language?: string | null;
+    referenceKind?: string | null;
+    referenceName?: string | null;
+    metadata?: Record<string, unknown> | null;
+}): boolean;
+/** Emit one typed unresolved runtime reference from the containing procedure. */
+export declare function emitVbaFilesystemStatementReference(ctx: VbaExtractorContext, caller: ProcInfo, statement: string, lineNum: number): boolean;
+//# sourceMappingURL=filesystem-statements.d.ts.map

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

@@ -1,4 +1,4 @@
-import { VbaExtractorContext, VbaClassifier } from './context';
+import { VbaClassifier } from './context';
 import { VbaExtractionRule } from './rules';
 /**
  * Issue #153: the declarative rule table for the implements concern.
@@ -19,9 +19,4 @@ export declare const RULES: readonly VbaExtractionRule<unknown>[];
  * if/else cascade" is gone.
  */
 export declare function createImplementsClassifier(): VbaClassifier;
-/**
- * Backward-compat wrapper (see procedures.ts). Returns the classifier's
- * `count` so the orchestrator can decide `hasAnySymbols`.
- */
-export declare function sweepImplements(ctx: VbaExtractorContext, src: string): number;
 //# sourceMappingURL=implements.d.ts.map

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

@@ -0,0 +1,26 @@
+import type { VbaErrorPolicy, VbaErrorPolicyState, VbaExtractorContext } from './context';
+/** `handles-error` edges and their unresolved twin carry this provenance. */
+export declare const ERROR_HANDLER_SYNTHESIZED_BY = "vba-error-handler";
+/** A plain `GoTo <label>` jump — a generic `references` edge. */
+export declare const GOTO_SYNTHESIZED_BY = "vba-goto";
+/**
+ * A `GoTo` (plain or `On Error`) naming a label the procedure never defines.
+ * One shared tag for both, because from a consumer's point of view they are
+ * the same defect: a jump with no landing site.
+ */
+export declare const GOTO_UNRESOLVED_SYNTHESIZED_BY = "vba-goto-unresolved";
+/**
+ * Emit this procedure's `label` nodes and the three edge shapes that reach
+ * them, then hand control back to `closeErrorPolicy`.
+ *
+ * `policy` is the object that was just folded from `state`; it is read, never
+ * recomputed. `endLine` is the procedure's terminating `End` line.
+ *
+ * Ordering matters and is the caller's responsibility: this runs BEFORE
+ * #260's `markErrorHandlerRegion`, so a `GoTo` or a second `On Error GoTo`
+ * written inside the handler region is stamped `metadata.inErrorHandler` by
+ * that single stamping point like every other edge, instead of quietly
+ * becoming the one emitter that opted out of it.
+ */
+export declare function emitLabelNodes(ctx: VbaExtractorContext, state: VbaErrorPolicyState, policy: VbaErrorPolicy, endLine: number): void;
+//# sourceMappingURL=labels.d.ts.map

package/dist/extraction/vba/module-vars.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Module-level variable read/write sweep (issue #251).
+ *
+ * The dims classifier emits one `variable` node per module-level
+ * declaration and registers the name on `ctx.moduleVariables`. A node
+ * nobody points at answers nothing, so this sweep supplies the other
+ * half: for every procedure body line, an identifier that matches one of
+ * THIS FILE's module-level variable names becomes an
+ * `UnresolvedReference` tagged `synthesizedBy: 'vba-module-var'`, with
+ * `referenceKind: 'property-get'` for a read and `'property-set'` for a
+ * write.
+ *
+ * The gate is the whole design. The sweep never looks for "identifiers
+ * that might be variables"; it only ever asks whether a name is already
+ * registered as a module-level variable of the module being extracted.
+ * Any looser rule turns a codebase-wide sweep into thousands of
+ * references to names that merely collide.
+ *
+ * Issue #261 adds ONE field on top: when the matched variable is the project's
+ * error channel (`m_Error`, `p_Error`, … — see `./error-channel`), the
+ * reference also carries `metadata.errorChannel: true`. No new node kind, no
+ * new edge kind and not a single extra row: the propagation chain
+ * `inner procedure --property-set--> m_Error --property-get--> caller` is the
+ * one this sweep already emits, and the flag is what makes it identifiable as
+ * error flow instead of ordinary module state.
+ */
+import { VbaExtractorContext, ProcInfo } from './context';
+/**
+ * Scan one procedure-body line for reads and writes of this module's
+ * module-level variables.
+ *
+ * `line` must be the string-literal-masked line: a variable name that
+ * appears inside `"…"` is prose, not an access.
+ */
+export declare function scanModuleVariableReferences(ctx: VbaExtractorContext, line: string, from: ProcInfo, lineNum: number): void;
+//# sourceMappingURL=module-vars.d.ts.map

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

@@ -0,0 +1,88 @@
+/**
+ * `VbaExtractionOptions` — the single object that carries every VBA
+ * extraction knob from `codegraph.json` down to `VbaExtractor` (issue #243).
+ *
+ * ## Why this module exists
+ *
+ * The knobs used to travel as positional parameters through five files:
+ *
+ * ```
+ * project-config.ts  loadVbaConfig()
+ *   -> extraction/index.ts     reads vbaConfig
+ *     -> extraction/parse-pool.ts  ParseTask fields
+ *       -> extraction/parse-worker.ts  message shape
+ *         -> extraction/tree-sitter.ts extractFromSource(..., vbaTargets, maxRaiseFanout, ...)
+ *           -> new VbaExtractor(filePath, source, vbaTargets, maxRaiseFanout)
+ * ```
+ *
+ * Every new knob meant editing all five signatures and every call site. One
+ * object collapses that to "add a field here, read it in the extractor".
+ *
+ * ## Worker-boundary constraint — READ BEFORE ADDING A FIELD
+ *
+ * This object crosses the `parse-pool` -> `parse-worker` boundary through
+ * `worker.postMessage`, which is `structuredClone`-based. Every field MUST be
+ * plain, structured-cloneable data: primitives, plain objects, and arrays of
+ * those. NO functions, NO `RegExp`, NO `Map`/`Set`, NO class instances — a
+ * function throws `DataCloneError` at the boundary and a `RegExp` silently
+ * loses its `lastIndex`/identity semantics.
+ *
+ * A derived value that is not cloneable (a compiled wrapper `RegExp`, a
+ * lookup `Map`) belongs on the extractor context, built inside the extractor
+ * from the plain data in this object.
+ *
+ * This module is a LEAF: it imports nothing, so the config layer, the pool,
+ * the worker, and the extractor can all depend on it without a cycle.
+ */
+/**
+ * Every VBA-specific extraction knob, in one structured-cloneable object.
+ *
+ * All fields are optional; `{}` is the zero-config default and must behave
+ * exactly like the pre-#243 "caller passed nothing" path.
+ */
+export interface VbaExtractionOptions {
+    /**
+     * Conditional-compilation targets — the `#Const` name -> truth map used to
+     * decide which `#If` branches stay active. Sourced from `codegraph.json` ->
+     * `vba.targets`. Undefined means "no project overrides"; the preprocessor
+     * falls back to its built-in defaults.
+     */
+    targets?: Record<string, boolean>;
+    /**
+     * Issue #152: per-file fanout cap for `RaiseEvent <EventName>` edges. An
+     * event raised from more than this many sites in one file is flagged
+     * `metadata.highFanout: true` and ALL its `raises-event` edges are dropped.
+     * Undefined means the caller did not choose, so `VbaExtractor` applies
+     * `DEFAULT_MAX_RAISE_FANOUT` (50). Sourced from `codegraph.json` ->
+     * `vba.maxRaiseFanout`.
+     */
+    maxRaiseFanout?: number;
+    /**
+     * Names of project-specific procedures that wrap a SQL execution call
+     * (e.g. a shared `EjecutarSQL(sql)` helper), so a call to one of them is
+     * treated as a SQL execution site instead of an ordinary call.
+     *
+     * Declared here now and threaded end-to-end by #243; the SQL-wrapper task
+     * is the consumer. Kept as a `readonly string[]` of plain strings — the
+     * compiled matcher built from these names is NOT cloneable and therefore
+     * belongs on the extractor context, never in this object.
+     */
+    sqlWrappers?: readonly string[];
+    /**
+     * Issue #261 — the module-level variable names this project uses to carry
+     * an error message from where it happened to where the user sees it
+     * (`m_Error`, `p_Error`, a project's own `lastFailure`). A read or write of
+     * one of them is flagged `metadata.errorChannel: true`, and a handler that
+     * writes one is classified `behavior: 'channel'`.
+     *
+     * Bare VBA identifiers, matched as WHOLE names — never substrings, never
+     * user-supplied regex (this runs per identifier per line, the same reasoning
+     * `sqlWrappers` was built on). Sourced from `codegraph.json` →
+     * `vba.errorChannel`, and EXTENDS the built-in list rather than replacing
+     * it. Kept as plain strings for the same reason `sqlWrappers` is: the
+     * compiled `Set`/`RegExp` form cannot cross the `structuredClone` worker
+     * boundary, so it is built on the extractor context instead.
+     */
+    errorChannel?: readonly string[];
+}
+//# sourceMappingURL=options.d.ts.map

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

@@ -0,0 +1,35 @@
+/**
+ * Issue #257 (task T16, half A): turn a procedure's already-parsed signature
+ * into `parameter` nodes.
+ *
+ * This module is EMISSION ONLY. The signature was parsed once by
+ * `signature.ts` — after the preprocessor joined `_` line continuations — and
+ * stamped onto the `function` node's `metadata.params` by `procedures.ts`.
+ * The same `VbaParameterInfo[]` is handed here, so a continued signature and
+ * its one-line equivalent produce byte-identical nodes by construction. Never
+ * re-parse the declaration line here; that is how the two views drift.
+ */
+import { Node } from '../../types';
+import { VbaExtractorContext } from './context';
+import type { VbaParameterInfo } from './signature';
+/**
+ * Emit one `parameter` node per declared parameter of `procedureNode`, the
+ * `contains` edge that binds it to its procedure, and — for a non-primitive
+ * declared type — a `type_of` edge onto the type's node.
+ *
+ * Parameters have no line of their own: VBA writes them inside the procedure
+ * header, and after continuation joining even the physical line is a fiction.
+ * So `startLine` / `endLine` are the procedure's declaration line, and the id
+ * is disambiguated by `<Procedure>.<param>` rather than by position — two
+ * accessors of the same property (`Property Get X` / `Property Let X`) sit on
+ * different lines and therefore still get distinct ids.
+ *
+ * `qualifiedName` is `<ModuleOrClass>.<Procedure>.<param>`, using
+ * `ctx.moduleName` (the resolved `Attribute VB_Name`, or the basename) rather
+ * than `ctx.classNamePrefix` — the latter is `null` for a `.bas`, and a
+ * parameter of a module-level Sub wants the module prefix just as much as a
+ * class method's does. Same choice the module-level `variable` nodes made in
+ * issue #251.
+ */
+export declare function emitParameterNodes(ctx: VbaExtractorContext, procedureNode: Node, params: readonly VbaParameterInfo[], lineNum: number, line: string): void;
+//# sourceMappingURL=parameters.d.ts.map

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

@@ -1,4 +1,4 @@
-import { VbaExtractorContext, ProcInfo, VbaClassifier } from './context';
+import { VbaClassifier } from './context';
 import { VbaExtractionRule } from './rules';
 /**
  * Issue #153: the declarative rule table for the procedures concern.
@@ -17,12 +17,4 @@ import { VbaExtractionRule } from './rules';
  */
 export declare const RULES: readonly VbaExtractionRule<unknown>[];
 export declare function createProceduresClassifier(): VbaClassifier;
-/**
- * Backward-compat wrapper: pre-#83 callers (e.g. legacy test fixtures)
- * used `sweepProcedures(ctx, src)` and got back the ProcInfo[].
- * Now it returns `ctx.procedures` (the same flat list the factory
- * appends to). The implementation still calls the classifier once per
- * pre-split line, so the count is identical to the new walker path.
- */
-export declare function sweepProcedures(ctx: VbaExtractorContext, src: string): ProcInfo[];
 //# sourceMappingURL=procedures.d.ts.map

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

@@ -50,10 +50,8 @@ import type { VbaExtractorContext } from './context';
  *                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
+ *  - `requires?` Optional structural gate from the closed
+ *                `VbaRuleRequirement` union. 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.
@@ -75,6 +73,8 @@ import type { VbaExtractorContext } from './context';
  *                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).
+ *  - `terminal?` Stop dispatch after this rule matches, without coupling
+ *                dispatcher control flow to a rule id.
  *
  * The `count` parameter is typed as `unknown` to keep the
  * `VbaExtractionRule<T>` shape covariant in `T` — narrowing `T`
@@ -87,11 +87,14 @@ export interface VbaExtractionRule<T = unknown> {
     readonly id: string;
     readonly description: string;
     readonly pattern: RegExp | RegExp[];
-    readonly requires?: 'class' | 'module' | 'inside-procedure' | string;
+    readonly requires?: VbaRuleRequirement;
     readonly scan?: 'masked' | 'unmasked' | 'both';
+    readonly terminal?: boolean;
     readonly emit: (match: RegExpMatchArray, ctx: VbaExtractorContext, line: string, lineNum: number) => T | null;
     readonly count?: (result: unknown) => number;
 }
+export type VbaRuleRequirement = 'inside-procedure' | 'inside-type-block' | 'outside-type-block' | 'inside-enum-block' | 'outside-enum-block';
+export type VbaRuleGates = Partial<Record<VbaRuleRequirement, boolean>>;
 /**
  * Helper to build a `VbaExtractionRule<T>` with a single RegExp.
  * Most rules are 1-line declarations; this collapses the boilerplate
@@ -126,4 +129,6 @@ export declare function matchRuleForScan(rule: VbaExtractionRule, line: string,
     match: RegExpMatchArray;
     line: string;
 } | null;
+/** Dispatch a rule table with consistent scan, gate, count, and terminal semantics. */
+export declare function runRules(rules: readonly VbaExtractionRule[], ctx: VbaExtractorContext, line: string, maskedLine: string, lineNum: number, gates: VbaRuleGates): number;
 //# sourceMappingURL=rules.d.ts.map

package/dist/extraction/vba/runtime-objects.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Canonical list of VBA/Access runtime objects and singletons whose
+ * `Receiver.Member` calls are NEVER user-defined code — DAO, FileSystemObject
+ * (`fso`), intrinsic collections, error/debug intrinsics, late-binding
+ * factories, and Access application singletons.
+ *
+ * Issue #245: this used to be TWO literal sets written at different times.
+ * `RUNTIME_OBJECTS` (formerly in `src/resolution/vba-runtime-objects.ts`)
+ * decided whether a synthetic call EDGE was stamped `declined-runtime`;
+ * `RUNTIME_RECEIVER_BLACKLIST` (formerly a second literal in
+ * `./constants.ts`) decided whether the call-site scan looked at a receiver
+ * at all. Because the second list omitted `VBA`, `fso`, `Collection`,
+ * `ListBox` and friends, the extractor still synthesized a `function` NODE
+ * for every one of those calls — 6,132 stub nodes against 3,840 real
+ * procedures on the reference corpus. Edge consumers can filter on
+ * `repointDecision`; symbol search and node counts cannot.
+ *
+ * The two sets are now one literal (`RUNTIME_OBJECT_DEFS`) with two derived
+ * views, so they can never drift apart again:
+ *
+ *   - `RUNTIME_OBJECTS` — every canonical name, lowercased, for the
+ *     case-insensitive `isRuntimeObject` predicate. Consumed by the
+ *     post-extraction stub resolver (`ReferenceResolver.resolveVbaCallStubTarget`)
+ *     to DECLINE repointing a stub whose receiver is a runtime object, and by
+ *     the extractor's stub-NODE gate in `./calls.ts`.
+ *   - `RUNTIME_RECEIVER_BLACKLIST` — the case-sensitive PascalCase subset
+ *     flagged `blocksCallScan`. These receivers/members are dropped by the
+ *     call-site scans BEFORE any reference is surfaced, so the set is
+ *     deliberately narrow: widening it would silently delete
+ *     `unresolved_refs` rows. Widening the canonical set is safe; promoting
+ *     an entry to `blocksCallScan` is not.
+ *
+ * A user class or module that happens to share a runtime-object name (a
+ * "shadow" declaration, e.g. a user `.cls` literally named `DAO`) is still
+ * linked by the resolver: it runs its normal two-step name resolution FIRST
+ * and only falls back to this list when no real target exists (FR-2.1).
+ *
+ * This module is a LEAF: it imports nothing. `src/extraction/` must not
+ * depend on `src/resolution/`, so the canonical set lives here and
+ * `src/resolution/vba-runtime-objects.ts` re-exports it — every existing
+ * resolver import keeps working unchanged.
+ */
+/**
+ * Every canonical runtime-object name, lowercased so matching is
+ * case-insensitive against a receiver as it appears in source.
+ */
+export declare const RUNTIME_OBJECTS: ReadonlySet<string>;
+/**
+ * Derived view: the case-sensitive receivers/members the call-site scans drop
+ * before surfacing anything. NOT a second literal — see `blocksCallScan`.
+ */
+export declare const RUNTIME_RECEIVER_BLACKLIST: ReadonlySet<string>;
+/**
+ * True iff `receiver` (any case) names a known VBA/Access runtime object.
+ * Leading/trailing brackets and surrounding whitespace are stripped
+ * defensively so a bracketed receiver (`[DAO]`) still matches.
+ */
+export declare function isRuntimeObject(receiver: string | null | undefined): boolean;
+//# sourceMappingURL=runtime-objects.d.ts.map

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

@@ -0,0 +1,57 @@
+/**
+ * Issue #250 (task T8): parse a VBA procedure's parameter list off its
+ * declaration line.
+ *
+ * The line handed in here has already been through the preprocessor, so a
+ * signature split with `_` continuations arrives as ONE logical line and a
+ * trailing `'` comment is already gone. This module must never re-implement
+ * continuation joining — see `vba-preprocess.ts` and issue #202.
+ */
+/** One declared parameter of a `Sub` / `Function` / `Property` signature. */
+export interface VbaParameterInfo {
+    /** Declared name, original casing, brackets unwrapped. */
+    name: string;
+    /** The `As <Type>` type, or `null` for an implicitly-`Variant` parameter. */
+    type: string | null;
+    /**
+     * `true` unless the declaration says `ByVal`. VBA passes by reference by
+     * default, so an unqualified parameter really is a `ByRef` one.
+     */
+    byRef: boolean;
+    /** The literal `Optional` keyword was present. */
+    optional: boolean;
+    /** Declared as an array — `name()`. */
+    isArray: boolean;
+    /** An `= <default>` clause was present. */
+    hasDefault: boolean;
+}
+/**
+ * Declared arity. `total` is `null` — not `Infinity` — when the signature ends
+ * in a `ParamArray`, because this value is serialised into node metadata and
+ * crosses the parse-worker boundary, and JSON has no `Infinity`.
+ */
+export interface VbaArity {
+    required: number;
+    total: number | null;
+}
+/** The parsed shape of one procedure signature. */
+export interface VbaSignatureInfo {
+    params: VbaParameterInfo[];
+    arity: VbaArity;
+}
+/**
+ * Split a parameter-list body on its top-level commas. Depth- and
+ * string-aware, so `Optional s As String = "a,b"` stays one entry.
+ */
+export declare function splitParameterList(body: string): string[];
+/**
+ * Parse the signature of the procedure whose name ends at `nameEndIndex`.
+ *
+ * A `ParamArray` tail is excluded from `arity.required` (it accepts zero
+ * arguments) and forces `arity.total` to `null` (it accepts any number). The
+ * `ParamArray` parameter itself is still reported in `params` with
+ * `optional: false`, because that flag mirrors the literal `Optional` keyword
+ * — which VBA forbids on a `ParamArray`.
+ */
+export declare function parseSignature(line: string, nameEndIndex: number): VbaSignatureInfo;
+//# sourceMappingURL=signature.d.ts.map