fix: free leaked WASM trees in native engine typeMap backfill (#534)

* perf: reduce query latency regression from 3.1.4 → 3.3.0

Three targeted fixes for the +28–56% query latency regression:

1. Pin benchmark hub target to stable function names (buildGraph,
   openDb, loadConfig) instead of auto-selecting the most-connected
   node. Barrel/type files becoming the hub made version-to-version
   comparison meaningless.

2. Gate implementors queries in bfsTransitiveCallers — check once
   whether the graph has any 'implements' edges before doing per-node
   findNodeById + findImplementors lookups. Skips all implementor
   overhead for codebases without interface/trait hierarchies.

3. Cache loadConfig() results per cwd. The config file is read from
   disk on every fnImpactData and diffImpactData call; caching
   eliminates redundant fs.existsSync + readFileSync + JSON.parse
   per query invocation.

Impact: 5 functions changed, 123 affected

* fix: return structuredClone from config cache and guard benchmark db handle

Prevent callers from mutating the cached config object by returning a
deep clone on cache hits. Add try/finally to selectTargets() so the
database handle is closed even if a query throws.

Impact: 2 functions changed, 1 affected

* fix: install @huggingface/transformers in npm-mode benchmark workers

The embedding benchmark's npm mode installs codegraph into a temp dir,
but @huggingface/transformers is a devDependency and not included.
All 6 model workers crash on import, producing symbols: 0, models: {}.

Install it explicitly from the local devDependencies version, matching
the existing pattern for native platform packages. Also add a guard in
update-embedding-report.js to reject empty results and fail loudly
instead of silently overwriting valid benchmark data.

* fix: free leaked WASM trees in native engine typeMap backfill

The typeMap backfill path in parseFilesAuto and backfillTypeMap called
wasmExtractSymbols but never freed the returned WASM tree objects.
Over repeated builds (benchmarks, watch mode), hundreds of trees
accumulated in WASM linear memory, eventually corrupting V8 state and
crashing the native addon with ACCESS_VIOLATION / has_exception().

Two fixes:
1. Free WASM trees immediately after extracting typeMap data in both
   backfillTypeMap() and the parseFilesAuto() bulk backfill loop.
2. Skip backfill entirely for JS files — only TS/TSX have type
   annotations that WASM can extract. The native engine already
   handles JS `new Expr()` patterns, so re-parsing all JS files
   with WASM was pure waste.

Closes #530

Impact: 2 functions changed, 2 affected

* fix(native): align edge builder kind filters with JS parity

The Rust edge builder only matched `kind == "class"` when looking up
source nodes and targets for extends/implements edges. This caused all
`impl Trait for Struct` relationships (and any non-class hierarchy) to
be silently dropped — producing 0 implements edges for Rust sources
while WASM correctly found 9.

Align the three kind filter sets with the JS-side constants:
- Source: class, struct, record, enum (was: class only)
- Extends targets: class, struct, trait, record (was: class only)
- Implements targets: interface, class, trait (was: interface, class)

Fixes #530 (partial — implements parity gap)

Impact: 1 functions changed, 0 affected

* fix: address review feedback on WASM tree cleanup and JS backfill skip

- Consolidate duplicated tree.delete() in backfillTypeMap into a single
  finally block, preventing future early-return paths from leaking trees
- Skip WASM typeMap backfill for JS files in parseFileAuto and
  parseFileIncremental single-file paths, matching the bulk path behavior

Impact: 3 functions changed, 2 affected

Author: carlos-alm

crates/codegraph-core/src/edge_builder.rs

@@ -339,13 +339,17 @@ pub fn build_call_edges(
         for cls in &file_input.classes {
             let source_row = nodes_by_name_and_file
                 .get(&(cls.name.as_str(), rel_path.as_str()))
-                .and_then(|v| v.iter().find(|n| n.kind == "class"));
+                .and_then(|v| v.iter().find(|n| {
+                    n.kind == "class" || n.kind == "struct" || n.kind == "record" || n.kind == "enum"
+                }));
 
             if let Some(source) = source_row {
                 if let Some(ref extends_name) = cls.extends {
                     let targets = nodes_by_name
                         .get(extends_name.as_str())
-                        .map(|v| v.iter().filter(|n| n.kind == "class").collect::<Vec<_>>())
+                        .map(|v| v.iter().filter(|n| {
+                            n.kind == "class" || n.kind == "struct" || n.kind == "trait" || n.kind == "record"
+                        }).collect::<Vec<_>>())
                         .unwrap_or_default();
                     for t in targets {
                         edges.push(ComputedEdge {
@@ -362,7 +366,7 @@ pub fn build_call_edges(
                         .get(implements_name.as_str())
                         .map(|v| {
                             v.iter()
-                                .filter(|n| n.kind == "interface" || n.kind == "class")
+                                .filter(|n| n.kind == "interface" || n.kind == "class" || n.kind == "trait")
                                 .collect::<Vec<_>>()
                         })
                         .unwrap_or_default();

src/domain/parser.js

@@ -395,12 +395,23 @@ async function backfillTypeMap(filePath, source) {
   }
   const parsers = await createParsers();
   const extracted = wasmExtractSymbols(parsers, filePath, code);
-  if (!extracted?.symbols?.typeMap) return { typeMap: [], backfilled: false };
-  const tm = extracted.symbols.typeMap;
-  return {
-    typeMap: tm instanceof Map ? tm : new Map(tm.map((e) => [e.name, e.typeName])),
-    backfilled: true,
-  };
+  try {
+    if (!extracted?.symbols?.typeMap) {
+      return { typeMap: [], backfilled: false };
+    }
+    const tm = extracted.symbols.typeMap;
+    return {
+      typeMap: tm instanceof Map ? tm : new Map(tm.map((e) => [e.name, e.typeName])),
+      backfilled: true,
+    };
+  } 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 {}
+    }
+  }
 }
 
 /**
@@ -441,7 +452,13 @@ export async function parseFileAuto(filePath, source, opts = {}) {
     const result = native.parseFile(filePath, source, !!opts.dataflow, opts.ast !== false);
     if (!result) return null;
     const patched = patchNativeResult(result);
-    if (!patched.typeMap || patched.typeMap.length === 0) {
+    // Only backfill typeMap for TS/TSX — JS files have no type annotations,
+    // and the native engine already handles `new Expr()` patterns.
+    const TS_BACKFILL_EXTS = new Set(['.ts', '.tsx']);
+    if (
+      (!patched.typeMap || patched.typeMap.length === 0) &&
+      TS_BACKFILL_EXTS.has(path.extname(filePath))
+    ) {
       const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
       patched.typeMap = typeMap;
       if (backfilled) patched._typeMapBackfilled = true;
@@ -486,21 +503,35 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
     }
     // Backfill typeMap via WASM for native binaries that predate the type-map feature
     if (needsTypeMap.length > 0) {
-      const parsers = await createParsers();
-      for (const { filePath, relPath } of needsTypeMap) {
-        try {
-          const code = fs.readFileSync(filePath, 'utf-8');
-          const extracted = wasmExtractSymbols(parsers, filePath, code);
-          if (extracted?.symbols?.typeMap) {
-            const symbols = result.get(relPath);
-            symbols.typeMap =
-              extracted.symbols.typeMap instanceof Map
-                ? extracted.symbols.typeMap
-                : new Map(extracted.symbols.typeMap.map((e) => [e.name, e.typeName]));
-            symbols._typeMapBackfilled = true;
+      // 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 TS_EXTS = new Set(['.ts', '.tsx']);
+      const tsFiles = needsTypeMap.filter(({ filePath }) => TS_EXTS.has(path.extname(filePath)));
+      if (tsFiles.length > 0) {
+        const parsers = await createParsers();
+        for (const { filePath, relPath } of tsFiles) {
+          let extracted;
+          try {
+            const code = fs.readFileSync(filePath, 'utf-8');
+            extracted = wasmExtractSymbols(parsers, filePath, code);
+            if (extracted?.symbols?.typeMap) {
+              const symbols = result.get(relPath);
+              symbols.typeMap =
+                extracted.symbols.typeMap instanceof Map
+                  ? extracted.symbols.typeMap
+                  : new Map(extracted.symbols.typeMap.map((e) => [e.name, e.typeName]));
+              symbols._typeMapBackfilled = true;
+            }
+          } catch {
+            /* skip — typeMap is a best-effort backfill */
+          } 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 {}
+            }
           }
-        } catch {
-          /* skip — typeMap is a best-effort backfill */
         }
       }
     }
@@ -578,7 +609,13 @@ export async function parseFileIncremental(cache, filePath, source, opts = {}) {
     const result = cache.parseFile(filePath, source);
     if (!result) return null;
     const patched = patchNativeResult(result);
-    if (!patched.typeMap || patched.typeMap.length === 0) {
+    // Only backfill typeMap for TS/TSX — JS files have no type annotations,
+    // and the native engine already handles `new Expr()` patterns.
+    const TS_BACKFILL_EXTS = new Set(['.ts', '.tsx']);
+    if (
+      (!patched.typeMap || patched.typeMap.length === 0) &&
+      TS_BACKFILL_EXTS.has(path.extname(filePath))
+    ) {
       const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
       patched.typeMap = typeMap;
       if (backfilled) patched._typeMapBackfilled = true;