@optave/codegraph 3.5.0 → 3.6.0

package/src/domain/graph/builder/stages/insert-nodes.ts

@@ -39,6 +39,12 @@ interface PrecomputedFileData {
 // ── Native fast-path ─────────────────────────────────────────────────
 
 function tryNativeInsert(ctx: PipelineContext): boolean {
+  // Disabled: bulkInsertNodes corrupts the DB when both the JS (better-sqlite3)
+  // and Rust (rusqlite) connections are open to the same WAL-mode file.
+  // The native path was never operational before — it always crashed on null
+  // visibility serialisation. See #696 for the dual-connection fix.
+  if (ctx.db) return false;
+
   // Use NativeDatabase persistent connection (Phase 6.15+).
   // Standalone napi functions were removed in 6.17 — falls through to JS if nativeDb unavailable.
   if (!ctx.nativeDb?.bulkInsertNodes) return false;
@@ -52,14 +58,14 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
       name: string;
       kind: string;
       line: number;
-      endLine?: number | null;
-      visibility?: string | null;
+      endLine?: number;
+      visibility?: string;
       children: Array<{
         name: string;
         kind: string;
         line: number;
-        endLine?: number | null;
-        visibility?: string | null;
+        endLine?: number;
+        visibility?: string;
       }>;
     }>;
     exports: Array<{ name: string; kind: string; line: number }>;
@@ -72,14 +78,14 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
         name: def.name,
         kind: def.kind,
         line: def.line,
-        endLine: def.endLine ?? null,
-        visibility: def.visibility ?? null,
+        endLine: def.endLine ?? undefined,
+        visibility: def.visibility ?? undefined,
         children: (def.children ?? []).map((c) => ({
           name: c.name,
           kind: c.kind,
           line: c.line,
-          endLine: c.endLine ?? null,
-          visibility: c.visibility ?? null,
+          endLine: c.endLine ?? undefined,
+          visibility: c.visibility ?? undefined,
         })),
       })),
       exports: symbols.exports.map((exp) => ({
@@ -138,7 +144,7 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
     fileHashes.push({ file: item.relPath, hash: item.hash, mtime, size });
   }
 
-  return ctx.nativeDb.bulkInsertNodes(batches, fileHashes, removed);
+  return ctx.nativeDb!.bulkInsertNodes(batches, fileHashes, removed);
 }
 
 // ── JS fallback: Phase 1 ────────────────────────────────────────────
@@ -330,7 +336,7 @@ function updateFileHashes(
 // ── Main entry point ────────────────────────────────────────────────
 
 export async function insertNodes(ctx: PipelineContext): Promise<void> {
-  const { db, allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+  const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
 
   // Populate fileSymbols before any DB writes (used by later stages)
   for (const [relPath, symbols] of allSymbols) {
@@ -340,11 +346,16 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
   const t0 = performance.now();
 
   // Try native Rust path first — single transaction, no JS↔C overhead
-  if (ctx.engineName === 'native' && tryNativeInsert(ctx)) {
-    ctx.timing.insertMs = performance.now() - t0;
-
-    // Removed-file hash cleanup is handled inside the native call
-    return;
+  if (ctx.engineName === 'native') {
+    try {
+      if (tryNativeInsert(ctx)) {
+        ctx.timing.insertMs = performance.now() - t0;
+        // Removed-file hash cleanup is handled inside the native call
+        return;
+      }
+    } catch {
+      // Native insert failed — fall through to JS implementation
+    }
   }
 
   // JS fallback
@@ -355,17 +366,17 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
 
   let upsertHash: SqliteStatement | null;
   try {
-    upsertHash = db.prepare(
+    upsertHash = ctx.db.prepare(
       'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
     );
   } catch {
     upsertHash = null;
   }
 
-  const insertAll = db.transaction(() => {
-    insertDefinitionsAndExports(db, allSymbols);
-    insertChildrenAndEdges(db, allSymbols);
-    updateFileHashes(db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash);
+  const insertAll = ctx.db.transaction(() => {
+    insertDefinitionsAndExports(ctx.db, allSymbols);
+    insertChildrenAndEdges(ctx.db, allSymbols);
+    updateFileHashes(ctx.db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash);
   });
 
   insertAll();
@@ -373,7 +384,7 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
 
   // Clean up removed file hashes
   if (upsertHash && removed.length > 0) {
-    const deleteHash = db.prepare('DELETE FROM file_hashes WHERE file = ?');
+    const deleteHash = ctx.db.prepare('DELETE FROM file_hashes WHERE file = ?');
     for (const relPath of removed) {
       deleteHash.run(relPath);
     }

package/src/domain/graph/builder/stages/resolve-imports.ts

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
+import { debug } from '../../../../infrastructure/logger.js';
 import type { Import } from '../../../../types.js';
 import { parseFilesAuto } from '../../../parser.js';
 import { resolveImportPath, resolveImportsBatch } from '../../resolve.js';
@@ -132,8 +133,8 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
             );
           }
         }
-      } catch {
-        /* skip if unreadable */
+      } catch (e: unknown) {
+        debug(`Barrel re-parse failed (non-fatal): ${(e as Error).message}`);
       }
     }
   }

package/src/domain/graph/resolve.ts

@@ -117,6 +117,35 @@ function matchSubpathPattern(pattern: string, subpath: string): string | null {
  * Resolve a bare specifier through the package.json exports field.
  * Returns an absolute path or null.
  */
+/** Try to resolve a condition target to a file path in packageDir. */
+function tryResolveTarget(target: string | null, packageDir: string): string | null {
+  if (!target) return null;
+  const resolved = path.resolve(packageDir, target);
+  return fs.existsSync(resolved) ? resolved : null;
+}
+
+/** Resolve subpath against a subpath map (object with "." keys). */
+function resolveSubpathMap(
+  exports: Record<string, unknown>,
+  subpath: string,
+  packageDir: string,
+): string | null {
+  // Exact match first
+  if (subpath in exports) {
+    return tryResolveTarget(resolveCondition(exports[subpath]), packageDir);
+  }
+  // Pattern matching (keys with *)
+  for (const [pattern, value] of Object.entries(exports)) {
+    if (!pattern.includes('*')) continue;
+    const matched = matchSubpathPattern(pattern, subpath);
+    if (matched == null) continue;
+    const rawTarget = resolveCondition(value);
+    if (!rawTarget) continue;
+    return tryResolveTarget(rawTarget.replace(/\*/g, matched), packageDir);
+  }
+  return null;
+}
+
 export function resolveViaExports(specifier: string, rootDir: string): string | null {
   const parsed = parseBareSpecifier(specifier);
   if (!parsed) return null;
@@ -131,66 +160,25 @@ export function resolveViaExports(specifier: string, rootDir: string): string |
 
   // Simple string exports: "exports": "./index.js"
   if (typeof exports === 'string') {
-    if (subpath === '.') {
-      const resolved = path.resolve(packageDir, exports);
-      return fs.existsSync(resolved) ? resolved : null;
-    }
-    return null;
+    return subpath === '.' ? tryResolveTarget(exports, packageDir) : null;
   }
 
   // Array form at top level
   if (Array.isArray(exports)) {
-    if (subpath === '.') {
-      const target = resolveCondition(exports);
-      if (target) {
-        const resolved = path.resolve(packageDir, target);
-        return fs.existsSync(resolved) ? resolved : null;
-      }
-    }
-    return null;
+    return subpath === '.' ? tryResolveTarget(resolveCondition(exports), packageDir) : null;
   }
 
   if (typeof exports !== 'object') return null;
 
-  // Determine if exports is a conditions object (no keys start with ".")
-  // or a subpath map (keys start with ".")
+  // Determine if exports is a conditions object or a subpath map
   const keys = Object.keys(exports);
   const isSubpathMap = keys.length > 0 && keys.some((k) => k.startsWith('.'));
 
   if (!isSubpathMap) {
-    // Conditions object at top level → applies to "." subpath only
-    if (subpath === '.') {
-      const target = resolveCondition(exports);
-      if (target) {
-        const resolved = path.resolve(packageDir, target);
-        return fs.existsSync(resolved) ? resolved : null;
-      }
-    }
-    return null;
+    return subpath === '.' ? tryResolveTarget(resolveCondition(exports), packageDir) : null;
   }
 
-  // Subpath map: try exact match first, then pattern match
-  if (subpath in exports) {
-    const target = resolveCondition(exports[subpath]);
-    if (target) {
-      const resolved = path.resolve(packageDir, target);
-      return fs.existsSync(resolved) ? resolved : null;
-    }
-  }
-
-  // Pattern matching (keys with *)
-  for (const [pattern, value] of Object.entries(exports)) {
-    if (!pattern.includes('*')) continue;
-    const matched = matchSubpathPattern(pattern, subpath);
-    if (matched == null) continue;
-    const rawTarget = resolveCondition(value);
-    if (!rawTarget) continue;
-    const target = rawTarget.replace(/\*/g, matched);
-    const resolved = path.resolve(packageDir, target);
-    if (fs.existsSync(resolved)) return resolved;
-  }
-
-  return null;
+  return resolveSubpathMap(exports as Record<string, unknown>, subpath, packageDir);
 }
 
 /** Clear the exports cache (for testing). */

package/src/domain/graph/watcher.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { closeDb, getNodeId as getNodeIdQuery, initSchema, openDb } from '../../db/index.js';
-import { info } from '../../infrastructure/logger.js';
+import { debug, info } from '../../infrastructure/logger.js';
 import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../shared/constants.js';
 import { DbError } from '../../shared/errors.js';
 import { createParseTreeCache, getActiveEngine } from '../parser.js';
@@ -32,12 +32,10 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
     ast: false,
   };
   const { name: engineName, version: engineVersion } = getActiveEngine(engineOpts);
-  console.log(
-    `Watch mode using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`,
-  );
+  info(`Watch mode using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
 
   const cache = createParseTreeCache();
-  console.log(
+  info(
     cache
       ? 'Incremental parsing enabled (native tree cache)'
       : 'Incremental parsing unavailable (full re-parse)',
@@ -124,8 +122,8 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
       }));
       try {
         appendJournalEntries(rootDir, entries);
-      } catch {
-        /* journal write failure is non-fatal */
+      } catch (e: unknown) {
+        debug(`Journal write failed (non-fatal): ${(e as Error).message}`);
       }
 
       const changeEvents = updates.map((r) =>
@@ -137,8 +135,8 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
       );
       try {
         appendChangeEvents(rootDir, changeEvents);
-      } catch {
-        /* change event write failure is non-fatal */
+      } catch (e: unknown) {
+        debug(`Change event write failed (non-fatal): ${(e as Error).message}`);
       }
     }
 
@@ -153,8 +151,8 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
     }
   }
 
-  console.log(`Watching ${rootDir} for changes...`);
-  console.log('Press Ctrl+C to stop.\n');
+  info(`Watching ${rootDir} for changes...`);
+  info('Press Ctrl+C to stop.');
 
   const watcher = fs.watch(rootDir, { recursive: true }, (_eventType, filename) => {
     if (!filename) return;
@@ -169,7 +167,7 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
   });
 
   process.on('SIGINT', () => {
-    console.log('\nStopping watcher...');
+    info('Stopping watcher...');
     watcher.close();
     // Flush any pending file paths to journal before exit
     if (pending.size > 0) {
@@ -178,8 +176,8 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
       }));
       try {
         appendJournalEntries(rootDir, entries);
-      } catch {
-        /* best-effort */
+      } catch (e: unknown) {
+        debug(`Journal flush on exit failed (non-fatal): ${(e as Error).message}`);
       }
     }
     if (cache) cache.clear();

package/src/domain/parser.ts

@@ -16,26 +16,38 @@ import type {
 
 // Re-export all extractors for backward compatibility
 export {
+  extractBashSymbols,
+  extractCppSymbols,
   extractCSharpSymbols,
+  extractCSymbols,
   extractGoSymbols,
   extractHCLSymbols,
   extractJavaSymbols,
+  extractKotlinSymbols,
   extractPHPSymbols,
   extractPythonSymbols,
   extractRubySymbols,
   extractRustSymbols,
+  extractScalaSymbols,
+  extractSwiftSymbols,
   extractSymbols,
 } from '../extractors/index.js';
 
 import {
+  extractBashSymbols,
+  extractCppSymbols,
   extractCSharpSymbols,
+  extractCSymbols,
   extractGoSymbols,
   extractHCLSymbols,
   extractJavaSymbols,
+  extractKotlinSymbols,
   extractPHPSymbols,
   extractPythonSymbols,
   extractRubySymbols,
   extractRustSymbols,
+  extractScalaSymbols,
+  extractSwiftSymbols,
   extractSymbols,
 } from '../extractors/index.js';
 
@@ -273,37 +285,38 @@ function resolveEngine(opts: ParseEngineOpts = {}): ResolvedEngine {
  *  - Backward compat for older native binaries missing js_name annotations
  *  - dataflow argFlows/mutations bindingType -> binding wrapper
  */
-function patchNativeResult(r: any): ExtractorOutput {
-  // lineCount: napi(js_name) emits "lineCount"; older binaries may emit "line_count"
-  r.lineCount = r.lineCount ?? r.line_count ?? null;
-  r._lineCount = r.lineCount;
-
-  // Backward compat for older binaries missing js_name annotations
-  if (r.definitions) {
-    for (const d of r.definitions) {
-      if (d.endLine === undefined && d.end_line !== undefined) {
-        d.endLine = d.end_line;
-      }
+/** Patch definition fields for backward compat with older native binaries. */
+function patchDefinitions(definitions: any[]): void {
+  for (const d of definitions) {
+    if (d.endLine === undefined && d.end_line !== undefined) {
+      d.endLine = d.end_line;
     }
   }
-  if (r.imports) {
-    for (const i of r.imports) {
-      if (i.typeOnly === undefined) i.typeOnly = i.type_only;
-      if (i.wildcardReexport === undefined) i.wildcardReexport = i.wildcard_reexport;
-      if (i.pythonImport === undefined) i.pythonImport = i.python_import;
-      if (i.goImport === undefined) i.goImport = i.go_import;
-      if (i.rustUse === undefined) i.rustUse = i.rust_use;
-      if (i.javaImport === undefined) i.javaImport = i.java_import;
-      if (i.csharpUsing === undefined) i.csharpUsing = i.csharp_using;
-      if (i.rubyRequire === undefined) i.rubyRequire = i.ruby_require;
-      if (i.phpUse === undefined) i.phpUse = i.php_use;
-      if (i.dynamicImport === undefined) i.dynamicImport = i.dynamic_import;
-    }
+}
+
+/** Patch import fields for backward compat with older native binaries. */
+function patchImports(imports: any[]): void {
+  for (const i of imports) {
+    if (i.typeOnly === undefined) i.typeOnly = i.type_only;
+    if (i.wildcardReexport === undefined) i.wildcardReexport = i.wildcard_reexport;
+    if (i.pythonImport === undefined) i.pythonImport = i.python_import;
+    if (i.goImport === undefined) i.goImport = i.go_import;
+    if (i.rustUse === undefined) i.rustUse = i.rust_use;
+    if (i.javaImport === undefined) i.javaImport = i.java_import;
+    if (i.csharpUsing === undefined) i.csharpUsing = i.csharp_using;
+    if (i.rubyRequire === undefined) i.rubyRequire = i.ruby_require;
+    if (i.phpUse === undefined) i.phpUse = i.php_use;
+    if (i.cInclude === undefined) i.cInclude = i.c_include;
+    if (i.kotlinImport === undefined) i.kotlinImport = i.kotlin_import;
+    if (i.swiftImport === undefined) i.swiftImport = i.swift_import;
+    if (i.scalaImport === undefined) i.scalaImport = i.scala_import;
+    if (i.bashSource === undefined) i.bashSource = i.bash_source;
+    if (i.dynamicImport === undefined) i.dynamicImport = i.dynamic_import;
   }
+}
 
-  // typeMap: native returns an array of {name, typeName}; normalize to Map.
-  // Non-TS languages may omit typeMap entirely — default to empty Map so
-  // callers can safely access .entries()/.size without null checks.
+/** Normalize native typeMap array to a Map instance. */
+function patchTypeMap(r: any): void {
   if (!r.typeMap) {
     r.typeMap = new Map();
   } else if (!(r.typeMap instanceof Map)) {
@@ -314,20 +327,31 @@ function patchNativeResult(r: any): ExtractorOutput {
       ]),
     );
   }
+}
 
-  // dataflow: wrap bindingType into binding object for argFlows and mutations
-  if (r.dataflow) {
-    if (r.dataflow.argFlows) {
-      for (const f of r.dataflow.argFlows) {
-        f.binding = f.bindingType ? { type: f.bindingType } : null;
-      }
+/** Wrap bindingType into binding object for dataflow argFlows and mutations. */
+function patchDataflow(dataflow: any): void {
+  if (dataflow.argFlows) {
+    for (const f of dataflow.argFlows) {
+      f.binding = f.bindingType ? { type: f.bindingType } : null;
     }
-    if (r.dataflow.mutations) {
-      for (const m of r.dataflow.mutations) {
-        m.binding = m.bindingType ? { type: m.bindingType } : null;
-      }
+  }
+  if (dataflow.mutations) {
+    for (const m of dataflow.mutations) {
+      m.binding = m.bindingType ? { type: m.bindingType } : null;
     }
   }
+}
+
+function patchNativeResult(r: any): ExtractorOutput {
+  // lineCount: napi(js_name) emits "lineCount"; older binaries may emit "line_count"
+  r.lineCount = r.lineCount ?? r.line_count ?? null;
+  r._lineCount = r.lineCount;
+
+  if (r.definitions) patchDefinitions(r.definitions);
+  if (r.imports) patchImports(r.imports);
+  patchTypeMap(r);
+  if (r.dataflow) patchDataflow(r.dataflow);
 
   return r;
 }
@@ -414,6 +438,48 @@ export const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
     extractor: extractPHPSymbols,
     required: false,
   },
+  {
+    id: 'c',
+    extensions: ['.c', '.h'],
+    grammarFile: 'tree-sitter-c.wasm',
+    extractor: extractCSymbols,
+    required: false,
+  },
+  {
+    id: 'cpp',
+    extensions: ['.cpp', '.cc', '.cxx', '.hpp'],
+    grammarFile: 'tree-sitter-cpp.wasm',
+    extractor: extractCppSymbols,
+    required: false,
+  },
+  {
+    id: 'kotlin',
+    extensions: ['.kt', '.kts'],
+    grammarFile: 'tree-sitter-kotlin.wasm',
+    extractor: extractKotlinSymbols,
+    required: false,
+  },
+  {
+    id: 'swift',
+    extensions: ['.swift'],
+    grammarFile: 'tree-sitter-swift.wasm',
+    extractor: extractSwiftSymbols,
+    required: false,
+  },
+  {
+    id: 'scala',
+    extensions: ['.scala'],
+    grammarFile: 'tree-sitter-scala.wasm',
+    extractor: extractScalaSymbols,
+    required: false,
+  },
+  {
+    id: 'bash',
+    extensions: ['.sh', '.bash'],
+    grammarFile: 'tree-sitter-bash.wasm',
+    extractor: extractBashSymbols,
+    required: false,
+  },
 ];
 
 const _extToLang: Map<string, LanguageRegistryEntry> = new Map();
@@ -522,73 +588,48 @@ export async function parseFileAuto(
   return extracted ? extracted.symbols : null;
 }
 
-/**
- * Parse multiple files in bulk and return a Map<relPath, symbols>.
- */
-export async function parseFilesAuto(
-  filePaths: string[],
-  rootDir: string,
-  opts: ParseEngineOpts = {},
-): Promise<Map<string, ExtractorOutput>> {
-  const { native } = resolveEngine(opts);
-  const result = new Map<string, ExtractorOutput>();
+/** Backfill typeMap via WASM for files missing type-map data from native engine. */
+async function backfillTypeMapBatch(
+  needsTypeMap: { filePath: string; relPath: string }[],
+  result: Map<string, ExtractorOutput>,
+): Promise<void> {
+  const tsFiles = needsTypeMap.filter(({ filePath }) =>
+    TS_BACKFILL_EXTS.has(path.extname(filePath)),
+  );
+  if (tsFiles.length === 0) return;
 
-  if (native) {
-    const nativeResults = native.parseFiles(
-      filePaths,
-      rootDir,
-      !!opts.dataflow,
-      opts.ast !== false,
-    );
-    const needsTypeMap: { filePath: string; relPath: string }[] = [];
-    for (const r of nativeResults) {
-      if (!r) continue;
-      const patched = patchNativeResult(r);
-      const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
-      result.set(relPath, patched);
-      if (patched.typeMap.size === 0) {
-        needsTypeMap.push({ filePath: r.file, relPath });
+  const parsers = await createParsers();
+  for (const { filePath, relPath } of tsFiles) {
+    let extracted: WasmExtractResult | null | undefined;
+    try {
+      const code = fs.readFileSync(filePath, 'utf-8');
+      extracted = wasmExtractSymbols(parsers, filePath, code);
+      if (extracted?.symbols && extracted.symbols.typeMap.size > 0) {
+        const symbols = result.get(relPath);
+        if (!symbols) continue;
+        symbols.typeMap = extracted.symbols.typeMap;
+        symbols._typeMapBackfilled = true;
       }
-    }
-    // Backfill typeMap via WASM for native binaries that predate the type-map feature
-    if (needsTypeMap.length > 0) {
-      // Only backfill for languages where WASM extraction can produce typeMap
-      // (TS/TSX have type annotations; JS only has `new Expr()` which native already handles)
-      const tsFiles = needsTypeMap.filter(({ filePath }) =>
-        TS_BACKFILL_EXTS.has(path.extname(filePath)),
-      );
-      if (tsFiles.length > 0) {
-        const parsers = await createParsers();
-        for (const { filePath, relPath } of tsFiles) {
-          let extracted: WasmExtractResult | null | undefined;
-          try {
-            const code = fs.readFileSync(filePath, 'utf-8');
-            extracted = wasmExtractSymbols(parsers, filePath, code);
-            if (extracted?.symbols && extracted.symbols.typeMap.size > 0) {
-              const symbols = result.get(relPath);
-              if (!symbols) continue;
-              symbols.typeMap = extracted.symbols.typeMap;
-              symbols._typeMapBackfilled = true;
-            }
-          } catch (e) {
-            debug(`batchExtract: typeMap backfill failed: ${toErrorMessage(e)}`);
-          } finally {
-            // Free the WASM tree to prevent memory accumulation across repeated builds
-            if (extracted?.tree && typeof extracted.tree.delete === 'function') {
-              try {
-                extracted.tree.delete();
-              } catch (e) {
-                debug(`batchExtract: WASM tree cleanup failed: ${toErrorMessage(e)}`);
-              }
-            }
-          }
+    } catch (e) {
+      debug(`batchExtract: typeMap backfill failed: ${toErrorMessage(e)}`);
+    } finally {
+      if (extracted?.tree && typeof extracted.tree.delete === 'function') {
+        try {
+          extracted.tree.delete();
+        } catch (e) {
+          debug(`batchExtract: WASM tree cleanup failed: ${toErrorMessage(e)}`);
         }
       }
     }
-    return result;
   }
+}
 
-  // WASM path
+/** Parse files via WASM engine, returning a Map<relPath, symbols>. */
+async function parseFilesWasm(
+  filePaths: string[],
+  rootDir: string,
+): Promise<Map<string, ExtractorOutput>> {
+  const result = new Map<string, ExtractorOutput>();
   const parsers = await createParsers();
   for (const filePath of filePaths) {
     let code: string;
@@ -610,6 +651,36 @@ export async function parseFilesAuto(
   return result;
 }
 
+/**
+ * Parse multiple files in bulk and return a Map<relPath, symbols>.
+ */
+export async function parseFilesAuto(
+  filePaths: string[],
+  rootDir: string,
+  opts: ParseEngineOpts = {},
+): Promise<Map<string, ExtractorOutput>> {
+  const { native } = resolveEngine(opts);
+
+  if (!native) return parseFilesWasm(filePaths, rootDir);
+
+  const result = new Map<string, ExtractorOutput>();
+  const nativeResults = native.parseFiles(filePaths, rootDir, !!opts.dataflow, opts.ast !== false);
+  const needsTypeMap: { filePath: string; relPath: string }[] = [];
+  for (const r of nativeResults) {
+    if (!r) continue;
+    const patched = patchNativeResult(r);
+    const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
+    result.set(relPath, patched);
+    if (patched.typeMap.size === 0) {
+      needsTypeMap.push({ filePath: r.file, relPath });
+    }
+  }
+  if (needsTypeMap.length > 0) {
+    await backfillTypeMapBatch(needsTypeMap, result);
+  }
+  return result;
+}
+
 /**
  * Report which engine is active.
  */