gitnexus 1.5.3 → 1.6.1

package/dist/core/ingestion/workers/parse-worker.js

@@ -35,14 +35,15 @@ try {
 }
 catch { }
 import { getLanguageFromFilename } from '../../../_shared/index.js';
-import { FUNCTION_NODE_TYPES, extractFunctionName, getDefinitionNodeFromCaptures, findEnclosingClassId, getLabelFromCaptures, extractMethodSignature, findDescendant, extractStringContent, } from '../utils/ast-helpers.js';
+import { FUNCTION_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, findDescendant, extractStringContent, genericFuncName, inferFunctionLabel, CLASS_CONTAINER_TYPES, } from '../utils/ast-helpers.js';
 import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, extractCallArgTypes, } from '../utils/call-analysis.js';
 import { extractParsedCallSite } from '../call-sites/extract-language-call-site.js';
 import { buildTypeEnv } from '../type-env.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
 import { generateId } from '../../../lib/utils.js';
 import { preprocessImportPath } from '../import-processor.js';
-import { CLASS_CONTAINER_TYPES } from '../utils/ast-helpers.js';
+import { extractVueScript, extractTemplateComponents, isVueSetupTopLevel, } from '../vue-sfc-extractor.js';
+import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from '../utils/method-props.js';
 // ============================================================================
 // Worker-local parser + language map
 // ============================================================================
@@ -61,6 +62,7 @@ const languageMap = {
     ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}),
     [SupportedLanguages.PHP]: PHP.php_only,
     [SupportedLanguages.Ruby]: Ruby,
+    [SupportedLanguages.Vue]: TypeScript.typescript,
     ...(Dart ? { [SupportedLanguages.Dart]: Dart } : {}),
     ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
 };
@@ -114,21 +116,100 @@ function findEnclosingClassNode(node) {
     let current = node.parent;
     while (current) {
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            // Return singleton_class directly so the method extractor sees it as
+            // the owner node and correctly marks methods as static. Name resolution
+            // for qualified names is handled separately by findEnclosingClassInfo.
             return current;
         }
         current = current.parent;
     }
     return null;
 }
+/**
+ * For C++ out-of-class method definitions (e.g. `void Foo::bar() {}`), extract the
+ * class name from the qualified_identifier scope and find the class declaration in the
+ * file's AST. Returns the class SyntaxNode or null if not found.
+ *
+ * Handles pointer/reference return types where function_declarator is nested inside
+ * pointer_declarator or reference_declarator.
+ */
+function findClassNodeByQualifiedName(node) {
+    const declarator = node.childForFieldName('declarator');
+    if (!declarator)
+        return null;
+    // Find the function_declarator, recursively unwrapping pointer_declarator /
+    // reference_declarator chains (e.g. int** Foo::bar() has
+    // pointer_declarator → pointer_declarator → function_declarator).
+    let funcDecl = null;
+    if (declarator.type === 'function_declarator') {
+        funcDecl = declarator;
+    }
+    else {
+        let current = declarator;
+        while (current && !funcDecl) {
+            for (let i = 0; i < current.namedChildCount; i++) {
+                const child = current.namedChild(i);
+                if (child?.type === 'function_declarator') {
+                    funcDecl = child;
+                    break;
+                }
+            }
+            if (!funcDecl) {
+                const next = current.namedChildren.find((c) => c.type === 'pointer_declarator' || c.type === 'reference_declarator');
+                current = next ?? null;
+            }
+        }
+    }
+    if (!funcDecl)
+        return null;
+    // Check if the inner declarator is a qualified_identifier (Foo::bar)
+    const innerDecl = funcDecl.childForFieldName('declarator');
+    if (!innerDecl || innerDecl.type !== 'qualified_identifier')
+        return null;
+    const scope = innerDecl.childForFieldName('scope');
+    if (!scope)
+        return null;
+    const className = scope.text;
+    // Search the file for a matching class/struct specifier, including inside
+    // namespace_definition blocks (the majority of production C++ uses namespaces).
+    const root = node.tree.rootNode;
+    const classTypes = new Set(['class_specifier', 'struct_specifier']);
+    const searchIn = (parent) => {
+        for (let i = 0; i < parent.namedChildCount; i++) {
+            const child = parent.namedChild(i);
+            if (!child)
+                continue;
+            if (classTypes.has(child.type)) {
+                const nameNode = child.childForFieldName('name');
+                if (nameNode?.text === className)
+                    return child;
+            }
+            // Recurse into namespace blocks
+            if (child.type === 'namespace_definition') {
+                const found = searchIn(child);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    };
+    return searchIn(root);
+}
 /**
  * Minimal no-op SymbolTable stub for FieldExtractorContext in the worker.
- * Field extraction only uses symbolTable.lookupExactAll for optional type resolution —
- * returning [] causes the extractor to use the raw type string, which is fine for us.
+ * Field extraction only uses symbolTable.lookupExactAll for optional type
+ * resolution — returning [] causes the extractor to use the raw type
+ * string, which is fine for us. Every other method is a no-op so the
+ * stub remains safe if a future FieldExtractor consults it through the
+ * full {@link SymbolTableReader} surface.
  */
 const NOOP_SYMBOL_TABLE = {
-    lookupExactAll: () => [],
     lookupExact: () => undefined,
     lookupExactFull: () => undefined,
+    lookupExactAll: () => [],
+    lookupCallableByName: () => [],
+    getFiles: () => [][Symbol.iterator](),
+    getStats: () => ({ fileCount: 0 }),
 };
 /**
  * Get (or extract and cache) field info for a class node.
@@ -180,6 +261,9 @@ function getMethodInfo(classNode, provider, context) {
     methodInfoCache.set(cacheKey, cached);
     return cached;
 }
+// ============================================================================
+// Enclosing function detection (for call extraction) — cached
+// ============================================================================
 /** Walk up AST to find enclosing function, return its generateId or null for top-level.
  *  Applies provider.labelOverride so the label matches the definition phase (single source of truth). */
 const findEnclosingFunctionId = (node, filePath, provider) => {
@@ -189,7 +273,9 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            const { funcName, label } = extractFunctionName(current);
+            const efnResult = provider.methodExtractor?.extractFunctionName?.(current);
+            const funcName = efnResult?.funcName ?? genericFuncName(current);
+            const label = efnResult?.label ?? inferFunctionLabel(current.type);
             if (funcName) {
                 // Apply labelOverride so label matches definition phase (e.g., Kotlin Function→Method).
                 // null means "skip as definition" — keep original label for scope identification.
@@ -199,7 +285,39 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
                     if (override !== null)
                         finalLabel = override;
                 }
-                const result = generateId(finalLabel, `${filePath}:${funcName}`);
+                // Qualify with enclosing class to match definition-phase node IDs
+                const classInfo = cachedFindEnclosingClassInfo(current, filePath, provider.resolveEnclosingOwner);
+                const qualifiedName = classInfo ? `${classInfo.className}.${funcName}` : funcName;
+                // Include #<arity> suffix to match definition-phase Method/Constructor IDs.
+                // Use the same MethodExtractor (getMethodInfo) as the definition phase.
+                // When same-arity collisions exist, also append ~type1,type2.
+                let arity;
+                let encTypeTag = '';
+                if (finalLabel === 'Method' || finalLabel === 'Constructor') {
+                    const encLang = getLanguageFromFilename(filePath);
+                    const classNode = findEnclosingClassNode(current) ?? findClassNodeByQualifiedName(current);
+                    if (classNode && encLang) {
+                        const methodMap = getMethodInfo(classNode, provider, {
+                            filePath,
+                            language: encLang,
+                        });
+                        const defLine = current.startPosition.row + 1;
+                        const info = methodMap?.get(`${funcName}:${defLine}`);
+                        if (info) {
+                            arity = info.parameters.some((p) => p.isVariadic)
+                                ? undefined
+                                : info.parameters.length;
+                            if (methodMap && arity !== undefined) {
+                                const g = buildCollisionGroups(methodMap);
+                                encTypeTag =
+                                    typeTagForId(methodMap, funcName, arity, info, encLang, g) +
+                                        constTagForId(methodMap, funcName, arity, info, g);
+                            }
+                        }
+                    }
+                }
+                const arityTag = arity !== undefined ? `#${arity}${encTypeTag}` : '';
+                const result = generateId(finalLabel, `${filePath}:${qualifiedName}${arityTag}`);
                 functionIdCache.set(node, result);
                 return result;
             }
@@ -215,7 +333,41 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
                     if (override !== null)
                         finalLabel = override;
                 }
-                const result = generateId(finalLabel, `${filePath}:${customResult.funcName}`);
+                // Qualify custom result with enclosing class
+                const classInfo = cachedFindEnclosingClassInfo(current.previousSibling ?? current, filePath, provider.resolveEnclosingOwner);
+                const qualifiedName = classInfo
+                    ? `${classInfo.className}.${customResult.funcName}`
+                    : customResult.funcName;
+                // Include #<arity> suffix to match definition-phase Method/Constructor IDs.
+                // When same-arity collisions exist, also append ~type1,type2.
+                const sigNode = current.previousSibling ?? current;
+                let arity2;
+                let encTypeTag2 = '';
+                if (finalLabel === 'Method' || finalLabel === 'Constructor') {
+                    const encLang2 = getLanguageFromFilename(filePath);
+                    const classNode2 = findEnclosingClassNode(sigNode) ?? findClassNodeByQualifiedName(sigNode);
+                    if (classNode2 && encLang2) {
+                        const methodMap2 = getMethodInfo(classNode2, provider, {
+                            filePath,
+                            language: encLang2,
+                        });
+                        const defLine2 = sigNode.startPosition.row + 1;
+                        const info2 = methodMap2?.get(`${customResult.funcName}:${defLine2}`);
+                        if (info2) {
+                            arity2 = info2.parameters.some((p) => p.isVariadic)
+                                ? undefined
+                                : info2.parameters.length;
+                            if (methodMap2 && arity2 !== undefined) {
+                                const g2 = buildCollisionGroups(methodMap2);
+                                encTypeTag2 =
+                                    typeTagForId(methodMap2, customResult.funcName, arity2, info2, encLang2, g2) +
+                                        constTagForId(methodMap2, customResult.funcName, arity2, info2, g2);
+                            }
+                        }
+                    }
+                }
+                const arityTag2 = arity2 !== undefined ? `#${arity2}${encTypeTag2}` : '';
+                const result = generateId(finalLabel, `${filePath}:${qualifiedName}${arityTag2}`);
                 functionIdCache.set(node, result);
                 return result;
             }
@@ -225,12 +377,12 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
     functionIdCache.set(node, null);
     return null;
 };
-/** Cached wrapper for findEnclosingClassId — avoids repeated parent walks. */
-const cachedFindEnclosingClassId = (node, filePath) => {
+/** Cached wrapper for findEnclosingClassInfo — avoids repeated parent walks. */
+const cachedFindEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) => {
     const cached = classIdCache.get(node);
     if (cached !== undefined)
         return cached;
-    const result = findEnclosingClassId(node, filePath);
+    const result = findEnclosingClassInfo(node, filePath, resolveEnclosingOwner);
     classIdCache.set(node, result);
     return result;
 };
@@ -263,7 +415,7 @@ const processBatch = (files, onProgress) => {
         toolDefs: [],
         ormQueries: [],
         constructorBindings: [],
-        typeEnvBindings: [],
+        fileScopeBindings: [],
         skippedLanguages: {},
         fileCount: 0,
     };
@@ -311,7 +463,10 @@ const processBatch = (files, onProgress) => {
             }
         }
         else {
-            regularFiles.push(...langFiles);
+            // Manual loop (not spread) — `push(...arr)` blows the stack on very
+            // large arrays when langFiles has tens of thousands of entries.
+            for (const f of langFiles)
+                regularFiles.push(f);
         }
         // Process regular files for this language
         if (regularFiles.length > 0) {
@@ -375,6 +530,27 @@ const EXPRESS_ROUTE_METHODS = new Set([
 // the express_route handler as route definitions, not consumers. The fetch() global
 // function is captured separately by the route.fetch query.
 const HTTP_CLIENT_ONLY_METHODS = new Set(['head', 'options', 'request', 'ajax']);
+// Known HTTP client receivers u2014 skip these, they're API consumers not routes
+const HTTP_CLIENT_RECEIVERS = new Set([
+    'axios',
+    'request',
+    'fetch',
+    'http',
+    'https',
+    'got',
+    'ky',
+    'superagent',
+    'needle',
+    'undici',
+    'apiclient',
+    'client',
+    'httpclient',
+    'api',
+    '$http',
+    'session',
+    'httpservice',
+    'conn',
+]);
 // Decorator names that indicate HTTP route handlers (NestJS, Flask, FastAPI, Spring)
 const ROUTE_DECORATOR_NAMES = new Set([
     'Get',
@@ -684,24 +860,28 @@ function extractLaravelRoutes(tree, filePath) {
             });
         }
     }
-    function walk(node, groupStack) {
+    const walkStack = [{ node: tree.rootNode, groupSnapshot: [] }];
+    while (walkStack.length > 0) {
+        const { node, groupSnapshot } = walkStack.pop();
         // Case 1: Simple Route::get(...), Route::post(...), etc.
         if (isRouteStaticCall(node)) {
             const method = getCallMethodName(node);
             if (method && (ROUTE_HTTP_METHODS.has(method) || ROUTE_RESOURCE_METHODS.has(method))) {
-                emitRoute(method, getArguments(node), node.startPosition.row, groupStack, []);
-                return;
+                emitRoute(method, getArguments(node), node.startPosition.row, groupSnapshot, []);
+                continue;
             }
             if (method === 'group') {
                 const argsNode = getArguments(node);
                 const groupCtx = parseArrayGroupArgs(argsNode);
                 const body = findClosureBody(argsNode);
                 if (body) {
-                    groupStack.push(groupCtx);
-                    walkChildren(body, groupStack);
-                    groupStack.pop();
+                    const childSnapshot = [...groupSnapshot, groupCtx];
+                    const children = body.children ?? [];
+                    for (let i = children.length - 1; i >= 0; i--) {
+                        walkStack.push({ node: children[i], groupSnapshot: childSnapshot });
+                    }
                 }
-                return;
+                continue;
             }
         }
         // Case 2: Fluent chain — Route::middleware(...)->group(...) or Route::middleware(...)->get(...)
@@ -719,27 +899,26 @@ function extractLaravelRoutes(tree, filePath) {
                 }
                 const body = findClosureBody(chain.terminalArgs);
                 if (body) {
-                    groupStack.push(groupCtx);
-                    walkChildren(body, groupStack);
-                    groupStack.pop();
+                    const childSnapshot = [...groupSnapshot, groupCtx];
+                    const children = body.children ?? [];
+                    for (let i = children.length - 1; i >= 0; i--) {
+                        walkStack.push({ node: children[i], groupSnapshot: childSnapshot });
+                    }
                 }
-                return;
+                continue;
             }
             if (ROUTE_HTTP_METHODS.has(chain.terminalMethod) ||
                 ROUTE_RESOURCE_METHODS.has(chain.terminalMethod)) {
-                emitRoute(chain.terminalMethod, chain.terminalArgs, node.startPosition.row, groupStack, chain.attributes);
-                return;
+                emitRoute(chain.terminalMethod, chain.terminalArgs, node.startPosition.row, groupSnapshot, chain.attributes);
+                continue;
             }
         }
-        // Default: recurse into children
-        walkChildren(node, groupStack);
-    }
-    function walkChildren(node, groupStack) {
-        for (const child of node.children ?? []) {
-            walk(child, groupStack);
+        // Default: push children in reverse so leftmost is processed first
+        const children = node.children ?? [];
+        for (let i = children.length - 1; i >= 0; i--) {
+            walkStack.push({ node: children[i], groupSnapshot });
         }
     }
-    walk(tree.rootNode, []);
     return routes;
 }
 // ============================================================================
@@ -806,11 +985,23 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // Skip files larger than the max tree-sitter buffer (32 MB)
         if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
+        // Vue SFC preprocessing: extract <script> block content
+        let parseContent = file.content;
+        let lineOffset = 0;
+        let isVueSetup = false;
+        if (language === SupportedLanguages.Vue) {
+            const extracted = extractVueScript(file.content);
+            if (!extracted)
+                continue; // skip .vue files with no script block
+            parseContent = extracted.scriptContent;
+            lineOffset = extracted.lineOffset;
+            isVueSetup = extracted.isSetup;
+        }
         clearCaches(); // Reset memoization before each new file
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, {
-                bufferSize: getTreeSitterBufferSize(file.content.length),
+            tree = parser.parse(parseContent, undefined, {
+                bufferSize: getTreeSitterBufferSize(parseContent.length),
             });
         }
         catch (err) {
@@ -861,6 +1052,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         const typeEnv = buildTypeEnv(tree, language, {
             parentMap,
             enclosingFunctionFinder: provider?.enclosingFunctionFinder,
+            extractFunctionName: provider?.methodExtractor?.extractFunctionName,
         });
         const callRouter = provider.callRouter;
         if (typeEnv.constructorBindings.length > 0) {
@@ -869,15 +1061,23 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 bindings: [...typeEnv.constructorBindings],
             });
         }
-        // Extract file-scope bindings for ExportedTypeMap (closes worker/sequential quality gap).
-        // Sequential path uses collectExportedBindings(typeEnv) directly; worker path serializes
-        // these bindings so the main thread can merge them into ExportedTypeMap.
+        // Serialize file-scope bindings for BindingAccumulator. These feed the
+        // ExportedTypeMap enrichment loop in pipeline.ts — the only current
+        // consumer of worker-path binding data.
+        //
+        // Historical note: we previously serialized all scopes
+        // (`typeEnv.allScopes()`), which pushed ~4.9 MB of function-scope
+        // bindings across the IPC boundary on every worker batch with zero
+        // downstream readers. Narrowing to `fileScope()` recovers that cost.
+        // See the `FileScopeBindings` JSDoc above for the Phase 9 reversion
+        // path when a function-scope consumer lands.
         const fileScope = typeEnv.fileScope();
         if (fileScope.size > 0) {
-            const bindings = [];
-            for (const [name, type] of fileScope)
-                bindings.push([name, type]);
-            result.typeEnvBindings.push({ filePath: file.path, bindings });
+            const scopeBindings = [];
+            for (const [varName, typeName] of fileScope) {
+                scopeBindings.push([varName, typeName]);
+            }
+            result.fileScopeBindings.push({ filePath: file.path, bindings: scopeBindings });
         }
         // Per-file map: decorator end-line → decorator info, for associating with definitions
         const fileDecorators = new Map();
@@ -946,7 +1146,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         routePath,
                         httpMethod,
                         decoratorName,
-                        lineNumber: decoratorNode.startPosition.row,
+                        lineNumber: decoratorNode.startPosition.row + lineOffset,
                     });
                 }
                 // MCP/RPC tool detection: @mcp.tool(), @app.tool(), @server.tool()
@@ -967,7 +1167,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     result.fetchCalls.push({
                         filePath: file.path,
                         fetchURL: urlNode.text,
-                        lineNumber: captureMap['route.fetch'].startPosition.row,
+                        lineNumber: captureMap['route.fetch'].startPosition.row + lineOffset,
                     });
                 }
                 continue;
@@ -982,7 +1182,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     result.fetchCalls.push({
                         filePath: file.path,
                         fetchURL: url,
-                        lineNumber: captureMap['http_client'].startPosition.row,
+                        lineNumber: captureMap['http_client'].startPosition.row + lineOffset,
                     });
                 }
                 continue;
@@ -994,6 +1194,45 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 const method = captureMap['express_route.method'].text;
                 const routePath = captureMap['express_route.path'].text;
                 if (EXPRESS_ROUTE_METHODS.has(method) && routePath.startsWith('/')) {
+                    // Extract the receiver (the object the method is called on) to filter out
+                    // HTTP client calls like axios.get('/api/users') that match the same pattern
+                    // as Express route registrations.
+                    const callNode = captureMap['express_route'];
+                    const funcNode = callNode.childForFieldName?.('function') ?? callNode.children?.[0];
+                    // Walk through nested member_expressions and call_expressions to
+                    // reach the innermost receiver identifier.  Handles chains like:
+                    //   this.httpService.get('/path')   -> member chain    -> 'httpservice'
+                    //   getClient().get('/path')         -> call_expression -> 'getclient'
+                    //   axios.get('/path')               -> bare identifier -> 'axios'
+                    let receiverNode = funcNode?.childForFieldName?.('object') ?? funcNode?.children?.[0];
+                    while (receiverNode?.type === 'member_expression' ||
+                        receiverNode?.type === 'call_expression') {
+                        if (receiverNode.type === 'member_expression') {
+                            // Drill into the property (rightmost part) of the member expression
+                            const propNode = receiverNode.childForFieldName?.('property');
+                            if (propNode) {
+                                receiverNode = propNode;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        else {
+                            // call_expression: unwrap to the function being called
+                            const innerFunc = receiverNode.childForFieldName?.('function') ?? receiverNode.children?.[0];
+                            if (innerFunc && innerFunc !== receiverNode) {
+                                receiverNode = innerFunc;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                    }
+                    const receiverText = receiverNode?.text?.toLowerCase() ?? '';
+                    if (HTTP_CLIENT_RECEIVERS.has(receiverText)) {
+                        // This is an HTTP client call, not a route definition u2014 skip it
+                        continue;
+                    }
                     const httpMethod = method === 'all' || method === 'use' || method === 'route'
                         ? 'GET'
                         : method.toUpperCase();
@@ -1002,7 +1241,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         routePath,
                         httpMethod,
                         decoratorName: `express.${method}`,
-                        lineNumber: captureMap['express_route'].startPosition.row,
+                        lineNumber: captureMap['express_route'].startPosition.row + lineOffset,
                     });
                 }
                 continue;
@@ -1069,7 +1308,8 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                             continue;
                         }
                         if (routed.kind === 'properties') {
-                            const propEnclosingClassId = cachedFindEnclosingClassId(captureMap['call'], file.path);
+                            const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
+                            const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
                             // Enrich routed properties with FieldExtractor metadata
                             let routedFieldMap;
                             if (provider.fieldExtractor && typeEnv) {
@@ -1085,7 +1325,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                             }
                             for (const item of routed.items) {
                                 const routedFieldInfo = routedFieldMap?.get(item.propName);
-                                const nodeId = generateId('Property', `${file.path}:${item.propName}`);
+                                const propQualifiedName = propEnclosingInfo
+                                    ? `${propEnclosingInfo.className}.${item.propName}`
+                                    : item.propName;
+                                const nodeId = generateId('Property', `${file.path}:${propQualifiedName}`);
                                 result.nodes.push({
                                     id: nodeId,
                                     label: 'Property',
@@ -1250,25 +1493,119 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     continue;
                 }
             }
-            const nodeLabel = getLabelFromCaptures(captureMap, provider);
-            if (!nodeLabel)
+            const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+            const defaultNodeLabel = getLabelFromCaptures(captureMap, provider);
+            if (!defaultNodeLabel)
                 continue;
             const nameNode = captureMap['name'];
+            const extractedClassSymbol = definitionNode && provider.classExtractor?.isTypeDeclaration(definitionNode)
+                ? provider.classExtractor.extract(definitionNode, {
+                    name: nameNode?.text,
+                    type: defaultNodeLabel,
+                })
+                : null;
+            const nodeLabel = extractedClassSymbol?.type ?? defaultNodeLabel;
             // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
-            if (!nameNode && nodeLabel !== 'Constructor')
+            if (!nameNode && nodeLabel !== 'Constructor' && !extractedClassSymbol)
                 continue;
-            const nodeName = nameNode ? nameNode.text : 'init';
-            const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+            const nodeName = extractedClassSymbol?.name ?? (nameNode ? nameNode.text : 'init');
             const startLine = definitionNode
-                ? definitionNode.startPosition.row
+                ? definitionNode.startPosition.row + lineOffset
                 : nameNode
-                    ? nameNode.startPosition.row
-                    : 0;
-            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
+                    ? nameNode.startPosition.row + lineOffset
+                    : lineOffset;
+            // Compute enclosing class BEFORE node ID — needed to qualify method IDs
+            const needsOwner = nodeLabel === 'Method' ||
+                nodeLabel === 'Constructor' ||
+                nodeLabel === 'Property' ||
+                nodeLabel === 'Function';
+            const enclosingClassInfo = needsOwner
+                ? cachedFindEnclosingClassInfo(nameNode || definitionNode, file.path, provider.resolveEnclosingOwner)
+                : null;
+            const enclosingClassId = enclosingClassInfo?.classId ?? null;
+            // Qualify method/property IDs with enclosing class name to avoid collisions
+            const qualifiedName = enclosingClassInfo
+                ? `${enclosingClassInfo.className}.${nodeName}`
+                : nodeName;
+            // Extract method metadata BEFORE generating node ID — parameterCount is needed
+            // to disambiguate overloaded methods via #<arity> suffix in the ID.
+            let declaredType;
+            let methodProps = {};
+            let arityForId; // raw param count for ID, even for variadic
+            let defMethodMap;
+            let defMethodInfo;
+            if (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor') {
+                // Use MethodExtractor for method metadata — provides parameterCount, parameterTypes,
+                // returnType, isAbstract/isFinal/annotations, visibility, and more.
+                let enrichedByMethodExtractor = false;
+                if (provider.methodExtractor && definitionNode) {
+                    const classNode = findEnclosingClassNode(definitionNode) ?? findClassNodeByQualifiedName(definitionNode);
+                    if (classNode) {
+                        const methodMap = getMethodInfo(classNode, provider, {
+                            filePath: file.path,
+                            language,
+                        });
+                        const defLine = definitionNode.startPosition.row + 1;
+                        const info = methodMap?.get(`${nodeName}:${defLine}`);
+                        if (info) {
+                            enrichedByMethodExtractor = true;
+                            arityForId = arityForIdFromInfo(info);
+                            methodProps = buildMethodProps(info);
+                            defMethodMap = methodMap;
+                            defMethodInfo = info;
+                        }
+                    }
+                }
+                // For top-level methods (e.g. Go method_declaration), try extractFromNode
+                if (!enrichedByMethodExtractor &&
+                    provider.methodExtractor?.extractFromNode &&
+                    definitionNode) {
+                    const info = provider.methodExtractor.extractFromNode(definitionNode, {
+                        filePath: file.path,
+                        language,
+                    });
+                    if (info) {
+                        enrichedByMethodExtractor = true;
+                        arityForId = arityForIdFromInfo(info);
+                        methodProps = buildMethodProps(info);
+                    }
+                }
+            }
+            // Append #<paramCount> to Method/Constructor IDs to disambiguate overloads.
+            // Functions are not suffixed — they don't overload by name in the same scope.
+            // When same-arity collisions exist, append ~type1,type2 for further disambiguation.
+            const needsAritySuffix = nodeLabel === 'Method' || nodeLabel === 'Constructor';
+            let arityTag = needsAritySuffix && arityForId !== undefined ? `#${arityForId}` : '';
+            if (arityTag && defMethodMap && defMethodInfo) {
+                const groups = buildCollisionGroups(defMethodMap);
+                arityTag += typeTagForId(defMethodMap, nodeName, arityForId, defMethodInfo, language, groups);
+                arityTag += constTagForId(defMethodMap, nodeName, arityForId, defMethodInfo, groups);
+            }
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${arityTag}`);
+            const classNodeForSymbol = definitionNode || nameNode;
+            const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
+                (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
+                    ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
+                    : undefined);
             const description = provider.descriptionExtractor?.(nodeLabel, nodeName, captureMap);
             let frameworkHint = definitionNode
                 ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
                 : null;
+            // Suppress Spring framework hint for methods inside interfaces
+            // (Feign clients, JAX-RS proxies are consumers, not providers)
+            if (frameworkHint && definitionNode) {
+                let classCheck = definitionNode.parent;
+                while (classCheck) {
+                    if (classCheck.type === 'interface_declaration') {
+                        frameworkHint = null;
+                        break;
+                    }
+                    if (classCheck.type === 'class_declaration' || classCheck.type === 'program') {
+                        break;
+                    }
+                    classCheck = classCheck.parent;
+                }
+            }
             // Decorators appear on lines immediately before their definition; allow up to
             // MAX_DECORATOR_SCAN_LINES gap for blank lines / multi-line decorator stacks.
             const MAX_DECORATOR_SCAN_LINES = 5;
@@ -1291,94 +1628,15 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                 filePath: file.path,
                                 toolName: nodeName,
                                 description: dec.arg || '',
-                                lineNumber: definitionNode.startPosition.row,
+                                lineNumber: definitionNode.startPosition.row + lineOffset,
                             });
                         }
                         fileDecorators.delete(checkLine);
                     }
                 }
             }
-            let parameterCount;
-            let requiredParameterCount;
-            let parameterTypes;
-            let returnType;
-            let declaredType;
-            let visibility;
-            let isStatic;
-            let isReadonly;
-            let isAbstract;
-            let isFinal;
-            let isVirtual;
-            let isOverride;
-            let isAsync;
-            let isPartial;
-            let annotations;
-            if (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor') {
-                // Try MethodExtractor first — it provides everything extractMethodSignature does, plus
-                // isAbstract/isFinal/annotations. Only fall back to extractMethodSignature when no
-                // MethodExtractor is available or the method isn't inside a class body.
-                let enrichedByMethodExtractor = false;
-                if (provider.methodExtractor && definitionNode) {
-                    const classNode = findEnclosingClassNode(definitionNode);
-                    if (classNode) {
-                        const methodMap = getMethodInfo(classNode, provider, {
-                            filePath: file.path,
-                            language,
-                        });
-                        const defLine = definitionNode.startPosition.row + 1;
-                        const info = methodMap?.get(`${nodeName}:${defLine}`);
-                        if (info) {
-                            enrichedByMethodExtractor = true;
-                            parameterCount = info.parameters.length;
-                            const types = [];
-                            let optionalCount = 0;
-                            for (const p of info.parameters) {
-                                if (p.type !== null)
-                                    types.push(p.type);
-                                if (p.isOptional)
-                                    optionalCount++;
-                            }
-                            parameterTypes = types.length > 0 ? types : undefined;
-                            requiredParameterCount =
-                                optionalCount > 0 ? parameterCount - optionalCount : undefined;
-                            returnType = info.returnType ?? undefined;
-                            visibility = info.visibility;
-                            isStatic = info.isStatic;
-                            isAbstract = info.isAbstract;
-                            isFinal = info.isFinal;
-                            if (info.isVirtual)
-                                isVirtual = info.isVirtual;
-                            if (info.isOverride)
-                                isOverride = info.isOverride;
-                            if (info.isAsync)
-                                isAsync = info.isAsync;
-                            if (info.isPartial)
-                                isPartial = info.isPartial;
-                            if (info.annotations.length > 0)
-                                annotations = info.annotations;
-                        }
-                    }
-                }
-                if (!enrichedByMethodExtractor) {
-                    const sig = extractMethodSignature(definitionNode);
-                    parameterCount = sig.parameterCount;
-                    requiredParameterCount = sig.requiredParameterCount;
-                    parameterTypes = sig.parameterTypes;
-                    returnType = sig.returnType;
-                }
-                // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
-                // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
-                if ((!returnType || returnType === 'array' || returnType === 'iterable') &&
-                    definitionNode) {
-                    const tc = provider.typeConfig;
-                    if (tc?.extractReturnType) {
-                        const docReturn = tc.extractReturnType(definitionNode);
-                        if (docReturn)
-                            returnType = docReturn;
-                    }
-                }
-            }
-            else if (nodeLabel === 'Property' && definitionNode) {
+            // Property metadata extraction (not needed before nodeId — Properties don't overload)
+            if (nodeLabel === 'Property' && definitionNode) {
                 // FieldExtractor is the single source of truth when available
                 if (provider.fieldExtractor && typeEnv) {
                     const classNode = findEnclosingClassNode(definitionNode);
@@ -1392,9 +1650,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         const info = fieldMap?.get(nodeName);
                         if (info) {
                             declaredType = info.type ?? undefined;
-                            visibility = info.visibility;
-                            isStatic = info.isStatic;
-                            isReadonly = info.isReadonly;
+                            methodProps.visibility = info.visibility;
+                            methodProps.isStatic = info.isStatic;
+                            methodProps.isReadonly = info.isReadonly;
                         }
                     }
                 }
@@ -1405,10 +1663,13 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 properties: {
                     name: nodeName,
                     filePath: file.path,
-                    startLine: definitionNode ? definitionNode.startPosition.row : startLine,
-                    endLine: definitionNode ? definitionNode.endPosition.row : startLine,
+                    startLine: definitionNode ? definitionNode.startPosition.row + lineOffset : startLine,
+                    endLine: definitionNode ? definitionNode.endPosition.row + lineOffset : startLine,
                     language: language,
-                    isExported: cachedExportCheck(provider.exportChecker, nameNode || definitionNode, nodeName),
+                    isExported: language === SupportedLanguages.Vue && isVueSetup
+                        ? isVueSetupTopLevel(nameNode || definitionNode)
+                        : cachedExportCheck(provider.exportChecker, nameNode || definitionNode, nodeName),
+                    ...(qualifiedTypeName !== undefined ? { qualifiedName: qualifiedTypeName } : {}),
                     ...(frameworkHint
                         ? {
                             astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
@@ -1416,53 +1677,41 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         }
                         : {}),
                     ...(description !== undefined ? { description } : {}),
-                    ...(parameterCount !== undefined ? { parameterCount } : {}),
-                    ...(requiredParameterCount !== undefined ? { requiredParameterCount } : {}),
-                    ...(parameterTypes !== undefined ? { parameterTypes } : {}),
-                    ...(returnType !== undefined ? { returnType } : {}),
+                    ...methodProps,
                     ...(declaredType !== undefined ? { declaredType } : {}),
-                    ...(visibility !== undefined ? { visibility } : {}),
-                    ...(isStatic !== undefined ? { isStatic } : {}),
-                    ...(isReadonly !== undefined ? { isReadonly } : {}),
-                    ...(isAbstract !== undefined ? { isAbstract } : {}),
-                    ...(isFinal !== undefined ? { isFinal } : {}),
-                    ...(isVirtual !== undefined ? { isVirtual } : {}),
-                    ...(isOverride !== undefined ? { isOverride } : {}),
-                    ...(isAsync !== undefined ? { isAsync } : {}),
-                    ...(isPartial !== undefined ? { isPartial } : {}),
-                    ...(annotations !== undefined ? { annotations } : {}),
                 },
             });
-            // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD
-            // Function is included because Kotlin/Rust/Python capture class methods as Function nodes
-            const needsOwner = nodeLabel === 'Method' ||
-                nodeLabel === 'Constructor' ||
-                nodeLabel === 'Property' ||
-                nodeLabel === 'Function';
-            const enclosingClassId = needsOwner
-                ? cachedFindEnclosingClassId(nameNode || definitionNode, file.path)
-                : null;
+            // enclosingClassId already computed above (before nodeId generation)
             result.symbols.push({
                 filePath: file.path,
                 name: nodeName,
                 nodeId,
                 type: nodeLabel,
-                ...(parameterCount !== undefined ? { parameterCount } : {}),
-                ...(requiredParameterCount !== undefined ? { requiredParameterCount } : {}),
-                ...(parameterTypes !== undefined ? { parameterTypes } : {}),
-                ...(returnType !== undefined ? { returnType } : {}),
+                ...(qualifiedTypeName !== undefined ? { qualifiedName: qualifiedTypeName } : {}),
+                parameterCount: methodProps.parameterCount,
+                requiredParameterCount: methodProps.requiredParameterCount,
+                parameterTypes: methodProps.parameterTypes,
+                returnType: methodProps.returnType,
                 ...(declaredType !== undefined ? { declaredType } : {}),
                 ...(enclosingClassId ? { ownerId: enclosingClassId } : {}),
-                ...(visibility !== undefined ? { visibility } : {}),
-                ...(isStatic !== undefined ? { isStatic } : {}),
-                ...(isReadonly !== undefined ? { isReadonly } : {}),
-                ...(isAbstract !== undefined ? { isAbstract } : {}),
-                ...(isFinal !== undefined ? { isFinal } : {}),
-                ...(isVirtual !== undefined ? { isVirtual } : {}),
-                ...(isOverride !== undefined ? { isOverride } : {}),
-                ...(isAsync !== undefined ? { isAsync } : {}),
-                ...(isPartial !== undefined ? { isPartial } : {}),
-                ...(annotations !== undefined ? { annotations } : {}),
+                visibility: methodProps.visibility,
+                isStatic: methodProps.isStatic,
+                isReadonly: methodProps.isReadonly,
+                isAbstract: methodProps.isAbstract,
+                isFinal: methodProps.isFinal,
+                ...(methodProps.isVirtual !== undefined
+                    ? { isVirtual: methodProps.isVirtual }
+                    : {}),
+                ...(methodProps.isOverride !== undefined
+                    ? { isOverride: methodProps.isOverride }
+                    : {}),
+                ...(methodProps.isAsync !== undefined ? { isAsync: methodProps.isAsync } : {}),
+                ...(methodProps.isPartial !== undefined
+                    ? { isPartial: methodProps.isPartial }
+                    : {}),
+                ...(methodProps.annotations !== undefined
+                    ? { annotations: methodProps.annotations }
+                    : {}),
             });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
@@ -1490,10 +1739,23 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // Extract framework routes via provider detection (e.g., Laravel routes.php)
         if (provider.isRouteFile?.(file.path)) {
             const extractedRoutes = extractLaravelRoutes(tree, file.path);
-            result.routes.push(...extractedRoutes);
+            for (const r of extractedRoutes)
+                result.routes.push(r);
         }
         // Extract ORM queries (Prisma, Supabase)
-        extractORMQueries(file.path, file.content, result.ormQueries);
+        extractORMQueries(file.path, parseContent, result.ormQueries);
+        // Vue: emit CALLS edges for components used in <template>
+        if (language === SupportedLanguages.Vue) {
+            const templateComponents = extractTemplateComponents(file.content);
+            for (const componentName of templateComponents) {
+                result.calls.push({
+                    filePath: file.path,
+                    calledName: componentName,
+                    sourceId: generateId('File', file.path),
+                    callForm: 'free',
+                });
+            }
+        }
     }
 };
 // ============================================================================
@@ -1514,26 +1776,33 @@ let accumulated = {
     toolDefs: [],
     ormQueries: [],
     constructorBindings: [],
-    typeEnvBindings: [],
+    fileScopeBindings: [],
     skippedLanguages: {},
     fileCount: 0,
 };
 let cumulativeProcessed = 0;
+// Use a loop instead of push(...spread) to avoid hitting V8's argument limit
+// when merging large result sets (push(...arr) calls apply() under the hood
+// and blows the stack when arr has >~65k elements).
+const appendAll = (target, src) => {
+    for (let i = 0; i < src.length; i++)
+        target.push(src[i]);
+};
 const mergeResult = (target, src) => {
-    target.nodes.push(...src.nodes);
-    target.relationships.push(...src.relationships);
-    target.symbols.push(...src.symbols);
-    target.imports.push(...src.imports);
-    target.calls.push(...src.calls);
-    target.assignments.push(...src.assignments);
-    target.heritage.push(...src.heritage);
-    target.routes.push(...src.routes);
-    target.fetchCalls.push(...src.fetchCalls);
-    target.decoratorRoutes.push(...src.decoratorRoutes);
-    target.toolDefs.push(...src.toolDefs);
-    target.ormQueries.push(...src.ormQueries);
-    target.constructorBindings.push(...src.constructorBindings);
-    target.typeEnvBindings.push(...src.typeEnvBindings);
+    appendAll(target.nodes, src.nodes);
+    appendAll(target.relationships, src.relationships);
+    appendAll(target.symbols, src.symbols);
+    appendAll(target.imports, src.imports);
+    appendAll(target.calls, src.calls);
+    appendAll(target.assignments, src.assignments);
+    appendAll(target.heritage, src.heritage);
+    appendAll(target.routes, src.routes);
+    appendAll(target.fetchCalls, src.fetchCalls);
+    appendAll(target.decoratorRoutes, src.decoratorRoutes);
+    appendAll(target.toolDefs, src.toolDefs);
+    appendAll(target.ormQueries, src.ormQueries);
+    appendAll(target.constructorBindings, src.constructorBindings);
+    appendAll(target.fileScopeBindings, src.fileScopeBindings);
     for (const [lang, count] of Object.entries(src.skippedLanguages)) {
         target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
     }
@@ -1581,7 +1850,7 @@ parentPort.on('message', (msg) => {
                 toolDefs: [],
                 ormQueries: [],
                 constructorBindings: [],
-                typeEnvBindings: [],
+                fileScopeBindings: [],
                 skippedLanguages: {},
                 fileCount: 0,
             };