@optave/codegraph 3.9.4 → 3.9.6

package/src/domain/wasm-worker-pool.ts

@@ -0,0 +1,330 @@
+/**
+ * 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';
+import type { ASTNodeRow, ExtractorOutput, TypeMapEntry } from '../types.js';
+import type {
+  SerializedExtractorOutput,
+  WorkerAnalysisOpts,
+  WorkerRequest,
+  WorkerResponse,
+} from './wasm-worker-protocol.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(): URL {
+  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}`,
+  );
+}
+
+interface PendingJob {
+  id: number;
+  filePath: string;
+  code: string;
+  opts: WorkerAnalysisOpts;
+  resolve: (out: ExtractorOutput | null) => void;
+  /** setTimeout handle — fires if the worker hangs in a non-crashing loop. */
+  timeoutHandle: NodeJS.Timeout | null;
+}
+
+/**
+ * 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: SerializedExtractorOutput | null): ExtractorOutput | null {
+  if (!ser) return null;
+  const typeMap = new Map<string, TypeMapEntry>();
+  for (const [k, v] of ser.typeMap) typeMap.set(k, v);
+  const out: ExtractorOutput = {
+    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 as unknown as ASTNodeRow[];
+  return out;
+}
+
+export class WasmWorkerPool {
+  private worker: Worker | null = null;
+  private nextId = 1;
+  private queue: PendingJob[] = [];
+  private inFlight: PendingJob | null = null;
+  private disposed = false;
+  /** filePaths that already caused one worker crash — skipped rather than retried. */
+  private crashedFiles = new Set<string>();
+  /**
+   * 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: number | null = 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: string, code: string, opts: WorkerAnalysisOpts): Promise<ExtractorOutput | null> {
+    if (this.disposed) return Promise.resolve(null);
+    if (this.crashedFiles.has(filePath)) return Promise.resolve(null);
+    return new Promise((resolve) => {
+      const job: PendingJob = {
+        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(): Promise<void> {
+    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: unknown) {
+        debug(`WasmWorkerPool dispose: terminate failed: ${(e as Error).message}`);
+      }
+      this.worker = null;
+    }
+  }
+
+  private pump(): void {
+    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: WorkerRequest = {
+      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`.
+   */
+  private onTimeout(jobId: number): void {
+    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: unknown) => {
+        debug(`WasmWorkerPool onTimeout: terminate failed: ${(e as Error).message}`);
+      });
+      // onExit will fire and clean up `inFlight` + resolve the job.
+    }
+  }
+
+  private ensureWorker(): Worker {
+    if (this.worker) return this.worker;
+    const w = new Worker(resolveWorkerEntry());
+    this.worker = w;
+    w.on('message', (msg: WorkerResponse) => this.onMessage(msg));
+    w.on('error', (err: unknown) => this.onError(err));
+    w.on('exit', (code) => this.onExit(code));
+    return w;
+  }
+
+  private onMessage(msg: WorkerResponse): void {
+    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();
+  }
+
+  private onError(err: unknown): void {
+    // '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}`);
+  }
+
+  private onExit(code: number): void {
+    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: WasmWorkerPool | null = null;
+
+/** Shared pool instance for the process. Callers share the worker across builds. */
+export function getWasmWorkerPool(): WasmWorkerPool {
+  if (!_sharedPool) _sharedPool = new WasmWorkerPool();
+  return _sharedPool;
+}
+
+/** Dispose the shared pool (used by tests + `disposeParsers`). */
+export async function disposeWasmWorkerPool(): Promise<void> {
+  if (!_sharedPool) return;
+  const p = _sharedPool;
+  _sharedPool = null;
+  await p.dispose();
+}

package/src/domain/wasm-worker-protocol.ts

@@ -0,0 +1,81 @@
+/**
+ * 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;

package/src/extractors/javascript.ts

@@ -1182,7 +1182,11 @@ function handleVarDeclaratorTypeMap(
       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);
         }
       }
@@ -1277,16 +1281,159 @@ function extractSubscriptCallInfo(fn: TreeSitterNode, callNode: TreeSitterNode):
   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: ReadonlySet<string> = 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: ReadonlySet<string> = 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: TreeSitterNode): string | null {
+  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: TreeSitterNode): boolean {
+  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: TreeSitterNode): Call[] {
   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: Call[] = [];
   const callLine = callNode.startPosition.row + 1;
 
@@ -1296,7 +1443,7 @@ function extractCallbackReferenceCalls(callNode: TreeSitterNode): Call[] {
 
     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) {

package/src/features/ast.ts

@@ -1,5 +1,9 @@
 import path from 'node:path';
-import { AST_TYPE_MAPS } from '../ast-analysis/rules/index.js';
+import {
+  AST_STRING_CONFIGS,
+  AST_TYPE_MAPS,
+  astStopRecurseKinds,
+} from '../ast-analysis/rules/index.js';
 import { buildExtensionSet } from '../ast-analysis/shared.js';
 import { walkWithVisitors } from '../ast-analysis/visitor.js';
 import { createAstStoreVisitor } from '../ast-analysis/visitors/ast-store-visitor.js';
@@ -22,8 +26,6 @@ const KIND_ICONS: Record<string, string> = {
   await: '\u22B3', // ⊳
 };
 
-const JS_TS_AST_TYPES = AST_TYPE_MAPS.get('javascript');
-
 const WALK_EXTENSIONS = buildExtensionSet(AST_TYPE_MAPS);
 
 // ─── Helpers ──────────────────────────────────────────────────────────
@@ -171,9 +173,10 @@ function collectFileAstRows(
 
   // WASM fallback — walk tree if available
   const ext = path.extname(relPath).toLowerCase();
-  if (WALK_EXTENSIONS.has(ext) && symbols._tree) {
+  const langId = symbols._langId || '';
+  if ((WALK_EXTENSIONS.has(ext) || AST_TYPE_MAPS.has(langId)) && symbols._tree) {
     const rows: AstRow[] = [];
-    walkAst(symbols._tree.rootNode, defs, relPath, rows, nodeIdMap);
+    walkAst(symbols._tree.rootNode, defs, relPath, rows, nodeIdMap, langId);
     return rows;
   }
 
@@ -226,13 +229,23 @@ function walkAst(
   relPath: string,
   rows: AstRow[],
   nodeIdMap: Map<string, number>,
+  langId: string,
 ): void {
-  if (!JS_TS_AST_TYPES) {
-    debug('ast-store: JS_TS_AST_TYPES not available — skipping walk');
+  const astTypeMap = AST_TYPE_MAPS.get(langId);
+  if (!astTypeMap) {
+    debug(`ast-store: no astTypes for langId=${langId} — skipping walk`);
     return;
   }
-  const visitor = createAstStoreVisitor(JS_TS_AST_TYPES, defs, relPath, nodeIdMap);
-  const results = walkWithVisitors(rootNode, [visitor], 'javascript');
+  const stringConfig = AST_STRING_CONFIGS.get(langId);
+  const visitor = createAstStoreVisitor(
+    astTypeMap,
+    defs,
+    relPath,
+    nodeIdMap,
+    stringConfig,
+    astStopRecurseKinds(langId),
+  );
+  const results = walkWithVisitors(rootNode, [visitor], langId);
   const collected = (results['ast-store'] || []) as AstRow[];
   rows.push(...collected);
 }

package/src/features/boundaries.ts

@@ -1,34 +1,9 @@
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { BoundaryError } from '../shared/errors.js';
+import { globToRegex } from '../shared/globs.js';
 import type { BetterSqlite3Database } from '../types.js';
 
-// ─── Glob-to-Regex ───────────────────────────────────────────────────
-
-export function globToRegex(pattern: string): RegExp {
-  let re = '';
-  let i = 0;
-  while (i < pattern.length) {
-    const ch = pattern[i] as string;
-    if (ch === '*' && pattern[i + 1] === '*') {
-      re += '.*';
-      i += 2;
-      if (pattern[i] === '/') i++;
-    } else if (ch === '*') {
-      re += '[^/]*';
-      i++;
-    } else if (ch === '?') {
-      re += '[^/]';
-      i++;
-    } else if (/[.+^${}()|[\]\\]/.test(ch)) {
-      re += `\\${ch}`;
-      i++;
-    } else {
-      re += ch;
-      i++;
-    }
-  }
-  return new RegExp(`^${re}$`);
-}
+export { globToRegex };
 
 // ─── Presets ─────────────────────────────────────────────────────────