@aroman22/codegraph-vba 1.15.0 → 1.16.0

package/dist/mcp/proxy.d.ts

@@ -58,6 +58,35 @@ export declare function runProxy(socketPath: string, expectedVersion?: string):
  * owns the socket. Used by the local-handshake proxy's background connect.
  */
 export declare function connectWithHello(socketPath: string, expectedVersion?: string): Promise<net.Socket | 'version-mismatch' | null>;
+type JsonRpc = Record<string, unknown>;
+type ProxyWrite = (obj: JsonRpc | string) => void;
+/** Tracks request order across the proxy's pending-before-connect and in-flight phases. */
+export declare class ProxyRequestBarrier {
+    private readonly pending;
+    private readonly inflight;
+    private readonly drainWaiters;
+    private track;
+    private requestId;
+    private resolveDrain;
+    buffer(line: string): void;
+    forward(line: string, send: (line: string) => void): void;
+    flush(send: (line: string) => void): void;
+    settle(id: unknown): void;
+    settleLine(line: string): void;
+    inflightLines(): string[];
+    pendingCount(): number;
+    inflightCount(): number;
+    drain(): Promise<void>;
+}
+/** Per-proxy barrier for intentional release of the project this session owns. */
+export declare class ProxyReleaseCoordinator {
+    private readonly drainEarlierRequests;
+    private readonly entries;
+    private readonly sessionKey;
+    constructor(sessionRoot: string, drainEarlierRequests?: () => Promise<void>);
+    getState(root?: string): 'active' | 'releasing' | 'released';
+    handle(msg: JsonRpc, enabled: boolean, releaseProject: ((root: string) => Promise<unknown>) | undefined, write: ProxyWrite): boolean;
+}
 /** Dependencies the local-handshake proxy needs, injected by MCPServer (which
  *  owns the daemon-spawn machinery and the engine factory). */
 export interface LocalHandshakeDeps {
@@ -69,6 +98,8 @@ export interface LocalHandshakeDeps {
     makeEngine(): MCPEngine;
     /** Project root for the fallback engine's lazy init. */
     root: string;
+    /** Release one root locally so the proxy can suppress watchdog respawn first. */
+    releaseProject?(root: string): Promise<unknown>;
 }
 /**
  * Local-handshake proxy (the cold-start fix).
@@ -84,4 +115,5 @@ export interface LocalHandshakeDeps {
  * never costs the old fall-back-to-direct robustness.
  */
 export declare function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<void>;
+export {};
 //# sourceMappingURL=proxy.d.ts.map

package/dist/project-config.d.ts

@@ -46,6 +46,39 @@ export interface ProjectConfig {
          * `true`.
          */
         dysflowExport?: boolean;
+        /**
+         * Extra receiver names that execute SQL, so table references inside the
+         * SQL they run are still found (#244). Two entry forms are accepted:
+         *
+         *   - a bare identifier fragment — `"getdb"` reaches `getdb()`,
+         *     `getdbHPS()` and `getdbExpedientes()`;
+         *   - an explicit `receiver.method` pair — `"cnn.Execute"`.
+         *
+         * Raw regular expressions are deliberately NOT accepted: these patterns
+         * run against every line of every VBA file, where a user-supplied regex
+         * is a catastrophic-backtracking hazard. Entries EXTEND the built-in
+         * list (`db`, `getdb`, `CurrentDb`, `DBEngine`, the DAO `QueryDef`
+         * receivers, `DoCmd.RunSQL` and the ADO pair) — they never replace it.
+         * A non-array value, or an entry that is not one of the two forms,
+         * warns and is ignored.
+         */
+        sqlWrappers?: string[];
+        /**
+         * Issue #261 — extra module-level variable names this project uses as its
+         * error channel: the field a failing procedure writes and its caller
+         * reads, which is how an error message actually travels in an Access
+         * codebase of this shape (VBA's own mechanism unwinds one frame and is
+         * used for that, not for the message).
+         *
+         * Bare VBA identifiers only, matched as WHOLE names — `"lastFailure"`
+         * flags `lastFailure` and never `lastFailureCount`. Raw regular
+         * expressions are deliberately NOT accepted, for the same reason
+         * `sqlWrappers` refuses them: these names are tested against every
+         * identifier of every line of every VBA file. Entries EXTEND the built-in
+         * list (`m_Error`, `p_Error`, `g_Error`, `Error`) — they never replace
+         * it. A non-array value, or a non-identifier entry, warns and is ignored.
+         */
+        errorChannel?: string[];
     };
     /**
      * Gitignore-style patterns for first-party source to force INTO the index even
@@ -62,11 +95,19 @@ export interface ProjectConfig {
      */
     include?: string[];
 }
-export declare function loadVbaConfig(rootDir: string): {
+/**
+ * Parsed, validated view of the `vba` block. Named (rather than repeated
+ * inline at each of its five use sites) so adding a knob — `sqlWrappers` in
+ * #244 — is one edit instead of five that can silently drift apart.
+ */
+export interface VbaConfig {
     targets?: Record<string, boolean>;
     maxRaiseFanout?: number;
     dysflowExport?: boolean;
-};
+    sqlWrappers?: string[];
+    errorChannel?: string[];
+}
+export declare function loadVbaConfig(rootDir: string): VbaConfig;
 /**
  * Load the validated `vba.dysflowExport` flag for a project, mtime-cached
  * (issue #154). Returns `true` when the flag is absent — the default keeps

package/dist/resolution/index.d.ts

@@ -302,10 +302,55 @@ export declare class ReferenceResolver {
      * (enum, class, interface, struct, type_alias). Exactly one match →
      * repoint; zero or 2+ → decline (leave the stub as-is).
      *
-     * Duplicate `(source, target, 'references')` rows after repointing are
-     * collapsed the same way `resolveVbaCallStubs` handles F1 duplicates.
+     * Duplicate `(source, target, kind)` rows after repointing are collapsed the
+     * same way `resolveVbaCallStubs` handles F1 duplicates.
+     *
+     * Issue #257: `type_of` edges are repointed alongside `references` ones.
+     * They share the stub by construction (`emitTypeOf` and `emitReference` both
+     * go through `ensureSynthTypeNode`), and the stub is DELETED at the end of
+     * each iteration — with `ON DELETE CASCADE` on both endpoint columns, an
+     * un-repointed `type_of` edge would be silently destroyed rather than
+     * resolved. The de-duplication key carries the edge kind so a module's
+     * `references` edge and its parameter's `type_of` edge onto the same type
+     * cannot collapse into each other.
      */
     resolveVbaReferenceStubs(): number;
+    /**
+     * Promote Access ERD table declarations to canonical and repoint the
+     * SQL-derived placeholders onto them (#257, half B).
+     *
+     * Two extractors already synthesize a `class` placeholder for every table
+     * name they see in SQL text (`vba-sql-table` from in-code SQL,
+     * `sql-query-table` from a saved query), each keyed on the REFERENCING file.
+     * `AccessErdExtractor` emits its own table node keyed on the ERD document.
+     * Left alone, `TbAnexos` from the ERD and `TbAnexos` from a `SELECT` in a
+     * `.cls` are two unrelated nodes — the fields land on one, the references on
+     * the other, and the whole feature buys nothing.
+     *
+     * This pass is the convergence step, and it reuses the mechanism
+     * `resolveVbaCallStubs` already proved: repoint the incoming edges onto the
+     * canonical node, collapse would-be duplicates, delete the emptied
+     * placeholder, and stamp `metadata.repointDecision` on every edge it touched
+     * so the outcome is auditable (same vocabulary as `docs/vba-stub-repoint-
+     * decision.md`).
+     *
+     * Three deliberate declines:
+     *  - **No ERD declares this name** → leave the placeholder exactly as it is.
+     *    That is the no-ERD project, and its behavior must not change at all.
+     *  - **Two ERD files declare the same name** (two backends, same table) →
+     *    `declined-ambiguous`. Repoint nothing and keep both declarations; which
+     *    backend a bare `SELECT` meant is not something to guess.
+     *  - **The placeholder still has other edges** → keep the node. Only a
+     *    placeholder whose every edge has moved is deleted.
+     *
+     * Runs BEFORE `resolveVbaReferenceStubs` so this explicit, decision-stamping
+     * pass owns the outcome rather than the generic stub resolver silently
+     * arriving at half of it. Idempotent: a repointed placeholder is gone, so a
+     * second pass finds nothing to do.
+     *
+     * @returns the number of edges repointed onto an ERD table node.
+     */
+    resolveAccessErdTableNodes(): number;
     /**
      * Resolve a single VBA call-stub node to its real target, or `null` when
      * unresolvable/ambiguous. See `resolveVbaCallStubs` for the two-step

package/dist/resolution/name-matcher.d.ts

@@ -7,6 +7,31 @@ import { Node } from '../types';
 import { UnresolvedRef, ResolvedRef, ResolutionContext } from './types';
 /** Resolve Me.<Control> only inside the extractor-declared sibling layout. */
 export declare function matchVbaMeControl(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Resolve a module-level variable read/write to that variable's node in
+ * the SAME file (issue #251).
+ *
+ * The binding is file-scoped and never falls through to global name
+ * matching. `m_count`, `strSQL` and `blnOk` are declared privately in
+ * dozens of modules of a typical Access project; a global match would
+ * pick one of them at random and claim a coupling between two modules
+ * that never reference each other. The extractor only emits these refs
+ * for names it already registered as module-level variables of the file
+ * being scanned, so the answer, when there is one, is always in that file.
+ */
+export declare function matchVbaModuleVariable(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Issue #253: resolve a saved-query name to the `query` node that
+ * `SqlQueryExtractor` builds from `queries/<Name>.sql`.
+ *
+ * Query-kind only, and a miss DECLINES rather than falling through to global
+ * name matching. That is the whole point of the gate: a name matching neither
+ * a query nor a table must stay a `failed` reference, because a fallback that
+ * invented a table placeholder would turn "this query does not exist" into a
+ * confident, wrong answer — and a fallback to generic name matching could bind
+ * the name to an unrelated same-named class or procedure.
+ */
+export declare function matchVbaQueryName(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
 /** Resolve Access SourceObject embeddings only to a unique real layout node. */
 export declare function matchVbaSourceObject(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
 /** Keep a layout's sibling-code binding from resolving back to the layout. */

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

@@ -1,3 +1,4 @@
+import { isRuntimeObject as canonicalIsRuntimeObject } from '../extraction/vba/runtime-objects';
 /**
  * Canonical list of VBA/Access runtime objects and singletons whose
  * `Receiver.Member` calls are NEVER user-defined code — DAO, FileSystemObject
@@ -18,14 +19,15 @@
  * only falls back to this list when no real target exists, so a shadow
  * declaration is repointed exactly like any other real symbol (FR-2.1).
  *
- * NOTE — this is complementary to, NOT a duplicate of, the VBA extractor's
- * own `RUNTIME_RECEIVER_BLACKLIST` (`src/extraction/vba/constants.ts`). That
- * set is case-sensitive PascalCase and suppresses stub SYNTHESIS for the
- * common receivers at extraction time; this set is lowercased and catches the
- * runtime-object stubs that still reached the graph (lowercase receivers,
- * `Dim x As DAO.*` typed locals whose receiver survives as raw text, etc.).
- * The extractor blacklist deliberately stays untouched (AC-4: `src/extraction`
- * has 0 diff); the two layers are independent by design.
+ * Issue #245 — this used to be a SECOND literal, complementary to the VBA
+ * extractor's `RUNTIME_RECEIVER_BLACKLIST`. The two drifted: the extractor
+ * list omitted `VBA`, `fso`, `Collection` and `ListBox`, so those receivers
+ * kept synthesizing stub function NODES even though the resolver already
+ * declined their edges. Both sets now derive from one literal in
+ * `src/extraction/vba/runtime-objects.ts` (a leaf module — `src/extraction`
+ * must not import from `src/resolution`, so the canonical set lives on the
+ * extraction side and is re-exported here). Every existing
+ * `from '../src/resolution/vba-runtime-objects'` import keeps working.
  *
  * Entries are lowercased so matching is case-insensitive against a stub's
  * receiver.
@@ -36,9 +38,7 @@ export declare const RUNTIME_OBJECTS: ReadonlySet<string>;
  * 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;
-/** Canonical VBA and Access built-in functions that never resolve to project code. */
-export declare const VBA_STDLIB_FUNCTIONS: ReadonlySet<string>;
+export declare const isRuntimeObject: typeof canonicalIsRuntimeObject;
 export declare function isVbaStdlibFunction(name: string | null | undefined): boolean;
 /**
  * Issue #188 — VBA intrinsic constants and DAO enum values reach

package/dist/types.d.ts

@@ -10,12 +10,12 @@
  * of truth backs both the TS type and any runtime validation
  * (e.g. the search query parser).
  */
-export declare const NODE_KINDS: readonly ["file", "module", "class", "struct", "interface", "trait", "protocol", "function", "method", "property", "field", "variable", "constant", "enum", "enum_member", "event", "type", "type_member", "declare", "type_alias", "namespace", "parameter", "import", "export", "route", "component", "query", "form-layout", "form-instance-control", "report-layout"];
+export declare const NODE_KINDS: readonly ["file", "module", "class", "struct", "interface", "trait", "protocol", "function", "method", "property", "field", "variable", "constant", "enum", "enum_member", "event", "type", "type_member", "declare", "type_alias", "namespace", "parameter", "import", "export", "route", "component", "query", "form-layout", "form-instance-control", "report-layout", "label"];
 export type NodeKind = (typeof NODE_KINDS)[number];
 /**
  * Types of edges (relationships) between nodes
  */
-export type EdgeKind = 'contains' | 'calls' | 'imports' | 'exports' | 'extends' | 'implements' | 'references' | 'type_of' | 'returns' | 'instantiates' | 'overrides' | 'decorates' | 'event-handler' | 'opens-form' | 'opens-report' | 'raises-event' | 'subscribes-event' | 'type-member';
+export type EdgeKind = 'contains' | 'calls' | 'imports' | 'exports' | 'extends' | 'implements' | 'references' | 'type_of' | 'returns' | 'instantiates' | 'overrides' | 'decorates' | 'event-handler' | 'opens-form' | 'opens-report' | 'raises-event' | 'subscribes-event' | 'type-member' | 'handles-error';
 /**
  * Supported programming languages. See NODE_KINDS for why this is a
  * runtime-iterable const array.
@@ -175,7 +175,11 @@ export interface ExtractionError {
  * layer. The legacy `EdgeKind` literal `'references'` is preserved as
  * `references` here via `EdgeKind` — back-compat for any push site this
  * round does not reclassify (e.g. the Implements emitter). New literals:
- *   - `calls`            paren-form `Name(...)` or statement-form Sub call
+ *   - `calls`            paren-form `Name(...)`, or a statement-form Sub call
+ *                        whose syntax rules out a `Const` read (issue #265):
+ *                        `Call Escribir` (the `Call` keyword is only valid on
+ *                        a procedure) and `Escribir 1, 2` (a constant takes no
+ *                        argument list)
  *   - `qualified-call`   `Receiver.Member(...)` (qualified-paren) or
  *                        `Receiver.Member args` (qualified-statement)
  *   - `property-get`     `Me.Name` (dot access, read)
@@ -183,9 +187,13 @@ export interface ExtractionError {
  *   - `bang-get`         `Me!SubCtl` (bang read) or
  *                        `Forms!FormX!Ctl` / `Forms("FormX")!Ctl` (cross-form)
  *   - `bang-set`         `Me!SubCtl = value` (bang assignment)
- *   - `unqualified-ident` bare identifier without `(` after; default for
+ *   - `unqualified-ident` bare identifier with no `(` after it, no `Call`
+ *                        keyword and no argument list; default for
  *                        `HayErrorEnRiesgo`-style hits — Const-read takes
- *                        priority via FR-3.1 disambiguation
+ *                        priority via FR-3.1 disambiguation. That shape is
+ *                        genuinely ambiguous between a no-argument Sub call
+ *                        and a `Const` read, which is why it stays here while
+ *                        the two unambiguous statement forms are `calls`
  *   - `member-with`      `.Member` inside a `With <receiver>` block
  *   - `dao-query`        `DoCmd.OpenQuery "X"` argument
  * `dao-field-get` / `dao-field-set` are deliberately deferred to round-4.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aroman22/codegraph-vba",
-  "version": "1.15.0",
+  "version": "1.16.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.15.0",
-    "@aroman22/codegraph-vba-darwin-x64": "1.15.0",
-    "@aroman22/codegraph-vba-linux-arm64": "1.15.0",
-    "@aroman22/codegraph-vba-linux-x64": "1.15.0",
-    "@aroman22/codegraph-vba-win32-arm64": "1.15.0",
-    "@aroman22/codegraph-vba-win32-x64": "1.15.0"
+    "@aroman22/codegraph-vba-darwin-arm64": "1.16.0",
+    "@aroman22/codegraph-vba-darwin-x64": "1.16.0",
+    "@aroman22/codegraph-vba-linux-arm64": "1.16.0",
+    "@aroman22/codegraph-vba-linux-x64": "1.16.0",
+    "@aroman22/codegraph-vba-win32-arm64": "1.16.0",
+    "@aroman22/codegraph-vba-win32-x64": "1.16.0"
   },
   "files": [
     "npm-shim.js",