@optave/codegraph 3.9.4 → 3.9.5

package/dist/domain/wasm-worker-pool.d.ts

@@ -0,0 +1,59 @@
+/**
+ * WASM parse worker pool with crash recovery.
+ *
+ * The WASM grammar can trigger uncatchable V8 fatal errors (#965) that kill
+ * whichever thread is running it. Running parses in a worker_thread means the
+ * crash kills only the worker — the pool detects the exit, marks the in-flight
+ * file as skipped, respawns the worker, and continues with the rest.
+ *
+ * This is a single-worker pool; dispatch is sequential. Multi-worker parallelism
+ * is a future optimization — correctness of crash isolation does not depend on
+ * it. Sequential dispatch also simplifies attribution of a crash to a single
+ * "in-flight" file.
+ */
+import type { ExtractorOutput } from '../types.js';
+import type { WorkerAnalysisOpts } from './wasm-worker-protocol.js';
+export declare class WasmWorkerPool {
+    private worker;
+    private nextId;
+    private queue;
+    private inFlight;
+    private disposed;
+    /** filePaths that already caused one worker crash — skipped rather than retried. */
+    private crashedFiles;
+    /**
+     * Tracks the id of the job whose timeout fired and triggered `terminate()`.
+     * Node timers are delivered before poll-phase I/O, so `onTimeout` can fire in
+     * the same loop iteration that already has the worker's response queued. In
+     * that race, `onMessage` resolves the timed-out job and starts the next one
+     * BEFORE `onExit` arrives for the earlier `terminate()` — so the `inFlight`
+     * job `onExit` sees is the innocent next job, not the one that actually hung.
+     * `onExit` uses this field to detect the mismatch and re-queue the new job
+     * instead of silently discarding it.
+     */
+    private timedOutJobId;
+    /**
+     * Parse a single file via the worker. Returns the fully pre-computed
+     * ExtractorOutput, or `null` if the worker crashed on this file or
+     * reported a soft error.
+     */
+    parse(filePath: string, code: string, opts: WorkerAnalysisOpts): Promise<ExtractorOutput | null>;
+    /** Terminate the worker and drain pending jobs with null results. */
+    dispose(): Promise<void>;
+    private pump;
+    /**
+     * Called when the per-job watchdog fires. Terminate the worker so the
+     * hang stops consuming CPU; `onExit` will then resolve the in-flight job
+     * with `null` and blacklist the file via `crashedFiles`.
+     */
+    private onTimeout;
+    private ensureWorker;
+    private onMessage;
+    private onError;
+    private onExit;
+}
+/** Shared pool instance for the process. Callers share the worker across builds. */
+export declare function getWasmWorkerPool(): WasmWorkerPool;
+/** Dispose the shared pool (used by tests + `disposeParsers`). */
+export declare function disposeWasmWorkerPool(): Promise<void>;
+//# sourceMappingURL=wasm-worker-pool.d.ts.map

package/dist/domain/wasm-worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-worker-pool.d.ts","sourceRoot":"","sources":["../../src/domain/wasm-worker-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,OAAO,KAAK,EAAc,eAAe,EAAgB,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAEV,kBAAkB,EAGnB,MAAM,2BAA2B,CAAC;AAsFnC,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,QAAQ,CAAS;IACzB,oFAAoF;IACpF,OAAO,CAAC,YAAY,CAAqB;IACzC;;;;;;;;;OASG;IACH,OAAO,CAAC,aAAa,CAAuB;IAE5C;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAiBhG,qEAAqE;IAC/D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB9B,OAAO,CAAC,IAAI;IAmBZ;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAoBjB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,SAAS;IA0BjB,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,MAAM;CAmDf;AAID,oFAAoF;AACpF,wBAAgB,iBAAiB,IAAI,cAAc,CAGlD;AAED,kEAAkE;AAClE,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAK3D"}

package/dist/domain/wasm-worker-pool.js

@@ -0,0 +1,312 @@
+/**
+ * WASM parse worker pool with crash recovery.
+ *
+ * The WASM grammar can trigger uncatchable V8 fatal errors (#965) that kill
+ * whichever thread is running it. Running parses in a worker_thread means the
+ * crash kills only the worker — the pool detects the exit, marks the in-flight
+ * file as skipped, respawns the worker, and continues with the rest.
+ *
+ * This is a single-worker pool; dispatch is sequential. Multi-worker parallelism
+ * is a future optimization — correctness of crash isolation does not depend on
+ * it. Sequential dispatch also simplifies attribution of a crash to a single
+ * "in-flight" file.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { debug, warn } from '../infrastructure/logger.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Resolve the path to the compiled worker entry script.
+ *
+ * The worker is always loaded from compiled `.js` — Node's worker_threads
+ * loader does not apply vitest/ts-node transforms or rewrite `.js` specifiers
+ * to `.ts`, so even under `--experimental-strip-types` the worker's
+ * relative `.js` imports (e.g. `../ast-analysis/metrics.js`) would fail to
+ * resolve inside the src/ tree.
+ *
+ * Resolution order:
+ *   1. Sibling `.js` (dist build — `dist/domain/wasm-worker-entry.js`).
+ *   2. Corresponding `dist/` file when running from `src/` (tests/dev).
+ * If neither exists, surface a clear error instead of silently exiting the
+ * worker with "module not found".
+ */
+function resolveWorkerEntry() {
+    const selfUrl = import.meta.url;
+    const selfPath = fileURLToPath(selfUrl);
+    // Prefer the sibling .js first (dist build — fast path).
+    const siblingJs = path.join(path.dirname(selfPath), 'wasm-worker-entry.js');
+    if (fs.existsSync(siblingJs))
+        return pathToFileURL(siblingJs);
+    // Running from src/ — fall back to the compiled dist/ copy. Walk up to the
+    // package root (parent of `src/`) and look for `dist/domain/wasm-worker-entry.js`.
+    // This lets vitest import parser.ts while the worker still runs real .js.
+    const srcIdx = selfPath.lastIndexOf(`${path.sep}src${path.sep}`);
+    if (srcIdx !== -1) {
+        const repoRoot = selfPath.slice(0, srcIdx);
+        const distJs = path.join(repoRoot, 'dist', 'domain', 'wasm-worker-entry.js');
+        if (fs.existsSync(distJs))
+            return pathToFileURL(distJs);
+    }
+    throw new Error(`wasm-worker-entry.js not found — run \`npm run build\` to generate dist/. Searched: ${siblingJs}`);
+}
+/**
+ * Per-file watchdog deadline. A parse that takes longer than this is assumed
+ * to be hung (e.g. WASM grammar stuck in an infinite loop rather than
+ * crashing). We terminate the worker, skip the file, and continue.
+ *
+ * 60s is comfortably above worst-case real parses seen in CI (~12s for the
+ * slowest fixture) while still giving the build a definite upper bound
+ * instead of stalling forever.
+ */
+const WORKER_PARSE_TIMEOUT_MS = 60_000;
+function deserializeResult(ser) {
+    if (!ser)
+        return null;
+    const typeMap = new Map();
+    for (const [k, v] of ser.typeMap)
+        typeMap.set(k, v);
+    const out = {
+        definitions: ser.definitions,
+        calls: ser.calls,
+        imports: ser.imports,
+        classes: ser.classes,
+        exports: ser.exports,
+        typeMap,
+    };
+    if (ser._langId !== undefined)
+        out._langId = ser._langId;
+    if (ser._lineCount !== undefined)
+        out._lineCount = ser._lineCount;
+    if (ser.dataflow !== undefined)
+        out.dataflow = ser.dataflow;
+    // Pre-existing type mismatch: ExtractorOutput.astNodes is typed ASTNodeRow[]
+    // (DB-row shape with node_id), but all producers/consumers use the simpler
+    // {line, kind, name, text?, receiver?} shape — see engine.ts:822 where the
+    // visitor output is cast the same way.
+    if (ser.astNodes !== undefined)
+        out.astNodes = ser.astNodes;
+    return out;
+}
+export class WasmWorkerPool {
+    worker = null;
+    nextId = 1;
+    queue = [];
+    inFlight = null;
+    disposed = false;
+    /** filePaths that already caused one worker crash — skipped rather than retried. */
+    crashedFiles = new Set();
+    /**
+     * Tracks the id of the job whose timeout fired and triggered `terminate()`.
+     * Node timers are delivered before poll-phase I/O, so `onTimeout` can fire in
+     * the same loop iteration that already has the worker's response queued. In
+     * that race, `onMessage` resolves the timed-out job and starts the next one
+     * BEFORE `onExit` arrives for the earlier `terminate()` — so the `inFlight`
+     * job `onExit` sees is the innocent next job, not the one that actually hung.
+     * `onExit` uses this field to detect the mismatch and re-queue the new job
+     * instead of silently discarding it.
+     */
+    timedOutJobId = null;
+    /**
+     * Parse a single file via the worker. Returns the fully pre-computed
+     * ExtractorOutput, or `null` if the worker crashed on this file or
+     * reported a soft error.
+     */
+    parse(filePath, code, opts) {
+        if (this.disposed)
+            return Promise.resolve(null);
+        if (this.crashedFiles.has(filePath))
+            return Promise.resolve(null);
+        return new Promise((resolve) => {
+            const job = {
+                id: this.nextId++,
+                filePath,
+                code,
+                opts,
+                resolve,
+                timeoutHandle: null,
+            };
+            this.queue.push(job);
+            this.pump();
+        });
+    }
+    /** Terminate the worker and drain pending jobs with null results. */
+    async dispose() {
+        this.disposed = true;
+        const pending = this.queue.splice(0);
+        const inFlight = this.inFlight;
+        this.inFlight = null;
+        this.timedOutJobId = null;
+        for (const j of pending)
+            j.resolve(null);
+        if (inFlight) {
+            if (inFlight.timeoutHandle)
+                clearTimeout(inFlight.timeoutHandle);
+            inFlight.resolve(null);
+        }
+        if (this.worker) {
+            try {
+                await this.worker.terminate();
+            }
+            catch (e) {
+                debug(`WasmWorkerPool dispose: terminate failed: ${e.message}`);
+            }
+            this.worker = null;
+        }
+    }
+    pump() {
+        if (this.disposed)
+            return;
+        if (this.inFlight)
+            return;
+        const next = this.queue.shift();
+        if (!next)
+            return;
+        this.inFlight = next;
+        const worker = this.ensureWorker();
+        const req = {
+            type: 'parse',
+            id: next.id,
+            filePath: next.filePath,
+            code: next.code,
+            opts: next.opts,
+        };
+        // Arm the hang watchdog BEFORE posting so we can't race a fast reply.
+        next.timeoutHandle = setTimeout(() => this.onTimeout(next.id), WORKER_PARSE_TIMEOUT_MS);
+        worker.postMessage(req);
+    }
+    /**
+     * Called when the per-job watchdog fires. Terminate the worker so the
+     * hang stops consuming CPU; `onExit` will then resolve the in-flight job
+     * with `null` and blacklist the file via `crashedFiles`.
+     */
+    onTimeout(jobId) {
+        const job = this.inFlight;
+        if (!job || job.id !== jobId)
+            return; // already resolved
+        warn(`WASM worker parse timed out after ${WORKER_PARSE_TIMEOUT_MS}ms on ${job.filePath} — terminating worker and skipping file`);
+        this.crashedFiles.add(job.filePath);
+        // Record which job we're terminating so onExit can distinguish this
+        // terminate-induced exit from a crash on a different (innocent) job that
+        // got pumped in between — see `timedOutJobId` field comment.
+        this.timedOutJobId = jobId;
+        const w = this.worker;
+        if (w) {
+            w.terminate().catch((e) => {
+                debug(`WasmWorkerPool onTimeout: terminate failed: ${e.message}`);
+            });
+            // onExit will fire and clean up `inFlight` + resolve the job.
+        }
+    }
+    ensureWorker() {
+        if (this.worker)
+            return this.worker;
+        const w = new Worker(resolveWorkerEntry());
+        this.worker = w;
+        w.on('message', (msg) => this.onMessage(msg));
+        w.on('error', (err) => this.onError(err));
+        w.on('exit', (code) => this.onExit(code));
+        return w;
+    }
+    onMessage(msg) {
+        const job = this.inFlight;
+        if (!job || job.id !== msg.id) {
+            debug(`WasmWorkerPool: stale or unmatched response id=${msg.id}`);
+            return;
+        }
+        if (job.timeoutHandle) {
+            clearTimeout(job.timeoutHandle);
+            job.timeoutHandle = null;
+        }
+        // If a terminate() is pending for this same job (response + timeout raced
+        // in the same loop tick — timers fire before poll-phase I/O), delay
+        // pumping the next job until `onExit` runs. Otherwise the upcoming exit
+        // would land on an innocent follow-up job. `onExit` clears
+        // `timedOutJobId` and calls pump() itself once the worker is fully gone.
+        const terminatePending = this.timedOutJobId === job.id;
+        this.inFlight = null;
+        if (msg.ok) {
+            job.resolve(deserializeResult(msg.result));
+        }
+        else {
+            warn(`WASM worker soft error on ${job.filePath}: ${msg.error}`);
+            job.resolve(null);
+        }
+        if (!terminatePending)
+            this.pump();
+    }
+    onError(err) {
+        // 'error' fires for uncaught exceptions inside the worker — not always fatal
+        // (Node may still follow with 'exit'). Log and let 'exit' handle cleanup.
+        const msg = err instanceof Error ? err.message : String(err);
+        debug(`WASM worker 'error' event: ${msg}`);
+    }
+    onExit(code) {
+        const crashed = this.inFlight;
+        this.worker = null;
+        const timedOutJobId = this.timedOutJobId;
+        this.timedOutJobId = null;
+        if (!crashed) {
+            // Clean exit with no in-flight job — e.g. shutdown, or the race where
+            // `onMessage` already resolved the timed-out job (and deferred pump()
+            // because a terminate was in flight). Nothing to crash; just pump the
+            // queue so any waiting jobs get dispatched on a fresh worker.
+            if (code !== 0) {
+                debug(`WASM worker exited with code ${code}, no job in flight`);
+            }
+            if (timedOutJobId !== null)
+                this.pump();
+            return;
+        }
+        if (timedOutJobId !== null && crashed.id !== timedOutJobId) {
+            // Defensive: a terminate() we issued for a different (earlier) job is
+            // what triggered this exit, but somehow an innocent follow-up job ended
+            // up in-flight. `onMessage` normally defers pumping when a terminate is
+            // pending, so this path should not trigger — but if it does, re-queue
+            // the follow-up rather than silently discarding a valid parse.
+            if (crashed.timeoutHandle) {
+                clearTimeout(crashed.timeoutHandle);
+                crashed.timeoutHandle = null;
+            }
+            this.inFlight = null;
+            this.queue.unshift(crashed);
+            this.pump();
+            return;
+        }
+        if (crashed.timeoutHandle) {
+            clearTimeout(crashed.timeoutHandle);
+            crashed.timeoutHandle = null;
+        }
+        this.inFlight = null;
+        if (code === 0) {
+            // Clean exit mid-job — could be our own terminate() from onTimeout,
+            // or an unexpected worker shutdown. In either case the file is
+            // skipped (crashedFiles was already set in onTimeout if that was the cause).
+            warn(`WASM worker exited cleanly mid-job on ${crashed.filePath} — skipping`);
+        }
+        else {
+            warn(`WASM worker crashed (exit ${code}) parsing ${crashed.filePath} — skipping file and restarting worker`);
+        }
+        this.crashedFiles.add(crashed.filePath);
+        crashed.resolve(null);
+        // Respawn lazily on the next pump()
+        this.pump();
+    }
+}
+let _sharedPool = null;
+/** Shared pool instance for the process. Callers share the worker across builds. */
+export function getWasmWorkerPool() {
+    if (!_sharedPool)
+        _sharedPool = new WasmWorkerPool();
+    return _sharedPool;
+}
+/** Dispose the shared pool (used by tests + `disposeParsers`). */
+export async function disposeWasmWorkerPool() {
+    if (!_sharedPool)
+        return;
+    const p = _sharedPool;
+    _sharedPool = null;
+    await p.dispose();
+}
+//# sourceMappingURL=wasm-worker-pool.js.map

package/dist/domain/wasm-worker-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-worker-pool.js","sourceRoot":"","sources":["../../src/domain/wasm-worker-pool.ts"],"names":[],"mappings":"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"}

package/dist/domain/wasm-worker-protocol.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Message protocol between the main thread and the WASM parse worker.
+ *
+ * The worker owns every tree-sitter WASM call. Fatal V8 aborts from the
+ * grammar (#965) kill only the worker — the main thread respawns it and
+ * skips the file that crashed.
+ *
+ * The worker returns fully pre-computed ExtractorOutput — matching what the
+ * native engine's parseFilesFull emits — so the main thread never holds a
+ * live Tree. The `_tree` field is never populated by this pipeline.
+ */
+import type { Call, ClassRelation, DataflowResult, Definition, Export, Import, LanguageId, TypeMapEntry } from '../types.js';
+export interface WorkerAnalysisOpts {
+    ast: boolean;
+    complexity: boolean;
+    cfg: boolean;
+    dataflow: boolean;
+}
+export interface WorkerParseRequest {
+    type: 'parse';
+    id: number;
+    filePath: string;
+    code: string;
+    opts: WorkerAnalysisOpts;
+}
+export type WorkerRequest = WorkerParseRequest;
+/**
+ * Serialized ExtractorOutput shape. Identical to ExtractorOutput except:
+ *  - `_tree` is never set (cannot cross worker boundary).
+ *  - `typeMap` is encoded as an array of [key, value] tuples. Structured
+ *    clone supports Map natively in Node 22, but the tuple form keeps the
+ *    wire format language-agnostic and matches the native engine's form.
+ */
+export interface SerializedExtractorOutput {
+    definitions: Definition[];
+    calls: Call[];
+    imports: Import[];
+    classes: ClassRelation[];
+    exports: Export[];
+    typeMap: Array<[string, TypeMapEntry]>;
+    _langId?: LanguageId;
+    _lineCount?: number;
+    dataflow?: DataflowResult;
+    astNodes?: Array<{
+        line: number;
+        kind: string;
+        name: string;
+        text?: string;
+        receiver?: string;
+    }>;
+}
+export interface WorkerParseResponseOk {
+    type: 'result';
+    id: number;
+    ok: true;
+    result: SerializedExtractorOutput | null;
+}
+export interface WorkerParseResponseErr {
+    type: 'result';
+    id: number;
+    ok: false;
+    error: string;
+}
+export type WorkerResponse = WorkerParseResponseOk | WorkerParseResponseErr;
+//# sourceMappingURL=wasm-worker-protocol.d.ts.map

package/dist/domain/wasm-worker-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-worker-protocol.d.ts","sourceRoot":"","sources":["../../src/domain/wasm-worker-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,IAAI,EACJ,aAAa,EACb,cAAc,EACd,UAAU,EACV,MAAM,EACN,MAAM,EACN,UAAU,EACV,YAAY,EACb,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,OAAO,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,kBAAkB,CAAC;CAC1B;AAED,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IACvC,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,QAAQ,CAAC,EAAE,KAAK,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,yBAAyB,GAAG,IAAI,CAAC;CAC1C;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,cAAc,GAAG,qBAAqB,GAAG,sBAAsB,CAAC"}

package/dist/domain/wasm-worker-protocol.js

@@ -0,0 +1,13 @@
+/**
+ * Message protocol between the main thread and the WASM parse worker.
+ *
+ * The worker owns every tree-sitter WASM call. Fatal V8 aborts from the
+ * grammar (#965) kill only the worker — the main thread respawns it and
+ * skips the file that crashed.
+ *
+ * The worker returns fully pre-computed ExtractorOutput — matching what the
+ * native engine's parseFilesFull emits — so the main thread never holds a
+ * live Tree. The `_tree` field is never populated by this pipeline.
+ */
+export {};
+//# sourceMappingURL=wasm-worker-protocol.js.map

package/dist/domain/wasm-worker-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-worker-protocol.js","sourceRoot":"","sources":["../../src/domain/wasm-worker-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/extractors/javascript.js

@@ -1088,7 +1088,9 @@ function handleVarDeclaratorTypeMap(node, typeMap) {
             const obj = fn.childForFieldName('object');
             if (obj && obj.type === 'identifier') {
                 const objName = obj.text;
-                if (objName[0] !== objName[0].toLowerCase() && !BUILTIN_GLOBALS.has(objName)) {
+                if (objName[0] &&
+                    objName[0] !== objName[0].toLowerCase() &&
+                    !BUILTIN_GLOBALS.has(objName)) {
                     setTypeMapEntry(typeMap, nameN.text, objName, 0.7);
                 }
             }
@@ -1179,16 +1181,158 @@ function extractSubscriptCallInfo(fn, callNode) {
     }
     return null;
 }
+/**
+ * Callee names that idiomatically accept callback references. Used to gate
+ * member_expression args in {@link extractCallbackReferenceCalls}: arguments
+ * like `user.id` are only emitted as dynamic callback calls when the callee
+ * is a known callback-accepting API (router/middleware, promises, array
+ * methods, event emitters, scheduling APIs). This avoids false positives
+ * from plain property reads passed as data, e.g. `store.set(user.id, user)`.
+ *
+ * Identifier args (e.g. `router.use(handleToken)`) are always emitted — the
+ * collateral damage of dropping them is larger than the FP risk, since plain
+ * identifier data args rarely collide with real function names.
+ */
+const CALLBACK_ACCEPTING_CALLEES = new Set([
+    // Express / router / middleware
+    'use',
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+    'options',
+    'head',
+    'all',
+    // Promises
+    'then',
+    'catch',
+    'finally',
+    // Array iteration / reduction
+    'map',
+    'filter',
+    'forEach',
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'some',
+    'every',
+    'reduce',
+    'reduceRight',
+    'flatMap',
+    'sort',
+    // Event emitters / DOM
+    'on',
+    'once',
+    'off',
+    'addListener',
+    'removeListener',
+    'addEventListener',
+    'removeEventListener',
+    'subscribe',
+    'unsubscribe',
+    // Scheduling / plain function callbacks
+    'setTimeout',
+    'setInterval',
+    'setImmediate',
+    'queueMicrotask',
+    'requestAnimationFrame',
+    'requestIdleCallback',
+    'nextTick',
+    // Commander / yargs / hooks
+    'action',
+    'command',
+]);
+/**
+ * HTTP-verb callees that double as Map/cache/repository method names (`get`,
+ * `post`, `put`, `delete`, `patch`, `options`, `head`, `all`). Express/router
+ * invocations always take a string-literal route path as the first argument
+ * (`app.get('/path', handler)`), whereas Map-like APIs pass values/keys
+ * (`cache.get(user.id)`). Requiring a string-literal first arg keeps real
+ * route handlers covered while dropping the Map/cache false-positive surface.
+ *
+ * `use` and `all` without a path are legitimate middleware registrations, so
+ * `use` is intentionally excluded here — it stays in the general allowlist.
+ */
+const HTTP_VERB_CALLEES = new Set([
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+    'options',
+    'head',
+    'all',
+]);
+/**
+ * Extract the callee's final name (function identifier or member expression
+ * property) for callback-eligibility filtering. Returns null if the callee
+ * shape is not analyzable (e.g. computed subscripts, IIFEs).
+ *
+ * Optional-chaining (`obj?.method(...)`) is handled transparently: in both
+ * tree-sitter-javascript and tree-sitter-typescript grammars `obj?.method` is
+ * still a `member_expression` (the `?.` appears as an `optional_chain` child),
+ * so the property extraction below returns `method` as expected.
+ */
+function extractCalleeName(callNode) {
+    const fn = callNode.childForFieldName('function');
+    if (!fn)
+        return null;
+    if (fn.type === 'identifier')
+        return fn.text;
+    if (fn.type === 'member_expression') {
+        const prop = fn.childForFieldName('property');
+        return prop ? prop.text : null;
+    }
+    return null;
+}
+/**
+ * True iff the first argument of an arguments node is a string literal.
+ * Used to distinguish Express/router route handlers (`app.get('/path', h)`)
+ * from Map/cache APIs that reuse the same verb names (`cache.get(user.id)`).
+ */
+function firstArgIsStringLiteral(argsNode) {
+    for (let i = 0; i < argsNode.childCount; i++) {
+        const child = argsNode.child(i);
+        if (!child)
+            continue;
+        // Skip parens and commas; the first non-punctuation child is the first arg.
+        if (child.type === '(' || child.type === ',' || child.type === ')')
+            continue;
+        return child.type === 'string' || child.type === 'template_string';
+    }
+    return false;
+}
 /**
  * Extract Call entries for named function references passed as arguments.
  * e.g. `router.use(handleToken, checkAuth)` yields calls to handleToken and checkAuth.
  * `app.use(auth.validate)` yields a call to validate with receiver auth.
  * Skips literals, objects, arrays, anonymous functions, and call expressions (already handled).
+ *
+ * To avoid false positives where plain property reads are passed as data
+ * (e.g. `store.set(user.id, user)` — `user.id` is a value, not a callback),
+ * member_expression args are only emitted when the callee is in
+ * {@link CALLBACK_ACCEPTING_CALLEES}. Identifier args are always emitted.
+ *
+ * HTTP-verb callees (`get`, `post`, `put`, `delete`, `patch`, `options`,
+ * `head`, `all`) double as Map/cache/repository method names, so their
+ * member-expr args are only emitted when the first argument is a string
+ * literal route path — matching Express/router shape and skipping
+ * `cache.get(user.id)`-style calls.
  */
 function extractCallbackReferenceCalls(callNode) {
     const args = callNode.childForFieldName('arguments') || findChild(callNode, 'arguments');
     if (!args)
         return [];
+    const calleeName = extractCalleeName(callNode);
+    let memberExprArgsAllowed = calleeName !== null && CALLBACK_ACCEPTING_CALLEES.has(calleeName);
+    if (memberExprArgsAllowed && calleeName !== null && HTTP_VERB_CALLEES.has(calleeName)) {
+        // HTTP verbs require a string-literal route path to be treated as a
+        // callback-accepting API; otherwise `cache.get(user.id)` etc. would
+        // still emit `id` as a dynamic call.
+        memberExprArgsAllowed = firstArgIsStringLiteral(args);
+    }
     const result = [];
     const callLine = callNode.startPosition.row + 1;
     for (let i = 0; i < args.childCount; i++) {
@@ -1198,7 +1342,7 @@ function extractCallbackReferenceCalls(callNode) {
         if (child.type === 'identifier') {
             result.push({ name: child.text, line: callLine, dynamic: true });
         }
-        else if (child.type === 'member_expression') {
+        else if (child.type === 'member_expression' && memberExprArgsAllowed) {
             const prop = child.childForFieldName('property');
             const obj = child.childForFieldName('object');
             if (prop) {