fix: free leaked WASM trees in native engine typeMap backfill

[carlos-alm]

Summary

• Free WASM trees in backfillTypeMap() and the parseFilesAuto() bulk backfill loop — previously these trees were never freed, accumulating in WASM linear memory across repeated builds
• Skip backfill for JS files — only TS/TSX files 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 and the primary leak vector for JS-only codebases like codegraph itself

Closes #530

Root cause

When the native engine is used, parseFilesAuto calls native.parseFiles() then checks if any files need typeMap backfill via WASM. For every file where typeMap was empty (all JS files — they have no type annotations), it called wasmExtractSymbols() which returns a { symbols, tree } object. The tree (WASM tree-sitter Tree requiring explicit .delete()) was never freed. Over repeated builds in benchmarks, hundreds of leaked trees accumulated in WASM linear memory, eventually corrupting V8 internal state and crashing the native addon with ACCESS_VIOLATION (0xC0000005) or V8 has_exception() assertion failures.

Test plan

• 478 integration tests pass (3 pre-existing WASM grammar failures unrelated)
• Lint clean
• Run node scripts/benchmark.js — native worker should complete all iterations without crashing
• Run node scripts/query-benchmark.js — native worker should complete without V8 assertion failure

[greptile-apps]

Greptile Summary

This PR fixes a WASM linear memory leak in the native engine's typeMap backfill path: backfillTypeMap now wraps its result logic in try/finally to guarantee tree.delete() is called, and parseFilesAuto / parseFileAuto / parseFileIncremental now skip the WASM backfill entirely for JS files (which carry no type annotations). Together these eliminate the hundreds of leaked trees that accumulated across repeated builds and eventually corrupted V8 internal state.

• The try/finally pattern in backfillTypeMap and the bulk parseFilesAuto loop correctly handles both early-return and error paths, ensuring trees are freed in all cases.
• Restricting backfill to .ts/.tsx is both a correctness improvement (JS WASM extraction can't produce typeMap) and the primary leak vector for JS-only codebases.
• TS_BACKFILL_EXTS / TS_EXTS constants are re-created as new Set(...) inside parseFileAuto and parseFileIncremental on every call; these should be a single module-level constant.
• wasmExtractSymbols itself still leaks a WASM tree in the !entry and !symbols early-return paths — these are not introduced by this PR but remain unaddressed now that callers have been hardened.
• The edge_builder.rs changes (adding struct, record, enum, trait to inheritance edge matching) are unrelated to the leak fix and should be shipped in a separate PR per the project's "one PR = one concern" convention.

Confidence Score: 4/5

• Safe to merge for the JS-side fix; the bundled Rust change should ideally be split out but poses no regression risk.
• The core leak-fix logic is sound and the try/finally pattern is correctly applied in all three backfill call sites. The JS-file skip is semantically correct. Minor residual issues (inline Set allocations, two internal wasmExtractSymbols leak paths) do not affect correctness. The unrelated edge_builder.rs change is a process concern rather than a bug.
• src/domain/parser.js — wasmExtractSymbols still has two internal tree-leak paths; crates/codegraph-core/src/edge_builder.rs — unrelated change bundled into this PR

Important Files Changed

Filename	Overview
src/domain/parser.js	Core WASM tree-leak fix: backfillTypeMap now uses try/finally to guarantee tree.delete() is called, and parseFilesAuto/parseFileAuto/parseFileIncremental now skip WASM backfill for JS files. Logic is correct. Minor: TS_BACKFILL_EXTS constant is re-allocated per call, and wasmExtractSymbols still has two internal leak paths not addressed by this PR.
crates/codegraph-core/src/edge_builder.rs	Extends class-inheritance and implements edge matching to accept struct, record, enum, and trait node kinds — broadening support for non-class OOP constructs. The logic itself is sound but this change is unrelated to the WASM tree-leak fix and should be in a separate PR per project convention.

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[parseFilesAuto / parseFileAuto] --> B{Native engine?}
    B -- No --> C[WASM path: wasmExtractSymbols\nstores tree in symbols._tree]
    B -- Yes --> D[native.parseFiles / parseFile]
    D --> E{typeMap empty?}
    E -- No --> F[Return result]
    E -- Yes --> G{ext in .ts or .tsx?\nNEW: skip JS files}
    G -- No --> F
    G -- Yes --> H[backfillTypeMap]
    H --> I[createParsers]
    I --> J[wasmExtractSymbols]
    J --> K{symbols?.typeMap?}
    K -- No --> L[return typeMap empty]
    K -- Yes --> M[build Map from typeMap]
    M --> N[return typeMap, backfilled=true]
    L --> O[finally: extracted?.tree?.delete\nNEW: always free WASM tree]
    N --> O
    O --> F

Loading

_{Last reviewed commit: "fix: address review ..."}

[greptile-apps]

Inconsistent return value on first vs. subsequent cache hits

On the first call for a given cwd, loadConfig returns the actual cached object stored in _configCache. All subsequent calls correctly return a structuredClone. If any caller mutates the returned config (e.g., patching llm.apiKey or similar), the cached entry is silently corrupted and all future callers receive the mutated data.

Both return sites after populating the cache should return a clone for consistency:

Suggested change

	const result = resolveSecrets(applyEnvOverrides(merged));
	_configCache.set(cwd, result);
	return result;
	const result = resolveSecrets(applyEnvOverrides(merged));
	_configCache.set(cwd, result);
	return structuredClone(result);

[carlos-alm]

Addressed. The merge with main already brought in the structuredClone fix for both cache-population return sites (commit f8016c6 on main). The merged resolution preserves structuredClone(result) when storing to cache, so the first caller gets the raw object and the cache holds an isolated copy.

[greptile-apps]

Same raw-reference return for the defaults branch

The defaults code path has the same issue — the object stored in the cache is returned directly on the first call. This should also return a structuredClone to match the behaviour of the early-return cache hit path above:

Suggested change

	const defaults = resolveSecrets(applyEnvOverrides({ ...DEFAULTS }));
	_configCache.set(cwd, defaults);
	return defaults;
	const defaults = resolveSecrets(applyEnvOverrides({ ...DEFAULTS }));
	_configCache.set(cwd, defaults);
	return structuredClone(defaults);

[carlos-alm]

Addressed. Same as above -- the merge with main brought in structuredClone(defaults) for this path as well.

[carlos-alm]

@greptileai re-review: merged origin/main to resolve config.js conflicts (structuredClone fix already on main), refactored backfillTypeMap to use a single finally block for tree cleanup, and added TS/TSX extension guard to parseFileAuto and parseFileIncremental single-file paths to skip unnecessary WASM parsing for JS files.