Proof-of-Pass Receipt

diff --git a/src/lib/analysis/analyzers/shared.test.ts b/src/lib/analysis/analyzers/shared.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..88dfc1282844cff4fc0461145c75661b8a5e6ad8
--- /dev/null
+++ b/src/lib/analysis/analyzers/shared.test.ts
@@ -0,0 +1,61 @@
+import type Parser from "web-tree-sitter";
+import { expect, test, vi } from "vitest";
+import { getParser } from "../treesitter";
+import { analyzeProjectWith, type LangSpec } from "./shared";
+
+vi.mock("../treesitter", () => ({
+  getParser: vi.fn(),
+}));
+
+test("deletes a parsed tree when extraction throws", async () => {
+  const extractionError = new Error("capture failed");
+  const deleteTree = vi.fn();
+  const tree = {
+    rootNode: {},
+    delete: deleteTree,
+  } as unknown as Parser.Tree;
+
+  const defQuery = {
+    captures: vi.fn(() => {
+      throw extractionError;
+    }),
+    delete: vi.fn(),
+  } as unknown as Parser.Query;
+  const callQuery = {
+    captures: vi.fn(() => []),
+    delete: vi.fn(),
+  } as unknown as Parser.Query;
+  const importQuery = {
+    captures: vi.fn(() => []),
+    delete: vi.fn(),
+  } as unknown as Parser.Query;
+
+  const parser = {
+    setTimeoutMicros: vi.fn(),
+    parse: vi.fn(() => tree),
+    delete: vi.fn(),
+  } as unknown as Parser;
+  const language = {
+    query: vi
+      .fn()
+      .mockReturnValueOnce(defQuery)
+      .mockReturnValueOnce(callQuery)
+      .mockReturnValueOnce(importQuery),
+  } as unknown as Parser.Language;
+  vi.mocked(getParser).mockResolvedValue({ parser, language });
+
+  const spec: LangSpec = {
+    language: "test",
+    wasm: "test.wasm",
+    funcDefQuery: "(function) @def",
+    callQuery: "(call) @callee",
+    importQuery: "(import) @mod",
+    funcDefTypes: new Set(["function"]),
+    resolveModule: () => null,
+  };
+
+  await expect(
+    analyzeProjectWith(spec, [{ path: "input.test", content: "source" }]),
+  ).rejects.toBe(extractionError);
+  expect(deleteTree).toHaveBeenCalledOnce();
+});
diff --git a/src/lib/analysis/analyzers/shared.ts b/src/lib/analysis/analyzers/shared.ts
index ae7437761ed8b2f0bace05b23219ad7c3720c22f..a0ab230a1f2a65e9223425892c47d49aa9826b7f 100644
--- a/src/lib/analysis/analyzers/shared.ts
+++ b/src/lib/analysis/analyzers/shared.ts
@@ -122,65 +122,68 @@ function parseFile(
       imports: new Set<string>(),
     };
   }
-  const root = tree.rootNode;
-
-  const classNodeTypes = spec.classNodeTypes ?? new Set<string>();
-  const defs = new Set<string>();
-  const methodClass = new Map<string, string | null>();
-  for (const { node } of queries.defQuery.captures(root)) {
-    const name = resolveName(node);
-    if (!name) continue;
-    defs.add(name);
-    const cls = enclosingClassName(node, classNodeTypes);
-    // Same name in different contexts (two classes, or module-level vs class)
-    // -> ambiguous, mark null so we don't attribute it to the wrong class.
-    if (methodClass.has(name)) {
-      if (methodClass.get(name) !== cls) methodClass.set(name, null);
-    } else {
-      methodClass.set(name, cls);
-    }
-  }
+  try {
+    const root = tree.rootNode;
 
-  const classes = new Set<string>();
-  const extendsRel: { cls: string; base: string }[] = [];
-  if (queries.classQuery) {
-    for (const { node } of queries.classQuery.captures(root)) {
+    const classNodeTypes = spec.classNodeTypes ?? new Set<string>();
+    const defs = new Set<string>();
+    const methodClass = new Map<string, string | null>();
+    for (const { node } of queries.defQuery.captures(root)) {
       const name = resolveName(node);
       if (!name) continue;
-      classes.add(name);
-      const bases = spec.classBases?.(node) ?? [];
-      for (const base of bases) extendsRel.push({ cls: name, base });
+      defs.add(name);
+      const cls = enclosingClassName(node, classNodeTypes);
+      // Same name in different contexts (two classes, or module-level vs class)
+      // -> ambiguous, mark null so we don't attribute it to the wrong class.
+      if (methodClass.has(name)) {
+        if (methodClass.get(name) !== cls) methodClass.set(name, null);
+      } else {
+        methodClass.set(name, cls);
+      }
     }
-  }
 
-  const calls: { caller: string | null; callee: string }[] = [];
-  for (const { node } of queries.callQuery.captures(root)) {
-    calls.push({
-      caller: enclosingFunctionName(node, spec.funcDefTypes),
-      callee: node.text,
-    });
-  }
+    const classes = new Set<string>();
+    const extendsRel: { cls: string; base: string }[] = [];
+    if (queries.classQuery) {
+      for (const { node } of queries.classQuery.captures(root)) {
+        const name = resolveName(node);
+        if (!name) continue;
+        classes.add(name);
+        const bases = spec.classBases?.(node) ?? [];
+        for (const base of bases) extendsRel.push({ cls: name, base });
+      }
+    }
 
-  const imports = new Set<string>();
-  for (const { node } of queries.importQuery.captures(root)) {
-    const target = spec.resolveModule(
-      source.path,
-      stripQuotes(node.text),
-      paths,
-    );
-    if (target && target !== source.path) imports.add(target);
-  }
+    const calls: { caller: string | null; callee: string }[] = [];
+    for (const { node } of queries.callQuery.captures(root)) {
+      calls.push({
+        caller: enclosingFunctionName(node, spec.funcDefTypes),
+        callee: node.text,
+      });
+    }
 
-  tree.delete();
-  return {
-    file: source.path,
-    defs,
-    methodClass,
-    classes,
-    extendsRel,
-    calls,
-    imports,
-  };
+    const imports = new Set<string>();
+    for (const { node } of queries.importQuery.captures(root)) {
+      const target = spec.resolveModule(
+        source.path,
+        stripQuotes(node.text),
+        paths,
+      );
+      if (target && target !== source.path) imports.add(target);
+    }
+
+    return {
+      file: source.path,
+      defs,
+      methodClass,
+      classes,
+      extendsRel,
+      calls,
+      imports,
+    };
+  } finally {
+    tree.delete();
+  }
 }
 
 /** Pick the defining file for a name, preferring local, then imported, then unique. */