@orangepro/orangepro-mcp 0.1.0

package/dist/local/analyze/treeSitter/engine.js

@@ -0,0 +1,1253 @@
+/**
+ * Language-agnostic symbol extraction via tree-sitter (web-tree-sitter WASM — no
+ * native build, ships in the npm package). Grammars are LOADED ASYNC once
+ * (preloadTreeSitter), then extraction is SYNC so it drops into the synchronous
+ * analyzer walk. Replaces the fragile per-language regexes for non-TS languages.
+ */
+import { createRequire } from "node:module";
+import { Parser, Language } from "web-tree-sitter";
+import { MAX_SYMBOLS_PER_FILE } from "../symbols.js";
+import { TS_LANG_CONFIGS } from "./languages.js";
+const require = createRequire(import.meta.url);
+let initPromise = null;
+const loaded = new Map();
+const failed = new Set();
+const parsers = new Map();
+/** Resolve a grammar wasm shipped by the tree-sitter-wasms dependency. */
+function grammarPath(wasm) {
+    return require.resolve(`tree-sitter-wasms/out/${wasm}`);
+}
+/**
+ * Load the tree-sitter runtime + the grammars for `languages` (once; idempotent).
+ * Never throws. Returns which languages loaded vs FAILED so the caller/analyzer can
+ * surface a downgrade instead of silently serving shallow regex extraction.
+ */
+export async function preloadTreeSitter(languages) {
+    const requested = [...new Set(languages)].filter((l) => TS_LANG_CONFIGS[l]);
+    try {
+        if (!initPromise)
+            initPromise = Parser.init();
+        await initPromise;
+    }
+    catch {
+        // Runtime wasm failed → every requested grammar is unavailable.
+        for (const language of requested)
+            if (!loaded.has(language))
+                failed.add(language);
+        return treeSitterStatus();
+    }
+    for (const language of requested) {
+        if (loaded.has(language))
+            continue;
+        try {
+            loaded.set(language, await Language.load(grammarPath(TS_LANG_CONFIGS[language].wasm)));
+            failed.delete(language);
+        }
+        catch {
+            failed.add(language); // attempted + errored — distinct from "never preloaded"
+        }
+    }
+    return treeSitterStatus();
+}
+/** Snapshot of which grammars are ready vs failed (for analysis metadata / warnings). */
+export function treeSitterStatus() {
+    return { loaded: [...loaded.keys()], failed: [...failed] };
+}
+/** True once a grammar for `language` is loaded and ready for sync extraction. */
+export function treeSitterReady(language) {
+    return loaded.has(language);
+}
+/** True when a grammar load was ATTEMPTED and failed (vs simply never preloaded). */
+export function treeSitterFailed(language) {
+    return failed.has(language);
+}
+/** Test-only: forget loaded grammars so a test can exercise the pre-preload (regex) path. */
+export function __resetTreeSitterForTests() {
+    loaded.clear();
+    failed.clear();
+    parsers.clear();
+}
+function parserFor(language) {
+    const lang = loaded.get(language);
+    if (!lang)
+        return null;
+    let parser = parsers.get(language);
+    if (!parser) {
+        parser = new Parser();
+        parser.setLanguage(lang);
+        parsers.set(language, parser);
+    }
+    return parser;
+}
+// A trivial getter returns a bare field / `this.field` / `this`; never a call,
+// arithmetic, or anything with behavior. Used to make boilerplate exclusion
+// body-aware so `getOwner()` that calls a repository is NOT dropped.
+const TRIVIAL_RETURN_TYPES = new Set(["identifier", "field_access", "this"]);
+const RESERVED_SYMBOL_NAMES = new Set([
+    "auto",
+    "bool",
+    "case",
+    "char",
+    "class",
+    "const",
+    "default",
+    "define",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "extern",
+    "float",
+    "for",
+    "goto",
+    "if",
+    "ifdef",
+    "ifndef",
+    "include",
+    "inline",
+    "int",
+    "long",
+    "namespace",
+    "private",
+    "protected",
+    "public",
+    "register",
+    "return",
+    "short",
+    "signed",
+    "sizeof",
+    "static",
+    "struct",
+    "switch",
+    "template",
+    "typename",
+    "typedef",
+    "union",
+    "unsigned",
+    "void",
+    "volatile",
+    "while"
+]);
+const FUNCTION_DECLARATOR_TYPES = new Set(["function_declarator"]);
+/** Statement children of a block, ignoring comments. */
+function blockStatements(block) {
+    const out = [];
+    for (let i = 0; i < block.namedChildCount; i++) {
+        const c = block.namedChild(i);
+        if (c && !/comment/.test(c.type))
+            out.push(c);
+    }
+    return out;
+}
+/**
+ * AST-proven trivial accessor: an empty body, a single bare-field `return`, or a
+ * single `this.field = param` assignment. Java-only for now (the motivating
+ * entity-heavy case); other languages return false so a name match alone never
+ * excludes a method. Abstract/interface methods (no body) are NOT trivial — they
+ * are contract surface and stay countable.
+ */
+function isTrivialAccessorBody(methodNode, language) {
+    if (language !== "java")
+        return false;
+    const body = methodNode.childForFieldName("body");
+    if (!body || body.type !== "block")
+        return false;
+    const stmts = blockStatements(body);
+    if (stmts.length === 0)
+        return true; // empty body
+    if (stmts.length !== 1)
+        return false;
+    const s = stmts[0];
+    if (s.type === "return_statement") {
+        const expr = s.namedChild(0);
+        return !expr || TRIVIAL_RETURN_TYPES.has(expr.type); // return this.field / return field / return;
+    }
+    if (s.type === "expression_statement") {
+        const assign = s.namedChild(0);
+        if (assign?.type !== "assignment_expression")
+            return false;
+        return assign.childForFieldName("right")?.type === "identifier"; // this.field = param
+    }
+    return false;
+}
+function firstDescendantOfType(node, types) {
+    for (const child of namedChildren(node)) {
+        if (types.has(child.type))
+            return child;
+        const nested = firstDescendantOfType(child, types);
+        if (nested)
+            return nested;
+    }
+    return null;
+}
+function hasAncestorType(node, type) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === type)
+            return true;
+        cur = cur.parent;
+    }
+    return false;
+}
+function shouldEmitSymbol(node, language) {
+    if (language === "rust" && node.type === "function_signature_item") {
+        return hasAncestorType(node, "trait_item");
+    }
+    return true;
+}
+function symbolName(node, cfg) {
+    if (node.type === "function_definition" && cfg.nameNodeTypes) {
+        const declarator = node.childForFieldName("declarator");
+        const functionDeclarator = declarator?.type === "function_declarator" ? declarator : declarator ? firstDescendantOfType(declarator, FUNCTION_DECLARATOR_TYPES) : null;
+        const fromDeclarator = functionDeclarator ? firstDescendantOfType(functionDeclarator, cfg.nameNodeTypes) : null;
+        return fromDeclarator?.text;
+    }
+    if (["struct_specifier", "union_specifier", "enum_specifier", "class_specifier"].includes(node.type)) {
+        if (!node.childForFieldName("body"))
+            return undefined;
+        return node.childForFieldName(cfg.nameField)?.text;
+    }
+    return node.childForFieldName(cfg.nameField)?.text ?? (cfg.nameNodeTypes ? firstDescendantOfType(node, cfg.nameNodeTypes)?.text : undefined);
+}
+function nodeLines(node) {
+    return { start_line: node.startPosition.row + 1, end_line: node.endPosition.row + 1 };
+}
+/**
+ * Extract class/function/method symbol metadata (names + a trivial-accessor flag —
+ * never source bodies) from a tree-sitter-supported language. Sync; returns [] when
+ * the grammar isn't loaded.
+ */
+export function extractTreeSitterSymbols(content, language) {
+    const cfg = TS_LANG_CONFIGS[language];
+    const parser = parserFor(language);
+    if (!cfg || !parser)
+        return { symbols: [], truncated: false };
+    const tree = parser.parse(content);
+    if (!tree)
+        return { symbols: [], truncated: false };
+    const byName = new Map();
+    let truncated = false;
+    const add = (sym) => {
+        const existing = byName.get(sym.name);
+        if (existing) {
+            // Prefer a class over a method/function of the same name (rare collisions).
+            if (existing.symbol_kind !== "class" && sym.symbol_kind === "class")
+                byName.set(sym.name, sym);
+            return;
+        }
+        if (byName.size >= MAX_SYMBOLS_PER_FILE) {
+            truncated = true;
+            return;
+        }
+        byName.set(sym.name, sym);
+    };
+    const walk = (node) => {
+        let kind = null;
+        if (cfg.classTypes.has(node.type))
+            kind = "class";
+        else if (cfg.methodTypes.has(node.type))
+            kind = "method";
+        else if (cfg.functionTypes.has(node.type))
+            kind = "function";
+        if (kind && shouldEmitSymbol(node, language)) {
+            const name = symbolName(node, cfg);
+            if (name && !RESERVED_SYMBOL_NAMES.has(name)) {
+                add(kind === "method"
+                    ? { name, symbol_kind: kind, trivial_accessor: isTrivialAccessorBody(node, language), ...nodeLines(node) }
+                    : { name, symbol_kind: kind, ...nodeLines(node) });
+            }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                walk(child);
+        }
+    };
+    walk(tree.rootNode);
+    tree.delete();
+    return { symbols: [...byName.values()], truncated };
+}
+function namedChildren(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            out.push(child);
+    }
+    return out;
+}
+function stripQuotes(s) {
+    return s.replace(/^['"`<]/, "").replace(/['"`>]$/, "");
+}
+function lastDottedPart(s) {
+    const parts = s.split(/[./\\:]/).filter(Boolean);
+    return parts[parts.length - 1] || s;
+}
+function collectNames(node, out) {
+    if (!node)
+        return;
+    if (/^(identifier|package_identifier|field_identifier|simple_identifier)$/.test(node.type)) {
+        out.add(node.text);
+        return;
+    }
+    for (const child of namedChildren(node))
+        collectNames(child, out);
+}
+function localBindings(fn, language) {
+    const out = new Set();
+    const params = fn.childForFieldName("parameters") ?? (language === "kotlin" ? namedChildren(fn).find((n) => n.type === "function_value_parameters") : null);
+    if (params) {
+        if (language === "python")
+            collectNames(params, out);
+        else {
+            for (const child of namedChildren(params)) {
+                if (/parameter/.test(child.type))
+                    collectNames(child.childForFieldName("name") ?? child, out);
+            }
+        }
+    }
+    const body = fn.childForFieldName("body") ?? (language === "kotlin" ? namedChildren(fn).find((n) => n.type === "function_body") : null);
+    const walk = (node) => {
+        if (language === "python" && node.type === "assignment")
+            collectNames(node.childForFieldName("left") ?? node.namedChild(0), out);
+        if (language === "python" && (node.type === "function_definition" || node.type === "class_definition"))
+            collectNames(node.childForFieldName("name"), out);
+        if (language === "python" && node.type === "for_statement")
+            collectNames(node.childForFieldName("left"), out);
+        if (language === "python" && node.type === "for_in_clause")
+            collectNames(node.childForFieldName("left"), out);
+        if (language === "python" && node.type === "except_clause")
+            collectNames(namedChildren(node).find((n) => n.type === "as_pattern") ?? null, out);
+        if (language === "python" && node.type === "lambda")
+            collectNames(node.childForFieldName("parameters"), out);
+        if (language === "go" && (node.type === "short_var_declaration" || node.type === "var_spec"))
+            collectNames(node.childForFieldName("name") ?? node.namedChild(0), out);
+        if (language === "go" && node.type === "range_clause")
+            collectNames(node.childForFieldName("left"), out);
+        if (language === "java" && node.type === "variable_declarator")
+            collectNames(node.childForFieldName("name"), out);
+        if (language === "java" && node.type === "catch_formal_parameter")
+            collectNames(node.childForFieldName("name"), out);
+        if (language === "java" && node.type === "enhanced_for_statement")
+            collectNames(node.childForFieldName("name"), out);
+        if (language === "rust" && node.type === "let_declaration")
+            collectNames(node.childForFieldName("pattern") ?? node.namedChild(0), out);
+        if (language === "rust" && node.type === "for_expression")
+            collectNames(node.childForFieldName("pattern"), out);
+        if (language === "rust" && node.type === "closure_expression")
+            collectNames(node.childForFieldName("parameters"), out);
+        if (language === "csharp" && node.type === "variable_declarator")
+            collectNames(node.childForFieldName("name") ?? node.namedChild(0), out);
+        if (language === "csharp" && node.type === "declaration_expression")
+            collectNames(node.childForFieldName("name"), out);
+        if (language === "csharp" && node.type === "catch_declaration")
+            collectNames(node.childForFieldName("name"), out);
+        if (language === "csharp" && node.type === "for_each_statement")
+            collectNames(node.childForFieldName("left"), out);
+        if (language === "csharp" && node.type === "lambda_expression") {
+            const lambdaParams = node.childForFieldName("parameters");
+            if (lambdaParams) {
+                for (const child of namedChildren(lambdaParams)) {
+                    if (/parameter/.test(child.type))
+                        collectNames(child.childForFieldName("name") ?? child, out);
+                    else if (child.type === "identifier")
+                        collectNames(child, out);
+                }
+            }
+            else {
+                const first = namedChildren(node)[0];
+                if (first?.type === "identifier")
+                    collectNames(first, out);
+            }
+        }
+        if (language === "kotlin" && node.type === "variable_declaration")
+            collectNames(node.childForFieldName("name") ?? node.namedChild(0), out);
+        if (language === "kotlin" && node.type === "catch_block")
+            collectNames(namedChildren(node).find((n) => n.type === "simple_identifier") ?? null, out);
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    if (body)
+        walk(body);
+    return out;
+}
+function functionName(node, language) {
+    const name = node.childForFieldName("name")?.text;
+    if (!name && language === "kotlin")
+        return namedChildren(node).find((n) => n.type === "simple_identifier")?.text;
+    if (!name)
+        return undefined;
+    if (language === "go" && node.type === "method_declaration")
+        return name;
+    return name;
+}
+function javaPackage(root) {
+    const pkg = namedChildren(root).find((n) => n.type === "package_declaration");
+    return pkg ? namedChildren(pkg).find((n) => n.type.endsWith("identifier"))?.text : undefined;
+}
+function goPackage(root) {
+    const pkg = namedChildren(root).find((n) => n.type === "package_clause");
+    return pkg ? namedChildren(pkg).find((n) => n.type === "package_identifier")?.text : undefined;
+}
+function kotlinPackage(root) {
+    const pkg = namedChildren(root).find((n) => n.type === "package_header");
+    return pkg ? namedChildren(pkg).find((n) => n.type === "identifier")?.text : undefined;
+}
+function phpNamespace(root) {
+    const ns = namedChildren(root).find((n) => n.type === "namespace_definition");
+    const name = ns?.childForFieldName("name") ?? namedChildren(ns ?? root).find((n) => n.type === "namespace_name");
+    return name?.text;
+}
+function csharpNamespace(root) {
+    const ns = namedChildren(root).find((n) => n.type === "file_scoped_namespace_declaration" || n.type === "namespace_declaration");
+    return ns?.childForFieldName("name")?.text;
+}
+function kotlinTopLevelSymbols(root) {
+    const out = new Set();
+    for (const child of namedChildren(root)) {
+        if (child.type === "function_declaration") {
+            const name = functionName(child, "kotlin");
+            if (name)
+                out.add(name);
+        }
+        else if (child.type === "class_declaration" || child.type === "object_declaration") {
+            const name = symbolName(child, TS_LANG_CONFIGS.kotlin);
+            if (name)
+                out.add(name);
+        }
+    }
+    return [...out].sort();
+}
+function extractImports(root, language) {
+    const imports = [];
+    const add = (binding) => {
+        if (!binding.local || !binding.module)
+            return;
+        imports.push(binding);
+    };
+    const walk = (node) => {
+        if (language === "java" && node.type === "import_declaration") {
+            const spec = namedChildren(node).find((n) => n.type.endsWith("identifier"))?.text;
+            if (spec && !spec.endsWith(".*"))
+                add({ local: lastDottedPart(spec), module: spec, imported: lastDottedPart(spec), kind: "named" });
+        }
+        else if (language === "python" && node.type === "import_statement") {
+            for (const child of namedChildren(node)) {
+                const name = child.childForFieldName("name")?.text ?? child.text;
+                const alias = child.childForFieldName("alias")?.text;
+                if (name)
+                    add({ local: alias || lastDottedPart(name), module: name, kind: "module" });
+            }
+        }
+        else if (language === "python" && node.type === "import_from_statement") {
+            const kids = namedChildren(node);
+            const moduleNode = kids.find((n) => n.type === "dotted_name" || n.type === "relative_import");
+            const module = moduleNode?.text;
+            if (module) {
+                if (/\bimport\s+\*/.test(node.text))
+                    add({ local: "*", module, imported: "*", kind: "named" });
+                for (const child of kids) {
+                    if (child === moduleNode)
+                        continue;
+                    const imported = child.childForFieldName("name")?.text ?? (child.type === "identifier" || child.type === "dotted_name" ? child.text : undefined);
+                    const alias = child.childForFieldName("alias")?.text;
+                    if (imported === "*")
+                        add({ local: "*", module, imported, kind: "named" });
+                    else if (imported)
+                        add({ local: alias || imported, module, imported, kind: "named" });
+                }
+            }
+        }
+        else if (language === "go" && node.type === "import_spec") {
+            const raw = node.childForFieldName("path")?.text;
+            const module = raw ? stripQuotes(raw) : undefined;
+            const alias = node.childForFieldName("name")?.text;
+            if (module && alias !== "_" && alias !== ".")
+                add({ local: alias || lastDottedPart(module), module, kind: "module" });
+        }
+        else if (language === "ruby" && node.type === "call") {
+            const method = node.childForFieldName("method")?.text;
+            if (method === "require_relative") {
+                const str = namedChildren(node).find((n) => n.type === "argument_list")?.descendantsOfType("string_content")[0]?.text;
+                if (str)
+                    add({ local: lastDottedPart(str), module: `./${str}`, kind: "module" });
+            }
+        }
+        else if (language === "kotlin" && node.type === "import_header") {
+            const spec = namedChildren(node).find((n) => n.type === "identifier")?.text;
+            if (spec && !spec.endsWith(".*"))
+                add({ local: lastDottedPart(spec), module: spec, imported: lastDottedPart(spec), kind: "named" });
+        }
+        else if (language === "rust" && node.type === "mod_item") {
+            const name = node.childForFieldName("name")?.text;
+            if (name && !node.childForFieldName("body"))
+                add({ local: name, module: `./${name}`, kind: "module" });
+        }
+        else if (language === "rust" && node.type === "use_declaration") {
+            const arg = node.childForFieldName("argument");
+            if (arg && (arg.type === "scoped_identifier" || arg.type === "identifier")) {
+                const module = arg.text.replace(/::/g, ".");
+                const imported = lastDottedPart(module);
+                add({ local: imported, module, imported, kind: "named" });
+            }
+        }
+        else if (language === "php" && node.type === "namespace_use_clause") {
+            const spec = namedChildren(node).find((n) => n.type === "qualified_name" || n.type === "namespace_name")?.text;
+            if (spec)
+                add({ local: lastDottedPart(spec), module: spec, imported: lastDottedPart(spec), kind: "named" });
+        }
+        else if (language === "csharp" && node.type === "using_directive") {
+            const spec = namedChildren(node).find((n) => n.type === "qualified_name" || n.type === "identifier")?.text;
+            if (spec)
+                add({ local: lastDottedPart(spec), module: spec, kind: "module" });
+        }
+        else if ((language === "c" || language === "cpp") && node.type === "preproc_include") {
+            const raw = node.childForFieldName("path")?.text;
+            if (raw && !raw.startsWith("<")) {
+                const module = stripQuotes(raw);
+                add({ local: lastDottedPart(module), module, kind: "module" });
+            }
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    walk(root);
+    return imports;
+}
+function callParts(node, language) {
+    if (language === "java" && node.type === "method_invocation") {
+        const nameNode = node.childForFieldName("name");
+        const name = nameNode?.text;
+        if (!name)
+            return null;
+        const kids = namedChildren(node);
+        const qualifier = kids[0] !== nameNode && kids[0]?.type !== "argument_list" ? kids[0]?.text : undefined;
+        return { callee: name, qualifier, via: qualifier ? "qualified" : "free" };
+    }
+    if (language === "python" && node.type === "call") {
+        const fn = node.childForFieldName("function");
+        if (!fn)
+            return null;
+        if (fn.type === "identifier")
+            return { callee: fn.text, via: "free" };
+        if (fn.type === "attribute") {
+            const kids = namedChildren(fn);
+            const callee = kids[kids.length - 1]?.text;
+            const qualifier = kids.slice(0, -1).map((n) => n.text).join(".");
+            return callee ? { callee, qualifier, via: "qualified" } : null;
+        }
+    }
+    if (language === "go" && node.type === "call_expression") {
+        const fn = node.childForFieldName("function");
+        if (!fn)
+            return null;
+        if (fn.type === "identifier")
+            return { callee: fn.text, via: "free" };
+        if (fn.type === "selector_expression") {
+            const kids = namedChildren(fn);
+            const callee = kids[kids.length - 1]?.text;
+            const qualifier = kids.slice(0, -1).map((n) => n.text).join(".");
+            return callee ? { callee, qualifier, via: "qualified" } : null;
+        }
+    }
+    if (language === "rust" && node.type === "call_expression") {
+        const fn = node.childForFieldName("function");
+        if (!fn)
+            return null;
+        if (fn.type === "identifier")
+            return { callee: fn.text, via: "free" };
+        if (fn.type === "scoped_identifier") {
+            const callee = fn.childForFieldName("name")?.text;
+            const qualifier = fn.childForFieldName("path")?.text.replace(/::/g, ".");
+            return callee && qualifier ? { callee, qualifier, via: "qualified" } : null;
+        }
+    }
+    if (language === "kotlin" && node.type === "call_expression") {
+        const fn = namedChildren(node).find((n) => n.type !== "call_suffix");
+        if (!fn)
+            return null;
+        if (fn.type === "simple_identifier")
+            return { callee: fn.text, via: "free" };
+        if (fn.type === "navigation_expression") {
+            const kids = namedChildren(fn);
+            const suffix = kids[kids.length - 1];
+            const suffixKids = suffix?.type === "navigation_suffix" ? namedChildren(suffix) : [];
+            const callee = suffixKids[suffixKids.length - 1]?.text;
+            const qualifier = kids.slice(0, -1).map((n) => n.text).join(".");
+            return callee && qualifier ? { callee, qualifier, via: "qualified" } : null;
+        }
+    }
+    if (language === "php") {
+        if (node.type === "function_call_expression") {
+            const fn = node.childForFieldName("function");
+            return fn?.text ? { callee: fn.text, via: "free" } : null;
+        }
+        if (node.type === "scoped_call_expression") {
+            const qualifier = node.childForFieldName("scope")?.text;
+            const callee = node.childForFieldName("name")?.text;
+            return callee && qualifier ? { callee, qualifier, via: "qualified" } : null;
+        }
+    }
+    if (language === "csharp" && node.type === "invocation_expression") {
+        const fn = node.childForFieldName("function");
+        if (!fn)
+            return null;
+        if (fn.type === "identifier")
+            return { callee: fn.text, via: "free" };
+        if (fn.type === "member_access_expression") {
+            const kids = namedChildren(fn);
+            const callee = fn.childForFieldName("name")?.text ?? kids[kids.length - 1]?.text;
+            const qualifier = (fn.childForFieldName("expression")?.text ?? kids.slice(0, -1).map((n) => n.text).join(".")).replace(/\?$/, "");
+            return callee && qualifier ? { callee, qualifier, via: "qualified" } : null;
+        }
+    }
+    return null;
+}
+const GO_TEST_FAIL_METHODS = new Set(["Error", "Errorf", "Fatal", "Fatalf", "Fail", "FailNow"]);
+const GO_TESTIFY_ASSERT_MODULE = /^github\.com\/stretchr\/testify\/(?:v\d+\/)?(?:assert|require)$/;
+const GO_TESTIFY_SUITE_MODULE = /^github\.com\/stretchr\/testify\/(?:v\d+\/)?suite$/;
+const GO_ASSERT_METHODS = new Set([
+    "Contains",
+    "Equal",
+    "Error",
+    "ErrorIs",
+    "False",
+    "Len",
+    "Nil",
+    "NoError",
+    "NotContains",
+    "NotEqual",
+    "NotNil",
+    "NotZero",
+    "True",
+    "Zero"
+]);
+function selectorParts(node) {
+    if (node.type !== "selector_expression")
+        return null;
+    const kids = namedChildren(node);
+    const name = kids[kids.length - 1]?.text;
+    const qualifier = kids.slice(0, -1).map((n) => n.text).join(".");
+    return qualifier && name ? { qualifier, name } : null;
+}
+function callFunctionSelector(node) {
+    if (node.type !== "call_expression")
+        return null;
+    const fn = node.childForFieldName("function");
+    return fn ? selectorParts(fn) : null;
+}
+function containsIdentifier(node, names) {
+    if (!node)
+        return false;
+    if ((node.type === "identifier" || node.type === "package_identifier") && names.has(node.text))
+        return true;
+    return namedChildren(node).some((child) => containsIdentifier(child, names));
+}
+function goTestingParamNames(fn) {
+    const out = new Set();
+    const params = fn.childForFieldName("parameters");
+    collectGoTestingParamNames(params, out);
+    return out;
+}
+function collectGoTestingParamNames(params, out) {
+    if (!params)
+        return;
+    for (const child of namedChildren(params)) {
+        if (!/parameter/.test(child.type))
+            continue;
+        const type = child.childForFieldName("type")?.text ?? "";
+        if (/testing\.[TB]\b/.test(type)) {
+            const name = child.childForFieldName("name")?.text;
+            if (name)
+                out.add(name);
+        }
+    }
+}
+function goAssertLocals(imports) {
+    const out = new Set();
+    for (const i of imports) {
+        if (GO_TESTIFY_ASSERT_MODULE.test(i.module))
+            out.add(i.local);
+    }
+    return out;
+}
+function goSuiteLocals(imports) {
+    const out = new Set();
+    for (const i of imports) {
+        if (GO_TESTIFY_SUITE_MODULE.test(i.module))
+            out.add(i.local);
+    }
+    return out;
+}
+function goCanonicalSuiteTypes(root, suiteLocals) {
+    const out = new Set();
+    const isSuiteType = (node) => {
+        if (!node)
+            return false;
+        const text = node.text.replace(/^\*/, "");
+        return [...suiteLocals].some((local) => text === `${local}.Suite`);
+    };
+    const walk = (node) => {
+        if (node.type === "type_spec") {
+            const name = node.childForFieldName("name")?.text;
+            const typeNode = node.childForFieldName("type");
+            if (name && typeNode?.type === "struct_type") {
+                const embedsSuite = typeNode
+                    .descendantsOfType("field_declaration")
+                    .some((field) => Boolean(field && isSuiteType(field.childForFieldName("type"))));
+                if (embedsSuite)
+                    out.add(name);
+            }
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    walk(root);
+    return out;
+}
+function goDotAssertMethods(root) {
+    const out = new Set();
+    const walk = (node) => {
+        if (node.type === "import_spec") {
+            const raw = node.childForFieldName("path")?.text;
+            const module = raw ? stripQuotes(raw) : undefined;
+            const alias = node.childForFieldName("name")?.text;
+            if (alias === "." && module && GO_TESTIFY_ASSERT_MODULE.test(module)) {
+                for (const method of GO_ASSERT_METHODS)
+                    out.add(method);
+            }
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    walk(root);
+    return out;
+}
+function callExpressions(node) {
+    if (!node)
+        return [];
+    const out = [];
+    const walk = (cur) => {
+        if (cur.type === "call_expression")
+            out.push(cur);
+        for (const child of namedChildren(cur))
+            walk(child);
+    };
+    walk(node);
+    return out;
+}
+function goProductCallsIn(node) {
+    return callExpressions(node).map((call) => callParts(call, "go")).filter((p) => Boolean(p));
+}
+function singleGoProductCallIn(node) {
+    const calls = goProductCallsIn(node);
+    return calls.length === 1 ? calls : [];
+}
+function hasGoTestingFailure(node, testingParams) {
+    return callExpressions(node).some((call) => {
+        const sel = callFunctionSelector(call);
+        return Boolean(sel && testingParams.has(sel.qualifier) && GO_TEST_FAIL_METHODS.has(sel.name));
+    });
+}
+function goAssertionCalls(node, assertLocals, dotAssertMethods, shadowed) {
+    return callExpressions(node).filter((call) => {
+        const sel = callFunctionSelector(call);
+        if (sel)
+            return !shadowed.has(sel.qualifier) && assertLocals.has(sel.qualifier) && GO_ASSERT_METHODS.has(sel.name);
+        const fn = call.childForFieldName("function");
+        return Boolean(fn?.type === "identifier" && !shadowed.has(fn.text) && dotAssertMethods.has(fn.text));
+    });
+}
+function goAssertionSubject(assertion, testingParams) {
+    const sel = callFunctionSelector(assertion);
+    const name = sel?.name ?? assertion.childForFieldName("function")?.text;
+    const args = namedChildren(assertion.childForFieldName("arguments") ?? assertion).filter((n) => n.type !== "comment");
+    if (!name || args.length < 2)
+        return null;
+    if (!testingParams.has(args[0]?.text ?? ""))
+        return null;
+    if (name === "Equal" || name === "NotEqual")
+        return args[2] ?? null;
+    return args[1] ?? null;
+}
+function goSuiteReceiver(fn, suiteTypes) {
+    const receiver = fn.childForFieldName("receiver");
+    const param = namedChildren(receiver ?? fn).find((n) => n.type === "parameter_declaration");
+    const name = param?.childForFieldName("name")?.text;
+    const type = param?.childForFieldName("type")?.text.replace(/^\*/, "");
+    return name && type && suiteTypes.has(type) ? name : null;
+}
+function goSuiteAssertionCalls(node, receiver, shadowed) {
+    if (shadowed.has(receiver))
+        return [];
+    return callExpressions(node).filter((call) => {
+        const fn = call.childForFieldName("function");
+        const sel = fn ? selectorParts(fn) : null;
+        if (!sel || !GO_ASSERT_METHODS.has(sel.name))
+            return false;
+        if (sel.qualifier === receiver)
+            return true;
+        const operand = fn?.childForFieldName("operand");
+        const access = operand?.type === "call_expression" ? callFunctionSelector(operand) : null;
+        return Boolean(access && access.qualifier === receiver && (access.name === "Require" || access.name === "Assert"));
+    });
+}
+function goSuiteAssertionSubject(assertion) {
+    const sel = callFunctionSelector(assertion);
+    const args = namedChildren(assertion.childForFieldName("arguments") ?? assertion).filter((n) => n.type !== "comment");
+    if (!sel?.name || args.length < 1)
+        return null;
+    if (sel.name === "Equal" || sel.name === "NotEqual")
+        return args[1] ?? null;
+    return args[0] ?? null;
+}
+function goSubtestBody(stmt, testingParams) {
+    const call = callExpressions(stmt).find((c) => {
+        const sel = callFunctionSelector(c);
+        return Boolean(sel && testingParams.has(sel.qualifier) && sel.name === "Run");
+    });
+    if (!call)
+        return null;
+    const fn = namedChildren(call.childForFieldName("arguments") ?? call).find((n) => n.type === "func_literal");
+    const body = fn?.childForFieldName("body");
+    if (!fn || !body)
+        return null;
+    const nextTestingParams = new Set(testingParams);
+    collectGoTestingParamNames(fn.childForFieldName("parameters"), nextTestingParams);
+    return nextTestingParams.size > testingParams.size ? { body, testingParams: nextTestingParams } : null;
+}
+function goShortVarCalls(stmt) {
+    if (stmt.type !== "short_var_declaration")
+        return null;
+    const names = new Set();
+    collectNames(stmt.childForFieldName("left") ?? stmt.namedChild(0), names);
+    const calls = singleGoProductCallIn(stmt.childForFieldName("right") ?? namedChildren(stmt)[1] ?? null);
+    return names.size && calls.length ? { names, calls } : null;
+}
+function extractGoProofCalls(root, imports) {
+    const out = [];
+    const seen = new Set();
+    const assertLocals = goAssertLocals(imports);
+    const dotAssertMethods = goDotAssertMethods(root);
+    const suiteTypes = goCanonicalSuiteTypes(root, goSuiteLocals(imports));
+    const add = (testName, shadowed, assertion, calls) => {
+        for (const c of calls) {
+            const key = `${testName}|${c.qualifier ?? ""}|${c.callee}|${assertion}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ caller: testName, testName, ...c, shadowed: [...shadowed], assertion });
+        }
+    };
+    const processBlock = (block, testName, testingParams, shadowed) => {
+        for (const stmt of blockStatements(block)) {
+            for (const assertion of goAssertionCalls(stmt, assertLocals, dotAssertMethods, shadowed)) {
+                add(testName, shadowed, "assert_helper", singleGoProductCallIn(goAssertionSubject(assertion, testingParams)));
+            }
+            if (stmt.type === "if_statement" && hasGoTestingFailure(stmt.childForFieldName("consequence"), testingParams)) {
+                const condition = stmt.childForFieldName("condition");
+                add(testName, shadowed, "testing_fail", singleGoProductCallIn(condition));
+                const init = stmt.childForFieldName("initializer");
+                const initCalls = init ? goShortVarCalls(init) : null;
+                if (initCalls && containsIdentifier(condition, initCalls.names))
+                    add(testName, shadowed, "testing_fail", initCalls.calls);
+            }
+            for (const child of namedChildren(stmt)) {
+                if (child.type === "block")
+                    processBlock(child, testName, testingParams, shadowed);
+            }
+            const subtest = goSubtestBody(stmt, testingParams);
+            if (subtest)
+                processBlock(subtest.body, testName, subtest.testingParams, shadowed);
+        }
+    };
+    const processSuiteBlock = (block, testName, receiver, shadowed) => {
+        for (const stmt of blockStatements(block)) {
+            for (const assertion of goSuiteAssertionCalls(stmt, receiver, shadowed)) {
+                add(testName, shadowed, "assert_helper", singleGoProductCallIn(goSuiteAssertionSubject(assertion)));
+            }
+            for (const child of namedChildren(stmt)) {
+                if (child.type === "block")
+                    processSuiteBlock(child, testName, receiver, shadowed);
+            }
+        }
+    };
+    for (const child of namedChildren(root)) {
+        if (child.type === "method_declaration") {
+            const name = functionName(child, "go");
+            if (!name || !/^Test[A-Z0-9_]/.test(name))
+                continue;
+            const receiver = goSuiteReceiver(child, suiteTypes);
+            const body = child.childForFieldName("body");
+            if (!receiver || !body)
+                continue;
+            processSuiteBlock(body, name, receiver, localBindings(child, "go"));
+            continue;
+        }
+        if (child.type !== "function_declaration")
+            continue;
+        const name = functionName(child, "go");
+        if (!name || !/^Test[A-Z0-9_]/.test(name))
+            continue;
+        const testingParams = goTestingParamNames(child);
+        const body = child.childForFieldName("body");
+        if (!testingParams.size || !body)
+            continue;
+        processBlock(body, name, testingParams, localBindings(child, "go"));
+    }
+    return out;
+}
+const JAVA_JUNIT_ASSERT_CLASSES = {
+    junit4: "org.junit.Assert",
+    junit5: "org.junit.jupiter.api.Assertions"
+};
+const JAVA_JUNIT_TEST_ANNOTATIONS = new Set(["org.junit.Test", "org.junit.jupiter.api.Test"]);
+const JAVA_ASSERT_ACTUAL_ARG = new Set([
+    "assertArrayEquals",
+    "assertEquals",
+    "assertIterableEquals",
+    "assertLinesMatch",
+    "assertNotEquals",
+    "assertNotSame",
+    "assertSame"
+]);
+const JAVA_ASSERT_SUBJECT_ARG = new Set(["assertFalse", "assertNotNull", "assertNull", "assertTrue"]);
+const JAVA_ASSERT_METHODS = new Set([...JAVA_ASSERT_ACTUAL_ARG, ...JAVA_ASSERT_SUBJECT_ARG]);
+function addJavaAssertionImport(out, name, assertion) {
+    if (!JAVA_ASSERT_METHODS.has(name))
+        return;
+    let set = out.get(name);
+    if (!set)
+        out.set(name, (set = new Set()));
+    set.add(assertion);
+}
+function javaJunitAssertImports(root) {
+    const out = new Map();
+    for (const node of root.descendantsOfType("import_declaration")) {
+        if (!node)
+            continue;
+        if (!/^import\s+static\b/.test(node.text))
+            continue;
+        const spec = namedChildren(node).find((n) => n.type.endsWith("identifier"))?.text;
+        if (!spec)
+            continue;
+        const star = namedChildren(node).some((n) => n.type === "asterisk");
+        for (const [assertion, owner] of Object.entries(JAVA_JUNIT_ASSERT_CLASSES)) {
+            if (star && spec === owner) {
+                for (const method of JAVA_ASSERT_METHODS)
+                    addJavaAssertionImport(out, method, assertion);
+            }
+            else if (!star && spec.startsWith(`${owner}.`)) {
+                addJavaAssertionImport(out, lastDottedPart(spec), assertion);
+            }
+        }
+    }
+    return out;
+}
+function javaJunitTestAnnotationLocals(imports) {
+    const out = new Set();
+    for (const i of imports) {
+        if (JAVA_JUNIT_TEST_ANNOTATIONS.has(i.module))
+            out.add(i.local);
+    }
+    return out;
+}
+function annotationName(node) {
+    if (node.type !== "marker_annotation" && node.type !== "annotation")
+        return undefined;
+    return node.childForFieldName("name")?.text ?? namedChildren(node)[0]?.text;
+}
+function javaAnnotationNames(method) {
+    const modifiers = namedChildren(method).find((n) => n.type === "modifiers");
+    if (!modifiers)
+        return [];
+    const out = [];
+    const walk = (node) => {
+        const name = annotationName(node);
+        if (name)
+            out.push(name);
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    walk(modifiers);
+    return out;
+}
+function isJavaJunitTestMethod(method, testAnnotationLocals) {
+    return javaAnnotationNames(method).some((name) => JAVA_JUNIT_TEST_ANNOTATIONS.has(name) || testAnnotationLocals.has(name));
+}
+function javaDeclaredMethodNames(root) {
+    const out = new Set();
+    for (const method of root.descendantsOfType("method_declaration")) {
+        if (!method)
+            continue;
+        const name = functionName(method, "java");
+        if (name)
+            out.add(name);
+    }
+    return out;
+}
+function javaClassInfos(root) {
+    const out = [];
+    const walk = (node) => {
+        if (node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "enum_declaration" || node.type === "record_declaration") {
+            const name = node.childForFieldName("name")?.text;
+            const body = node.childForFieldName("body");
+            const methods = new Set();
+            if (body) {
+                for (const child of namedChildren(body)) {
+                    if (child.type !== "method_declaration")
+                        continue;
+                    const method = functionName(child, "java");
+                    if (method)
+                        methods.add(method);
+                }
+            }
+            if (name)
+                out.push({ name, methods: [...methods].sort() });
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    walk(root);
+    return out;
+}
+function hasAncestorTypeBefore(node, stop, type) {
+    let cur = node.parent;
+    while (cur && cur.id !== stop.id) {
+        if (cur.type === type)
+            return true;
+        cur = cur.parent;
+    }
+    return false;
+}
+function javaAssertionCalls(node, assertImports, shadowed) {
+    return node
+        .descendantsOfType("method_invocation")
+        .filter((call) => Boolean(call))
+        .filter((call) => !hasAncestorTypeBefore(call, node, "lambda_expression"))
+        .map((call) => {
+        const name = call.childForFieldName("name")?.text;
+        const object = call.childForFieldName("object");
+        const assertions = name && !object && !shadowed.has(name) ? assertImports.get(name) : undefined;
+        return assertions ? { call, assertions } : null;
+    })
+        .filter((v) => Boolean(v));
+}
+function javaAssertionSubject(call, assertions) {
+    const name = call.childForFieldName("name")?.text;
+    const args = namedChildren(call.childForFieldName("arguments") ?? call).filter((n) => n.type !== "comment");
+    if (!name)
+        return null;
+    if (JAVA_ASSERT_ACTUAL_ARG.has(name)) {
+        if (args.length === 2)
+            return args[1] ?? null;
+        if (args.length === 3 && assertions.size === 1 && assertions.has("junit5"))
+            return args[1] ?? null;
+        return null;
+    }
+    if (JAVA_ASSERT_SUBJECT_ARG.has(name)) {
+        if (args.length === 1)
+            return args[0] ?? null;
+        if (args.length === 2 && assertions.size === 1 && assertions.has("junit5"))
+            return args[0] ?? null;
+    }
+    return null;
+}
+function javaCallLikeCount(node) {
+    if (!node)
+        return 0;
+    let count = node.type === "method_invocation" || node.type === "object_creation_expression" ? 1 : 0;
+    for (const child of namedChildren(node))
+        count += javaCallLikeCount(child);
+    return count;
+}
+function simpleJavaClassName(text) {
+    return text && /^[A-Za-z_$][\w$]*$/.test(text) ? text : null;
+}
+function javaObjectCreationClassName(node) {
+    if (node.type !== "object_creation_expression")
+        return null;
+    if (namedChildren(node).some((n) => n.type === "class_body"))
+        return null;
+    return simpleJavaClassName(node.childForFieldName("type")?.text);
+}
+function javaDirectProofTarget(subject) {
+    if (!subject || javaCallLikeCount(subject) !== 1)
+        return null;
+    if (subject.type === "object_creation_expression") {
+        const className = javaObjectCreationClassName(subject);
+        return className ? { className, callee: className, target_kind: "constructor" } : null;
+    }
+    if (subject.type !== "method_invocation")
+        return null;
+    const callee = subject.childForFieldName("name")?.text;
+    const object = subject.childForFieldName("object");
+    const className = object?.type === "identifier" ? simpleJavaClassName(object.text) : null;
+    return callee && className ? { className, callee, target_kind: "method" } : null;
+}
+function processJavaNestedBlocks(block, testName, shadowed, processBlock) {
+    const walk = (node) => {
+        if (node.type === "lambda_expression")
+            return;
+        for (const child of namedChildren(node)) {
+            if (child.type === "block")
+                processBlock(child, testName, shadowed);
+            else
+                walk(child);
+        }
+    };
+    walk(block);
+}
+function extractJavaProofCalls(root, imports) {
+    const out = [];
+    const seen = new Set();
+    const assertImports = javaJunitAssertImports(root);
+    if (assertImports.size === 0)
+        return out;
+    const testAnnotationLocals = javaJunitTestAnnotationLocals(imports);
+    const declaredMethods = javaDeclaredMethodNames(root);
+    const add = (testName, shadowed, assertions, target) => {
+        if (!target || shadowed.has(target.className))
+            return;
+        const assertion = assertions.has("junit5") ? "junit5" : "junit4";
+        const key = `${testName}|${target.target_kind}|${target.className}|${target.callee}|${assertion}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push({ testName, ...target, assertion, shadowed: [...shadowed] });
+    };
+    const processBlock = (block, testName, shadowed) => {
+        for (const stmt of blockStatements(block)) {
+            for (const assertion of javaAssertionCalls(stmt, assertImports, shadowed)) {
+                add(testName, shadowed, assertion.assertions, javaDirectProofTarget(javaAssertionSubject(assertion.call, assertion.assertions)));
+            }
+            processJavaNestedBlocks(stmt, testName, shadowed, processBlock);
+        }
+    };
+    for (const method of root.descendantsOfType("method_declaration")) {
+        if (!method)
+            continue;
+        if (!isJavaJunitTestMethod(method, testAnnotationLocals))
+            continue;
+        const name = functionName(method, "java");
+        const body = method.childForFieldName("body");
+        if (!name || !body)
+            continue;
+        const shadowed = localBindings(method, "java");
+        for (const declared of declaredMethods) {
+            shadowed.add(declared);
+        }
+        processBlock(body, name, shadowed);
+    }
+    return out;
+}
+function directPythonAssertCall(assertion) {
+    const subject = namedChildren(assertion)[0];
+    if (!subject)
+        return null;
+    const actual = subject.type === "comparison_operator" ? singlePythonComparisonCall(subject) : subject;
+    if (actual?.type !== "call")
+        return null;
+    return callParts(actual, "python");
+}
+function singlePythonComparisonCall(comparison) {
+    const calls = namedChildren(comparison).filter((child) => child.type === "call");
+    return calls.length === 1 ? calls[0] ?? null : null;
+}
+function extractPythonProofCalls(root) {
+    const out = [];
+    const seen = new Set();
+    const add = (testName, shadowed, call) => {
+        if (!call)
+            return;
+        const key = `${testName}|${call.qualifier ?? ""}|${call.callee}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push({ caller: testName, testName, ...call, shadowed: [...shadowed], assertion: "pytest_assert" });
+    };
+    const processBlock = (block, testName, shadowed) => {
+        for (const stmt of blockStatements(block)) {
+            if (stmt.type === "assert_statement")
+                add(testName, shadowed, directPythonAssertCall(stmt));
+            if (stmt.type === "function_definition" || stmt.type === "class_definition" || stmt.type === "lambda")
+                continue;
+            for (const child of namedChildren(stmt)) {
+                if (child.type === "block")
+                    processBlock(child, testName, shadowed);
+            }
+        }
+    };
+    const walk = (node, insideFunction) => {
+        if (node.type === "function_definition") {
+            const name = functionName(node, "python");
+            const body = node.childForFieldName("body");
+            if (name && /^test_/.test(name) && body)
+                processBlock(body, name, localBindings(node, "python"));
+            if (insideFunction)
+                return;
+        }
+        for (const child of namedChildren(node))
+            walk(child, insideFunction || node.type === "function_definition");
+    };
+    walk(root, false);
+    return out;
+}
+export function extractTreeSitterStructure(content, language) {
+    const parser = parserFor(language);
+    if (!parser)
+        return { imports: [], calls: [] };
+    const tree = parser.parse(content);
+    if (!tree)
+        return { imports: [], calls: [] };
+    const root = tree.rootNode;
+    const calls = [];
+    const isCallableNode = (node) => (language === "java" && node.type === "method_declaration") ||
+        (language === "python" && node.type === "function_definition") ||
+        (language === "go" && (node.type === "function_declaration" || node.type === "method_declaration")) ||
+        (language === "kotlin" && node.type === "function_declaration") ||
+        (language === "rust" && node.type === "function_item") ||
+        (language === "php" && (node.type === "function_definition" || node.type === "method_declaration")) ||
+        (language === "csharp" && node.type === "method_declaration");
+    const visit = (node, caller, shadowed, insideFunction) => {
+        let nextCaller = caller;
+        let nextShadowed = shadowed;
+        let nextInsideFunction = insideFunction;
+        if (isCallableNode(node)) {
+            if (insideFunction) {
+                nextCaller = null; // nested function body: calls belong to an un-emitted local symbol
+                nextShadowed = new Set();
+                nextInsideFunction = true;
+            }
+            else {
+                const name = functionName(node, language);
+                if (name) {
+                    nextCaller = name;
+                    nextShadowed = localBindings(node, language);
+                    nextInsideFunction = true;
+                }
+            }
+        }
+        const parts = callParts(node, language);
+        if (nextCaller && parts) {
+            calls.push({ caller: nextCaller, ...parts, shadowed: [...nextShadowed] });
+        }
+        for (const child of namedChildren(node))
+            visit(child, nextCaller, nextShadowed, nextInsideFunction);
+    };
+    visit(root, null, new Set(), false);
+    const imports = extractImports(root, language);
+    const result = {
+        ...(language === "java" ? { packageName: javaPackage(root), javaClasses: javaClassInfos(root), javaProofCalls: extractJavaProofCalls(root, imports) } : {}),
+        ...(language === "go" ? { packageName: goPackage(root) } : {}),
+        ...(language === "kotlin" ? { packageName: kotlinPackage(root), topLevelSymbols: kotlinTopLevelSymbols(root) } : {}),
+        ...(language === "php" ? { moduleName: phpNamespace(root) } : {}),
+        ...(language === "csharp" ? { moduleName: csharpNamespace(root) } : {}),
+        imports,
+        calls,
+        ...(language === "go" ? { goProofCalls: extractGoProofCalls(root, imports) } : {}),
+        ...(language === "python" ? { pythonProofCalls: extractPythonProofCalls(root) } : {})
+    };
+    tree.delete();
+    return result;
+}