@colbymchenry/codegraph 0.6.6 → 0.7.2

package/dist/extraction/tree-sitter.js

@@ -38,813 +38,39 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DfmExtractor = exports.SvelteExtractor = exports.LiquidExtractor = exports.TreeSitterExtractor = void 0;
-exports.generateNodeId = generateNodeId;
+exports.TreeSitterExtractor = exports.generateNodeId = void 0;
 exports.extractFromSource = extractFromSource;
-const crypto = __importStar(require("crypto"));
 const path = __importStar(require("path"));
 const grammars_1 = require("./grammars");
-const sentry_1 = require("../sentry");
-/**
- * Generate a unique node ID
- *
- * Uses a 32-character (128-bit) hash to avoid collisions when indexing
- * large codebases with many files containing similar symbols.
- */
-function generateNodeId(filePath, kind, name, line) {
-    const hash = crypto
-        .createHash('sha256')
-        .update(`${filePath}:${kind}:${name}:${line}`)
-        .digest('hex')
-        .substring(0, 32);
-    return `${kind}:${hash}`;
-}
-/**
- * Extract text from a syntax node
- */
-function getNodeText(node, source) {
-    return source.substring(node.startIndex, node.endIndex);
-}
-/**
- * Find a child node by field name
- */
-function getChildByField(node, fieldName) {
-    return node.childForFieldName(fieldName);
-}
-/**
- * Get the docstring/comment preceding a node
- */
-function getPrecedingDocstring(node, source) {
-    let sibling = node.previousNamedSibling;
-    const comments = [];
-    while (sibling) {
-        if (sibling.type === 'comment' ||
-            sibling.type === 'line_comment' ||
-            sibling.type === 'block_comment' ||
-            sibling.type === 'documentation_comment') {
-            comments.unshift(getNodeText(sibling, source));
-            sibling = sibling.previousNamedSibling;
-        }
-        else {
-            break;
-        }
-    }
-    if (comments.length === 0)
-        return undefined;
-    // Clean up comment markers
-    return comments
-        .map((c) => c
-        .replace(/^\/\*\*?|\*\/$/g, '')
-        .replace(/^\/\/\s?/gm, '')
-        .replace(/^\s*\*\s?/gm, '')
-        .trim())
-        .join('\n')
-        .trim();
-}
-/**
- * Language-specific extractors
- */
-const EXTRACTORS = {
-    typescript: {
-        functionTypes: ['function_declaration', 'arrow_function', 'function_expression'],
-        classTypes: ['class_declaration'],
-        methodTypes: ['method_definition', 'public_field_definition'],
-        interfaceTypes: ['interface_declaration'],
-        structTypes: [],
-        enumTypes: ['enum_declaration'],
-        typeAliasTypes: ['type_alias_declaration'],
-        importTypes: ['import_statement'],
-        callTypes: ['call_expression'],
-        variableTypes: ['lexical_declaration', 'variable_declaration'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        returnField: 'return_type',
-        getSignature: (node, source) => {
-            const params = getChildByField(node, 'parameters');
-            const returnType = getChildByField(node, 'return_type');
-            if (!params)
-                return undefined;
-            let sig = getNodeText(params, source);
-            if (returnType) {
-                sig += ': ' + getNodeText(returnType, source).replace(/^:\s*/, '');
-            }
-            return sig;
-        },
-        getVisibility: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'accessibility_modifier') {
-                    const text = child.text;
-                    if (text === 'public')
-                        return 'public';
-                    if (text === 'private')
-                        return 'private';
-                    if (text === 'protected')
-                        return 'protected';
-                }
-            }
-            return undefined;
-        },
-        isExported: (node, _source) => {
-            // Walk the parent chain to find an export_statement ancestor.
-            // This correctly handles deeply nested nodes like arrow functions
-            // inside variable declarations: `export const X = () => { ... }`
-            // where the arrow_function is 3 levels deep under export_statement.
-            let current = node.parent;
-            while (current) {
-                if (current.type === 'export_statement')
-                    return true;
-                current = current.parent;
-            }
-            return false;
-        },
-        isAsync: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'async')
-                    return true;
-            }
-            return false;
-        },
-        isStatic: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'static')
-                    return true;
-            }
-            return false;
-        },
-        isConst: (node) => {
-            // For lexical_declaration, check if it's 'const' or 'let'
-            // For variable_declaration, it's always 'var'
-            if (node.type === 'lexical_declaration') {
-                for (let i = 0; i < node.childCount; i++) {
-                    const child = node.child(i);
-                    if (child?.type === 'const')
-                        return true;
-                }
-            }
-            return false;
-        },
-    },
-    javascript: {
-        functionTypes: ['function_declaration', 'arrow_function', 'function_expression'],
-        classTypes: ['class_declaration'],
-        methodTypes: ['method_definition', 'field_definition'],
-        interfaceTypes: [],
-        structTypes: [],
-        enumTypes: [],
-        typeAliasTypes: [],
-        importTypes: ['import_statement'],
-        callTypes: ['call_expression'],
-        variableTypes: ['lexical_declaration', 'variable_declaration'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        getSignature: (node, source) => {
-            const params = getChildByField(node, 'parameters');
-            return params ? getNodeText(params, source) : undefined;
-        },
-        isExported: (node, _source) => {
-            let current = node.parent;
-            while (current) {
-                if (current.type === 'export_statement')
-                    return true;
-                current = current.parent;
-            }
-            return false;
-        },
-        isAsync: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'async')
-                    return true;
-            }
-            return false;
-        },
-        isConst: (node) => {
-            if (node.type === 'lexical_declaration') {
-                for (let i = 0; i < node.childCount; i++) {
-                    const child = node.child(i);
-                    if (child?.type === 'const')
-                        return true;
-                }
-            }
-            return false;
-        },
-    },
-    python: {
-        functionTypes: ['function_definition'],
-        classTypes: ['class_definition'],
-        methodTypes: ['function_definition'], // Methods are functions inside classes
-        interfaceTypes: [],
-        structTypes: [],
-        enumTypes: [],
-        typeAliasTypes: [],
-        importTypes: ['import_statement', 'import_from_statement'],
-        callTypes: ['call'],
-        variableTypes: ['assignment'], // Python uses assignment for variable declarations
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        returnField: 'return_type',
-        getSignature: (node, source) => {
-            const params = getChildByField(node, 'parameters');
-            const returnType = getChildByField(node, 'return_type');
-            if (!params)
-                return undefined;
-            let sig = getNodeText(params, source);
-            if (returnType) {
-                sig += ' -> ' + getNodeText(returnType, source);
-            }
-            return sig;
-        },
-        isAsync: (node) => {
-            const prev = node.previousSibling;
-            return prev?.type === 'async';
-        },
-        isStatic: (node) => {
-            // Check for @staticmethod decorator
-            const prev = node.previousNamedSibling;
-            if (prev?.type === 'decorator') {
-                const text = prev.text;
-                return text.includes('staticmethod');
-            }
-            return false;
-        },
-    },
-    go: {
-        functionTypes: ['function_declaration'],
-        classTypes: [], // Go doesn't have classes
-        methodTypes: ['method_declaration'],
-        interfaceTypes: ['interface_type'],
-        structTypes: ['struct_type'],
-        enumTypes: [],
-        typeAliasTypes: ['type_spec'], // Go type declarations
-        importTypes: ['import_declaration'],
-        callTypes: ['call_expression'],
-        variableTypes: ['var_declaration', 'short_var_declaration', 'const_declaration'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        returnField: 'result',
-        getSignature: (node, source) => {
-            const params = getChildByField(node, 'parameters');
-            const result = getChildByField(node, 'result');
-            if (!params)
-                return undefined;
-            let sig = getNodeText(params, source);
-            if (result) {
-                sig += ' ' + getNodeText(result, source);
-            }
-            return sig;
-        },
-    },
-    rust: {
-        functionTypes: ['function_item'],
-        classTypes: [], // Rust has impl blocks
-        methodTypes: ['function_item'], // Methods are functions in impl blocks
-        interfaceTypes: ['trait_item'],
-        structTypes: ['struct_item'],
-        enumTypes: ['enum_item'],
-        typeAliasTypes: ['type_item'], // Rust type aliases
-        importTypes: ['use_declaration'],
-        callTypes: ['call_expression'],
-        variableTypes: ['let_declaration', 'const_item', 'static_item'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        returnField: 'return_type',
-        getSignature: (node, source) => {
-            const params = getChildByField(node, 'parameters');
-            const returnType = getChildByField(node, 'return_type');
-            if (!params)
-                return undefined;
-            let sig = getNodeText(params, source);
-            if (returnType) {
-                sig += ' -> ' + getNodeText(returnType, source);
-            }
-            return sig;
-        },
-        isAsync: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'async')
-                    return true;
-            }
-            return false;
-        },
-        getVisibility: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'visibility_modifier') {
-                    return child.text.includes('pub') ? 'public' : 'private';
-                }
-            }
-            return 'private'; // Rust defaults to private
-        },
-    },
-    java: {
-        functionTypes: [],
-        classTypes: ['class_declaration'],
-        methodTypes: ['method_declaration', 'constructor_declaration'],
-        interfaceTypes: ['interface_declaration'],
-        structTypes: [],
-        enumTypes: ['enum_declaration'],
-        typeAliasTypes: [],
-        importTypes: ['import_declaration'],
-        callTypes: ['method_invocation'],
-        variableTypes: ['local_variable_declaration', 'field_declaration'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        returnField: 'type',
-        getSignature: (node, source) => {
-            const params = getChildByField(node, 'parameters');
-            const returnType = getChildByField(node, 'type');
-            if (!params)
-                return undefined;
-            const paramsText = getNodeText(params, source);
-            return returnType ? getNodeText(returnType, source) + ' ' + paramsText : paramsText;
-        },
-        getVisibility: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifiers') {
-                    const text = child.text;
-                    if (text.includes('public'))
-                        return 'public';
-                    if (text.includes('private'))
-                        return 'private';
-                    if (text.includes('protected'))
-                        return 'protected';
-                }
-            }
-            return undefined;
-        },
-        isStatic: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifiers' && child.text.includes('static')) {
-                    return true;
-                }
-            }
-            return false;
-        },
-    },
-    c: {
-        functionTypes: ['function_definition'],
-        classTypes: [],
-        methodTypes: [],
-        interfaceTypes: [],
-        structTypes: ['struct_specifier'],
-        enumTypes: ['enum_specifier'],
-        typeAliasTypes: ['type_definition'], // typedef
-        importTypes: ['preproc_include'],
-        callTypes: ['call_expression'],
-        variableTypes: ['declaration'],
-        nameField: 'declarator',
-        bodyField: 'body',
-        paramsField: 'parameters',
-    },
-    cpp: {
-        functionTypes: ['function_definition'],
-        classTypes: ['class_specifier'],
-        methodTypes: ['function_definition'],
-        interfaceTypes: [],
-        structTypes: ['struct_specifier'],
-        enumTypes: ['enum_specifier'],
-        typeAliasTypes: ['type_definition', 'alias_declaration'], // typedef and using
-        importTypes: ['preproc_include'],
-        callTypes: ['call_expression'],
-        variableTypes: ['declaration'],
-        nameField: 'declarator',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        getVisibility: (node) => {
-            // Check for access specifier in parent
-            const parent = node.parent;
-            if (parent) {
-                for (let i = 0; i < parent.childCount; i++) {
-                    const child = parent.child(i);
-                    if (child?.type === 'access_specifier') {
-                        const text = child.text;
-                        if (text.includes('public'))
-                            return 'public';
-                        if (text.includes('private'))
-                            return 'private';
-                        if (text.includes('protected'))
-                            return 'protected';
-                    }
-                }
-            }
-            return undefined;
-        },
-    },
-    csharp: {
-        functionTypes: [],
-        classTypes: ['class_declaration'],
-        methodTypes: ['method_declaration', 'constructor_declaration'],
-        interfaceTypes: ['interface_declaration'],
-        structTypes: ['struct_declaration'],
-        enumTypes: ['enum_declaration'],
-        typeAliasTypes: [],
-        importTypes: ['using_directive'],
-        callTypes: ['invocation_expression'],
-        variableTypes: ['local_declaration_statement', 'field_declaration'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameter_list',
-        getVisibility: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifier') {
-                    const text = child.text;
-                    if (text === 'public')
-                        return 'public';
-                    if (text === 'private')
-                        return 'private';
-                    if (text === 'protected')
-                        return 'protected';
-                    if (text === 'internal')
-                        return 'internal';
-                }
-            }
-            return 'private'; // C# defaults to private
-        },
-        isStatic: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifier' && child.text === 'static') {
-                    return true;
-                }
-            }
-            return false;
-        },
-        isAsync: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifier' && child.text === 'async') {
-                    return true;
-                }
-            }
-            return false;
-        },
-    },
-    php: {
-        functionTypes: ['function_definition'],
-        classTypes: ['class_declaration'],
-        methodTypes: ['method_declaration'],
-        interfaceTypes: ['interface_declaration'],
-        structTypes: [],
-        enumTypes: ['enum_declaration'],
-        typeAliasTypes: [],
-        importTypes: ['namespace_use_declaration'],
-        callTypes: ['function_call_expression', 'member_call_expression', 'scoped_call_expression'],
-        variableTypes: ['property_declaration', 'const_declaration'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        returnField: 'return_type',
-        getVisibility: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'visibility_modifier') {
-                    const text = child.text;
-                    if (text === 'public')
-                        return 'public';
-                    if (text === 'private')
-                        return 'private';
-                    if (text === 'protected')
-                        return 'protected';
-                }
-            }
-            return 'public'; // PHP defaults to public
-        },
-        isStatic: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'static_modifier')
-                    return true;
-            }
-            return false;
-        },
-    },
-    ruby: {
-        functionTypes: ['method'],
-        classTypes: ['class'],
-        methodTypes: ['method', 'singleton_method'],
-        interfaceTypes: [], // Ruby uses modules
-        structTypes: [],
-        enumTypes: [],
-        typeAliasTypes: [],
-        importTypes: ['call'], // require/require_relative
-        callTypes: ['call', 'method_call'],
-        variableTypes: ['assignment'], // Ruby uses assignment like Python
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameters',
-        getVisibility: (node) => {
-            // Ruby visibility is based on preceding visibility modifiers
-            let sibling = node.previousNamedSibling;
-            while (sibling) {
-                if (sibling.type === 'call') {
-                    const methodName = getChildByField(sibling, 'method');
-                    if (methodName) {
-                        const text = methodName.text;
-                        if (text === 'private')
-                            return 'private';
-                        if (text === 'protected')
-                            return 'protected';
-                        if (text === 'public')
-                            return 'public';
-                    }
-                }
-                sibling = sibling.previousNamedSibling;
-            }
-            return 'public';
-        },
-    },
-    swift: {
-        functionTypes: ['function_declaration'],
-        classTypes: ['class_declaration'],
-        methodTypes: ['function_declaration'], // Methods are functions inside classes
-        interfaceTypes: ['protocol_declaration'],
-        structTypes: ['struct_declaration'],
-        enumTypes: ['enum_declaration'],
-        typeAliasTypes: ['typealias_declaration'],
-        importTypes: ['import_declaration'],
-        callTypes: ['call_expression'],
-        variableTypes: ['property_declaration', 'constant_declaration'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'parameter',
-        returnField: 'return_type',
-        getSignature: (node, source) => {
-            // Swift function signature: func name(params) -> ReturnType
-            const params = getChildByField(node, 'parameter');
-            const returnType = getChildByField(node, 'return_type');
-            if (!params)
-                return undefined;
-            let sig = getNodeText(params, source);
-            if (returnType) {
-                sig += ' -> ' + getNodeText(returnType, source);
-            }
-            return sig;
-        },
-        getVisibility: (node) => {
-            // Check for visibility modifiers in Swift
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifiers') {
-                    const text = child.text;
-                    if (text.includes('public'))
-                        return 'public';
-                    if (text.includes('private'))
-                        return 'private';
-                    if (text.includes('internal'))
-                        return 'internal';
-                    if (text.includes('fileprivate'))
-                        return 'private';
-                }
-            }
-            return 'internal'; // Swift defaults to internal
-        },
-        isStatic: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifiers') {
-                    if (child.text.includes('static') || child.text.includes('class')) {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        },
-        isAsync: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifiers' && child.text.includes('async')) {
-                    return true;
-                }
-            }
-            return false;
-        },
-    },
-    kotlin: {
-        functionTypes: ['function_declaration'],
-        classTypes: ['class_declaration'],
-        methodTypes: ['function_declaration'], // Methods are functions inside classes
-        interfaceTypes: ['class_declaration'], // Interfaces use class_declaration with 'interface' modifier
-        structTypes: [], // Kotlin uses data classes
-        enumTypes: ['class_declaration'], // Enums use class_declaration with 'enum' modifier
-        typeAliasTypes: ['type_alias'],
-        importTypes: ['import_header'],
-        callTypes: ['call_expression'],
-        variableTypes: ['property_declaration'],
-        nameField: 'simple_identifier',
-        bodyField: 'function_body',
-        paramsField: 'function_value_parameters',
-        returnField: 'type',
-        getSignature: (node, source) => {
-            // Kotlin function signature: fun name(params): ReturnType
-            const params = getChildByField(node, 'function_value_parameters');
-            const returnType = getChildByField(node, 'type');
-            if (!params)
-                return undefined;
-            let sig = getNodeText(params, source);
-            if (returnType) {
-                sig += ': ' + getNodeText(returnType, source);
-            }
-            return sig;
-        },
-        getVisibility: (node) => {
-            // Check for visibility modifiers in Kotlin
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifiers') {
-                    const text = child.text;
-                    if (text.includes('public'))
-                        return 'public';
-                    if (text.includes('private'))
-                        return 'private';
-                    if (text.includes('protected'))
-                        return 'protected';
-                    if (text.includes('internal'))
-                        return 'internal';
-                }
-            }
-            return 'public'; // Kotlin defaults to public
-        },
-        isStatic: (_node) => {
-            // Kotlin doesn't have static, uses companion objects
-            // Check if inside companion object would require more context
-            return false;
-        },
-        isAsync: (node) => {
-            // Kotlin uses suspend keyword for coroutines
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'modifiers' && child.text.includes('suspend')) {
-                    return true;
-                }
-            }
-            return false;
-        },
-    },
-    dart: {
-        functionTypes: ['function_signature'],
-        classTypes: ['class_definition'],
-        methodTypes: ['method_signature'],
-        interfaceTypes: [],
-        structTypes: [],
-        enumTypes: ['enum_declaration'],
-        typeAliasTypes: ['type_alias'],
-        importTypes: ['import_or_export'],
-        callTypes: [], // Dart calls use identifier+selector, handled via function body traversal
-        variableTypes: [],
-        nameField: 'name',
-        bodyField: 'body', // class_definition uses 'body' field
-        paramsField: 'formal_parameter_list',
-        returnField: 'type',
-        getSignature: (node, source) => {
-            // For function_signature: extract params + return type
-            // For method_signature: delegate to inner function_signature
-            let sig = node;
-            if (node.type === 'method_signature') {
-                const inner = node.namedChildren.find((c) => c.type === 'function_signature' || c.type === 'getter_signature' || c.type === 'setter_signature');
-                if (inner)
-                    sig = inner;
-            }
-            const params = sig.namedChildren.find((c) => c.type === 'formal_parameter_list');
-            const retType = sig.namedChildren.find((c) => c.type === 'type_identifier' || c.type === 'void_type');
-            if (!params && !retType)
-                return undefined;
-            let result = '';
-            if (retType)
-                result += getNodeText(retType, source) + ' ';
-            if (params)
-                result += getNodeText(params, source);
-            return result.trim() || undefined;
-        },
-        getVisibility: (node) => {
-            // Dart convention: _ prefix means private, otherwise public
-            let nameNode = null;
-            if (node.type === 'method_signature') {
-                const inner = node.namedChildren.find((c) => c.type === 'function_signature' || c.type === 'getter_signature' || c.type === 'setter_signature');
-                if (inner)
-                    nameNode = inner.namedChildren.find((c) => c.type === 'identifier') || null;
-            }
-            else {
-                nameNode = node.childForFieldName('name');
-            }
-            if (nameNode && nameNode.text.startsWith('_'))
-                return 'private';
-            return 'public';
-        },
-        isAsync: (node) => {
-            // In Dart, 'async' is on the function_body (next sibling), not the signature
-            const nextSibling = node.nextNamedSibling;
-            if (nextSibling?.type === 'function_body') {
-                for (let i = 0; i < nextSibling.childCount; i++) {
-                    const child = nextSibling.child(i);
-                    if (child?.type === 'async')
-                        return true;
-                }
-            }
-            return false;
-        },
-        isStatic: (node) => {
-            // For method_signature, check for 'static' child
-            if (node.type === 'method_signature') {
-                for (let i = 0; i < node.childCount; i++) {
-                    const child = node.child(i);
-                    if (child?.type === 'static')
-                        return true;
-                }
-            }
-            return false;
-        },
-    },
-    pascal: {
-        functionTypes: ['declProc'],
-        classTypes: ['declClass'],
-        methodTypes: ['declProc'],
-        interfaceTypes: ['declIntf'],
-        structTypes: [],
-        enumTypes: ['declEnum'],
-        typeAliasTypes: ['declType'],
-        importTypes: ['declUses'],
-        callTypes: ['exprCall'],
-        variableTypes: ['declField', 'declConst'],
-        nameField: 'name',
-        bodyField: 'body',
-        paramsField: 'args',
-        returnField: 'type',
-        getSignature: (node, source) => {
-            const args = getChildByField(node, 'args');
-            const returnType = node.namedChildren.find((c) => c.type === 'typeref');
-            if (!args && !returnType)
-                return undefined;
-            let sig = '';
-            if (args)
-                sig = getNodeText(args, source);
-            if (returnType) {
-                sig += ': ' + getNodeText(returnType, source);
-            }
-            return sig || undefined;
-        },
-        getVisibility: (node) => {
-            let current = node.parent;
-            while (current) {
-                if (current.type === 'declSection') {
-                    for (let i = 0; i < current.childCount; i++) {
-                        const child = current.child(i);
-                        if (child?.type === 'kPublic' || child?.type === 'kPublished')
-                            return 'public';
-                        if (child?.type === 'kPrivate')
-                            return 'private';
-                        if (child?.type === 'kProtected')
-                            return 'protected';
-                    }
-                }
-                current = current.parent;
-            }
-            return undefined;
-        },
-        isExported: (_node, _source) => {
-            // In Pascal, symbols declared in the interface section are exported
-            return false;
-        },
-        isStatic: (node) => {
-            for (let i = 0; i < node.childCount; i++) {
-                if (node.child(i)?.type === 'kClass')
-                    return true;
-            }
-            return false;
-        },
-        isConst: (node) => {
-            return node.type === 'declConst';
-        },
-    },
-};
-// TSX and JSX use the same extractors as their base languages
-EXTRACTORS.tsx = EXTRACTORS.typescript;
-EXTRACTORS.jsx = EXTRACTORS.javascript;
+const tree_sitter_helpers_1 = require("./tree-sitter-helpers");
+const languages_1 = require("./languages");
+const liquid_extractor_1 = require("./liquid-extractor");
+const svelte_extractor_1 = require("./svelte-extractor");
+const dfm_extractor_1 = require("./dfm-extractor");
+// Re-export for backward compatibility
+var tree_sitter_helpers_2 = require("./tree-sitter-helpers");
+Object.defineProperty(exports, "generateNodeId", { enumerable: true, get: function () { return tree_sitter_helpers_2.generateNodeId; } });
 /**
  * Extract the name from a node based on language
  */
 function extractName(node, source, extractor) {
     // Try field name first
-    const nameNode = getChildByField(node, extractor.nameField);
+    const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, extractor.nameField);
     if (nameNode) {
+        // Unwrap pointer_declarator(s) for C/C++ pointer return types
+        let resolved = nameNode;
+        while (resolved.type === 'pointer_declarator') {
+            const inner = (0, tree_sitter_helpers_1.getChildByField)(resolved, 'declarator') || resolved.namedChild(0);
+            if (!inner)
+                break;
+            resolved = inner;
+        }
         // Handle complex declarators (C/C++)
-        if (nameNode.type === 'function_declarator' || nameNode.type === 'declarator') {
-            const innerName = getChildByField(nameNode, 'declarator') || nameNode.namedChild(0);
-            return innerName ? getNodeText(innerName, source) : getNodeText(nameNode, source);
+        if (resolved.type === 'function_declarator' || resolved.type === 'declarator') {
+            const innerName = (0, tree_sitter_helpers_1.getChildByField)(resolved, 'declarator') || resolved.namedChild(0);
+            return innerName ? (0, tree_sitter_helpers_1.getNodeText)(innerName, source) : (0, tree_sitter_helpers_1.getNodeText)(resolved, source);
         }
-        return getNodeText(nameNode, source);
+        return (0, tree_sitter_helpers_1.getNodeText)(resolved, source);
     }
     // For Dart method_signature, look inside inner signature types
     if (node.type === 'method_signature') {
@@ -859,12 +85,19 @@ function extractName(node, source, extractor) {
                 for (let j = 0; j < child.namedChildCount; j++) {
                     const inner = child.namedChild(j);
                     if (inner?.type === 'identifier') {
-                        return getNodeText(inner, source);
+                        return (0, tree_sitter_helpers_1.getNodeText)(inner, source);
                     }
                 }
             }
         }
     }
+    // Arrow/function expressions get their name from the parent variable_declarator,
+    // not from identifiers in their body. Without this, single-expression arrow
+    // functions like `const fn = () => someIdentifier` get named "someIdentifier"
+    // instead of "fn", because the fallback below finds the body identifier.
+    if (node.type === 'arrow_function' || node.type === 'function_expression') {
+        return '<anonymous>';
+    }
     // Fall back to first identifier child
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
@@ -873,7 +106,7 @@ function extractName(node, source, extractor) {
                 child.type === 'type_identifier' ||
                 child.type === 'simple_identifier' ||
                 child.type === 'constant')) {
-            return getNodeText(child, source);
+            return (0, tree_sitter_helpers_1.getNodeText)(child, source);
         }
     }
     return '<anonymous>';
@@ -896,8 +129,8 @@ class TreeSitterExtractor {
     constructor(filePath, source, language) {
         this.filePath = filePath;
         this.source = source;
-        this.language = language || (0, grammars_1.detectLanguage)(filePath);
-        this.extractor = EXTRACTORS[this.language] || null;
+        this.language = language || (0, grammars_1.detectLanguage)(filePath, source);
+        this.extractor = languages_1.EXTRACTORS[this.language] || null;
     }
     /**
      * Parse and extract from the source code
@@ -912,7 +145,9 @@ class TreeSitterExtractor {
                 errors: [
                     {
                         message: `Unsupported language: ${this.language}`,
+                        filePath: this.filePath,
                         severity: 'error',
+                        code: 'unsupported_language',
                     },
                 ],
                 durationMs: Date.now() - startTime,
@@ -927,7 +162,9 @@ class TreeSitterExtractor {
                 errors: [
                     {
                         message: `Failed to get parser for language: ${this.language}`,
+                        filePath: this.filePath,
                         severity: 'error',
+                        code: 'parser_error',
                     },
                 ],
                 durationMs: Date.now() - startTime,
@@ -960,12 +197,30 @@ class TreeSitterExtractor {
             this.nodeStack.pop();
         }
         catch (error) {
-            (0, sentry_1.captureException)(error, { operation: 'tree-sitter-parse', filePath: this.filePath, language: this.language });
+            const msg = error instanceof Error ? error.message : String(error);
+            // WASM memory errors leave the module in a corrupted state — all subsequent
+            // parses would also fail. Re-throw so the worker can detect and crash,
+            // forcing a clean restart with a fresh heap.
+            if (msg.includes('memory access out of bounds') || msg.includes('out of memory')) {
+                throw error;
+            }
             this.errors.push({
-                message: `Parse error: ${error instanceof Error ? error.message : String(error)}`,
+                message: `Parse error: ${msg}`,
+                filePath: this.filePath,
                 severity: 'error',
+                code: 'parse_error',
             });
         }
+        finally {
+            // Free tree-sitter WASM memory immediately — trees hold native heap memory
+            // invisible to V8's GC that accumulates across thousands of files.
+            if (this.tree) {
+                this.tree.delete();
+                this.tree = null;
+            }
+            // Release source string to reduce GC pressure
+            this.source = '';
+        }
         return {
             nodes: this.nodes,
             edges: this.edges,
@@ -982,6 +237,13 @@ class TreeSitterExtractor {
             return;
         const nodeType = node.type;
         let skipChildren = false;
+        // Language-specific custom visitor hook
+        if (this.extractor.visitNode) {
+            const ctx = this.makeExtractorContext();
+            const handled = this.extractor.visitNode(node, ctx);
+            if (handled)
+                return;
+        }
         // Pascal-specific AST handling
         if (this.language === 'pascal') {
             skipChildren = this.visitPascalNode(node);
@@ -1003,21 +265,27 @@ class TreeSitterExtractor {
         }
         // Check for class declarations
         else if (this.extractor.classTypes.includes(nodeType)) {
-            // Swift uses class_declaration for both classes and structs
-            // Check for 'struct' child to differentiate
-            if (this.language === 'swift' && this.hasChildOfType(node, 'struct')) {
+            // Some languages reuse class_declaration for structs/enums (e.g. Swift)
+            const classification = this.extractor.classifyClassNode?.(node) ?? 'class';
+            if (classification === 'struct') {
                 this.extractStruct(node);
             }
-            else if (this.language === 'swift' && this.hasChildOfType(node, 'enum')) {
+            else if (classification === 'enum') {
                 this.extractEnum(node);
             }
+            else if (classification === 'interface') {
+                this.extractInterface(node);
+            }
+            else if (classification === 'trait') {
+                this.extractClass(node, 'trait');
+            }
             else {
                 this.extractClass(node);
             }
             skipChildren = true; // extractClass visits body children
         }
-        // Dart-specific: mixin and extension declarations treated as classes
-        else if (this.language === 'dart' && (nodeType === 'mixin_declaration' || nodeType === 'extension_declaration')) {
+        // Extra class node types (e.g. Dart mixin_declaration, extension_declaration)
+        else if (this.extractor.extraClassNodeTypes?.includes(nodeType)) {
             this.extractClass(node);
             skipChildren = true;
         }
@@ -1042,8 +310,20 @@ class TreeSitterExtractor {
             skipChildren = true; // extractEnum visits body children
         }
         // Check for type alias declarations (e.g. `type X = ...` in TypeScript)
+        // For Go, type_spec wraps struct/interface definitions — resolveTypeAliasKind
+        // detects these and extractTypeAlias creates the correct node kind.
         else if (this.extractor.typeAliasTypes.includes(nodeType)) {
-            this.extractTypeAlias(node);
+            skipChildren = this.extractTypeAlias(node);
+        }
+        // Check for class properties (e.g. C# property_declaration)
+        else if (this.extractor.propertyTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {
+            this.extractProperty(node);
+            skipChildren = true;
+        }
+        // Check for class fields (e.g. Java field_declaration, C# field_declaration)
+        else if (this.extractor.fieldTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {
+            this.extractField(node);
+            skipChildren = true;
         }
         // Check for variable declarations (const, let, var, etc.)
         // Only extract top-level variables (not inside functions/methods)
@@ -1065,6 +345,10 @@ class TreeSitterExtractor {
         else if (this.extractor.callTypes.includes(nodeType)) {
             this.extractCall(node);
         }
+        // Rust: `impl Trait for Type { ... }` — creates implements edge from Type to Trait
+        else if (nodeType === 'impl_item') {
+            this.extractRustImplItem(node);
+        }
         // Visit children (unless the extract method already visited them)
         if (!skipChildren) {
             for (let i = 0; i < node.namedChildCount; i++) {
@@ -1084,7 +368,7 @@ class TreeSitterExtractor {
         if (!name) {
             return null;
         }
-        const id = generateNodeId(this.filePath, kind, name, node.startPosition.row + 1);
+        const id = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, kind, name, node.startPosition.row + 1);
         const newNode = {
             id,
             kind,
@@ -1113,15 +397,28 @@ class TreeSitterExtractor {
         }
         return newNode;
     }
+    /**
+     * Find first named child whose type is in the given list.
+     * Used to locate inner type nodes (e.g. enum_specifier inside a typedef).
+     */
+    findChildByTypes(node, types) {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && types.includes(child.type))
+                return child;
+        }
+        return null;
+    }
     /**
      * Build qualified name from node stack
      */
     buildQualifiedName(name) {
-        // Get names from the node stack
-        const parts = [this.filePath];
+        // Build a qualified name from the semantic hierarchy only (no file path).
+        // The file path is stored separately in filePath and pollutes FTS if included here.
+        const parts = [];
         for (const nodeId of this.nodeStack) {
             const node = this.nodes.find((n) => n.id === nodeId);
-            if (node) {
+            if (node && node.kind !== 'file') {
                 parts.push(node.name);
             }
         }
@@ -1129,16 +426,23 @@ class TreeSitterExtractor {
         return parts.join('::');
     }
     /**
-     * Check if a node has a child of a specific type
+     * Build an ExtractorContext for passing to language-specific visitNode hooks.
      */
-    hasChildOfType(node, type) {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === type) {
-                return true;
-            }
-        }
-        return false;
+    makeExtractorContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return {
+            createNode: (kind, name, node, extra) => self.createNode(kind, name, node, extra),
+            visitNode: (node) => self.visitNode(node),
+            visitFunctionBody: (body, functionId) => self.visitFunctionBody(body, functionId),
+            addUnresolvedReference: (ref) => self.unresolvedReferences.push(ref),
+            pushScope: (nodeId) => self.nodeStack.push(nodeId),
+            popScope: () => self.nodeStack.pop(),
+            get filePath() { return self.filePath; },
+            get source() { return self.source; },
+            get nodeStack() { return self.nodeStack; },
+            get nodes() { return self.nodes; },
+        };
     }
     /**
      * Check if the current node stack indicates we are inside a class-like node
@@ -1157,7 +461,8 @@ class TreeSitterExtractor {
             parentNode.kind === 'struct' ||
             parentNode.kind === 'interface' ||
             parentNode.kind === 'trait' ||
-            parentNode.kind === 'enum');
+            parentNode.kind === 'enum' ||
+            parentNode.kind === 'module');
     }
     /**
      * Extract a function
@@ -1165,6 +470,12 @@ class TreeSitterExtractor {
     extractFunction(node) {
         if (!this.extractor)
             return;
+        // If the language provides getReceiverType and this function has a receiver
+        // (e.g., Rust function_item inside an impl block), extract as method instead
+        if (this.extractor.getReceiverType?.(node, this.source)) {
+            this.extractMethod(node);
+            return;
+        }
         let name = extractName(node, this.source, this.extractor);
         // For arrow functions and function expressions assigned to variables,
         // resolve the name from the parent variable_declarator.
@@ -1174,15 +485,25 @@ class TreeSitterExtractor {
             (node.type === 'arrow_function' || node.type === 'function_expression')) {
             const parent = node.parent;
             if (parent?.type === 'variable_declarator') {
-                const varName = getChildByField(parent, 'name');
+                const varName = (0, tree_sitter_helpers_1.getChildByField)(parent, 'name');
                 if (varName) {
-                    name = getNodeText(varName, this.source);
+                    name = (0, tree_sitter_helpers_1.getNodeText)(varName, this.source);
                 }
             }
         }
         if (name === '<anonymous>')
             return; // Skip anonymous functions
-        const docstring = getPrecedingDocstring(node, this.source);
+        // Check for misparse artifacts (e.g. C++ macros causing "namespace detail" functions)
+        // Skip the node but still visit the body for calls and structural nodes
+        if (this.extractor.isMisparsedFunction?.(name, node)) {
+            const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+                ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+            if (body) {
+                this.visitFunctionBody(body, '');
+            }
+            return;
+        }
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const signature = this.extractor.getSignature?.(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
         const isExported = this.extractor.isExported?.(node, this.source);
@@ -1198,12 +519,12 @@ class TreeSitterExtractor {
         });
         if (!funcNode)
             return;
+        // Extract type annotations (parameter types and return type)
+        this.extractTypeAnnotations(node, funcNode.id);
         // Push to stack and visit body
         this.nodeStack.push(funcNode.id);
-        // Dart: function_body is a next sibling of function_signature, not a child
-        const body = this.language === 'dart'
-            ? node.nextNamedSibling?.type === 'function_body' ? node.nextNamedSibling : null
-            : getChildByField(node, this.extractor.bodyField);
+        const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+            ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
         if (body) {
             this.visitFunctionBody(body, funcNode.id);
         }
@@ -1212,14 +533,14 @@ class TreeSitterExtractor {
     /**
      * Extract a class
      */
-    extractClass(node) {
+    extractClass(node, kind = 'class') {
         if (!this.extractor)
             return;
         const name = extractName(node, this.source, this.extractor);
-        const docstring = getPrecedingDocstring(node, this.source);
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
         const isExported = this.extractor.isExported?.(node, this.source);
-        const classNode = this.createNode('class', name, node, {
+        const classNode = this.createNode(kind, name, node, {
             docstring,
             visibility,
             isExported,
@@ -1230,11 +551,8 @@ class TreeSitterExtractor {
         this.extractInheritance(node, classNode.id);
         // Push to stack and visit body
         this.nodeStack.push(classNode.id);
-        let body = getChildByField(node, this.extractor.bodyField);
-        // Dart: mixin_declaration uses class_body, extension uses extension_body
-        if (!body && this.language === 'dart') {
-            body = node.namedChildren.find((c) => c.type === 'class_body' || c.type === 'extension_body') || null;
-        }
+        let body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+            ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
         if (!body)
             body = node;
         // Visit all children for methods and properties
@@ -1252,34 +570,71 @@ class TreeSitterExtractor {
     extractMethod(node) {
         if (!this.extractor)
             return;
+        // For languages with receiver types (Go, Rust), include receiver in qualified name
+        // so FTS can match "scrapeLoop.run" → qualified_name "...::scrapeLoop::run"
+        const receiverType = this.extractor.getReceiverType?.(node, this.source);
         // For most languages, only extract as method if inside a class-like node
-        // But Go methods are top-level with a receiver, so always treat them as methods
-        if (!this.isInsideClassLikeNode() && this.language !== 'go') {
-            // Not inside a class-like node and not Go, treat as function
+        // Languages with methodsAreTopLevel (e.g. Go) always treat them as methods
+        // Languages with getReceiverType (e.g. Rust) extract as method when receiver is found
+        if (!this.isInsideClassLikeNode() && !this.extractor.methodsAreTopLevel && !receiverType) {
+            // Skip method_definition nodes inside object literals (getters/setters/methods
+            // in inline objects). These are ephemeral and create noise (e.g., Svelte context
+            // objects: `ctx.set({ get view() { ... } })`).
+            if (node.parent?.type === 'object' || node.parent?.type === 'object_expression') {
+                return;
+            }
+            // Not inside a class-like node and no receiver type, treat as function
             this.extractFunction(node);
             return;
         }
         const name = extractName(node, this.source, this.extractor);
-        const docstring = getPrecedingDocstring(node, this.source);
+        // Check for misparse artifacts (e.g. C++ "switch" inside macro-confused class body)
+        if (this.extractor.isMisparsedFunction?.(name, node)) {
+            const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+                ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+            if (body) {
+                this.visitFunctionBody(body, '');
+            }
+            return;
+        }
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const signature = this.extractor.getSignature?.(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
         const isAsync = this.extractor.isAsync?.(node);
         const isStatic = this.extractor.isStatic?.(node);
-        const methodNode = this.createNode('method', name, node, {
+        const extraProps = {
             docstring,
             signature,
             visibility,
             isAsync,
             isStatic,
-        });
+        };
+        if (receiverType) {
+            extraProps.qualifiedName = `${receiverType}::${name}`;
+        }
+        const methodNode = this.createNode('method', name, node, extraProps);
         if (!methodNode)
             return;
+        // For methods with a receiver type but no class-like parent on the stack
+        // (e.g., Rust impl blocks), add a contains edge from the owning struct/trait
+        if (receiverType && !this.isInsideClassLikeNode()) {
+            const ownerNode = this.nodes.find((n) => n.name === receiverType &&
+                n.filePath === this.filePath &&
+                (n.kind === 'struct' || n.kind === 'class' || n.kind === 'enum' || n.kind === 'trait'));
+            if (ownerNode) {
+                this.edges.push({
+                    source: ownerNode.id,
+                    target: methodNode.id,
+                    kind: 'contains',
+                });
+            }
+        }
+        // Extract type annotations (parameter types and return type)
+        this.extractTypeAnnotations(node, methodNode.id);
         // Push to stack and visit body
         this.nodeStack.push(methodNode.id);
-        // Dart: function_body is a next sibling of method_signature, not a child
-        const body = this.language === 'dart'
-            ? node.nextNamedSibling?.type === 'function_body' ? node.nextNamedSibling : null
-            : getChildByField(node, this.extractor.bodyField);
+        const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+            ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
         if (body) {
             this.visitFunctionBody(body, methodNode.id);
         }
@@ -1292,16 +647,30 @@ class TreeSitterExtractor {
         if (!this.extractor)
             return;
         const name = extractName(node, this.source, this.extractor);
-        const docstring = getPrecedingDocstring(node, this.source);
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const isExported = this.extractor.isExported?.(node, this.source);
-        // Determine kind based on language
-        let kind = 'interface';
-        if (this.language === 'rust')
-            kind = 'trait';
-        this.createNode(kind, name, node, {
+        const kind = this.extractor.interfaceKind ?? 'interface';
+        const interfaceNode = this.createNode(kind, name, node, {
             docstring,
             isExported,
         });
+        if (!interfaceNode)
+            return;
+        // Extract extends (interface inheritance)
+        this.extractInheritance(node, interfaceNode.id);
+        // Visit body children for interface methods and nested types
+        this.nodeStack.push(interfaceNode.id);
+        let body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+            ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+        if (!body)
+            body = node;
+        for (let i = 0; i < body.namedChildCount; i++) {
+            const child = body.namedChild(i);
+            if (child) {
+                this.visitNode(child);
+            }
+        }
+        this.nodeStack.pop();
     }
     /**
      * Extract a struct
@@ -1309,8 +678,12 @@ class TreeSitterExtractor {
     extractStruct(node) {
         if (!this.extractor)
             return;
+        // Skip forward declarations and type references (no body = not a definition)
+        const body = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+        if (!body)
+            return;
         const name = extractName(node, this.source, this.extractor);
-        const docstring = getPrecedingDocstring(node, this.source);
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
         const isExported = this.extractor.isExported?.(node, this.source);
         const structNode = this.createNode('struct', name, node, {
@@ -1320,9 +693,10 @@ class TreeSitterExtractor {
         });
         if (!structNode)
             return;
+        // Extract inheritance (e.g. Swift: struct HTTPMethod: RawRepresentable)
+        this.extractInheritance(node, structNode.id);
         // Push to stack for field extraction
         this.nodeStack.push(structNode.id);
-        const body = getChildByField(node, this.extractor.bodyField) || node;
         for (let i = 0; i < body.namedChildCount; i++) {
             const child = body.namedChild(i);
             if (child) {
@@ -1337,15 +711,177 @@ class TreeSitterExtractor {
     extractEnum(node) {
         if (!this.extractor)
             return;
+        // Skip forward declarations and type references (no body = not a definition)
+        const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+            ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+        if (!body)
+            return;
         const name = extractName(node, this.source, this.extractor);
-        const docstring = getPrecedingDocstring(node, this.source);
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
         const isExported = this.extractor.isExported?.(node, this.source);
-        this.createNode('enum', name, node, {
+        const enumNode = this.createNode('enum', name, node, {
             docstring,
             visibility,
             isExported,
         });
+        if (!enumNode)
+            return;
+        // Extract inheritance (e.g. Swift: enum AFError: Error)
+        this.extractInheritance(node, enumNode.id);
+        // Push to stack and visit body children (enum members, nested types, methods)
+        this.nodeStack.push(enumNode.id);
+        const memberTypes = this.extractor.enumMemberTypes;
+        for (let i = 0; i < body.namedChildCount; i++) {
+            const child = body.namedChild(i);
+            if (!child)
+                continue;
+            if (memberTypes?.includes(child.type)) {
+                this.extractEnumMembers(child);
+            }
+            else {
+                this.visitNode(child);
+            }
+        }
+        this.nodeStack.pop();
+    }
+    /**
+     * Extract enum member names from an enum member node.
+     * Handles multi-case declarations (Swift: `case put, delete`) and single-case patterns.
+     */
+    extractEnumMembers(node) {
+        // Try field-based name first (e.g. Rust enum_variant has a 'name' field)
+        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
+        if (nameNode) {
+            this.createNode('enum_member', (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source), node);
+            return;
+        }
+        // Check for identifier-like children (Swift: simple_identifier, TS: property_identifier)
+        let found = false;
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && (child.type === 'simple_identifier' || child.type === 'identifier' || child.type === 'property_identifier')) {
+                this.createNode('enum_member', (0, tree_sitter_helpers_1.getNodeText)(child, this.source), child);
+                found = true;
+            }
+        }
+        // If the node itself IS the identifier (e.g. TS property_identifier directly in enum body)
+        if (!found && node.namedChildCount === 0) {
+            this.createNode('enum_member', (0, tree_sitter_helpers_1.getNodeText)(node, this.source), node);
+        }
+    }
+    /**
+     * Extract a class property declaration (e.g. C# `public string Name { get; set; }`).
+     * Extracts as 'property' kind node inside the owning class.
+     */
+    extractProperty(node) {
+        if (!this.extractor)
+            return;
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const visibility = this.extractor.getVisibility?.(node);
+        const isStatic = this.extractor.isStatic?.(node) ?? false;
+        // Property name is a direct identifier child
+        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name')
+            || node.namedChildren.find(c => c.type === 'identifier');
+        if (!nameNode)
+            return;
+        const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+        // Get property type from the type child (first named child that isn't modifier or identifier)
+        const typeNode = node.namedChildren.find(c => c.type !== 'modifier' && c.type !== 'modifiers'
+            && c.type !== 'identifier' && c.type !== 'accessor_list'
+            && c.type !== 'accessors' && c.type !== 'equals_value_clause');
+        const typeText = typeNode ? (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source) : undefined;
+        const signature = typeText ? `${typeText} ${name}` : name;
+        this.createNode('property', name, node, {
+            docstring,
+            signature,
+            visibility,
+            isStatic,
+        });
+    }
+    /**
+     * Extract a class field declaration (e.g. Java field_declaration, C# field_declaration).
+     * Extracts each declarator as a 'field' kind node inside the owning class.
+     */
+    extractField(node) {
+        if (!this.extractor)
+            return;
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
+        const visibility = this.extractor.getVisibility?.(node);
+        const isStatic = this.extractor.isStatic?.(node) ?? false;
+        // Java field_declaration: "private final String name = value;" → variable_declarator(s) are direct children
+        // C# field_declaration: wraps in variable_declaration → variable_declarator(s)
+        let declarators = node.namedChildren.filter(c => c.type === 'variable_declarator');
+        // C#: look inside variable_declaration wrapper
+        if (declarators.length === 0) {
+            const varDecl = node.namedChildren.find(c => c.type === 'variable_declaration');
+            if (varDecl) {
+                declarators = varDecl.namedChildren.filter(c => c.type === 'variable_declarator');
+            }
+        }
+        // PHP property_declaration: property_element → variable_name → name
+        if (declarators.length === 0) {
+            const propElements = node.namedChildren.filter(c => c.type === 'property_element');
+            if (propElements.length > 0) {
+                // Get type annotation if present (e.g. "string", "int", "?Foo")
+                const typeNode = node.namedChildren.find(c => c.type !== 'visibility_modifier' && c.type !== 'static_modifier'
+                    && c.type !== 'readonly_modifier' && c.type !== 'property_element'
+                    && c.type !== 'var_modifier');
+                const typeText = typeNode ? (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source) : undefined;
+                for (const elem of propElements) {
+                    const varName = elem.namedChildren.find(c => c.type === 'variable_name');
+                    const nameNode = varName?.namedChildren.find(c => c.type === 'name');
+                    if (!nameNode)
+                        continue;
+                    const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+                    const signature = typeText ? `${typeText} $${name}` : `$${name}`;
+                    this.createNode('field', name, elem, {
+                        docstring,
+                        signature,
+                        visibility,
+                        isStatic,
+                    });
+                }
+                return;
+            }
+        }
+        if (declarators.length > 0) {
+            // Get field type from the type child
+            // Java: type is a direct child of field_declaration
+            // C#: type is inside variable_declaration wrapper
+            const varDecl = node.namedChildren.find(c => c.type === 'variable_declaration');
+            const typeSearchNode = varDecl ?? node;
+            const typeNode = typeSearchNode.namedChildren.find(c => c.type !== 'modifiers' && c.type !== 'modifier' && c.type !== 'variable_declarator'
+                && c.type !== 'variable_declaration' && c.type !== 'marker_annotation' && c.type !== 'annotation');
+            const typeText = typeNode ? (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source) : undefined;
+            for (const decl of declarators) {
+                const nameNode = (0, tree_sitter_helpers_1.getChildByField)(decl, 'name')
+                    || decl.namedChildren.find(c => c.type === 'identifier');
+                if (!nameNode)
+                    continue;
+                const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+                const signature = typeText ? `${typeText} ${name}` : name;
+                this.createNode('field', name, decl, {
+                    docstring,
+                    signature,
+                    visibility,
+                    isStatic,
+                });
+            }
+        }
+        else {
+            // Fallback: try to find an identifier child directly
+            const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name')
+                || node.namedChildren.find(c => c.type === 'identifier');
+            if (nameNode) {
+                const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+                this.createNode('field', name, node, {
+                    docstring,
+                    visibility,
+                    isStatic,
+                });
+            }
+        }
     }
     /**
      * Extract a variable declaration (const, let, var, etc.)
@@ -1362,7 +898,7 @@ class TreeSitterExtractor {
         // Go: var_declaration, short_var_declaration, const_declaration
         const isConst = this.extractor.isConst?.(node) ?? false;
         const kind = isConst ? 'constant' : 'variable';
-        const docstring = getPrecedingDocstring(node, this.source);
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const isExported = this.extractor.isExported?.(node, this.source) ?? false;
         // Extract variable declarators based on language
         if (this.language === 'typescript' || this.language === 'javascript' ||
@@ -1372,36 +908,45 @@ class TreeSitterExtractor {
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
                 if (child?.type === 'variable_declarator') {
-                    const nameNode = getChildByField(child, 'name');
-                    const valueNode = getChildByField(child, 'value');
+                    const nameNode = (0, tree_sitter_helpers_1.getChildByField)(child, 'name');
+                    const valueNode = (0, tree_sitter_helpers_1.getChildByField)(child, 'value');
                     if (nameNode) {
-                        const name = getNodeText(nameNode, this.source);
+                        // Skip destructured patterns (e.g., `let { x, y } = $props()` in Svelte)
+                        // These produce ugly multi-line names like "{ class: className }"
+                        if (nameNode.type === 'object_pattern' || nameNode.type === 'array_pattern') {
+                            continue;
+                        }
+                        const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                         // Arrow functions / function expressions: extract as function instead of variable
                         if (valueNode && (valueNode.type === 'arrow_function' || valueNode.type === 'function_expression')) {
                             this.extractFunction(valueNode);
                             continue;
                         }
                         // Capture first 100 chars of initializer for context (stored in signature for searchability)
-                        const initValue = valueNode ? getNodeText(valueNode, this.source).slice(0, 100) : undefined;
+                        const initValue = valueNode ? (0, tree_sitter_helpers_1.getNodeText)(valueNode, this.source).slice(0, 100) : undefined;
                         const initSignature = initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined;
-                        this.createNode(kind, name, child, {
+                        const varNode = this.createNode(kind, name, child, {
                             docstring,
                             signature: initSignature,
                             isExported,
                         });
+                        // Extract type annotation references (e.g., const x: ITextModel = ...)
+                        if (varNode) {
+                            this.extractVariableTypeAnnotation(child, varNode.id);
+                        }
                     }
                 }
             }
         }
         else if (this.language === 'python' || this.language === 'ruby') {
             // Python/Ruby assignment: left = right
-            const left = getChildByField(node, 'left') || node.namedChild(0);
-            const right = getChildByField(node, 'right') || node.namedChild(1);
+            const left = (0, tree_sitter_helpers_1.getChildByField)(node, 'left') || node.namedChild(0);
+            const right = (0, tree_sitter_helpers_1.getChildByField)(node, 'right') || node.namedChild(1);
             if (left && left.type === 'identifier') {
-                const name = getNodeText(left, this.source);
+                const name = (0, tree_sitter_helpers_1.getNodeText)(left, this.source);
                 // Skip if name starts with lowercase and looks like a function call result
                 // Python constants are usually UPPER_CASE
-                const initValue = right ? getNodeText(right, this.source).slice(0, 100) : undefined;
+                const initValue = right ? (0, tree_sitter_helpers_1.getNodeText)(right, this.source).slice(0, 100) : undefined;
                 const initSignature = initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined;
                 this.createNode(kind, name, node, {
                     docstring,
@@ -1416,9 +961,9 @@ class TreeSitterExtractor {
             for (const spec of specs) {
                 const nameNode = spec.namedChild(0);
                 if (nameNode && nameNode.type === 'identifier') {
-                    const name = getNodeText(nameNode, this.source);
+                    const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                     const valueNode = spec.namedChildCount > 1 ? spec.namedChild(spec.namedChildCount - 1) : null;
-                    const initValue = valueNode ? getNodeText(valueNode, this.source).slice(0, 100) : undefined;
+                    const initValue = valueNode ? (0, tree_sitter_helpers_1.getNodeText)(valueNode, this.source).slice(0, 100) : undefined;
                     const initSignature = initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined;
                     this.createNode(node.type === 'const_declaration' ? 'constant' : 'variable', name, spec, {
                         docstring,
@@ -1428,16 +973,16 @@ class TreeSitterExtractor {
             }
             // Handle short_var_declaration (:=)
             if (node.type === 'short_var_declaration') {
-                const left = getChildByField(node, 'left');
-                const right = getChildByField(node, 'right');
+                const left = (0, tree_sitter_helpers_1.getChildByField)(node, 'left');
+                const right = (0, tree_sitter_helpers_1.getChildByField)(node, 'right');
                 if (left) {
                     // Can be expression_list with multiple identifiers
                     const identifiers = left.type === 'expression_list'
                         ? left.namedChildren.filter(c => c.type === 'identifier')
                         : [left];
                     for (const id of identifiers) {
-                        const name = getNodeText(id, this.source);
-                        const initValue = right ? getNodeText(right, this.source).slice(0, 100) : undefined;
+                        const name = (0, tree_sitter_helpers_1.getNodeText)(id, this.source);
+                        const initValue = right ? (0, tree_sitter_helpers_1.getNodeText)(right, this.source).slice(0, 100) : undefined;
                         const initSignature = initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined;
                         this.createNode('variable', name, node, {
                             docstring,
@@ -1454,7 +999,7 @@ class TreeSitterExtractor {
                 const child = node.namedChild(i);
                 if (child?.type === 'identifier' || child?.type === 'variable_declarator') {
                     const name = child.type === 'identifier'
-                        ? getNodeText(child, this.source)
+                        ? (0, tree_sitter_helpers_1.getNodeText)(child, this.source)
                         : extractName(child, this.source, this.extractor);
                     if (name && name !== '<anonymous>') {
                         this.createNode(kind, name, child, {
@@ -1467,20 +1012,98 @@ class TreeSitterExtractor {
         }
     }
     /**
-     * Extract a type alias (e.g. `export type X = ...` in TypeScript)
+     * Extract a type alias (e.g. `export type X = ...` in TypeScript).
+     * For languages like Go, resolveTypeAliasKind detects when the type_spec
+     * wraps a struct or interface definition and creates the correct node kind.
+     * Returns true if children should be skipped (struct/interface handled body visiting).
      */
     extractTypeAlias(node) {
         if (!this.extractor)
-            return;
+            return false;
         const name = extractName(node, this.source, this.extractor);
         if (name === '<anonymous>')
-            return;
-        const docstring = getPrecedingDocstring(node, this.source);
+            return false;
+        const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const isExported = this.extractor.isExported?.(node, this.source);
-        this.createNode('type_alias', name, node, {
+        // Check if this type alias is actually a struct or interface definition
+        // (e.g. Go: `type Foo struct { ... }` is a type_spec wrapping struct_type)
+        const resolvedKind = this.extractor.resolveTypeAliasKind?.(node, this.source);
+        if (resolvedKind === 'struct') {
+            const structNode = this.createNode('struct', name, node, { docstring, isExported });
+            if (!structNode)
+                return true;
+            // Visit body children for field extraction
+            this.nodeStack.push(structNode.id);
+            // Try Go-style 'type' field first, then find inner struct child (C typedef struct)
+            const typeChild = (0, tree_sitter_helpers_1.getChildByField)(node, 'type')
+                || this.findChildByTypes(node, this.extractor.structTypes);
+            if (typeChild) {
+                // Extract struct embedding (e.g. Go: `type DB struct { *Head; Queryable }`)
+                this.extractInheritance(typeChild, structNode.id);
+                const body = (0, tree_sitter_helpers_1.getChildByField)(typeChild, this.extractor.bodyField) || typeChild;
+                for (let i = 0; i < body.namedChildCount; i++) {
+                    const child = body.namedChild(i);
+                    if (child)
+                        this.visitNode(child);
+                }
+            }
+            this.nodeStack.pop();
+            return true;
+        }
+        if (resolvedKind === 'enum') {
+            const enumNode = this.createNode('enum', name, node, { docstring, isExported });
+            if (!enumNode)
+                return true;
+            this.nodeStack.push(enumNode.id);
+            // Find the inner enum type child (e.g. C: typedef enum { ... } name)
+            const innerEnum = this.findChildByTypes(node, this.extractor.enumTypes);
+            if (innerEnum) {
+                this.extractInheritance(innerEnum, enumNode.id);
+                const body = this.extractor.resolveBody?.(innerEnum, this.extractor.bodyField)
+                    ?? (0, tree_sitter_helpers_1.getChildByField)(innerEnum, this.extractor.bodyField);
+                if (body) {
+                    const memberTypes = this.extractor.enumMemberTypes;
+                    for (let i = 0; i < body.namedChildCount; i++) {
+                        const child = body.namedChild(i);
+                        if (!child)
+                            continue;
+                        if (memberTypes?.includes(child.type)) {
+                            this.extractEnumMembers(child);
+                        }
+                        else {
+                            this.visitNode(child);
+                        }
+                    }
+                }
+            }
+            this.nodeStack.pop();
+            return true;
+        }
+        if (resolvedKind === 'interface') {
+            const kind = this.extractor.interfaceKind ?? 'interface';
+            const interfaceNode = this.createNode(kind, name, node, { docstring, isExported });
+            if (!interfaceNode)
+                return true;
+            // Extract interface inheritance from the inner type node
+            const typeChild = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+            if (typeChild)
+                this.extractInheritance(typeChild, interfaceNode.id);
+            return true;
+        }
+        const typeAliasNode = this.createNode('type_alias', name, node, {
             docstring,
             isExported,
         });
+        // Extract type references from the alias value (e.g., `type X = ITextModel | null`)
+        if (typeAliasNode && this.TYPE_ANNOTATION_LANGUAGES.has(this.language)) {
+            // The value is everything after the `=`, which is typically the last named child
+            // In tree-sitter TS: type_alias_declaration has name + value children
+            const value = (0, tree_sitter_helpers_1.getChildByField)(node, 'value');
+            if (value) {
+                this.extractTypeRefsFromSubtree(value, typeAliasNode.id);
+            }
+        }
+        return false;
     }
     /**
      * Extract an exported variable declaration that isn't a function.
@@ -1509,20 +1132,20 @@ class TreeSitterExtractor {
                 const declarator = decl.namedChild(j);
                 if (!declarator || declarator.type !== 'variable_declarator')
                     continue;
-                const nameNode = getChildByField(declarator, 'name');
+                const nameNode = (0, tree_sitter_helpers_1.getChildByField)(declarator, 'name');
                 if (!nameNode)
                     continue;
-                const name = getNodeText(nameNode, this.source);
+                const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                 // Skip if the value is a function type — those are already handled
                 // by extractFunction via the functionTypes dispatch
-                const value = getChildByField(declarator, 'value');
+                const value = (0, tree_sitter_helpers_1.getChildByField)(declarator, 'value');
                 if (value) {
                     const valueType = value.type;
                     if (this.extractor.functionTypes.includes(valueType)) {
                         continue; // Already handled by extractFunction
                     }
                 }
-                const docstring = getPrecedingDocstring(exportNode, this.source);
+                const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(exportNode, this.source);
                 this.createNode('variable', name, declarator, {
                     docstring,
                     isExported: true,
@@ -1537,210 +1160,108 @@ class TreeSitterExtractor {
      * Also creates unresolved references for resolution purposes.
      */
     extractImport(node) {
-        const importText = getNodeText(node, this.source).trim();
-        // Extract module/package name based on language
-        let moduleName = '';
-        if (this.language === 'typescript' || this.language === 'javascript' ||
-            this.language === 'tsx' || this.language === 'jsx') {
-            const source = getChildByField(node, 'source');
-            if (source) {
-                moduleName = getNodeText(source, this.source).replace(/['"]/g, '');
-            }
-            // Create import node with full statement as signature for searchability
-            if (moduleName) {
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
+        if (!this.extractor)
+            return;
+        const importText = (0, tree_sitter_helpers_1.getNodeText)(node, this.source).trim();
+        // Try language-specific hook first
+        if (this.extractor.extractImport) {
+            const info = this.extractor.extractImport(node, this.source);
+            if (info) {
+                this.createNode('import', info.moduleName, node, {
+                    signature: info.signature,
                 });
+                // Create unresolved reference unless the hook handled it
+                if (!info.handledRefs && info.moduleName && this.nodeStack.length > 0) {
+                    const parentId = this.nodeStack[this.nodeStack.length - 1];
+                    if (parentId) {
+                        this.unresolvedReferences.push({
+                            fromNodeId: parentId,
+                            referenceName: info.moduleName,
+                            referenceKind: 'imports',
+                            line: node.startPosition.row + 1,
+                            column: node.startPosition.column,
+                        });
+                    }
+                }
+                return;
             }
-        }
-        else if (this.language === 'python') {
-            // Python has two import forms:
-            // 1. import_statement: import os, sys
-            // 2. import_from_statement: from os import path
-            if (node.type === 'import_from_statement') {
-                const moduleNode = getChildByField(node, 'module_name');
-                if (moduleNode) {
-                    moduleName = getNodeText(moduleNode, this.source);
-                }
-            }
-            else {
-                // import_statement - may have multiple modules
-                // Can be dotted_name (import os) or aliased_import (import numpy as np)
-                for (let i = 0; i < node.namedChildCount; i++) {
-                    const child = node.namedChild(i);
-                    if (child?.type === 'dotted_name') {
-                        const name = getNodeText(child, this.source);
-                        this.createNode('import', name, node, {
+            // Hook returned null — fall through to multi-import inline handlers only
+            // (hook returning null means "I didn't handle this" for multi-import cases,
+            // NOT "use generic fallback" — the hook already declined)
+        }
+        // Multi-import cases that create multiple nodes (can't be expressed with single-return hook)
+        // Python import_statement: import os, sys (creates one import per module)
+        if (this.language === 'python' && node.type === 'import_statement') {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child?.type === 'dotted_name') {
+                    this.createNode('import', (0, tree_sitter_helpers_1.getNodeText)(child, this.source), node, {
+                        signature: importText,
+                    });
+                }
+                else if (child?.type === 'aliased_import') {
+                    const dottedName = child.namedChildren.find(c => c.type === 'dotted_name');
+                    if (dottedName) {
+                        this.createNode('import', (0, tree_sitter_helpers_1.getNodeText)(dottedName, this.source), node, {
                             signature: importText,
                         });
                     }
-                    else if (child?.type === 'aliased_import') {
-                        // Extract the module name from inside aliased_import
-                        const dottedName = child.namedChildren.find(c => c.type === 'dotted_name');
-                        if (dottedName) {
-                            const name = getNodeText(dottedName, this.source);
-                            this.createNode('import', name, node, {
-                                signature: importText,
-                            });
-                        }
-                    }
-                }
-                // Skip creating another node below if we handled import_statement
-                if (node.type === 'import_statement') {
-                    return;
                 }
             }
-            if (moduleName) {
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
+            return;
         }
-        else if (this.language === 'go') {
-            // Go imports can be single or grouped
-            // Single: import "fmt" - uses import_spec directly as child
-            // Grouped: import ( "fmt" \n "os" ) - uses import_spec_list containing import_spec children
-            // Helper function to extract path from import_spec
+        // Go imports: single or grouped (creates one import per spec)
+        if (this.language === 'go') {
+            const parentId = this.nodeStack.length > 0 ? this.nodeStack[this.nodeStack.length - 1] : null;
             const extractFromSpec = (spec) => {
                 const stringLiteral = spec.namedChildren.find(c => c.type === 'interpreted_string_literal');
                 if (stringLiteral) {
-                    const path = getNodeText(stringLiteral, this.source).replace(/['"]/g, '');
-                    if (path) {
-                        this.createNode('import', path, spec, {
-                            signature: getNodeText(spec, this.source).trim(),
+                    const importPath = (0, tree_sitter_helpers_1.getNodeText)(stringLiteral, this.source).replace(/['"]/g, '');
+                    if (importPath) {
+                        this.createNode('import', importPath, spec, {
+                            signature: (0, tree_sitter_helpers_1.getNodeText)(spec, this.source).trim(),
                         });
+                        // Create unresolved reference so the resolver can create imports edges
+                        if (parentId) {
+                            this.unresolvedReferences.push({
+                                fromNodeId: parentId,
+                                referenceName: importPath,
+                                referenceKind: 'imports',
+                                line: spec.startPosition.row + 1,
+                                column: spec.startPosition.column,
+                            });
+                        }
                     }
                 }
             };
-            // Find import_spec_list for grouped imports
             const importSpecList = node.namedChildren.find(c => c.type === 'import_spec_list');
             if (importSpecList) {
-                // Grouped imports - iterate through import_spec children
-                const importSpecs = importSpecList.namedChildren.filter(c => c.type === 'import_spec');
-                for (const spec of importSpecs) {
+                for (const spec of importSpecList.namedChildren.filter(c => c.type === 'import_spec')) {
                     extractFromSpec(spec);
                 }
             }
             else {
-                // Single import: import "fmt" - import_spec is direct child
                 const importSpec = node.namedChildren.find(c => c.type === 'import_spec');
                 if (importSpec) {
                     extractFromSpec(importSpec);
                 }
             }
-            return; // Go handled completely above
-        }
-        else if (this.language === 'rust') {
-            // Rust use declarations
-            // use std::{ffi::OsStr, io}; -> scoped_use_list with identifier "std"
-            // use crate::error::Error;  -> scoped_identifier starting with "crate"
-            // use super::utils;         -> scoped_identifier starting with "super"
-            // Helper to get the root crate/module from a scoped path
-            const getRootModule = (scopedNode) => {
-                // Recursively find the leftmost identifier/crate/super/self
-                const firstChild = scopedNode.namedChild(0);
-                if (!firstChild)
-                    return getNodeText(scopedNode, this.source);
-                if (firstChild.type === 'identifier' ||
-                    firstChild.type === 'crate' ||
-                    firstChild.type === 'super' ||
-                    firstChild.type === 'self') {
-                    return getNodeText(firstChild, this.source);
-                }
-                else if (firstChild.type === 'scoped_identifier') {
-                    return getRootModule(firstChild);
-                }
-                return getNodeText(firstChild, this.source);
-            };
-            // Find the use argument (scoped_use_list or scoped_identifier)
-            const useArg = node.namedChildren.find(c => c.type === 'scoped_use_list' ||
-                c.type === 'scoped_identifier' ||
-                c.type === 'use_list' ||
-                c.type === 'identifier');
-            if (useArg) {
-                moduleName = getRootModule(useArg);
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // Rust handled completely above
-        }
-        else if (this.language === 'swift') {
-            // Swift imports: import Foundation, @testable import Alamofire
-            // AST structure: import_declaration -> identifier -> simple_identifier
-            const identifier = node.namedChildren.find(c => c.type === 'identifier');
-            if (identifier) {
-                moduleName = getNodeText(identifier, this.source);
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // Swift handled completely above
-        }
-        else if (this.language === 'kotlin') {
-            // Kotlin imports: import java.io.IOException, import x.y.Z as Alias, import x.y.*
-            // AST structure: import_header -> identifier (dotted path)
-            const identifier = node.namedChildren.find(c => c.type === 'identifier');
-            if (identifier) {
-                moduleName = getNodeText(identifier, this.source);
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // Kotlin handled completely above
-        }
-        else if (this.language === 'java') {
-            // Java imports: import java.util.List, import static x.Y.method, import x.y.*
-            // AST structure: import_declaration -> scoped_identifier (dotted path)
-            const scopedId = node.namedChildren.find(c => c.type === 'scoped_identifier');
-            if (scopedId) {
-                moduleName = getNodeText(scopedId, this.source);
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // Java handled completely above
-        }
-        else if (this.language === 'csharp') {
-            // C# using directives: using System, using System.Collections.Generic, using static X, using Alias = X
-            // AST structure: using_directive -> qualified_name (dotted) or identifier (simple)
-            // For alias imports: identifier = qualified_name - we want the qualified_name
-            const qualifiedName = node.namedChildren.find(c => c.type === 'qualified_name');
-            if (qualifiedName) {
-                moduleName = getNodeText(qualifiedName, this.source);
-            }
-            else {
-                // Simple namespace like "using System;" - get the first identifier
-                const identifier = node.namedChildren.find(c => c.type === 'identifier');
-                if (identifier) {
-                    moduleName = getNodeText(identifier, this.source);
-                }
-            }
-            if (moduleName) {
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // C# handled completely above
+            return;
         }
-        else if (this.language === 'php') {
-            // PHP use declarations: use X\Y\Z, use X as Y, use function X\func, use X\{A, B}
-            // AST structure: namespace_use_declaration -> namespace_use_clause -> qualified_name or name
-            // Check for grouped imports first: use X\{A, B}
+        // PHP grouped imports: use X\{A, B} (creates one import per item)
+        if (this.language === 'php') {
             const namespacePrefix = node.namedChildren.find(c => c.type === 'namespace_name');
             const useGroup = node.namedChildren.find(c => c.type === 'namespace_use_group');
             if (namespacePrefix && useGroup) {
-                // Grouped import - create one import per item
-                const prefix = getNodeText(namespacePrefix, this.source);
+                const prefix = (0, tree_sitter_helpers_1.getNodeText)(namespacePrefix, this.source);
                 const useClauses = useGroup.namedChildren.filter((c) => c.type === 'namespace_use_group_clause' || c.type === 'namespace_use_clause');
                 for (const clause of useClauses) {
-                    // WASM grammar wraps names in namespace_name; native uses name directly
                     const nsName = clause.namedChildren.find((c) => c.type === 'namespace_name');
                     const name = nsName
                         ? nsName.namedChildren.find((c) => c.type === 'name')
                         : clause.namedChildren.find((c) => c.type === 'name');
                     if (name) {
-                        const fullPath = `${prefix}\\${getNodeText(name, this.source)}`;
+                        const fullPath = `${prefix}\\${(0, tree_sitter_helpers_1.getNodeText)(name, this.source)}`;
                         this.createNode('import', fullPath, node, {
                             signature: importText,
                         });
@@ -1748,147 +1269,14 @@ class TreeSitterExtractor {
                 }
                 return;
             }
-            // Single import - find namespace_use_clause
-            const useClause = node.namedChildren.find(c => c.type === 'namespace_use_clause');
-            if (useClause) {
-                // Look for qualified_name (full path) or name (simple)
-                const qualifiedName = useClause.namedChildren.find((c) => c.type === 'qualified_name');
-                if (qualifiedName) {
-                    moduleName = getNodeText(qualifiedName, this.source);
-                }
-                else {
-                    const name = useClause.namedChildren.find((c) => c.type === 'name');
-                    if (name) {
-                        moduleName = getNodeText(name, this.source);
-                    }
-                }
-            }
-            if (moduleName) {
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // PHP handled completely above
-        }
-        else if (this.language === 'ruby') {
-            // Ruby imports: require 'json', require_relative '../helper'
-            // AST structure: call -> identifier (require/require_relative) + argument_list -> string -> string_content
-            // Check if this is a require/require_relative call
-            const identifier = node.namedChildren.find(c => c.type === 'identifier');
-            if (!identifier)
-                return;
-            const methodName = getNodeText(identifier, this.source);
-            if (methodName !== 'require' && methodName !== 'require_relative') {
-                return; // Not an import, skip
-            }
-            // Find the argument (string)
-            const argList = node.namedChildren.find(c => c.type === 'argument_list');
-            if (argList) {
-                const stringNode = argList.namedChildren.find((c) => c.type === 'string');
-                if (stringNode) {
-                    // Get string_content (without quotes)
-                    const stringContent = stringNode.namedChildren.find((c) => c.type === 'string_content');
-                    if (stringContent) {
-                        moduleName = getNodeText(stringContent, this.source);
-                    }
-                }
-            }
-            if (moduleName) {
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // Ruby handled completely above
-        }
-        else if (this.language === 'dart') {
-            // Dart imports: import 'dart:async'; import 'package:foo/bar.dart' as bar;
-            // AST: import_or_export -> library_import -> import_specification -> configurable_uri -> uri -> string_literal
-            const libraryImport = node.namedChildren.find(c => c.type === 'library_import');
-            if (libraryImport) {
-                const importSpec = libraryImport.namedChildren.find((c) => c.type === 'import_specification');
-                if (importSpec) {
-                    const configurableUri = importSpec.namedChildren.find((c) => c.type === 'configurable_uri');
-                    if (configurableUri) {
-                        const uri = configurableUri.namedChildren.find((c) => c.type === 'uri');
-                        if (uri) {
-                            const stringLiteral = uri.namedChildren.find((c) => c.type === 'string_literal');
-                            if (stringLiteral) {
-                                moduleName = getNodeText(stringLiteral, this.source).replace(/['"]/g, '');
-                            }
-                        }
-                    }
-                }
-            }
-            // Also handle exports: export 'src/foo.dart';
-            const libraryExport = node.namedChildren.find(c => c.type === 'library_export');
-            if (libraryExport) {
-                const configurableUri = libraryExport.namedChildren.find((c) => c.type === 'configurable_uri');
-                if (configurableUri) {
-                    const uri = configurableUri.namedChildren.find((c) => c.type === 'uri');
-                    if (uri) {
-                        const stringLiteral = uri.namedChildren.find((c) => c.type === 'string_literal');
-                        if (stringLiteral) {
-                            moduleName = getNodeText(stringLiteral, this.source).replace(/['"]/g, '');
-                        }
-                    }
-                }
-            }
-            if (moduleName) {
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // Dart handled completely above
-        }
-        else if (this.language === 'c' || this.language === 'cpp') {
-            // C/C++ includes: #include <iostream>, #include "myheader.h"
-            // AST: preproc_include -> system_lib_string (<...>) or string_literal ("...")
-            // Check for system include: <path>
-            const systemLib = node.namedChildren.find(c => c.type === 'system_lib_string');
-            if (systemLib) {
-                // Remove angle brackets: <iostream> -> iostream
-                moduleName = getNodeText(systemLib, this.source).replace(/^<|>$/g, '');
-            }
-            else {
-                // Check for local include: "path"
-                const stringLiteral = node.namedChildren.find(c => c.type === 'string_literal');
-                if (stringLiteral) {
-                    const stringContent = stringLiteral.namedChildren.find((c) => c.type === 'string_content');
-                    if (stringContent) {
-                        moduleName = getNodeText(stringContent, this.source);
-                    }
-                }
-            }
-            if (moduleName) {
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-            return; // C/C++ handled completely above
-        }
-        else {
-            // Generic extraction for other languages
-            moduleName = importText;
-            if (moduleName) {
-                this.createNode('import', moduleName, node, {
-                    signature: importText,
-                });
-            }
-        }
-        // Keep unresolved reference creation for resolution purposes
-        // This is used to resolve imports to their target files/modules
-        if (moduleName && this.nodeStack.length > 0) {
-            const parentId = this.nodeStack[this.nodeStack.length - 1];
-            if (parentId) {
-                this.unresolvedReferences.push({
-                    fromNodeId: parentId,
-                    referenceName: moduleName,
-                    referenceKind: 'imports',
-                    line: node.startPosition.row + 1,
-                    column: node.startPosition.column,
-                });
-            }
         }
+        // If a hook exists but returned null, it intentionally declined this node — don't create fallback
+        if (this.extractor.extractImport)
+            return;
+        // Generic fallback for languages without hooks
+        this.createNode('import', importText, node, {
+            signature: importText,
+        });
     }
     /**
      * Extract a function call
@@ -1901,21 +1289,74 @@ class TreeSitterExtractor {
             return;
         // Get the function/method being called
         let calleeName = '';
-        const func = getChildByField(node, 'function') || node.namedChild(0);
-        if (func) {
-            if (func.type === 'member_expression' || func.type === 'attribute') {
-                // Method call: obj.method()
-                const property = getChildByField(func, 'property') || func.namedChild(1);
-                if (property) {
-                    calleeName = getNodeText(property, this.source);
+        // Java/Kotlin method_invocation has 'object' + 'name' fields instead of 'function'
+        // PHP member_call_expression has 'object' + 'name', scoped_call_expression has 'scope' + 'name'
+        const nameField = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
+        const objectField = (0, tree_sitter_helpers_1.getChildByField)(node, 'object') || (0, tree_sitter_helpers_1.getChildByField)(node, 'scope');
+        if (nameField && objectField && (node.type === 'method_invocation' || node.type === 'member_call_expression' || node.type === 'scoped_call_expression')) {
+            // Method call with explicit receiver: receiver.method() / $receiver->method() / ClassName::method()
+            const methodName = (0, tree_sitter_helpers_1.getNodeText)(nameField, this.source);
+            let receiverName = (0, tree_sitter_helpers_1.getNodeText)(objectField, this.source);
+            // Strip PHP $ prefix from variable names
+            receiverName = receiverName.replace(/^\$/, '');
+            if (methodName) {
+                // Skip self/this/parent/static receivers — they don't aid resolution
+                const SKIP_RECEIVERS = new Set(['self', 'this', 'cls', 'super', 'parent', 'static']);
+                if (SKIP_RECEIVERS.has(receiverName)) {
+                    calleeName = methodName;
+                }
+                else {
+                    calleeName = `${receiverName}.${methodName}`;
                 }
             }
-            else if (func.type === 'scoped_identifier' || func.type === 'scoped_call_expression') {
-                // Scoped call: Module::function()
-                calleeName = getNodeText(func, this.source);
-            }
-            else {
-                calleeName = getNodeText(func, this.source);
+        }
+        else {
+            const func = (0, tree_sitter_helpers_1.getChildByField)(node, 'function') || node.namedChild(0);
+            if (func) {
+                if (func.type === 'member_expression' || func.type === 'attribute' || func.type === 'selector_expression' || func.type === 'navigation_expression') {
+                    // Method call: obj.method() or obj.field.method()
+                    // Go uses selector_expression with 'field', JS/TS uses member_expression with 'property'
+                    // Kotlin uses navigation_expression with navigation_suffix > simple_identifier
+                    let property = (0, tree_sitter_helpers_1.getChildByField)(func, 'property') || (0, tree_sitter_helpers_1.getChildByField)(func, 'field');
+                    if (!property) {
+                        const child1 = func.namedChild(1);
+                        // Kotlin: navigation_suffix wraps the method name — extract simple_identifier from it
+                        if (child1?.type === 'navigation_suffix') {
+                            property = child1.namedChildren.find((c) => c.type === 'simple_identifier') ?? child1;
+                        }
+                        else {
+                            property = child1;
+                        }
+                    }
+                    if (property) {
+                        const methodName = (0, tree_sitter_helpers_1.getNodeText)(property, this.source);
+                        // Include receiver name for qualified resolution (e.g., console.print → "console.print")
+                        // This helps the resolver distinguish method calls from bare function calls
+                        // (e.g., Python's console.print() vs builtin print())
+                        // Skip self/this/cls as they don't aid resolution
+                        const receiver = (0, tree_sitter_helpers_1.getChildByField)(func, 'object') || (0, tree_sitter_helpers_1.getChildByField)(func, 'operand') || func.namedChild(0);
+                        const SKIP_RECEIVERS = new Set(['self', 'this', 'cls', 'super']);
+                        if (receiver && (receiver.type === 'identifier' || receiver.type === 'simple_identifier')) {
+                            const receiverName = (0, tree_sitter_helpers_1.getNodeText)(receiver, this.source);
+                            if (!SKIP_RECEIVERS.has(receiverName)) {
+                                calleeName = `${receiverName}.${methodName}`;
+                            }
+                            else {
+                                calleeName = methodName;
+                            }
+                        }
+                        else {
+                            calleeName = methodName;
+                        }
+                    }
+                }
+                else if (func.type === 'scoped_identifier' || func.type === 'scoped_call_expression') {
+                    // Scoped call: Module::function()
+                    calleeName = (0, tree_sitter_helpers_1.getNodeText)(func, this.source);
+                }
+                else {
+                    calleeName = (0, tree_sitter_helpers_1.getNodeText)(func, this.source);
+                }
             }
         }
         if (calleeName) {
@@ -1929,24 +1370,74 @@ class TreeSitterExtractor {
         }
     }
     /**
-     * Visit function body and extract calls
+     * Visit function body and extract calls (and structural nodes).
+     *
+     * In addition to call expressions, this also detects class/struct/enum
+     * definitions inside function bodies. This handles two cases:
+     *   1. Local class/struct/enum definitions (valid in C++, Java, etc.)
+     *   2. C++ macro misparsing — macros like NLOHMANN_JSON_NAMESPACE_BEGIN cause
+     *      tree-sitter to interpret the namespace block as a function_definition,
+     *      hiding real class/struct/enum nodes inside the "function body".
      */
     visitFunctionBody(body, _functionId) {
         if (!this.extractor)
             return;
-        // Recursively find all call expressions
-        const visitForCalls = (node) => {
-            if (this.extractor.callTypes.includes(node.type)) {
+        const visitForCallsAndStructure = (node) => {
+            const nodeType = node.type;
+            if (this.extractor.callTypes.includes(nodeType)) {
                 this.extractCall(node);
             }
+            else if (this.extractor.extractBareCall) {
+                const calleeName = this.extractor.extractBareCall(node, this.source);
+                if (calleeName && this.nodeStack.length > 0) {
+                    const callerId = this.nodeStack[this.nodeStack.length - 1];
+                    if (callerId) {
+                        this.unresolvedReferences.push({
+                            fromNodeId: callerId,
+                            referenceName: calleeName,
+                            referenceKind: 'calls',
+                            line: node.startPosition.row + 1,
+                            column: node.startPosition.column,
+                        });
+                    }
+                }
+            }
+            // Extract structural nodes found inside function bodies.
+            // Each extract method visits its own children, so we return after extracting.
+            if (this.extractor.classTypes.includes(nodeType)) {
+                const classification = this.extractor.classifyClassNode?.(node) ?? 'class';
+                if (classification === 'struct')
+                    this.extractStruct(node);
+                else if (classification === 'enum')
+                    this.extractEnum(node);
+                else if (classification === 'interface')
+                    this.extractInterface(node);
+                else if (classification === 'trait')
+                    this.extractClass(node, 'trait');
+                else
+                    this.extractClass(node);
+                return;
+            }
+            if (this.extractor.structTypes.includes(nodeType)) {
+                this.extractStruct(node);
+                return;
+            }
+            if (this.extractor.enumTypes.includes(nodeType)) {
+                this.extractEnum(node);
+                return;
+            }
+            if (this.extractor.interfaceTypes.includes(nodeType)) {
+                this.extractInterface(node);
+                return;
+            }
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
                 if (child) {
-                    visitForCalls(child);
+                    visitForCallsAndStructure(child);
                 }
             }
         };
-        visitForCalls(body);
+        visitForCallsAndStructure(body);
     }
     /**
      * Extract inheritance relationships
@@ -1958,30 +1449,39 @@ class TreeSitterExtractor {
             if (!child)
                 continue;
             if (child.type === 'extends_clause' ||
-                child.type === 'class_heritage' ||
-                child.type === 'superclass') {
-                // Extract parent class name
-                const superclass = child.namedChild(0);
-                if (superclass) {
-                    const name = getNodeText(superclass, this.source);
-                    this.unresolvedReferences.push({
-                        fromNodeId: classId,
-                        referenceName: name,
-                        referenceKind: 'extends',
-                        line: child.startPosition.row + 1,
-                        column: child.startPosition.column,
-                    });
+                child.type === 'superclass' ||
+                child.type === 'base_clause' || // PHP class extends
+                child.type === 'extends_interfaces' // Java interface extends
+            ) {
+                // Extract parent class/interface names
+                // Java uses type_list wrapper: superclass -> type_identifier, extends_interfaces -> type_list -> type_identifier
+                const typeList = child.namedChildren.find((c) => c.type === 'type_list');
+                const targets = typeList ? typeList.namedChildren : [child.namedChild(0)];
+                for (const target of targets) {
+                    if (target) {
+                        const name = (0, tree_sitter_helpers_1.getNodeText)(target, this.source);
+                        this.unresolvedReferences.push({
+                            fromNodeId: classId,
+                            referenceName: name,
+                            referenceKind: 'extends',
+                            line: target.startPosition.row + 1,
+                            column: target.startPosition.column,
+                        });
+                    }
                 }
             }
             if (child.type === 'implements_clause' ||
                 child.type === 'class_interface_clause' ||
+                child.type === 'super_interfaces' || // Java class implements
                 child.type === 'interfaces' // Dart
             ) {
                 // Extract implemented interfaces
-                for (let j = 0; j < child.namedChildCount; j++) {
-                    const iface = child.namedChild(j);
+                // Java uses type_list wrapper: super_interfaces -> type_list -> type_identifier
+                const typeList = child.namedChildren.find((c) => c.type === 'type_list');
+                const targets = typeList ? typeList.namedChildren : child.namedChildren;
+                for (const iface of targets) {
                     if (iface) {
-                        const name = getNodeText(iface, this.source);
+                        const name = (0, tree_sitter_helpers_1.getNodeText)(iface, this.source);
                         this.unresolvedReferences.push({
                             fromNodeId: classId,
                             referenceName: name,
@@ -1992,6 +1492,306 @@ class TreeSitterExtractor {
                     }
                 }
             }
+            // Python superclass list: `class Flask(Scaffold, Mixin):`
+            // argument_list contains identifier children for each parent class
+            if (child.type === 'argument_list' && node.type === 'class_definition') {
+                for (const arg of child.namedChildren) {
+                    if (arg.type === 'identifier' || arg.type === 'attribute') {
+                        const name = (0, tree_sitter_helpers_1.getNodeText)(arg, this.source);
+                        this.unresolvedReferences.push({
+                            fromNodeId: classId,
+                            referenceName: name,
+                            referenceKind: 'extends',
+                            line: arg.startPosition.row + 1,
+                            column: arg.startPosition.column,
+                        });
+                    }
+                }
+            }
+            // Go interface embedding: `type Querier interface { LabelQuerier; ... }`
+            // constraint_elem wraps the embedded interface type identifier
+            if (child.type === 'constraint_elem') {
+                const typeId = child.namedChildren.find((c) => c.type === 'type_identifier');
+                if (typeId) {
+                    const name = (0, tree_sitter_helpers_1.getNodeText)(typeId, this.source);
+                    this.unresolvedReferences.push({
+                        fromNodeId: classId,
+                        referenceName: name,
+                        referenceKind: 'extends',
+                        line: typeId.startPosition.row + 1,
+                        column: typeId.startPosition.column,
+                    });
+                }
+            }
+            // Go struct embedding: field_declaration without field_identifier
+            // e.g. `type DB struct { *Head; Queryable }` — no field name means embedded type
+            if (child.type === 'field_declaration') {
+                const hasFieldIdentifier = child.namedChildren.some((c) => c.type === 'field_identifier');
+                if (!hasFieldIdentifier) {
+                    const typeId = child.namedChildren.find((c) => c.type === 'type_identifier');
+                    if (typeId) {
+                        const name = (0, tree_sitter_helpers_1.getNodeText)(typeId, this.source);
+                        this.unresolvedReferences.push({
+                            fromNodeId: classId,
+                            referenceName: name,
+                            referenceKind: 'extends',
+                            line: typeId.startPosition.row + 1,
+                            column: typeId.startPosition.column,
+                        });
+                    }
+                }
+            }
+            // Rust trait supertraits: `trait SubTrait: SuperTrait + Display { ... }`
+            // trait_bounds contains type_identifier, generic_type, or higher_ranked_trait_bound children
+            if (child.type === 'trait_bounds') {
+                for (const bound of child.namedChildren) {
+                    let typeName;
+                    let posNode;
+                    if (bound.type === 'type_identifier') {
+                        typeName = (0, tree_sitter_helpers_1.getNodeText)(bound, this.source);
+                        posNode = bound;
+                    }
+                    else if (bound.type === 'generic_type') {
+                        // e.g. `Deserialize<'de>`
+                        const inner = bound.namedChildren.find((c) => c.type === 'type_identifier');
+                        if (inner) {
+                            typeName = (0, tree_sitter_helpers_1.getNodeText)(inner, this.source);
+                            posNode = inner;
+                        }
+                    }
+                    else if (bound.type === 'higher_ranked_trait_bound') {
+                        // e.g. `for<'de> Deserialize<'de>`
+                        const generic = bound.namedChildren.find((c) => c.type === 'generic_type');
+                        const typeId = generic?.namedChildren.find((c) => c.type === 'type_identifier')
+                            ?? bound.namedChildren.find((c) => c.type === 'type_identifier');
+                        if (typeId) {
+                            typeName = (0, tree_sitter_helpers_1.getNodeText)(typeId, this.source);
+                            posNode = typeId;
+                        }
+                    }
+                    if (typeName && posNode) {
+                        this.unresolvedReferences.push({
+                            fromNodeId: classId,
+                            referenceName: typeName,
+                            referenceKind: 'extends',
+                            line: posNode.startPosition.row + 1,
+                            column: posNode.startPosition.column,
+                        });
+                    }
+                }
+            }
+            // C#: `class Movie : BaseItem, IPlugin` → base_list with identifier children
+            // base_list combines both base class and interfaces in a single colon-separated list.
+            // We emit all as 'extends' since the syntax doesn't distinguish them.
+            if (child.type === 'base_list') {
+                for (const baseType of child.namedChildren) {
+                    if (baseType) {
+                        // For generic base types like `ClientBase<T>`, extract just the type name
+                        const name = baseType.type === 'generic_name'
+                            ? (0, tree_sitter_helpers_1.getNodeText)(baseType.namedChildren.find((c) => c.type === 'identifier') ?? baseType, this.source)
+                            : (0, tree_sitter_helpers_1.getNodeText)(baseType, this.source);
+                        this.unresolvedReferences.push({
+                            fromNodeId: classId,
+                            referenceName: name,
+                            referenceKind: 'extends',
+                            line: baseType.startPosition.row + 1,
+                            column: baseType.startPosition.column,
+                        });
+                    }
+                }
+            }
+            // Kotlin: `class Foo : Bar, Baz` → delegation_specifier > user_type > type_identifier
+            // Also handles `class Foo : Bar()` → delegation_specifier > constructor_invocation > user_type
+            if (child.type === 'delegation_specifier') {
+                const userType = child.namedChildren.find((c) => c.type === 'user_type');
+                const constructorInvocation = child.namedChildren.find((c) => c.type === 'constructor_invocation');
+                const target = userType ?? constructorInvocation;
+                if (target) {
+                    const typeId = target.type === 'user_type'
+                        ? target.namedChildren.find((c) => c.type === 'type_identifier') ?? target
+                        : target.namedChildren.find((c) => c.type === 'user_type')?.namedChildren.find((c) => c.type === 'type_identifier')
+                            ?? target.namedChildren.find((c) => c.type === 'user_type') ?? target;
+                    const name = (0, tree_sitter_helpers_1.getNodeText)(typeId, this.source);
+                    this.unresolvedReferences.push({
+                        fromNodeId: classId,
+                        referenceName: name,
+                        referenceKind: 'extends',
+                        line: typeId.startPosition.row + 1,
+                        column: typeId.startPosition.column,
+                    });
+                }
+            }
+            // Swift: inheritance_specifier > user_type > type_identifier
+            // Used for class inheritance, protocol conformance, and protocol inheritance
+            if (child.type === 'inheritance_specifier') {
+                const userType = child.namedChildren.find((c) => c.type === 'user_type');
+                const typeId = userType?.namedChildren.find((c) => c.type === 'type_identifier');
+                if (typeId) {
+                    const name = (0, tree_sitter_helpers_1.getNodeText)(typeId, this.source);
+                    this.unresolvedReferences.push({
+                        fromNodeId: classId,
+                        referenceName: name,
+                        referenceKind: 'extends',
+                        line: typeId.startPosition.row + 1,
+                        column: typeId.startPosition.column,
+                    });
+                }
+            }
+            // JavaScript class_heritage has bare identifier without extends_clause wrapper
+            // e.g. `class Foo extends Bar {}` → class_heritage → identifier("Bar")
+            if ((child.type === 'identifier' || child.type === 'type_identifier') &&
+                node.type === 'class_heritage') {
+                const name = (0, tree_sitter_helpers_1.getNodeText)(child, this.source);
+                this.unresolvedReferences.push({
+                    fromNodeId: classId,
+                    referenceName: name,
+                    referenceKind: 'extends',
+                    line: child.startPosition.row + 1,
+                    column: child.startPosition.column,
+                });
+            }
+            // Recurse into container nodes (e.g. field_declaration_list in Go structs,
+            // class_heritage in TypeScript which wraps extends_clause/implements_clause)
+            if (child.type === 'field_declaration_list' || child.type === 'class_heritage') {
+                this.extractInheritance(child, classId);
+            }
+        }
+    }
+    /**
+     * Rust `impl Trait for Type` — creates an implements edge from Type to Trait.
+     * For plain `impl Type { ... }` (no trait), no inheritance edge is needed.
+     */
+    extractRustImplItem(node) {
+        // Check if this is `impl Trait for Type` by looking for a `for` keyword
+        const hasFor = node.children.some((c) => c.type === 'for' && !c.isNamed);
+        if (!hasFor)
+            return;
+        // In `impl Trait for Type`, the type_identifiers are:
+        // first = Trait name, last = implementing Type name
+        // Also handle generic types like `impl<T> Trait for MyStruct<T>`
+        const typeIdents = node.namedChildren.filter((c) => c.type === 'type_identifier' || c.type === 'generic_type' || c.type === 'scoped_type_identifier');
+        if (typeIdents.length < 2)
+            return;
+        const traitNode = typeIdents[0];
+        const typeNode = typeIdents[typeIdents.length - 1];
+        // Get the trait name (handle scoped paths like std::fmt::Display)
+        const traitName = traitNode.type === 'scoped_type_identifier'
+            ? this.source.substring(traitNode.startIndex, traitNode.endIndex)
+            : (0, tree_sitter_helpers_1.getNodeText)(traitNode, this.source);
+        // Get the implementing type name (extract inner type_identifier for generics)
+        let typeName;
+        if (typeNode.type === 'generic_type') {
+            const inner = typeNode.namedChildren.find((c) => c.type === 'type_identifier');
+            typeName = inner ? (0, tree_sitter_helpers_1.getNodeText)(inner, this.source) : (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source);
+        }
+        else {
+            typeName = (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source);
+        }
+        // Find the struct/type node for the implementing type
+        const typeNodeId = this.findNodeByName(typeName);
+        if (typeNodeId) {
+            this.unresolvedReferences.push({
+                fromNodeId: typeNodeId,
+                referenceName: traitName,
+                referenceKind: 'implements',
+                line: traitNode.startPosition.row + 1,
+                column: traitNode.startPosition.column,
+            });
+        }
+    }
+    /**
+     * Find a previously-extracted node by name (used for back-references like impl blocks)
+     */
+    findNodeByName(name) {
+        for (const node of this.nodes) {
+            if (node.name === name && (node.kind === 'struct' || node.kind === 'enum' || node.kind === 'class')) {
+                return node.id;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Languages that support type annotations (TypeScript, etc.)
+     */
+    TYPE_ANNOTATION_LANGUAGES = new Set([
+        'typescript', 'tsx', 'dart', 'kotlin', 'swift', 'rust', 'go', 'java', 'csharp',
+    ]);
+    /**
+     * Built-in/primitive type names that shouldn't create references
+     */
+    BUILTIN_TYPES = new Set([
+        'string', 'number', 'boolean', 'void', 'null', 'undefined', 'never', 'any', 'unknown',
+        'object', 'symbol', 'bigint', 'true', 'false',
+        // Rust
+        'str', 'bool', 'i8', 'i16', 'i32', 'i64', 'i128', 'isize',
+        'u8', 'u16', 'u32', 'u64', 'u128', 'usize', 'f32', 'f64', 'char',
+        // Java/C#
+        'int', 'long', 'short', 'byte', 'float', 'double', 'char',
+        // Go
+        'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64',
+        'float32', 'float64', 'complex64', 'complex128', 'rune', 'error',
+    ]);
+    /**
+     * Extract type references from type annotations on a function/method/field node.
+     * Creates 'references' edges for parameter types, return types, and field types.
+     */
+    extractTypeAnnotations(node, nodeId) {
+        if (!this.extractor)
+            return;
+        if (!this.TYPE_ANNOTATION_LANGUAGES.has(this.language))
+            return;
+        // Extract parameter type annotations
+        const params = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.paramsField || 'parameters');
+        if (params) {
+            this.extractTypeRefsFromSubtree(params, nodeId);
+        }
+        // Extract return type annotation
+        const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.returnField || 'return_type');
+        if (returnType) {
+            this.extractTypeRefsFromSubtree(returnType, nodeId);
+        }
+        // Extract direct type annotation (for class fields like `model: ITextModel`)
+        const typeAnnotation = node.namedChildren.find((c) => c.type === 'type_annotation');
+        if (typeAnnotation) {
+            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId);
+        }
+    }
+    /**
+     * Extract type references from a variable's type annotation.
+     */
+    extractVariableTypeAnnotation(node, nodeId) {
+        if (!this.TYPE_ANNOTATION_LANGUAGES.has(this.language))
+            return;
+        // Find type_annotation child (covers TS `: Type`, Rust `: Type`, etc.)
+        const typeAnnotation = node.namedChildren.find((c) => c.type === 'type_annotation');
+        if (typeAnnotation) {
+            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId);
+        }
+    }
+    /**
+     * Recursively walk a subtree and extract all type_identifier references.
+     * Handles unions, intersections, generics, arrays, etc.
+     */
+    extractTypeRefsFromSubtree(node, fromNodeId) {
+        if (node.type === 'type_identifier') {
+            const typeName = (0, tree_sitter_helpers_1.getNodeText)(node, this.source);
+            if (typeName && !this.BUILTIN_TYPES.has(typeName)) {
+                this.unresolvedReferences.push({
+                    fromNodeId,
+                    referenceName: typeName,
+                    referenceKind: 'references',
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                });
+            }
+            return; // type_identifier is a leaf
+        }
+        // Recurse into children (handles union_type, intersection_type, generic_type, etc.)
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child) {
+                this.extractTypeRefsFromSubtree(child, fromNodeId);
+            }
         }
     }
     /**
@@ -2003,7 +1803,7 @@ class TreeSitterExtractor {
         // Unit/Program/Library → module node
         if (nodeType === 'unit' || nodeType === 'program' || nodeType === 'library') {
             const moduleNameNode = node.namedChildren.find((c) => c.type === 'moduleName');
-            const name = moduleNameNode ? getNodeText(moduleNameNode, this.source) : '';
+            const name = moduleNameNode ? (0, tree_sitter_helpers_1.getNodeText)(moduleNameNode, this.source) : '';
             // Fallback to filename without extension if module name is empty
             const moduleName = name || path.basename(this.filePath).replace(/\.[^.]+$/, '');
             this.createNode('module', moduleName, node);
@@ -2055,9 +1855,9 @@ class TreeSitterExtractor {
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
                 if (child?.type === 'declVar') {
-                    const nameNode = getChildByField(child, 'name');
+                    const nameNode = (0, tree_sitter_helpers_1.getChildByField)(child, 'name');
                     if (nameNode) {
-                        const name = getNodeText(nameNode, this.source);
+                        const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                         this.createNode('variable', name, child);
                     }
                 }
@@ -2071,9 +1871,9 @@ class TreeSitterExtractor {
         }
         // declProp → property node
         if (nodeType === 'declProp') {
-            const nameNode = getChildByField(node, 'name');
+            const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
             if (nameNode) {
-                const name = getNodeText(nameNode, this.source);
+                const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                 const visibility = this.extractor.getVisibility?.(node);
                 this.createNode('property', name, node, { visibility });
             }
@@ -2081,9 +1881,9 @@ class TreeSitterExtractor {
         }
         // declField → field node
         if (nodeType === 'declField') {
-            const nameNode = getChildByField(node, 'name');
+            const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
             if (nameNode) {
-                const name = getNodeText(nameNode, this.source);
+                const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
                 const visibility = this.extractor.getVisibility?.(node);
                 this.createNode('field', name, node, { visibility });
             }
@@ -2123,10 +1923,10 @@ class TreeSitterExtractor {
      * Extract a Pascal declType node (class, interface, enum, or type alias)
      */
     extractPascalDeclType(node) {
-        const nameNode = getChildByField(node, 'name');
+        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
         if (!nameNode)
             return;
-        const name = getNodeText(nameNode, this.source);
+        const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
         // Find the inner type declaration
         const declClass = node.namedChildren.find((c) => c.type === 'declClass');
         const declIntf = node.namedChildren.find((c) => c.type === 'declIntf');
@@ -2170,9 +1970,9 @@ class TreeSitterExtractor {
                     for (let i = 0; i < declEnum.namedChildCount; i++) {
                         const child = declEnum.namedChild(i);
                         if (child?.type === 'declEnumValue') {
-                            const memberName = getChildByField(child, 'name');
+                            const memberName = (0, tree_sitter_helpers_1.getChildByField)(child, 'name');
                             if (memberName) {
-                                this.createNode('enum_member', getNodeText(memberName, this.source), child);
+                                this.createNode('enum_member', (0, tree_sitter_helpers_1.getNodeText)(memberName, this.source), child);
                             }
                         }
                     }
@@ -2193,11 +1993,11 @@ class TreeSitterExtractor {
      * Extract Pascal uses clause into individual import nodes
      */
     extractPascalUses(node) {
-        const importText = getNodeText(node, this.source).trim();
+        const importText = (0, tree_sitter_helpers_1.getNodeText)(node, this.source).trim();
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child?.type === 'moduleName') {
-                const unitName = getNodeText(child, this.source);
+                const unitName = (0, tree_sitter_helpers_1.getNodeText)(child, this.source);
                 this.createNode('import', unitName, child, {
                     signature: importText,
                 });
@@ -2221,12 +2021,12 @@ class TreeSitterExtractor {
      * Extract a Pascal constant declaration
      */
     extractPascalConst(node) {
-        const nameNode = getChildByField(node, 'name');
+        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
         if (!nameNode)
             return;
-        const name = getNodeText(nameNode, this.source);
+        const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
         const defaultValue = node.namedChildren.find((c) => c.type === 'defaultValue');
-        const sig = defaultValue ? getNodeText(defaultValue, this.source) : undefined;
+        const sig = defaultValue ? (0, tree_sitter_helpers_1.getNodeText)(defaultValue, this.source) : undefined;
         this.createNode('constant', name, node, { signature: sig });
     }
     /**
@@ -2236,7 +2036,7 @@ class TreeSitterExtractor {
         const typerefs = declClass.namedChildren.filter((c) => c.type === 'typeref');
         for (let i = 0; i < typerefs.length; i++) {
             const ref = typerefs[i];
-            const name = getNodeText(ref, this.source);
+            const name = (0, tree_sitter_helpers_1.getNodeText)(ref, this.source);
             this.unresolvedReferences.push({
                 fromNodeId: classId,
                 referenceName: name,
@@ -2255,10 +2055,10 @@ class TreeSitterExtractor {
         const declProc = node.namedChildren.find((c) => c.type === 'declProc');
         if (!declProc)
             return;
-        const nameNode = getChildByField(declProc, 'name');
+        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(declProc, 'name');
         if (!nameNode)
             return;
-        const fullName = getNodeText(nameNode, this.source).trim();
+        const fullName = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source).trim();
         // fullName is like "TAuthService.Create"
         const shortName = fullName.includes('.') ? fullName.split('.').pop() : fullName;
         const fullNameKey = fullName.toLowerCase();
@@ -2275,7 +2075,7 @@ class TreeSitterExtractor {
                     }
                     // For Pascal methods, also index qualified forms (e.g. TAuthService.Create).
                     if (n.kind === 'method') {
-                        const qualifiedParts = n.qualifiedName.split('::').slice(1); // drop file path
+                        const qualifiedParts = n.qualifiedName.split('::');
                         if (qualifiedParts.length >= 2) {
                             // Create suffix keys so both "Module.Class.Method" and "Class.Method" can resolve.
                             for (let i = 0; i < qualifiedParts.length - 1; i++) {
@@ -2318,11 +2118,11 @@ class TreeSitterExtractor {
             // Qualified call: Obj.Method(...)
             const identifiers = firstChild.namedChildren.filter((c) => c.type === 'identifier');
             if (identifiers.length > 0) {
-                calleeName = identifiers.map((id) => getNodeText(id, this.source)).join('.');
+                calleeName = identifiers.map((id) => (0, tree_sitter_helpers_1.getNodeText)(id, this.source)).join('.');
             }
         }
         else if (firstChild.type === 'identifier') {
-            calleeName = getNodeText(firstChild, this.source);
+            calleeName = (0, tree_sitter_helpers_1.getNodeText)(firstChild, this.source);
         }
         if (calleeName) {
             this.unresolvedReferences.push({
@@ -2366,634 +2166,26 @@ class TreeSitterExtractor {
     }
 }
 exports.TreeSitterExtractor = TreeSitterExtractor;
-/**
- * LiquidExtractor - Extracts relationships from Liquid template files
- *
- * Liquid is a templating language (used by Shopify, Jekyll, etc.) that doesn't
- * have traditional functions or classes. Instead, we extract:
- * - Section references ({% section 'name' %})
- * - Snippet references ({% render 'name' %} and {% include 'name' %})
- * - Schema blocks ({% schema %}...{% endschema %})
- */
-class LiquidExtractor {
-    filePath;
-    source;
-    nodes = [];
-    edges = [];
-    unresolvedReferences = [];
-    errors = [];
-    constructor(filePath, source) {
-        this.filePath = filePath;
-        this.source = source;
-    }
-    /**
-     * Extract from Liquid source
-     */
-    extract() {
-        const startTime = Date.now();
-        try {
-            // Create file node
-            const fileNode = this.createFileNode();
-            // Extract render/include statements (snippet references)
-            this.extractSnippetReferences(fileNode.id);
-            // Extract section references
-            this.extractSectionReferences(fileNode.id);
-            // Extract schema block
-            this.extractSchema(fileNode.id);
-            // Extract assign statements as variables
-            this.extractAssignments(fileNode.id);
-        }
-        catch (error) {
-            (0, sentry_1.captureException)(error, { operation: 'liquid-extraction', filePath: this.filePath });
-            this.errors.push({
-                message: `Liquid extraction error: ${error instanceof Error ? error.message : String(error)}`,
-                severity: 'error',
-            });
-        }
-        return {
-            nodes: this.nodes,
-            edges: this.edges,
-            unresolvedReferences: this.unresolvedReferences,
-            errors: this.errors,
-            durationMs: Date.now() - startTime,
-        };
-    }
-    /**
-     * Create a file node for the Liquid template
-     */
-    createFileNode() {
-        const lines = this.source.split('\n');
-        const id = generateNodeId(this.filePath, 'file', this.filePath, 1);
-        const fileNode = {
-            id,
-            kind: 'file',
-            name: this.filePath.split('/').pop() || this.filePath,
-            qualifiedName: this.filePath,
-            filePath: this.filePath,
-            language: 'liquid',
-            startLine: 1,
-            endLine: lines.length,
-            startColumn: 0,
-            endColumn: lines[lines.length - 1]?.length || 0,
-            updatedAt: Date.now(),
-        };
-        this.nodes.push(fileNode);
-        return fileNode;
-    }
-    /**
-     * Extract {% render 'snippet' %} and {% include 'snippet' %} references
-     */
-    extractSnippetReferences(fileNodeId) {
-        // Match {% render 'name' %} or {% include 'name' %} with optional parameters
-        const renderRegex = /\{%[-]?\s*(render|include)\s+['"]([^'"]+)['"]/g;
-        let match;
-        while ((match = renderRegex.exec(this.source)) !== null) {
-            const [fullMatch, tagType, snippetName] = match;
-            const line = this.getLineNumber(match.index);
-            // Create an import node for searchability
-            const importNodeId = generateNodeId(this.filePath, 'import', snippetName, line);
-            const importNode = {
-                id: importNodeId,
-                kind: 'import',
-                name: snippetName,
-                qualifiedName: `${this.filePath}::import:${snippetName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                signature: fullMatch,
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + fullMatch.length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(importNode);
-            // Add containment edge from file to import
-            this.edges.push({
-                source: fileNodeId,
-                target: importNodeId,
-                kind: 'contains',
-            });
-            // Create a component node for the snippet reference
-            const nodeId = generateNodeId(this.filePath, 'component', `${tagType}:${snippetName}`, line);
-            const node = {
-                id: nodeId,
-                kind: 'component',
-                name: snippetName,
-                qualifiedName: `${this.filePath}::${tagType}:${snippetName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + fullMatch.length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(node);
-            // Add containment edge from file
-            this.edges.push({
-                source: fileNodeId,
-                target: nodeId,
-                kind: 'contains',
-            });
-            // Add unresolved reference to the snippet file
-            this.unresolvedReferences.push({
-                fromNodeId: fileNodeId,
-                referenceName: `snippets/${snippetName}.liquid`,
-                referenceKind: 'references',
-                line,
-                column: match.index - this.getLineStart(line),
-            });
-        }
-    }
-    /**
-     * Extract {% section 'name' %} references
-     */
-    extractSectionReferences(fileNodeId) {
-        // Match {% section 'name' %}
-        const sectionRegex = /\{%[-]?\s*section\s+['"]([^'"]+)['"]/g;
-        let match;
-        while ((match = sectionRegex.exec(this.source)) !== null) {
-            const [fullMatch, sectionName] = match;
-            const line = this.getLineNumber(match.index);
-            // Create an import node for searchability
-            const importNodeId = generateNodeId(this.filePath, 'import', sectionName, line);
-            const importNode = {
-                id: importNodeId,
-                kind: 'import',
-                name: sectionName,
-                qualifiedName: `${this.filePath}::import:${sectionName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                signature: fullMatch,
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + fullMatch.length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(importNode);
-            // Add containment edge from file to import
-            this.edges.push({
-                source: fileNodeId,
-                target: importNodeId,
-                kind: 'contains',
-            });
-            // Create a component node for the section reference
-            const nodeId = generateNodeId(this.filePath, 'component', `section:${sectionName}`, line);
-            const node = {
-                id: nodeId,
-                kind: 'component',
-                name: sectionName,
-                qualifiedName: `${this.filePath}::section:${sectionName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + fullMatch.length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(node);
-            // Add containment edge from file
-            this.edges.push({
-                source: fileNodeId,
-                target: nodeId,
-                kind: 'contains',
-            });
-            // Add unresolved reference to the section file
-            this.unresolvedReferences.push({
-                fromNodeId: fileNodeId,
-                referenceName: `sections/${sectionName}.liquid`,
-                referenceKind: 'references',
-                line,
-                column: match.index - this.getLineStart(line),
-            });
-        }
-    }
-    /**
-     * Extract {% schema %}...{% endschema %} blocks
-     */
-    extractSchema(fileNodeId) {
-        // Match {% schema %}...{% endschema %}
-        const schemaRegex = /\{%[-]?\s*schema\s*[-]?%\}([\s\S]*?)\{%[-]?\s*endschema\s*[-]?%\}/g;
-        let match;
-        while ((match = schemaRegex.exec(this.source)) !== null) {
-            const [fullMatch, schemaContent] = match;
-            const startLine = this.getLineNumber(match.index);
-            const endLine = this.getLineNumber(match.index + fullMatch.length);
-            // Try to parse the schema JSON to get the name
-            let schemaName = 'schema';
-            try {
-                const schemaJson = JSON.parse(schemaContent);
-                if (schemaJson.name) {
-                    schemaName = schemaJson.name;
-                }
-            }
-            catch {
-                // Schema isn't valid JSON, use default name
-            }
-            // Create a node for the schema
-            const nodeId = generateNodeId(this.filePath, 'constant', `schema:${schemaName}`, startLine);
-            const node = {
-                id: nodeId,
-                kind: 'constant',
-                name: schemaName,
-                qualifiedName: `${this.filePath}::schema:${schemaName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                startLine,
-                endLine,
-                startColumn: match.index - this.getLineStart(startLine),
-                endColumn: 0,
-                docstring: schemaContent?.trim().substring(0, 200), // Store first 200 chars as docstring
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(node);
-            // Add containment edge from file
-            this.edges.push({
-                source: fileNodeId,
-                target: nodeId,
-                kind: 'contains',
-            });
-        }
-    }
-    /**
-     * Extract {% assign var = value %} statements
-     */
-    extractAssignments(fileNodeId) {
-        // Match {% assign variable_name = ... %}
-        const assignRegex = /\{%[-]?\s*assign\s+(\w+)\s*=/g;
-        let match;
-        while ((match = assignRegex.exec(this.source)) !== null) {
-            const [, variableName] = match;
-            const line = this.getLineNumber(match.index);
-            // Create a variable node
-            const nodeId = generateNodeId(this.filePath, 'variable', variableName, line);
-            const node = {
-                id: nodeId,
-                kind: 'variable',
-                name: variableName,
-                qualifiedName: `${this.filePath}::${variableName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + match[0].length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(node);
-            // Add containment edge from file
-            this.edges.push({
-                source: fileNodeId,
-                target: nodeId,
-                kind: 'contains',
-            });
-        }
-    }
-    /**
-     * Get the line number for a character index
-     */
-    getLineNumber(index) {
-        const substring = this.source.substring(0, index);
-        return (substring.match(/\n/g) || []).length + 1;
-    }
-    /**
-     * Get the character index of the start of a line
-     */
-    getLineStart(lineNumber) {
-        const lines = this.source.split('\n');
-        let index = 0;
-        for (let i = 0; i < lineNumber - 1 && i < lines.length; i++) {
-            index += lines[i].length + 1; // +1 for newline
-        }
-        return index;
-    }
-}
-exports.LiquidExtractor = LiquidExtractor;
-/**
- * SvelteExtractor - Extracts code relationships from Svelte component files
- *
- * Svelte files are multi-language (script + template + style). Rather than
- * parsing the full Svelte grammar, we extract the <script> block content
- * and delegate it to the TypeScript/JavaScript TreeSitterExtractor.
- *
- * Every .svelte file produces a component node (Svelte components are always importable).
- */
-class SvelteExtractor {
-    filePath;
-    source;
-    nodes = [];
-    edges = [];
-    unresolvedReferences = [];
-    errors = [];
-    constructor(filePath, source) {
-        this.filePath = filePath;
-        this.source = source;
-    }
-    /**
-     * Extract from Svelte source
-     */
-    extract() {
-        const startTime = Date.now();
-        try {
-            // Create component node for the .svelte file itself
-            const componentNode = this.createComponentNode();
-            // Extract and process script blocks
-            const scriptBlocks = this.extractScriptBlocks();
-            for (const block of scriptBlocks) {
-                this.processScriptBlock(block, componentNode.id);
-            }
-        }
-        catch (error) {
-            (0, sentry_1.captureException)(error, { operation: 'svelte-extraction', filePath: this.filePath });
-            this.errors.push({
-                message: `Svelte extraction error: ${error instanceof Error ? error.message : String(error)}`,
-                severity: 'error',
-            });
-        }
-        return {
-            nodes: this.nodes,
-            edges: this.edges,
-            unresolvedReferences: this.unresolvedReferences,
-            errors: this.errors,
-            durationMs: Date.now() - startTime,
-        };
-    }
-    /**
-     * Create a component node for the .svelte file
-     */
-    createComponentNode() {
-        const lines = this.source.split('\n');
-        const fileName = this.filePath.split(/[/\\]/).pop() || this.filePath;
-        const componentName = fileName.replace(/\.svelte$/, '');
-        const id = generateNodeId(this.filePath, 'component', componentName, 1);
-        const node = {
-            id,
-            kind: 'component',
-            name: componentName,
-            qualifiedName: `${this.filePath}::${componentName}`,
-            filePath: this.filePath,
-            language: 'svelte',
-            startLine: 1,
-            endLine: lines.length,
-            startColumn: 0,
-            endColumn: lines[lines.length - 1]?.length || 0,
-            isExported: true, // Svelte components are always importable
-            updatedAt: Date.now(),
-        };
-        this.nodes.push(node);
-        return node;
-    }
-    /**
-     * Extract <script> blocks from the Svelte source
-     */
-    extractScriptBlocks() {
-        const blocks = [];
-        const scriptRegex = /<script(\s[^>]*)?>(?<content>[\s\S]*?)<\/script>/g;
-        let match;
-        while ((match = scriptRegex.exec(this.source)) !== null) {
-            const attrs = match[1] || '';
-            const content = match.groups?.content || match[2] || '';
-            // Detect TypeScript from lang attribute
-            const isTypeScript = /lang\s*=\s*["'](ts|typescript)["']/.test(attrs);
-            // Detect module script
-            const isModule = /context\s*=\s*["']module["']/.test(attrs);
-            // Calculate start line of the script content (line after <script>)
-            const beforeScript = this.source.substring(0, match.index);
-            const scriptTagLine = (beforeScript.match(/\n/g) || []).length;
-            // The content starts on the line after the opening <script> tag
-            const openingTag = match[0].substring(0, match[0].indexOf('>') + 1);
-            const openingTagLines = (openingTag.match(/\n/g) || []).length;
-            const contentStartLine = scriptTagLine + openingTagLines + 1; // 0-indexed line
-            blocks.push({
-                content,
-                startLine: contentStartLine,
-                isModule,
-                isTypeScript,
-            });
-        }
-        return blocks;
-    }
-    /**
-     * Process a script block by delegating to TreeSitterExtractor
-     */
-    processScriptBlock(block, componentNodeId) {
-        const scriptLanguage = block.isTypeScript ? 'typescript' : 'javascript';
-        // Check if the script language parser is available
-        if (!(0, grammars_1.isLanguageSupported)(scriptLanguage)) {
-            this.errors.push({
-                message: `Parser for ${scriptLanguage} not available, cannot parse Svelte script block`,
-                severity: 'warning',
-            });
-            return;
-        }
-        // Delegate to TreeSitterExtractor
-        const extractor = new TreeSitterExtractor(this.filePath, block.content, scriptLanguage);
-        const result = extractor.extract();
-        // Offset line numbers from script block back to .svelte file positions
-        for (const node of result.nodes) {
-            node.startLine += block.startLine;
-            node.endLine += block.startLine;
-            node.language = 'svelte'; // Mark as svelte, not TS/JS
-            this.nodes.push(node);
-            // Add containment edge from component to this node
-            this.edges.push({
-                source: componentNodeId,
-                target: node.id,
-                kind: 'contains',
-            });
-        }
-        // Offset edges (they reference line numbers)
-        for (const edge of result.edges) {
-            if (edge.line) {
-                edge.line += block.startLine;
-            }
-            this.edges.push(edge);
-        }
-        // Offset unresolved references
-        for (const ref of result.unresolvedReferences) {
-            ref.line += block.startLine;
-            ref.filePath = this.filePath;
-            ref.language = 'svelte';
-            this.unresolvedReferences.push(ref);
-        }
-        // Carry over errors
-        for (const error of result.errors) {
-            if (error.line) {
-                error.line += block.startLine;
-            }
-            this.errors.push(error);
-        }
-    }
-}
-exports.SvelteExtractor = SvelteExtractor;
-/**
- * Custom extractor for Delphi DFM/FMX form files.
- *
- * DFM/FMX files describe the visual component hierarchy and event handler
- * bindings. They use a simple text format (object/end blocks) that we parse
- * with regex — no tree-sitter grammar exists for this format.
- *
- * Extracted information:
- * - Components as NodeKind `component`
- * - Nesting as EdgeKind `contains`
- * - Event handlers (OnClick = MethodName) as UnresolvedReference → EdgeKind `references`
- */
-class DfmExtractor {
-    filePath;
-    source;
-    nodes = [];
-    edges = [];
-    unresolvedReferences = [];
-    errors = [];
-    constructor(filePath, source) {
-        this.filePath = filePath;
-        this.source = source;
-    }
-    /**
-     * Extract components and event handler references from DFM/FMX source
-     */
-    extract() {
-        const startTime = Date.now();
-        try {
-            const fileNode = this.createFileNode();
-            this.parseComponents(fileNode.id);
-        }
-        catch (error) {
-            (0, sentry_1.captureException)(error, { operation: 'dfm-extraction', filePath: this.filePath });
-            this.errors.push({
-                message: `DFM extraction error: ${error instanceof Error ? error.message : String(error)}`,
-                severity: 'error',
-            });
-        }
-        return {
-            nodes: this.nodes,
-            edges: this.edges,
-            unresolvedReferences: this.unresolvedReferences,
-            errors: this.errors,
-            durationMs: Date.now() - startTime,
-        };
-    }
-    /** Create a file node for the DFM form file */
-    createFileNode() {
-        const lines = this.source.split('\n');
-        const id = generateNodeId(this.filePath, 'file', this.filePath, 1);
-        const fileNode = {
-            id,
-            kind: 'file',
-            name: this.filePath.split('/').pop() || this.filePath,
-            qualifiedName: this.filePath,
-            filePath: this.filePath,
-            language: 'pascal',
-            startLine: 1,
-            endLine: lines.length,
-            startColumn: 0,
-            endColumn: lines[lines.length - 1]?.length || 0,
-            updatedAt: Date.now(),
-        };
-        this.nodes.push(fileNode);
-        return fileNode;
-    }
-    /** Parse object/end blocks and extract components + event handlers */
-    parseComponents(fileNodeId) {
-        const lines = this.source.split('\n');
-        const stack = [fileNodeId];
-        const objectPattern = /^\s*(object|inherited|inline)\s+(\w+)\s*:\s*(\w+)/;
-        const eventPattern = /^\s*(On\w+)\s*=\s*(\w+)\s*$/;
-        const endPattern = /^\s*end\s*$/;
-        const multiLineStart = /=\s*\(\s*$/;
-        const multiLineItemStart = /=\s*<\s*$/;
-        let inMultiLine = false;
-        let multiLineEndChar = ')';
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const lineNum = i + 1;
-            // Skip multi-line properties
-            if (inMultiLine) {
-                if (line.trimEnd().endsWith(multiLineEndChar))
-                    inMultiLine = false;
-                continue;
-            }
-            if (multiLineStart.test(line)) {
-                inMultiLine = true;
-                multiLineEndChar = ')';
-                continue;
-            }
-            if (multiLineItemStart.test(line)) {
-                inMultiLine = true;
-                multiLineEndChar = '>';
-                continue;
-            }
-            // Component declaration
-            const objMatch = line.match(objectPattern);
-            if (objMatch) {
-                const [, , name, typeName] = objMatch;
-                const nodeId = generateNodeId(this.filePath, 'component', name, lineNum);
-                this.nodes.push({
-                    id: nodeId,
-                    kind: 'component',
-                    name: name,
-                    qualifiedName: `${this.filePath}#${name}`,
-                    filePath: this.filePath,
-                    language: 'pascal',
-                    startLine: lineNum,
-                    endLine: lineNum,
-                    startColumn: 0,
-                    endColumn: line.length,
-                    signature: typeName,
-                    updatedAt: Date.now(),
-                });
-                this.edges.push({
-                    source: stack[stack.length - 1],
-                    target: nodeId,
-                    kind: 'contains',
-                });
-                stack.push(nodeId);
-                continue;
-            }
-            // Event handler
-            const eventMatch = line.match(eventPattern);
-            if (eventMatch) {
-                const [, , methodName] = eventMatch;
-                this.unresolvedReferences.push({
-                    fromNodeId: stack[stack.length - 1],
-                    referenceName: methodName,
-                    referenceKind: 'references',
-                    line: lineNum,
-                    column: 0,
-                });
-                continue;
-            }
-            // Block end
-            if (endPattern.test(line)) {
-                if (stack.length > 1)
-                    stack.pop();
-            }
-        }
-    }
-}
-exports.DfmExtractor = DfmExtractor;
 /**
  * Extract nodes and edges from source code
  */
 function extractFromSource(filePath, source, language) {
-    const detectedLanguage = language || (0, grammars_1.detectLanguage)(filePath);
+    const detectedLanguage = language || (0, grammars_1.detectLanguage)(filePath, source);
     const fileExtension = path.extname(filePath).toLowerCase();
     // Use custom extractor for Svelte
     if (detectedLanguage === 'svelte') {
-        const extractor = new SvelteExtractor(filePath, source);
+        const extractor = new svelte_extractor_1.SvelteExtractor(filePath, source);
         return extractor.extract();
     }
     // Use custom extractor for Liquid
     if (detectedLanguage === 'liquid') {
-        const extractor = new LiquidExtractor(filePath, source);
+        const extractor = new liquid_extractor_1.LiquidExtractor(filePath, source);
         return extractor.extract();
     }
     // Use custom extractor for DFM/FMX form files
     if (detectedLanguage === 'pascal' &&
         (fileExtension === '.dfm' || fileExtension === '.fmx')) {
-        const extractor = new DfmExtractor(filePath, source);
+        const extractor = new dfm_extractor_1.DfmExtractor(filePath, source);
         return extractor.extract();
     }
     const extractor = new TreeSitterExtractor(filePath, source, detectedLanguage);