grepmax 0.26.4 → 0.26.6

package/dist/lib/index/chunker.js

@@ -43,6 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeSitterChunker = void 0;
+exports.repairLoneSurrogates = repairLoneSurrogates;
 exports.formatChunkText = formatChunkText;
 exports.buildAnchorChunk = buildAnchorChunk;
 const fs = __importStar(require("node:fs"));
@@ -71,6 +72,19 @@ function resolveTreeSitterWasmLocator() {
         return path.join(__dirname, "..", "..", "..", "node_modules", "web-tree-sitter", "tree-sitter.wasm");
     }
 }
+// Char-stride chunk splitting can slice through a UTF-16 surrogate pair
+// (e.g. PDF-extracted math italics like 𝑃), leaving a lone surrogate. That
+// poisons the whole embed batch — the HF fast tokenizer rejects non-well-
+// formed input — and puts invalid UTF-8 into the vector table's content
+// column. Repair to U+FFFD at the chunk emit boundary. (Regex stand-in for
+// String.prototype.toWellFormed, which the ES6 lib target doesn't declare.)
+const LONE_SURROGATE_TEST = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+const LONE_SURROGATE_ALL = new RegExp(LONE_SURROGATE_TEST.source, "g");
+function repairLoneSurrogates(s) {
+    if (!LONE_SURROGATE_TEST.test(s))
+        return s;
+    return s.replace(LONE_SURROGATE_ALL, "�");
+}
 function isDocLikeFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return [".md", ".mdx", ".txt", ".rst", ".adoc"].includes(ext);
@@ -249,6 +263,9 @@ class TreeSitterChunker {
             }
             // Split chunks if too big
             result.chunks = result.chunks.flatMap((c) => this.splitIfTooBig(c));
+            for (const c of result.chunks) {
+                c.content = repairLoneSurrogates(c.content);
+            }
             // Post-process: extract property function names from chunks.
             // Catches resolver patterns like `posTableTurnReport: withAuth(scope, async (args) => {`
             const PROP_FN_RE = /^\s*(\w+)\s*:\s*(?:async\s+)?(?:function\b|\(|[A-Za-z_]\w*\()/gm;
@@ -299,7 +316,7 @@ class TreeSitterChunker {
     }
     chunkWithTreeSitter(filePath, content) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a;
             const ext = path.extname(filePath);
             if (ext === ".json") {
                 return {
@@ -322,662 +339,676 @@ class TreeSitterChunker {
                 };
             this.parser.setLanguage(language);
             const tree = this.parser.parse(content);
-            const root = tree.rootNode;
-            const fileContext = `File: ${filePath}`;
-            const chunks = [];
-            const blockChunks = [];
-            let cursorIndex = 0;
-            let cursorRow = 0;
-            let sawDefinition = false;
-            const metadata = { imports: [], exports: [], comments: [] };
-            const definitionTypes = (langDef === null || langDef === void 0 ? void 0 : langDef.definitionTypes) || [];
-            const isDefType = (t) => definitionTypes.includes(t);
-            const classify = (node) => {
-                const t = node.type;
-                // Classify strictly by the node's own type; avoid language-wide keyword inference
-                if (t.includes("method"))
-                    return "method";
-                if (t.includes("class"))
-                    return "class";
-                if (t.includes("interface"))
-                    return "interface";
-                if (t.includes("type_alias"))
-                    return "type_alias";
-                if (isDefType(t) || isTopLevelValueDef(node))
-                    return "function";
-                return "block";
-            };
-            const unwrapExport = (node) => {
-                if (node.type === "export_statement" &&
-                    node.namedChildren &&
-                    node.namedChildren.length > 0) {
-                    return node.namedChildren[0];
-                }
-                return node;
-            };
-            const isTopLevelValueDef = (node) => {
-                var _a;
-                const t = node.type;
-                if (t !== "lexical_declaration" && t !== "variable_declaration")
-                    return false;
-                const parentType = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) || "";
-                const allowedParents = [
-                    "program",
-                    "module",
-                    "source_file",
-                    "class_body",
-                    "export_statement",
-                ];
-                if (parentType && !allowedParents.includes(parentType))
-                    return false;
-                // Exported declarations are part of the API surface, so always index
-                // them regardless of RHS shape. Without this, files whose only export
-                // is `export const typeDefs = gql\`...\`` (template literals, object
-                // literals, or non-PascalCase consts) had no defined_symbols entry
-                // and peek/extract returned "Symbol not found".
-                if (parentType === "export_statement" ||
-                    parentType === "export_declaration") {
-                    return true;
-                }
-                const text = node.text || "";
-                if (text.includes("=>"))
-                    return true;
-                if (text.includes("function "))
-                    return true;
-                if (text.includes("class "))
-                    return true;
-                if (/(?:^|\n)\s*(?:export\s+)?const\s+[A-Z0-9_]+\s*=/.test(text))
-                    return true;
-                return false;
-            };
-            const getNodeName = (node) => {
-                var _a, _b, _c;
-                const byField = (field) => {
-                    const child = typeof node.childForFieldName === "function"
-                        ? node.childForFieldName(field)
-                        : null;
-                    if (child === null || child === void 0 ? void 0 : child.text)
-                        return String(child.text);
-                    return null;
+            if (!tree) {
+                return {
+                    chunks: [],
+                    metadata: { imports: [], exports: [], comments: [] },
                 };
-                const fieldNames = ["name", "property", "identifier"];
-                for (const field of fieldNames) {
-                    const name = byField(field);
-                    if (name)
-                        return name;
-                }
-                const identifierChild = ((_a = node.namedChildren) !== null && _a !== void 0 ? _a : []).find((c) => [
-                    "identifier",
-                    "property_identifier",
-                    "type_identifier",
-                    "field_identifier",
-                    "simple_identifier", // Swift, Kotlin
-                    "word", // Bash
-                ].includes(c.type));
-                if (identifierChild === null || identifierChild === void 0 ? void 0 : identifierChild.text)
-                    return String(identifierChild.text);
-                for (const child of (_b = node.namedChildren) !== null && _b !== void 0 ? _b : []) {
-                    if (child.type === "variable_declarator") {
-                        const idChild = ((_c = child.namedChildren) !== null && _c !== void 0 ? _c : []).find((c) => ["identifier", "property_identifier", "type_identifier"].includes(c.type));
-                        if (idChild === null || idChild === void 0 ? void 0 : idChild.text)
-                            return String(idChild.text);
-                    }
-                }
-                const match = (node.text || "").match(/(?:class|function)\s+([A-Za-z0-9_$]+)/);
-                if (match === null || match === void 0 ? void 0 : match[1])
-                    return match[1];
-                const varMatch = (node.text || "").match(/(?:const|let|var)\s+([A-Za-z0-9_$]+)/);
-                if (varMatch === null || varMatch === void 0 ? void 0 : varMatch[1])
-                    return varMatch[1];
+            }
+            try {
+                return this.buildChunksFromTree(filePath, content, (langDef === null || langDef === void 0 ? void 0 : langDef.definitionTypes) || [], lang, tree.rootNode);
+            }
+            finally {
+                // Nothing in the guarded block may retain a Node.
+                tree.delete();
+            }
+        });
+    }
+    buildChunksFromTree(filePath, content, definitionTypes, lang, root) {
+        var _a;
+        const fileContext = `File: ${filePath}`;
+        const chunks = [];
+        const blockChunks = [];
+        let cursorIndex = 0;
+        let cursorRow = 0;
+        let sawDefinition = false;
+        const metadata = { imports: [], exports: [], comments: [] };
+        const isDefType = (t) => definitionTypes.includes(t);
+        const classify = (node) => {
+            const t = node.type;
+            // Classify strictly by the node's own type; avoid language-wide keyword inference
+            if (t.includes("method"))
+                return "method";
+            if (t.includes("class"))
+                return "class";
+            if (t.includes("interface"))
+                return "interface";
+            if (t.includes("type_alias"))
+                return "type_alias";
+            if (isDefType(t) || isTopLevelValueDef(node))
+                return "function";
+            return "block";
+        };
+        const unwrapExport = (node) => {
+            if (node.type === "export_statement" &&
+                node.namedChildren &&
+                node.namedChildren.length > 0) {
+                return node.namedChildren[0];
+            }
+            return node;
+        };
+        const isTopLevelValueDef = (node) => {
+            var _a;
+            const t = node.type;
+            if (t !== "lexical_declaration" && t !== "variable_declaration")
+                return false;
+            const parentType = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) || "";
+            const allowedParents = [
+                "program",
+                "module",
+                "source_file",
+                "class_body",
+                "export_statement",
+            ];
+            if (parentType && !allowedParents.includes(parentType))
+                return false;
+            // Exported declarations are part of the API surface, so always index
+            // them regardless of RHS shape. Without this, files whose only export
+            // is `export const typeDefs = gql\`...\`` (template literals, object
+            // literals, or non-PascalCase consts) had no defined_symbols entry
+            // and peek/extract returned "Symbol not found".
+            if (parentType === "export_statement" ||
+                parentType === "export_declaration") {
+                return true;
+            }
+            const text = node.text || "";
+            if (text.includes("=>"))
+                return true;
+            if (text.includes("function "))
+                return true;
+            if (text.includes("class "))
+                return true;
+            if (/(?:^|\n)\s*(?:export\s+)?const\s+[A-Z0-9_]+\s*=/.test(text))
+                return true;
+            return false;
+        };
+        const getNodeName = (node) => {
+            var _a, _b, _c;
+            const byField = (field) => {
+                const child = typeof node.childForFieldName === "function"
+                    ? node.childForFieldName(field)
+                    : null;
+                if (child === null || child === void 0 ? void 0 : child.text)
+                    return String(child.text);
                 return null;
             };
-            const labelForNode = (node) => {
-                const name = getNodeName(node);
-                const t = node.type;
-                if (t.includes("class"))
-                    return `Class: ${name !== null && name !== void 0 ? name : "<anonymous class>"}`;
-                if (t.includes("method"))
-                    return `Method: ${name !== null && name !== void 0 ? name : "<anonymous method>"}`;
-                if (t.includes("interface"))
-                    return `Interface: ${name !== null && name !== void 0 ? name : "<anonymous interface>"}`;
-                if (t.includes("type_alias"))
-                    return `Type: ${name !== null && name !== void 0 ? name : "<anonymous type>"}`;
-                if (t.includes("function"))
-                    return `Function: ${name !== null && name !== void 0 ? name : "<anonymous function>"}`;
-                if (isTopLevelValueDef(node))
-                    return `Function: ${name !== null && name !== void 0 ? name : "<anonymous function>"}`;
-                return name ? `Symbol: ${name}` : null;
-            };
-            const getDocstring = (node) => {
-                const comments = [];
-                let current = node.previousSibling;
-                while (current) {
-                    const t = current.type;
-                    if (t.includes("comment")) {
-                        comments.unshift(current.text);
-                        current = current.previousSibling;
-                    }
-                    else if (current.text.trim().length === 0) {
-                        // whitespace
-                        current = current.previousSibling;
-                    }
-                    else {
-                        break;
-                    }
+            const fieldNames = ["name", "property", "identifier"];
+            for (const field of fieldNames) {
+                const name = byField(field);
+                if (name)
+                    return name;
+            }
+            const identifierChild = ((_a = node.namedChildren) !== null && _a !== void 0 ? _a : []).find((c) => [
+                "identifier",
+                "property_identifier",
+                "type_identifier",
+                "field_identifier",
+                "simple_identifier", // Swift, Kotlin
+                "word", // Bash
+            ].includes(c.type));
+            if (identifierChild === null || identifierChild === void 0 ? void 0 : identifierChild.text)
+                return String(identifierChild.text);
+            for (const child of (_b = node.namedChildren) !== null && _b !== void 0 ? _b : []) {
+                if (child.type === "variable_declarator") {
+                    const idChild = ((_c = child.namedChildren) !== null && _c !== void 0 ? _c : []).find((c) => ["identifier", "property_identifier", "type_identifier"].includes(c.type));
+                    if (idChild === null || idChild === void 0 ? void 0 : idChild.text)
+                        return String(idChild.text);
                 }
-                return comments.length > 0 ? comments.join("\n") : undefined;
-            };
-            const visit = (node, stack) => {
-                var _a;
-                // Metadata extraction
-                if (node.type === "import_statement" ||
-                    node.type === "import_declaration" ||
-                    node.type === "import_header" // Kotlin
-                ) {
-                    metadata.imports.push(node.text.trim());
+            }
+            const match = (node.text || "").match(/(?:class|function)\s+([A-Za-z0-9_$]+)/);
+            if (match === null || match === void 0 ? void 0 : match[1])
+                return match[1];
+            const varMatch = (node.text || "").match(/(?:const|let|var)\s+([A-Za-z0-9_$]+)/);
+            if (varMatch === null || varMatch === void 0 ? void 0 : varMatch[1])
+                return varMatch[1];
+            return null;
+        };
+        const labelForNode = (node) => {
+            const name = getNodeName(node);
+            const t = node.type;
+            if (t.includes("class"))
+                return `Class: ${name !== null && name !== void 0 ? name : "<anonymous class>"}`;
+            if (t.includes("method"))
+                return `Method: ${name !== null && name !== void 0 ? name : "<anonymous method>"}`;
+            if (t.includes("interface"))
+                return `Interface: ${name !== null && name !== void 0 ? name : "<anonymous interface>"}`;
+            if (t.includes("type_alias"))
+                return `Type: ${name !== null && name !== void 0 ? name : "<anonymous type>"}`;
+            if (t.includes("function"))
+                return `Function: ${name !== null && name !== void 0 ? name : "<anonymous function>"}`;
+            if (isTopLevelValueDef(node))
+                return `Function: ${name !== null && name !== void 0 ? name : "<anonymous function>"}`;
+            return name ? `Symbol: ${name}` : null;
+        };
+        const getDocstring = (node) => {
+            const comments = [];
+            let current = node.previousSibling;
+            while (current) {
+                const t = current.type;
+                if (t.includes("comment")) {
+                    comments.unshift(current.text);
+                    current = current.previousSibling;
                 }
-                else if (node.type === "export_statement" ||
-                    node.type === "export_declaration") {
-                    // Extract exported identifier
-                    const effective = unwrapExport(node);
-                    const name = getNodeName(effective);
-                    if (name) {
-                        metadata.exports.push(name);
-                    }
+                else if (current.text.trim().length === 0) {
+                    // whitespace
+                    current = current.previousSibling;
                 }
-                else if (node.type.includes("comment")) {
-                    if (node.startPosition.row < 10) {
-                        // Only top comments
-                        metadata.comments.push(node.text.trim());
-                    }
+                else {
+                    break;
                 }
+            }
+            return comments.length > 0 ? comments.join("\n") : undefined;
+        };
+        const visit = (node, stack) => {
+            var _a;
+            // Metadata extraction
+            if (node.type === "import_statement" ||
+                node.type === "import_declaration" ||
+                node.type === "import_header" // Kotlin
+            ) {
+                metadata.imports.push(node.text.trim());
+            }
+            else if (node.type === "export_statement" ||
+                node.type === "export_declaration") {
+                // Extract exported identifier
                 const effective = unwrapExport(node);
-                const isDefinition = isDefType(effective.type) || isTopLevelValueDef(effective);
-                let nextStack = stack;
-                if (isDefinition) {
-                    sawDefinition = true;
-                    const label = labelForNode(effective);
-                    const context = [...stack, ...(label ? [label] : [])];
-                    const docstring = getDocstring(node);
-                    // Calculate complexity
-                    const getComplexity = (n) => {
-                        let complexity = 1;
-                        const complexTypes = [
-                            "if_statement",
-                            "for_statement",
-                            "while_statement",
-                            "switch_statement",
-                            "catch_clause",
-                            "conditional_expression",
-                            "binary_expression", // simplistic, but counts logical ops usually
-                        ];
-                        const countComplexity = (curr) => {
-                            var _a;
-                            if (complexTypes.includes(curr.type)) {
-                                if (curr.type === "binary_expression") {
-                                    const op = curr.childForFieldName
-                                        ? curr.childForFieldName("operator")
-                                        : null;
-                                    if (["&&", "||", "??"].includes((op === null || op === void 0 ? void 0 : op.text) || "")) {
-                                        complexity++;
-                                    }
-                                }
-                                else {
+                const name = getNodeName(effective);
+                if (name) {
+                    metadata.exports.push(name);
+                }
+            }
+            else if (node.type.includes("comment")) {
+                if (node.startPosition.row < 10) {
+                    // Only top comments
+                    metadata.comments.push(node.text.trim());
+                }
+            }
+            const effective = unwrapExport(node);
+            const isDefinition = isDefType(effective.type) || isTopLevelValueDef(effective);
+            let nextStack = stack;
+            if (isDefinition) {
+                sawDefinition = true;
+                const label = labelForNode(effective);
+                const context = [...stack, ...(label ? [label] : [])];
+                const docstring = getDocstring(node);
+                // Calculate complexity
+                const getComplexity = (n) => {
+                    let complexity = 1;
+                    const complexTypes = [
+                        "if_statement",
+                        "for_statement",
+                        "while_statement",
+                        "switch_statement",
+                        "catch_clause",
+                        "conditional_expression",
+                        "binary_expression", // simplistic, but counts logical ops usually
+                    ];
+                    const countComplexity = (curr) => {
+                        var _a;
+                        if (complexTypes.includes(curr.type)) {
+                            if (curr.type === "binary_expression") {
+                                const op = curr.childForFieldName
+                                    ? curr.childForFieldName("operator")
+                                    : null;
+                                if (["&&", "||", "??"].includes((op === null || op === void 0 ? void 0 : op.text) || "")) {
                                     complexity++;
                                 }
                             }
-                            for (const child of (_a = curr.namedChildren) !== null && _a !== void 0 ? _a : []) {
-                                countComplexity(child);
+                            else {
+                                complexity++;
                             }
-                        };
-                        countComplexity(n);
-                        return complexity;
-                    };
-                    const complexity = getComplexity(effective);
-                    // Check if exported
-                    const name = getNodeName(effective);
-                    const isExported = name ? metadata.exports.includes(name) : false;
-                    // Extract symbols
-                    const definedSymbols = [];
-                    if (name)
-                        definedSymbols.push(name);
-                    const referencedSymbols = [];
-                    // Reduce a constructor / instanceof operand to a simple symbol name:
-                    // bare identifier -> its text; `ns.ClassName` member -> the rightmost
-                    // property (`ClassName`). Returns null for shapes we can't name.
-                    const simpleRefName = (node) => {
-                        var _a, _b;
-                        if (!node)
-                            return null;
-                        if (node.type === "member_expression") {
-                            const prop = node.childForFieldName
-                                ? node.childForFieldName("property")
-                                : null;
-                            return (_a = prop === null || prop === void 0 ? void 0 : prop.text) !== null && _a !== void 0 ? _a : null;
                         }
-                        return (_b = node.text) !== null && _b !== void 0 ? _b : null;
-                    };
-                    const addRef = (name) => {
-                        if (name && !referencedSymbols.includes(name)) {
-                            referencedSymbols.push(name);
+                        for (const child of (_a = curr.namedChildren) !== null && _a !== void 0 ? _a : []) {
+                            countComplexity(child);
                         }
                     };
-                    // Type-position references go in a SEPARATE list so they never inflate
-                    // referencedSymbols.length (which drives role classification below and
-                    // the search structural boost). Navigation consumers union the two.
-                    const typeReferencedSymbols = [];
-                    const addTypeRef = (n) => {
-                        if (n && !typeReferencedSymbols.includes(n)) {
-                            typeReferencedSymbols.push(n);
+                    countComplexity(n);
+                    return complexity;
+                };
+                const complexity = getComplexity(effective);
+                // Check if exported
+                const name = getNodeName(effective);
+                const isExported = name ? metadata.exports.includes(name) : false;
+                // Extract symbols
+                const definedSymbols = [];
+                if (name)
+                    definedSymbols.push(name);
+                const referencedSymbols = [];
+                // Reduce a constructor / instanceof operand to a simple symbol name:
+                // bare identifier -> its text; `ns.ClassName` member -> the rightmost
+                // property (`ClassName`). Returns null for shapes we can't name.
+                const simpleRefName = (node) => {
+                    var _a, _b;
+                    if (!node)
+                        return null;
+                    if (node.type === "member_expression") {
+                        const prop = node.childForFieldName
+                            ? node.childForFieldName("property")
+                            : null;
+                        return (_a = prop === null || prop === void 0 ? void 0 : prop.text) !== null && _a !== void 0 ? _a : null;
+                    }
+                    return (_b = node.text) !== null && _b !== void 0 ? _b : null;
+                };
+                const addRef = (name) => {
+                    if (name && !referencedSymbols.includes(name)) {
+                        referencedSymbols.push(name);
+                    }
+                };
+                // Type-position references go in a SEPARATE list so they never inflate
+                // referencedSymbols.length (which drives role classification below and
+                // the search structural boost). Navigation consumers union the two.
+                const typeReferencedSymbols = [];
+                const addTypeRef = (n) => {
+                    if (n && !typeReferencedSymbols.includes(n)) {
+                        typeReferencedSymbols.push(n);
+                    }
+                };
+                // Member-call names (`obj.method()`), recorded additively alongside
+                // referencedSymbols (see Chunk.memberReferencedSymbols). Deduped, like
+                // type refs — a future resolver queries membership, not occurrence count.
+                const memberReferencedSymbols = [];
+                const addMemberRef = (n) => {
+                    if (n && !memberReferencedSymbols.includes(n)) {
+                        memberReferencedSymbols.push(n);
+                    }
+                };
+                // Leaf identifier node types across grammars (a bare name with no
+                // named children — `ErrorCodes`, not `a.ErrorCodes`).
+                const LEAF_ID_TYPES = new Set([
+                    "identifier",
+                    "type_identifier",
+                    "constant", // Ruby
+                    "name", // PHP
+                    "simple_identifier", // Kotlin, Swift
+                    "property_identifier",
+                    "field_identifier", // Go
+                ]);
+                const isLeafId = (n) => {
+                    var _a, _b;
+                    return !!n &&
+                        LEAF_ID_TYPES.has(n.type) &&
+                        ((_b = (_a = n.namedChildren) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) === 0;
+                };
+                const firstNamed = (n) => { var _a, _b; return (_b = ((_a = n.namedChildren) !== null && _a !== void 0 ? _a : [])[0]) !== null && _b !== void 0 ? _b : null; };
+                // Resolve the type name out of an instantiation node (`new Foo`,
+                // `Foo{}`, `new Foo()`), preferring an explicit `type` field and
+                // falling back to the first named child (qualified names reduce to
+                // their rightmost segment via simpleRefName).
+                const instantiatedTypeName = (n) => {
+                    var _a;
+                    const typed = (_a = (n.childForFieldName ? n.childForFieldName("type") : null)) !== null && _a !== void 0 ? _a : firstNamed(n);
+                    if (!typed)
+                        return null;
+                    if (isLeafId(typed))
+                        return typed.text;
+                    return simpleRefName(typed);
+                };
+                // First `type_identifier` reachable directly or via a `user_type`
+                // wrapper — covers Java `instanceof_expression` and Kotlin/Swift
+                // `check_expression` (`x is T`).
+                const firstTypeIdent = (n) => {
+                    var _a, _b;
+                    for (const c of (_a = n.namedChildren) !== null && _a !== void 0 ? _a : []) {
+                        if (c.type === "type_identifier")
+                            return c.text;
+                        if (c.type === "user_type") {
+                            const t = ((_b = c.namedChildren) !== null && _b !== void 0 ? _b : []).find((x) => x.type === "type_identifier");
+                            if (t === null || t === void 0 ? void 0 : t.text)
+                                return t.text;
                         }
-                    };
-                    // Member-call names (`obj.method()`), recorded additively alongside
-                    // referencedSymbols (see Chunk.memberReferencedSymbols). Deduped, like
-                    // type refs — a future resolver queries membership, not occurrence count.
-                    const memberReferencedSymbols = [];
-                    const addMemberRef = (n) => {
-                        if (n && !memberReferencedSymbols.includes(n)) {
-                            memberReferencedSymbols.push(n);
+                    }
+                    return null;
+                };
+                // Member / scope access node types, one per grammar. We capture the
+                // head (object/scope) only when it is a Capitalized leaf identifier,
+                // so `ErrorCodes.VALIDATION` / `ErrorCodes::NOT_FOUND` yield an edge
+                // to `ErrorCodes` while `this.x` / `req.body` / lowercase locals do not.
+                const MEMBER_ACCESS_TYPES = new Set([
+                    "member_expression", // TS/JS
+                    "attribute", // Python
+                    "selector_expression", // Go
+                    "field_access", // Java
+                    "member_access_expression", // C#
+                    "scoped_identifier", // Rust
+                    "scope_resolution", // Ruby
+                    "navigation_expression", // Kotlin, Swift
+                    "field_expression", // Scala
+                    "class_constant_access_expression", // PHP
+                ]);
+                // Instantiation node types whose first/`type` child names a type.
+                const INSTANTIATION_TYPES = new Set([
+                    "object_creation_expression", // Java, C#, PHP
+                    "composite_literal", // Go
+                    "struct_expression", // Rust
+                    "instance_expression", // Scala
+                ]);
+                // Harvest Capitalized type names out of an annotation subtree, for the
+                // grammars whose type names are NOT `type_identifier` nodes (so Shape 4
+                // can't see them): Python/C# spell them `identifier`, PHP spells them
+                // `name`. We walk the WHOLE subtree and keep every Capitalized leaf of
+                // those kinds — safe because we only ever enter from a type position (a
+                // `type` / `return_type` / `returns` field, or a base/heritage list).
+                // Excludes the chunk's own name; lowercase builtins (`list`, `int`,
+                // `string`) and non-name leaves (`predefined_type`, `string_content`
+                // in `Literal["x"]`) fall out via the kind + Capitalized gates.
+                const TYPE_NAME_LEAF_TYPES = new Set(["identifier", "name"]);
+                const harvestTypeLeaves = (node) => {
+                    var _a, _b, _c;
+                    if (!node)
+                        return;
+                    if (((_b = (_a = node.namedChildren) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) === 0) {
+                        if (TYPE_NAME_LEAF_TYPES.has(node.type) &&
+                            /^[A-Z]/.test(node.text) &&
+                            node.text !== name) {
+                            addTypeRef(node.text);
                         }
-                    };
-                    // Leaf identifier node types across grammars (a bare name with no
-                    // named children — `ErrorCodes`, not `a.ErrorCodes`).
-                    const LEAF_ID_TYPES = new Set([
-                        "identifier",
-                        "type_identifier",
-                        "constant", // Ruby
-                        "name", // PHP
-                        "simple_identifier", // Kotlin, Swift
-                        "property_identifier",
-                        "field_identifier", // Go
-                    ]);
-                    const isLeafId = (n) => {
-                        var _a, _b;
-                        return !!n &&
-                            LEAF_ID_TYPES.has(n.type) &&
-                            ((_b = (_a = n.namedChildren) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) === 0;
-                    };
-                    const firstNamed = (n) => { var _a, _b; return (_b = ((_a = n.namedChildren) !== null && _a !== void 0 ? _a : [])[0]) !== null && _b !== void 0 ? _b : null; };
-                    // Resolve the type name out of an instantiation node (`new Foo`,
-                    // `Foo{}`, `new Foo()`), preferring an explicit `type` field and
-                    // falling back to the first named child (qualified names reduce to
-                    // their rightmost segment via simpleRefName).
-                    const instantiatedTypeName = (n) => {
-                        var _a;
-                        const typed = (_a = (n.childForFieldName ? n.childForFieldName("type") : null)) !== null && _a !== void 0 ? _a : firstNamed(n);
-                        if (!typed)
-                            return null;
-                        if (isLeafId(typed))
-                            return typed.text;
-                        return simpleRefName(typed);
-                    };
-                    // First `type_identifier` reachable directly or via a `user_type`
-                    // wrapper — covers Java `instanceof_expression` and Kotlin/Swift
-                    // `check_expression` (`x is T`).
-                    const firstTypeIdent = (n) => {
-                        var _a, _b;
-                        for (const c of (_a = n.namedChildren) !== null && _a !== void 0 ? _a : []) {
-                            if (c.type === "type_identifier")
-                                return c.text;
-                            if (c.type === "user_type") {
-                                const t = ((_b = c.namedChildren) !== null && _b !== void 0 ? _b : []).find((x) => x.type === "type_identifier");
-                                if (t === null || t === void 0 ? void 0 : t.text)
-                                    return t.text;
+                        return;
+                    }
+                    for (const c of (_c = node.namedChildren) !== null && _c !== void 0 ? _c : [])
+                        harvestTypeLeaves(c);
+                };
+                const extractRefs = (n) => {
+                    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
+                    // Handle JS/TS (call_expression), Python (call), Lua (function_call)
+                    if (n.type === "call_expression" ||
+                        n.type === "call" ||
+                        n.type === "function_call") {
+                        const func = n.childForFieldName
+                            ? n.childForFieldName("function")
+                            : null;
+                        if (func) {
+                            let funcName = func.text;
+                            let isMemberCall = false;
+                            // Handle member access (obj.method) to extract just 'method'
+                            if (func.type === "member_expression") {
+                                // JS/TS: object.property
+                                const prop = func.childForFieldName
+                                    ? func.childForFieldName("property")
+                                    : null;
+                                if (prop) {
+                                    funcName = prop.text;
+                                    isMemberCall = true;
+                                }
                             }
-                        }
-                        return null;
-                    };
-                    // Member / scope access node types, one per grammar. We capture the
-                    // head (object/scope) only when it is a Capitalized leaf identifier,
-                    // so `ErrorCodes.VALIDATION` / `ErrorCodes::NOT_FOUND` yield an edge
-                    // to `ErrorCodes` while `this.x` / `req.body` / lowercase locals do not.
-                    const MEMBER_ACCESS_TYPES = new Set([
-                        "member_expression", // TS/JS
-                        "attribute", // Python
-                        "selector_expression", // Go
-                        "field_access", // Java
-                        "member_access_expression", // C#
-                        "scoped_identifier", // Rust
-                        "scope_resolution", // Ruby
-                        "navigation_expression", // Kotlin, Swift
-                        "field_expression", // Scala
-                        "class_constant_access_expression", // PHP
-                    ]);
-                    // Instantiation node types whose first/`type` child names a type.
-                    const INSTANTIATION_TYPES = new Set([
-                        "object_creation_expression", // Java, C#, PHP
-                        "composite_literal", // Go
-                        "struct_expression", // Rust
-                        "instance_expression", // Scala
-                    ]);
-                    // Harvest Capitalized type names out of an annotation subtree, for the
-                    // grammars whose type names are NOT `type_identifier` nodes (so Shape 4
-                    // can't see them): Python/C# spell them `identifier`, PHP spells them
-                    // `name`. We walk the WHOLE subtree and keep every Capitalized leaf of
-                    // those kinds — safe because we only ever enter from a type position (a
-                    // `type` / `return_type` / `returns` field, or a base/heritage list).
-                    // Excludes the chunk's own name; lowercase builtins (`list`, `int`,
-                    // `string`) and non-name leaves (`predefined_type`, `string_content`
-                    // in `Literal["x"]`) fall out via the kind + Capitalized gates.
-                    const TYPE_NAME_LEAF_TYPES = new Set(["identifier", "name"]);
-                    const harvestTypeLeaves = (node) => {
-                        var _a, _b, _c;
-                        if (!node)
-                            return;
-                        if (((_b = (_a = node.namedChildren) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) === 0) {
-                            if (TYPE_NAME_LEAF_TYPES.has(node.type) &&
-                                /^[A-Z]/.test(node.text) &&
-                                node.text !== name) {
-                                addTypeRef(node.text);
+                            else if (func.type === "attribute") {
+                                // Python: object.attribute
+                                const attr = func.childForFieldName
+                                    ? func.childForFieldName("attribute")
+                                    : null;
+                                if (attr) {
+                                    funcName = attr.text;
+                                    isMemberCall = true;
+                                }
                             }
-                            return;
+                            referencedSymbols.push(funcName);
+                            // Additive: member calls ALSO go here. referencedSymbols is left
+                            // untouched (no recall loss); this just tags which were members.
+                            if (isMemberCall)
+                                addMemberRef(funcName);
                         }
-                        for (const c of (_c = node.namedChildren) !== null && _c !== void 0 ? _c : [])
-                            harvestTypeLeaves(c);
-                    };
-                    const extractRefs = (n) => {
-                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
-                        // Handle JS/TS (call_expression), Python (call), Lua (function_call)
-                        if (n.type === "call_expression" ||
-                            n.type === "call" ||
-                            n.type === "function_call") {
-                            const func = n.childForFieldName
-                                ? n.childForFieldName("function")
-                                : null;
-                            if (func) {
-                                let funcName = func.text;
+                        else {
+                            // Swift/Kotlin: call_expression has no "function" field;
+                            // the callable is a positional child
+                            const firstChild = ((_a = n.namedChildren) !== null && _a !== void 0 ? _a : [])[0];
+                            if (firstChild) {
+                                let funcName = firstChild.text;
                                 let isMemberCall = false;
-                                // Handle member access (obj.method) to extract just 'method'
-                                if (func.type === "member_expression") {
-                                    // JS/TS: object.property
-                                    const prop = func.childForFieldName
-                                        ? func.childForFieldName("property")
+                                if (firstChild.type === "navigation_expression") {
+                                    const suffix = ((_b = firstChild.namedChildren) !== null && _b !== void 0 ? _b : []).find((c) => c.type === "navigation_suffix");
+                                    const methodId = suffix
+                                        ? ((_c = suffix.namedChildren) !== null && _c !== void 0 ? _c : []).find((c) => c.type === "simple_identifier")
                                         : null;
-                                    if (prop) {
-                                        funcName = prop.text;
-                                        isMemberCall = true;
-                                    }
-                                }
-                                else if (func.type === "attribute") {
-                                    // Python: object.attribute
-                                    const attr = func.childForFieldName
-                                        ? func.childForFieldName("attribute")
-                                        : null;
-                                    if (attr) {
-                                        funcName = attr.text;
+                                    if (methodId) {
+                                        funcName = methodId.text;
                                         isMemberCall = true;
                                     }
                                 }
                                 referencedSymbols.push(funcName);
-                                // Additive: member calls ALSO go here. referencedSymbols is left
-                                // untouched (no recall loss); this just tags which were members.
                                 if (isMemberCall)
                                     addMemberRef(funcName);
                             }
-                            else {
-                                // Swift/Kotlin: call_expression has no "function" field;
-                                // the callable is a positional child
-                                const firstChild = ((_a = n.namedChildren) !== null && _a !== void 0 ? _a : [])[0];
-                                if (firstChild) {
-                                    let funcName = firstChild.text;
-                                    let isMemberCall = false;
-                                    if (firstChild.type === "navigation_expression") {
-                                        const suffix = ((_b = firstChild.namedChildren) !== null && _b !== void 0 ? _b : []).find((c) => c.type === "navigation_suffix");
-                                        const methodId = suffix
-                                            ? ((_c = suffix.namedChildren) !== null && _c !== void 0 ? _c : []).find((c) => c.type === "simple_identifier")
-                                            : null;
-                                        if (methodId) {
-                                            funcName = methodId.text;
-                                            isMemberCall = true;
-                                        }
-                                    }
-                                    referencedSymbols.push(funcName);
-                                    if (isMemberCall)
-                                        addMemberRef(funcName);
-                                }
-                            }
                         }
-                        // JSX elements: <Component /> or <Component>
-                        if (n.type === "jsx_self_closing_element" ||
-                            n.type === "jsx_opening_element") {
-                            const nameChild = ((_d = n.namedChildren) !== null && _d !== void 0 ? _d : []).find((c) => c.type === "identifier" ||
-                                c.type === "member_expression" ||
-                                c.type === "nested_identifier");
-                            if (nameChild) {
-                                // Only capture PascalCase components (skip HTML tags like div, span)
-                                const name = nameChild.type === "member_expression"
-                                    ? ((_g = (_f = (_e = nameChild.childForFieldName) === null || _e === void 0 ? void 0 : _e.call(nameChild, "property")) === null || _f === void 0 ? void 0 : _f.text) !== null && _g !== void 0 ? _g : nameChild.text)
-                                    : nameChild.text;
-                                if (name && /^[A-Z]/.test(name)) {
-                                    referencedSymbols.push(name);
-                                }
+                    }
+                    // JSX elements: <Component /> or <Component>
+                    if (n.type === "jsx_self_closing_element" ||
+                        n.type === "jsx_opening_element") {
+                        const nameChild = ((_d = n.namedChildren) !== null && _d !== void 0 ? _d : []).find((c) => c.type === "identifier" ||
+                            c.type === "member_expression" ||
+                            c.type === "nested_identifier");
+                        if (nameChild) {
+                            // Only capture PascalCase components (skip HTML tags like div, span)
+                            const name = nameChild.type === "member_expression"
+                                ? ((_g = (_f = (_e = nameChild.childForFieldName) === null || _e === void 0 ? void 0 : _e.call(nameChild, "property")) === null || _f === void 0 ? void 0 : _f.text) !== null && _g !== void 0 ? _g : nameChild.text)
+                                : nameChild.text;
+                            if (name && /^[A-Z]/.test(name)) {
+                                referencedSymbols.push(name);
                             }
                         }
-                        // Identifier-as-value references: edges the call-expression capture
-                        // above misses. These feed the graph-walk consumers (PPR,
-                        // `gmax dead <ClassName>`, audit) that need class/enum references,
-                        // not just method-call names. Node types are grammar-specific but
-                        // each falls into one of three shapes — instantiation, type-test, or
-                        // member/scope access — handled uniformly across the 14 grammars.
-                        // Shape 1 — instantiation: `new ClassName(...)`, `ClassName{...}`.
-                        if (n.type === "new_expression") {
-                            // TS/JS — constructor may be qualified (`ns.ClassName`).
-                            const ctor = n.childForFieldName
-                                ? n.childForFieldName("constructor")
+                    }
+                    // Identifier-as-value references: edges the call-expression capture
+                    // above misses. These feed the graph-walk consumers (PPR,
+                    // `gmax dead <ClassName>`, audit) that need class/enum references,
+                    // not just method-call names. Node types are grammar-specific but
+                    // each falls into one of three shapes — instantiation, type-test, or
+                    // member/scope access — handled uniformly across the 14 grammars.
+                    // Shape 1 — instantiation: `new ClassName(...)`, `ClassName{...}`.
+                    if (n.type === "new_expression") {
+                        // TS/JS — constructor may be qualified (`ns.ClassName`).
+                        const ctor = n.childForFieldName
+                            ? n.childForFieldName("constructor")
+                            : null;
+                        addRef(simpleRefName(ctor));
+                    }
+                    else if (INSTANTIATION_TYPES.has(n.type)) {
+                        addRef(instantiatedTypeName(n));
+                    }
+                    // Shape 2 — type-test: `x instanceof T`, `x is T`.
+                    if (n.type === "binary_expression") {
+                        // TS/JS, PHP — instanceof is a binary operator.
+                        const op = n.childForFieldName
+                            ? n.childForFieldName("operator")
+                            : null;
+                        if ((op === null || op === void 0 ? void 0 : op.text) === "instanceof") {
+                            const right = n.childForFieldName
+                                ? n.childForFieldName("right")
                                 : null;
-                            addRef(simpleRefName(ctor));
+                            addRef(simpleRefName(right));
                         }
-                        else if (INSTANTIATION_TYPES.has(n.type)) {
-                            addRef(instantiatedTypeName(n));
+                    }
+                    else if (n.type === "instanceof_expression" || // Java
+                        n.type === "check_expression" // Kotlin, Swift (`x is T`)
+                    ) {
+                        addRef(firstTypeIdent(n));
+                    }
+                    else if (n.type === "is_pattern_expression") {
+                        // C# — `x is BeyondError`: the type sits in a constant_pattern.
+                        const cp = ((_h = n.namedChildren) !== null && _h !== void 0 ? _h : []).find((c) => c.type === "constant_pattern");
+                        const id = cp ? firstNamed(cp) : null;
+                        if (isLeafId(id) && id && /^[A-Z]/.test(id.text))
+                            addRef(id.text);
+                    }
+                    // Shape 3 — member / scope access: `ErrorCodes.MEMBER`,
+                    // `ErrorCodes::MEMBER`. Capitalized head only (skip `this.x`).
+                    if (MEMBER_ACCESS_TYPES.has(n.type)) {
+                        const head = firstNamed(n);
+                        if (head && isLeafId(head) && /^[A-Z]/.test(head.text)) {
+                            addRef(head.text);
                         }
-                        // Shape 2 — type-test: `x instanceof T`, `x is T`.
-                        if (n.type === "binary_expression") {
-                            // TS/JS, PHP — instanceof is a binary operator.
-                            const op = n.childForFieldName
-                                ? n.childForFieldName("operator")
-                                : null;
-                            if ((op === null || op === void 0 ? void 0 : op.text) === "instanceof") {
-                                const right = n.childForFieldName
-                                    ? n.childForFieldName("right")
-                                    : null;
-                                addRef(simpleRefName(right));
-                            }
+                    }
+                    // Shape 4 — type-position reference (TS/TSX): `: T`, `<T>`, `T[]`,
+                    // `as T`, `interface X extends T`, type aliases. TS uses a distinct
+                    // `type_identifier` node for type names (primitives are
+                    // `predefined_type`, so they never reach here). Capture Capitalized
+                    // ones, skipping the chunk's own name and any locally-declared type
+                    // parameter (`<T>` and its uses `value: T`). Constraints
+                    // (`T extends Foo`) still yield `Foo`. Type list, never referencedSymbols.
+                    if (n.type === "type_identifier" &&
+                        /^[A-Z]/.test(n.text) &&
+                        n.text !== name &&
+                        !declaredTypeParams.has(n.text)) {
+                        addTypeRef(n.text);
+                    }
+                    // Shape 5 — class heritage `class A extends B`: the superclass is an
+                    // `identifier` (a runtime value), not a `type_identifier`, so Shape 4
+                    // misses it. `implements I` and `interface X extends Y` use
+                    // type_identifier and are already covered. Reduce `extends ns.Base`
+                    // to `Base`; skip type arguments (Shape 4 handles those).
+                    if (n.type === "extends_clause") {
+                        for (const c of (_j = n.namedChildren) !== null && _j !== void 0 ? _j : []) {
+                            if (c.type === "type_arguments")
+                                continue;
+                            const sup = simpleRefName(c);
+                            if (sup && /^[A-Z]/.test(sup) && sup !== name)
+                                addTypeRef(sup);
                         }
-                        else if (n.type === "instanceof_expression" || // Java
-                            n.type === "check_expression" // Kotlin, Swift (`x is T`)
-                        ) {
-                            addRef(firstTypeIdent(n));
+                    }
+                    // Shape 6 — type-position references for grammars whose type names
+                    // are plain `identifier` / `name` nodes (not `type_identifier`), so
+                    // Shape 4 can't reach them. Read the annotation off the carrier
+                    // node's type field and harvest from THAT subtree only — never the
+                    // node as a whole — so value expressions stay out of the type list.
+                    // Each grammar is gated by `lang` because the carrier node/field
+                    // names collide across grammars (`function_definition`,
+                    // `method_declaration`, `assignment`, …). The other typed grammars
+                    // (Go/Rust/Java/Kotlin/Scala/Swift) spell type names as
+                    // `type_identifier` and are already covered by Shape 4.
+                    if (lang === "python") {
+                        // `x: Foo`, `-> Bar`, `v: Baz = …`, and `class C(Base)` bases.
+                        if (n.type === "typed_parameter" ||
+                            n.type === "typed_default_parameter") {
+                            harvestTypeLeaves((_l = (_k = n.childForFieldName) === null || _k === void 0 ? void 0 : _k.call(n, "type")) !== null && _l !== void 0 ? _l : null);
                         }
-                        else if (n.type === "is_pattern_expression") {
-                            // C# — `x is BeyondError`: the type sits in a constant_pattern.
-                            const cp = ((_h = n.namedChildren) !== null && _h !== void 0 ? _h : []).find((c) => c.type === "constant_pattern");
-                            const id = cp ? firstNamed(cp) : null;
-                            if (isLeafId(id) && id && /^[A-Z]/.test(id.text))
-                                addRef(id.text);
+                        else if (n.type === "function_definition") {
+                            harvestTypeLeaves((_o = (_m = n.childForFieldName) === null || _m === void 0 ? void 0 : _m.call(n, "return_type")) !== null && _o !== void 0 ? _o : null);
                         }
-                        // Shape 3 — member / scope access: `ErrorCodes.MEMBER`,
-                        // `ErrorCodes::MEMBER`. Capitalized head only (skip `this.x`).
-                        if (MEMBER_ACCESS_TYPES.has(n.type)) {
-                            const head = firstNamed(n);
-                            if (head && isLeafId(head) && /^[A-Z]/.test(head.text)) {
-                                addRef(head.text);
-                            }
+                        else if (n.type === "assignment") {
+                            harvestTypeLeaves((_q = (_p = n.childForFieldName) === null || _p === void 0 ? void 0 : _p.call(n, "type")) !== null && _q !== void 0 ? _q : null);
                         }
-                        // Shape 4 — type-position reference (TS/TSX): `: T`, `<T>`, `T[]`,
-                        // `as T`, `interface X extends T`, type aliases. TS uses a distinct
-                        // `type_identifier` node for type names (primitives are
-                        // `predefined_type`, so they never reach here). Capture Capitalized
-                        // ones, skipping the chunk's own name and any locally-declared type
-                        // parameter (`<T>` and its uses `value: T`). Constraints
-                        // (`T extends Foo`) still yield `Foo`. Type list, never referencedSymbols.
-                        if (n.type === "type_identifier" &&
-                            /^[A-Z]/.test(n.text) &&
-                            n.text !== name &&
-                            !declaredTypeParams.has(n.text)) {
-                            addTypeRef(n.text);
+                        else if (n.type === "class_definition") {
+                            harvestTypeLeaves((_s = (_r = n.childForFieldName) === null || _r === void 0 ? void 0 : _r.call(n, "superclasses")) !== null && _s !== void 0 ? _s : null);
                         }
-                        // Shape 5 — class heritage `class A extends B`: the superclass is an
-                        // `identifier` (a runtime value), not a `type_identifier`, so Shape 4
-                        // misses it. `implements I` and `interface X extends Y` use
-                        // type_identifier and are already covered. Reduce `extends ns.Base`
-                        // to `Base`; skip type arguments (Shape 4 handles those).
-                        if (n.type === "extends_clause") {
-                            for (const c of (_j = n.namedChildren) !== null && _j !== void 0 ? _j : []) {
-                                if (c.type === "type_arguments")
-                                    continue;
-                                const sup = simpleRefName(c);
-                                if (sup && /^[A-Z]/.test(sup) && sup !== name)
-                                    addTypeRef(sup);
-                            }
+                    }
+                    else if (lang === "c_sharp") {
+                        // Method return (`returns`), parameter / property / variable
+                        // (`type`), and the base/interface list.
+                        if (n.type === "parameter" ||
+                            n.type === "property_declaration" ||
+                            n.type === "variable_declaration") {
+                            harvestTypeLeaves((_u = (_t = n.childForFieldName) === null || _t === void 0 ? void 0 : _t.call(n, "type")) !== null && _u !== void 0 ? _u : null);
                         }
-                        // Shape 6 — type-position references for grammars whose type names
-                        // are plain `identifier` / `name` nodes (not `type_identifier`), so
-                        // Shape 4 can't reach them. Read the annotation off the carrier
-                        // node's type field and harvest from THAT subtree only — never the
-                        // node as a whole — so value expressions stay out of the type list.
-                        // Each grammar is gated by `lang` because the carrier node/field
-                        // names collide across grammars (`function_definition`,
-                        // `method_declaration`, `assignment`, …). The other typed grammars
-                        // (Go/Rust/Java/Kotlin/Scala/Swift) spell type names as
-                        // `type_identifier` and are already covered by Shape 4.
-                        if (lang === "python") {
-                            // `x: Foo`, `-> Bar`, `v: Baz = …`, and `class C(Base)` bases.
-                            if (n.type === "typed_parameter" ||
-                                n.type === "typed_default_parameter") {
-                                harvestTypeLeaves((_l = (_k = n.childForFieldName) === null || _k === void 0 ? void 0 : _k.call(n, "type")) !== null && _l !== void 0 ? _l : null);
-                            }
-                            else if (n.type === "function_definition") {
-                                harvestTypeLeaves((_o = (_m = n.childForFieldName) === null || _m === void 0 ? void 0 : _m.call(n, "return_type")) !== null && _o !== void 0 ? _o : null);
-                            }
-                            else if (n.type === "assignment") {
-                                harvestTypeLeaves((_q = (_p = n.childForFieldName) === null || _p === void 0 ? void 0 : _p.call(n, "type")) !== null && _q !== void 0 ? _q : null);
-                            }
-                            else if (n.type === "class_definition") {
-                                harvestTypeLeaves((_s = (_r = n.childForFieldName) === null || _r === void 0 ? void 0 : _r.call(n, "superclasses")) !== null && _s !== void 0 ? _s : null);
-                            }
+                        else if (n.type === "method_declaration") {
+                            harvestTypeLeaves((_w = (_v = n.childForFieldName) === null || _v === void 0 ? void 0 : _v.call(n, "returns")) !== null && _w !== void 0 ? _w : null);
                         }
-                        else if (lang === "c_sharp") {
-                            // Method return (`returns`), parameter / property / variable
-                            // (`type`), and the base/interface list.
-                            if (n.type === "parameter" ||
-                                n.type === "property_declaration" ||
-                                n.type === "variable_declaration") {
-                                harvestTypeLeaves((_u = (_t = n.childForFieldName) === null || _t === void 0 ? void 0 : _t.call(n, "type")) !== null && _u !== void 0 ? _u : null);
-                            }
-                            else if (n.type === "method_declaration") {
-                                harvestTypeLeaves((_w = (_v = n.childForFieldName) === null || _v === void 0 ? void 0 : _v.call(n, "returns")) !== null && _w !== void 0 ? _w : null);
-                            }
-                            else if (n.type === "base_list") {
-                                harvestTypeLeaves(n);
-                            }
+                        else if (n.type === "base_list") {
+                            harvestTypeLeaves(n);
                         }
-                        else if (lang === "php") {
-                            // Types are `name` inside `named_type` / `optional_type`.
-                            // Parameter / property (`type`), function & method return
-                            // (`return_type`), and the extends / implements clauses.
-                            if (n.type === "simple_parameter" ||
-                                n.type === "property_declaration") {
-                                harvestTypeLeaves((_y = (_x = n.childForFieldName) === null || _x === void 0 ? void 0 : _x.call(n, "type")) !== null && _y !== void 0 ? _y : null);
-                            }
-                            else if (n.type === "function_definition" ||
-                                n.type === "method_declaration") {
-                                harvestTypeLeaves((_0 = (_z = n.childForFieldName) === null || _z === void 0 ? void 0 : _z.call(n, "return_type")) !== null && _0 !== void 0 ? _0 : null);
-                            }
-                            else if (n.type === "base_clause" ||
-                                n.type === "class_interface_clause") {
-                                harvestTypeLeaves(n);
-                            }
+                    }
+                    else if (lang === "php") {
+                        // Types are `name` inside `named_type` / `optional_type`.
+                        // Parameter / property (`type`), function & method return
+                        // (`return_type`), and the extends / implements clauses.
+                        if (n.type === "simple_parameter" ||
+                            n.type === "property_declaration") {
+                            harvestTypeLeaves((_y = (_x = n.childForFieldName) === null || _x === void 0 ? void 0 : _x.call(n, "type")) !== null && _y !== void 0 ? _y : null);
                         }
-                        for (const child of (_1 = n.namedChildren) !== null && _1 !== void 0 ? _1 : []) {
-                            extractRefs(child);
+                        else if (n.type === "function_definition" ||
+                            n.type === "method_declaration") {
+                            harvestTypeLeaves((_0 = (_z = n.childForFieldName) === null || _z === void 0 ? void 0 : _z.call(n, "return_type")) !== null && _0 !== void 0 ? _0 : null);
                         }
-                    };
-                    // Collect locally-declared type-parameter names (`<T, K>`) so their
-                    // *uses* (`value: T`) are excluded from type refs, not just their
-                    // declarations. Chunk-scoped, which matches single-definition chunks.
-                    const declaredTypeParams = new Set();
-                    const collectTypeParams = (n) => {
-                        var _a;
-                        if (n.type === "type_parameter") {
-                            const nm = firstNamed(n);
-                            if ((nm === null || nm === void 0 ? void 0 : nm.type) === "type_identifier")
-                                declaredTypeParams.add(nm.text);
+                        else if (n.type === "base_clause" ||
+                            n.type === "class_interface_clause") {
+                            harvestTypeLeaves(n);
                         }
-                        for (const child of (_a = n.namedChildren) !== null && _a !== void 0 ? _a : [])
-                            collectTypeParams(child);
-                    };
-                    collectTypeParams(effective);
-                    extractRefs(effective);
-                    // Classify role
-                    let role = "IMPLEMENTATION";
-                    if (isDefinition)
-                        role = "DEFINITION";
-                    if (complexity > 5 && referencedSymbols.length > 5)
-                        role = "ORCHESTRATION";
-                    if (effective.type.includes("import"))
-                        role = "IMPORT";
-                    chunks.push({
-                        content: node.text,
-                        startLine: node.startPosition.row,
-                        endLine: node.endPosition.row,
-                        type: classify(effective),
-                        context,
-                        docstring,
-                        complexity,
-                        isExported,
-                        definedSymbols,
-                        referencedSymbols,
-                        typeReferencedSymbols,
-                        memberReferencedSymbols,
-                        role,
-                        parentSymbol: stack.length > 1
-                            ? stack[stack.length - 1].replace(/^(Class|Method|Function|Interface|Type): /, "")
-                            : undefined,
-                    });
-                    nextStack = context;
-                }
-                for (const child of (_a = effective.namedChildren) !== null && _a !== void 0 ? _a : []) {
-                    visit(child, nextStack);
-                }
-            };
-            for (const child of (_b = root.namedChildren) !== null && _b !== void 0 ? _b : []) {
-                visit(child, [fileContext]);
-                const effective = unwrapExport(child);
-                const isDefinition = isDefType(effective.type) || isTopLevelValueDef(effective);
-                if (!isDefinition)
-                    continue;
-                if (child.startIndex > cursorIndex) {
-                    const gapText = content.slice(cursorIndex, child.startIndex);
-                    if (gapText.trim().length > 0) {
-                        blockChunks.push({
-                            content: gapText,
-                            startLine: cursorRow,
-                            endLine: child.startPosition.row,
-                            type: "block",
-                            context: [fileContext],
-                        });
                     }
-                }
-                cursorIndex = child.endIndex;
-                cursorRow = child.endPosition.row;
+                    for (const child of (_1 = n.namedChildren) !== null && _1 !== void 0 ? _1 : []) {
+                        extractRefs(child);
+                    }
+                };
+                // Collect locally-declared type-parameter names (`<T, K>`) so their
+                // *uses* (`value: T`) are excluded from type refs, not just their
+                // declarations. Chunk-scoped, which matches single-definition chunks.
+                const declaredTypeParams = new Set();
+                const collectTypeParams = (n) => {
+                    var _a;
+                    if (n.type === "type_parameter") {
+                        const nm = firstNamed(n);
+                        if ((nm === null || nm === void 0 ? void 0 : nm.type) === "type_identifier")
+                            declaredTypeParams.add(nm.text);
+                    }
+                    for (const child of (_a = n.namedChildren) !== null && _a !== void 0 ? _a : [])
+                        collectTypeParams(child);
+                };
+                collectTypeParams(effective);
+                extractRefs(effective);
+                // Classify role
+                let role = "IMPLEMENTATION";
+                if (isDefinition)
+                    role = "DEFINITION";
+                if (complexity > 5 && referencedSymbols.length > 5)
+                    role = "ORCHESTRATION";
+                if (effective.type.includes("import"))
+                    role = "IMPORT";
+                chunks.push({
+                    content: node.text,
+                    startLine: node.startPosition.row,
+                    endLine: node.endPosition.row,
+                    type: classify(effective),
+                    context,
+                    docstring,
+                    complexity,
+                    isExported,
+                    definedSymbols,
+                    referencedSymbols,
+                    typeReferencedSymbols,
+                    memberReferencedSymbols,
+                    role,
+                    parentSymbol: stack.length > 1
+                        ? stack[stack.length - 1].replace(/^(Class|Method|Function|Interface|Type): /, "")
+                        : undefined,
+                });
+                nextStack = context;
+            }
+            for (const child of (_a = effective.namedChildren) !== null && _a !== void 0 ? _a : []) {
+                visit(child, nextStack);
             }
-            if (cursorIndex < content.length) {
-                const tailText = content.slice(cursorIndex);
-                if (tailText.trim().length > 0) {
+        };
+        for (const child of (_a = root.namedChildren) !== null && _a !== void 0 ? _a : []) {
+            visit(child, [fileContext]);
+            const effective = unwrapExport(child);
+            const isDefinition = isDefType(effective.type) || isTopLevelValueDef(effective);
+            if (!isDefinition)
+                continue;
+            if (child.startIndex > cursorIndex) {
+                const gapText = content.slice(cursorIndex, child.startIndex);
+                if (gapText.trim().length > 0) {
                     blockChunks.push({
-                        content: tailText,
+                        content: gapText,
                         startLine: cursorRow,
-                        endLine: root.endPosition.row,
+                        endLine: child.startPosition.row,
                         type: "block",
                         context: [fileContext],
                     });
                 }
             }
-            if (!sawDefinition)
-                return { chunks: [], metadata };
-            const combined = [...blockChunks, ...chunks].sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
-            return { chunks: combined, metadata };
-        });
+            cursorIndex = child.endIndex;
+            cursorRow = child.endPosition.row;
+        }
+        if (cursorIndex < content.length) {
+            const tailText = content.slice(cursorIndex);
+            if (tailText.trim().length > 0) {
+                blockChunks.push({
+                    content: tailText,
+                    startLine: cursorRow,
+                    endLine: root.endPosition.row,
+                    type: "block",
+                    context: [fileContext],
+                });
+            }
+        }
+        if (!sawDefinition)
+            return { chunks: [], metadata };
+        const combined = [...blockChunks, ...chunks].sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+        return { chunks: combined, metadata };
     }
     /**
      * Restrict a sub-chunk's symbol lists to names that actually occur in its