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

Author: carlos-alm

src/domain/parser.js

@@ -395,8 +395,22 @@ async function backfillTypeMap(filePath, source) {
   }
   const parsers = await createParsers();
   const extracted = wasmExtractSymbols(parsers, filePath, code);
-  if (!extracted?.symbols?.typeMap) return { typeMap: [], backfilled: false };
+  if (!extracted?.symbols?.typeMap) {
+    // Free the WASM tree to prevent memory accumulation across repeated builds
+    if (extracted?.tree && typeof extracted.tree.delete === 'function') {
+      try {
+        extracted.tree.delete();
+      } catch {}
+    }
+    return { typeMap: [], backfilled: false };
+  }
   const tm = extracted.symbols.typeMap;
+  // Free the WASM tree — only the typeMap data is needed
+  if (extracted.tree && typeof extracted.tree.delete === 'function') {
+    try {
+      extracted.tree.delete();
+    } catch {}
+  }
   return {
     typeMap: tm instanceof Map ? tm : new Map(tm.map((e) => [e.name, e.typeName])),
     backfilled: true,
@@ -486,21 +500,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 */
         }
       }
     }