gitnexus 1.4.8 → 1.4.10

package/dist/core/graph/types.d.ts

@@ -1,4 +1,4 @@
-export type NodeLabel = 'Project' | 'Package' | 'Module' | 'Folder' | 'File' | 'Class' | 'Function' | 'Method' | 'Variable' | 'Interface' | 'Enum' | 'Decorator' | 'Import' | 'Type' | 'CodeElement' | 'Community' | 'Process' | 'Struct' | 'Macro' | 'Typedef' | 'Union' | 'Namespace' | 'Trait' | 'Impl' | 'TypeAlias' | 'Const' | 'Static' | 'Property' | 'Record' | 'Delegate' | 'Annotation' | 'Constructor' | 'Template' | 'Section';
+export type NodeLabel = 'Project' | 'Package' | 'Module' | 'Folder' | 'File' | 'Class' | 'Function' | 'Method' | 'Variable' | 'Interface' | 'Enum' | 'Decorator' | 'Import' | 'Type' | 'CodeElement' | 'Community' | 'Process' | 'Struct' | 'Macro' | 'Typedef' | 'Union' | 'Namespace' | 'Trait' | 'Impl' | 'TypeAlias' | 'Const' | 'Static' | 'Property' | 'Record' | 'Delegate' | 'Annotation' | 'Constructor' | 'Template' | 'Section' | 'Route' | 'Tool';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 export type NodeProperties = {
     name: string;
@@ -25,8 +25,15 @@ export type NodeProperties = {
     parameterCount?: number;
     level?: number;
     returnType?: string;
+    declaredType?: string;
+    visibility?: string;
+    isStatic?: boolean;
+    isReadonly?: boolean;
+    responseKeys?: string[];
+    errorKeys?: string[];
+    middleware?: string[];
 };
-export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'HAS_METHOD' | 'HAS_PROPERTY' | 'ACCESSES' | 'MEMBER_OF' | 'STEP_IN_PROCESS';
+export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'HAS_METHOD' | 'HAS_PROPERTY' | 'ACCESSES' | 'MEMBER_OF' | 'STEP_IN_PROCESS' | 'HANDLES_ROUTE' | 'FETCHES' | 'HANDLES_TOOL' | 'ENTRY_POINT_OF' | 'WRAPS' | 'QUERIES';
 export interface GraphNode {
     id: string;
     label: NodeLabel;
@@ -64,4 +71,5 @@ export interface KnowledgeGraph {
     addRelationship: (relationship: GraphRelationship) => void;
     removeNode: (nodeId: string) => boolean;
     removeNodesByFile: (filePath: string) => number;
+    removeRelationship: (relationshipId: string) => boolean;
 }

package/dist/core/ingestion/call-processor.d.ts

@@ -2,7 +2,7 @@ import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
 import type { SymbolTable } from './symbol-table.js';
 import type { ResolutionContext } from './resolution-context.js';
-import type { ExtractedCall, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
+import type { ExtractedCall, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, ExtractedFetchCall, FileConstructorBindings } from './workers/parse-worker.js';
 /** Per-file resolved type bindings for exported symbols.
  *  Populated during call processing, consumed by Phase 14 re-resolution pass. */
 export type ExportedTypeMap = Map<string, Map<string, string>>;
@@ -68,3 +68,20 @@ export declare const processAssignmentsFromExtracted: (graph: KnowledgeGraph, as
  * Resolve pre-extracted Laravel routes to CALLS edges from route files to controller methods.
  */
 export declare const processRoutesFromExtracted: (graph: KnowledgeGraph, extractedRoutes: ExtractedRoute[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
+export declare const extractConsumerAccessedKeys: (content: string) => string[];
+/**
+ * Create FETCHES edges from extracted fetch() calls to matching Route nodes.
+ * When consumerContents is provided, extracts property access patterns from
+ * consumer files and encodes them in the edge reason field.
+ */
+export declare const processNextjsFetchRoutes: (graph: KnowledgeGraph, fetchCalls: ExtractedFetchCall[], routeRegistry: Map<string, string>, // routeURL → handlerFilePath
+consumerContents?: Map<string, string>) => void;
+/**
+ * Extract fetch() calls from source files (sequential path).
+ * Workers handle this via tree-sitter captures in parse-worker; this function
+ * provides the same extraction for the sequential fallback path.
+ */
+export declare const extractFetchCallsFromFiles: (files: {
+    path: string;
+    content: string;
+}[], astCache: ASTCache) => Promise<ExtractedFetchCall[]>;

package/dist/core/ingestion/call-processor.js

@@ -1,14 +1,17 @@
 import Parser from 'tree-sitter';
 import { TIER_CONFIDENCE } from './resolution-context.js';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
-import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
+import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, findEnclosingClassId, extractMixedChain, } from './utils.js';
+import { getLanguageFromFilename } from './utils/language-detection.js';
+import { isVerboseIngestionEnabled } from './utils/verbose.js';
+import { yieldToEventLoop } from './utils/event-loop.js';
+import { FUNCTION_NODE_TYPES, extractFunctionName, findEnclosingClassId } from './utils/ast-helpers.js';
+import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, } from './utils/call-analysis.js';
 import { buildTypeEnv, isSubclassOf } from './type-env.js';
 import { getTreeSitterBufferSize } from './constants.js';
-import { callRouters } from './call-routing.js';
+import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
-import { typeConfigs } from './type-extractors/index.js';
 const MAX_EXPORTS_PER_FILE = 500;
 const MAX_TYPE_NAME_LENGTH = 256;
 /** Build a map of imported callee names → return types for cross-file call-result binding.
@@ -48,7 +51,7 @@ export function buildImportedRawReturnTypes(filePath, namedImportMap, symbolTabl
 /** Collect resolved type bindings for exported file-scope symbols.
  *  Uses graph node isExported flag — does NOT require isExported on SymbolDefinition. */
 function collectExportedBindings(typeEnv, filePath, symbolTable, graph) {
-    const fileScope = typeEnv.env.get('');
+    const fileScope = typeEnv.fileScope();
     if (!fileScope || fileScope.size === 0)
         return null;
     const exported = new Map();
@@ -147,7 +150,7 @@ const TYPE_PRESERVING_METHODS = new Set([
  * Walk up the AST from a node to find the enclosing function/method.
  * Returns null if the call is at module/file level (top-level code).
  */
-const findEnclosingFunction = (node, filePath, ctx) => {
+const findEnclosingFunction = (node, filePath, ctx, provider) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
@@ -157,7 +160,33 @@ const findEnclosingFunction = (node, filePath, ctx) => {
                 if (resolved?.tier === 'same-file' && resolved.candidates.length > 0) {
                     return resolved.candidates[0].nodeId;
                 }
-                return generateId(label, `${filePath}:${funcName}`);
+                // Apply labelOverride so label matches the definition phase (single source of truth).
+                let finalLabel = label;
+                if (provider.labelOverride) {
+                    const override = provider.labelOverride(current, label);
+                    if (override !== null)
+                        finalLabel = override;
+                }
+                return generateId(finalLabel, `${filePath}:${funcName}`);
+            }
+        }
+        // Language-specific enclosing function resolution (e.g., Dart where
+        // function_body is a sibling of function_signature, not a child).
+        if (provider.enclosingFunctionFinder) {
+            const customResult = provider.enclosingFunctionFinder(current);
+            if (customResult) {
+                // Try SymbolTable first (same pattern as the FUNCTION_NODE_TYPES branch above).
+                const resolved = ctx.resolve(customResult.funcName, filePath);
+                if (resolved?.tier === 'same-file' && resolved.candidates.length > 0) {
+                    return resolved.candidates[0].nodeId;
+                }
+                let finalLabel = customResult.label;
+                if (provider.labelOverride) {
+                    const override = provider.labelOverride(current.previousSibling, finalLabel);
+                    if (override !== null)
+                        finalLabel = override;
+                }
+                return generateId(finalLabel, `${filePath}:${customResult.funcName}`);
             }
         }
         current = current.parent;
@@ -246,7 +275,8 @@ importedRawReturnTypesMap) => {
             }
             continue;
         }
-        const queryStr = LANGUAGE_QUERIES[language];
+        const provider = getProvider(language);
+        const queryStr = provider.treeSitterQueries;
         if (!queryStr)
             continue;
         await loadLanguage(language, file.path);
@@ -271,7 +301,6 @@ importedRawReturnTypesMap) => {
             console.warn(`Query error for ${file.path}:`, queryError);
             continue;
         }
-        const lang = getLanguageFromFilename(file.path);
         // Pre-pass: extract heritage from query matches to build parentMap for buildTypeEnv.
         // Heritage-processor runs in PARALLEL, so graph edges don't exist when buildTypeEnv runs.
         const fileParentMap = new Map();
@@ -318,18 +347,19 @@ importedRawReturnTypesMap) => {
         const importedBindings = importedBindingsMap?.get(file.path);
         const importedReturnTypes = importedReturnTypesMap?.get(file.path);
         const importedRawReturnTypes = importedRawReturnTypesMap?.get(file.path);
-        const typeEnv = lang ? buildTypeEnv(tree, lang, { symbolTable: ctx.symbols, parentMap, importedBindings, importedReturnTypes, importedRawReturnTypes }) : null;
+        const typeEnv = buildTypeEnv(tree, language, { symbolTable: ctx.symbols, parentMap, importedBindings, importedReturnTypes, importedRawReturnTypes, enclosingFunctionFinder: provider?.enclosingFunctionFinder });
         if (typeEnv && exportedTypeMap) {
             const fileExports = collectExportedBindings(typeEnv, file.path, ctx.symbols, graph);
             if (fileExports)
                 exportedTypeMap.set(file.path, fileExports);
         }
-        const callRouter = callRouters[language];
-        const verifiedReceivers = typeEnv && typeEnv.constructorBindings.length > 0
+        const callRouter = provider.callRouter;
+        const verifiedReceivers = typeEnv.constructorBindings.length > 0
             ? verifyConstructorBindings(typeEnv.constructorBindings, file.path, ctx)
             : new Map();
         const receiverIndex = buildReceiverTypeIndex(verifiedReceivers);
         ctx.enableCache(file.path);
+        const widenCache = new Map();
         matches.forEach(match => {
             const captureMap = {};
             match.captures.forEach(c => captureMap[c.name] = c.node);
@@ -345,7 +375,7 @@ importedRawReturnTypesMap) => {
                 }
                 // Fall back to verified constructor bindings (mirrors CALLS resolution tier 2)
                 if (!receiverTypeName && receiverText && receiverIndex.size > 0) {
-                    const enclosing = findEnclosingFunction(captureMap['assignment'], file.path, ctx);
+                    const enclosing = findEnclosingFunction(captureMap['assignment'], file.path, ctx, provider);
                     const funcName = enclosing ? extractFuncNameFromSourceId(enclosing) : '';
                     receiverTypeName = lookupReceiverType(receiverIndex, funcName, receiverText);
                 }
@@ -357,7 +387,7 @@ importedRawReturnTypesMap) => {
                     }
                 }
                 if (receiverTypeName) {
-                    const enclosing = findEnclosingFunction(captureMap['assignment'], file.path, ctx);
+                    const enclosing = findEnclosingFunction(captureMap['assignment'], file.path, ctx, provider);
                     const srcId = enclosing || generateId('File', file.path);
                     // Defer resolution: Ruby attr_accessor properties are registered during
                     // this same loop, so cross-file lookups fail if the declaring file hasn't
@@ -375,7 +405,7 @@ importedRawReturnTypesMap) => {
             if (!nameNode)
                 return;
             const calledName = nameNode.text;
-            const routed = callRouter(calledName, captureMap['call']);
+            const routed = callRouter?.(calledName, captureMap['call']);
             if (routed) {
                 switch (routed.kind) {
                     case 'skip':
@@ -429,7 +459,7 @@ importedRawReturnTypesMap) => {
                         break;
                 }
             }
-            if (isBuiltInOrNoise(calledName))
+            if (provider.isBuiltInName(calledName))
                 return;
             const callNode = captureMap['call'];
             const callForm = inferCallForm(callNode, nameNode);
@@ -475,7 +505,7 @@ importedRawReturnTypesMap) => {
             }
             // Fall back to verified constructor bindings for return type inference
             if (!receiverTypeName && receiverName && receiverIndex.size > 0) {
-                const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx);
+                const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx, provider);
                 const funcName = enclosingFunc ? extractFuncNameFromSourceId(enclosingFunc) : '';
                 receiverTypeName = lookupReceiverType(receiverIndex, funcName, receiverName);
             }
@@ -489,7 +519,7 @@ importedRawReturnTypesMap) => {
                 }
             }
             // Hoist sourceId so it's available for ACCESSES edge emission during chain walk.
-            const enclosingFuncId = findEnclosingFunction(callNode, file.path, ctx);
+            const enclosingFuncId = findEnclosingFunction(callNode, file.path, ctx, provider);
             const sourceId = enclosingFuncId || generateId('File', file.path);
             // Fall back to mixed chain resolution when the receiver is a complex expression
             // (field chain, call chain, or interleaved — e.g. user.address.city.save() or
@@ -520,7 +550,7 @@ importedRawReturnTypesMap) => {
             }
             // Build overload hints for languages with inferLiteralType (Java/Kotlin/C#/C++).
             // Only used when multiple candidates survive arity filtering — ~1-3% of calls.
-            const langConfig = lang ? typeConfigs[lang] : undefined;
+            const langConfig = provider.typeConfig;
             const hints = langConfig?.inferLiteralType
                 ? { callNode, inferLiteralType: langConfig.inferLiteralType }
                 : undefined;
@@ -530,7 +560,7 @@ importedRawReturnTypesMap) => {
                 callForm,
                 receiverTypeName,
                 receiverName,
-            }, file.path, ctx, hints);
+            }, file.path, ctx, hints, widenCache);
             if (!resolved)
                 return;
             const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);
@@ -694,21 +724,20 @@ const tryOverloadDisambiguation = (candidates, hints) => {
     }
     return null;
 };
-/**
- * Resolve a function call to its target node ID using priority strategy:
- * A. Narrow candidates by scope tier via ctx.resolve()
- * B. Filter to callable symbol kinds (constructor-aware when callForm is set)
- * C. Apply arity filtering when parameter metadata is available
- * D. Apply receiver-type filtering for member calls with typed receivers
- * E. Apply overload disambiguation via argument literal types (when available)
- *
- * If filtering still leaves multiple candidates, refuse to emit a CALLS edge.
- */
-const resolveCallTarget = (call, currentFile, ctx, overloadHints) => {
+const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache) => {
     const tiered = ctx.resolve(call.calledName, currentFile);
     if (!tiered)
         return null;
     let filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm);
+    // Swift/Kotlin: constructor calls look like free function calls (no `new` keyword).
+    // If free-form filtering found no callable candidates but the symbol resolves to a
+    // Class/Struct, retry with constructor form so CONSTRUCTOR_TARGET_TYPES applies.
+    if (filteredCandidates.length === 0 && call.callForm === 'free') {
+        const hasTypeTarget = tiered.candidates.some(c => c.type === 'Class' || c.type === 'Struct' || c.type === 'Enum');
+        if (hasTypeTarget) {
+            filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, 'constructor');
+        }
+    }
     // Module-qualified constructor pattern: e.g. Python `import models; models.User()`.
     // The attribute access gives callForm='member', but the callee may be a Class — a valid
     // constructor target. Re-try with constructor-form filtering so that `module.ClassName()`
@@ -716,17 +745,35 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints) => {
     if (filteredCandidates.length === 0 && call.callForm === 'member') {
         filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, 'constructor');
     }
-    // Module-alias disambiguation: Python `import auth; auth.User()` — when both models.py and
-    // auth.py export User, receiverName='auth' selects auth.py via moduleAliasMap.
-    // Runs when multiple candidates survive filtering and the receiver is a known module alias.
-    if (filteredCandidates.length > 1 && call.callForm === 'member' && call.receiverName) {
+    // Module-alias disambiguation: Python `import auth; auth.User()` — receiverName='auth'
+    // selects auth.py via moduleAliasMap. Runs for ALL member calls with a known module alias,
+    // not just ambiguous ones — same-file tier may shadow the correct cross-module target when
+    // the caller defines a function with the same name as the callee (Issue #417).
+    if (call.callForm === 'member' && call.receiverName) {
         const aliasMap = ctx.moduleAliasMap?.get(currentFile);
         if (aliasMap) {
             const moduleFile = aliasMap.get(call.receiverName);
             if (moduleFile) {
                 const aliasFiltered = filteredCandidates.filter(c => c.filePath === moduleFile);
-                if (aliasFiltered.length > 0)
+                if (aliasFiltered.length > 0) {
                     filteredCandidates = aliasFiltered;
+                }
+                else {
+                    // Same-file tier returned a local match, but the alias points elsewhere.
+                    // Widen to global candidates and filter to the aliased module's file.
+                    // Use per-file widenCache to avoid repeated lookupFuzzy for the same
+                    // calledName+moduleFile from multiple call sites in the same file.
+                    const cacheKey = `${call.calledName}\0${moduleFile}`;
+                    let fuzzyDefs = widenCache?.get(cacheKey);
+                    if (!fuzzyDefs) {
+                        fuzzyDefs = ctx.symbols.lookupFuzzy(call.calledName);
+                        widenCache?.set(cacheKey, fuzzyDefs);
+                    }
+                    const widened = filterCallableCandidates(fuzzyDefs, call.argCount, call.callForm)
+                        .filter(c => c.filePath === moduleFile);
+                    if (widened.length > 0)
+                        filteredCandidates = widened;
+                }
             }
         }
     }
@@ -780,8 +827,20 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints) => {
         if (disambiguated)
             return toResolveResult(disambiguated, tiered.tier);
     }
-    if (filteredCandidates.length !== 1)
+    if (filteredCandidates.length !== 1) {
+        // Deduplicate: Swift extensions create multiple Class nodes with the same name.
+        // When all candidates share the same type and differ only by file (extension vs
+        // primary definition), they represent the same symbol. Prefer the primary
+        // definition (shortest file path: Product.swift over ProductExtension.swift).
+        if (filteredCandidates.length > 1) {
+            const allSameType = filteredCandidates.every(c => c.type === filteredCandidates[0].type);
+            if (allSameType && (filteredCandidates[0].type === 'Class' || filteredCandidates[0].type === 'Struct')) {
+                const sorted = [...filteredCandidates].sort((a, b) => a.filePath.length - b.filePath.length);
+                return toResolveResult(sorted[0], tiered.tier);
+            }
+        }
         return null;
+    }
     return toResolveResult(filteredCandidates[0], tiered.tier);
 };
 // ── Scope key helpers ────────────────────────────────────────────────────
@@ -997,6 +1056,7 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
             await yieldToEventLoop();
         }
         ctx.enableCache(filePath);
+        const widenCache = new Map();
         const receiverMap = fileReceiverTypes.get(filePath);
         for (const call of calls) {
             let effectiveCall = call;
@@ -1038,7 +1098,7 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                     }
                 }
             }
-            const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx);
+            const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx, undefined, widenCache);
             if (!resolved)
                 continue;
             const relId = generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${resolved.nodeId}`);
@@ -1152,3 +1212,202 @@ export const processRoutesFromExtracted = async (graph, extractedRoutes, ctx, on
     }
     onProgress?.(extractedRoutes.length, extractedRoutes.length);
 };
+/**
+ * Extract property access keys from a consumer file's source code near fetch calls.
+ *
+ * Looks for three patterns after a fetch/response variable assignment:
+ * 1. Destructuring: `const { data, pagination } = await res.json()`
+ * 2. Property access: `response.data`, `result.items`
+ * 3. Optional chaining: `data?.key1?.key2`
+ *
+ * Returns deduplicated top-level property names accessed on the response.
+ *
+ * NOTE: This scans the entire file content, not just code near a specific fetch call.
+ * If a file has multiple fetch calls to different routes, all accessed keys are
+ * attributed to each fetch. This is an acceptable tradeoff for regex-based extraction.
+ */
+/** Common method names on response/data objects that are NOT property accesses */
+// Properties/methods to ignore when extracting consumer accessed keys from `data.X` patterns.
+// Avoids false positives from Fetch API, Array, Object, Promise, and DOM access on variables
+// that happen to share names with response variables (data, result, response, etc.).
+const RESPONSE_ACCESS_BLOCKLIST = new Set([
+    // Fetch/Response API
+    'json', 'text', 'blob', 'arrayBuffer', 'formData', 'ok', 'status', 'headers', 'clone',
+    // Promise
+    'then', 'catch', 'finally',
+    // Array
+    'map', 'filter', 'forEach', 'reduce', 'find', 'some', 'every',
+    'push', 'pop', 'shift', 'unshift', 'splice', 'slice', 'concat', 'join',
+    'sort', 'reverse', 'includes', 'indexOf',
+    // Object
+    'length', 'toString', 'valueOf', 'keys', 'values', 'entries',
+    // DOM methods — file-download patterns often reuse `data`/`response` variable names
+    'appendChild', 'removeChild', 'insertBefore', 'replaceChild', 'replaceChildren',
+    'createElement', 'getElementById', 'querySelector', 'querySelectorAll',
+    'setAttribute', 'getAttribute', 'removeAttribute', 'hasAttribute',
+    'addEventListener', 'removeEventListener', 'dispatchEvent',
+    'classList', 'className',
+    'parentNode', 'parentElement', 'childNodes', 'children',
+    'nextSibling', 'previousSibling', 'firstChild', 'lastChild',
+    'click', 'focus', 'blur', 'submit', 'reset',
+    'innerHTML', 'outerHTML', 'textContent', 'innerText',
+]);
+export const extractConsumerAccessedKeys = (content) => {
+    const keys = new Set();
+    // Pattern 1: Destructuring from .json() — const { key1, key2 } = await res.json()
+    // Also matches: const { key1, key2 } = await (await fetch(...)).json()
+    const destructurePattern = /(?:const|let|var)\s+\{([^}]+)\}\s*=\s*(?:await\s+)?(?:\w+\.json\s*\(\)|(?:await\s+)?(?:fetch|axios|got)\s*\([^)]*\)(?:\.then\s*\([^)]*\))?(?:\.json\s*\(\))?)/g;
+    let match;
+    while ((match = destructurePattern.exec(content)) !== null) {
+        const destructuredBody = match[1];
+        // Extract identifiers from destructuring, handling renamed bindings (key: alias)
+        const keyPattern = /(\w+)\s*(?::\s*\w+)?/g;
+        let keyMatch;
+        while ((keyMatch = keyPattern.exec(destructuredBody)) !== null) {
+            keys.add(keyMatch[1]);
+        }
+    }
+    // Pattern 2: Destructuring from a data/result/response/json variable
+    // e.g., const { items, total } = data; or const { error } = result;
+    const dataVarDestructure = /(?:const|let|var)\s+\{([^}]+)\}\s*=\s*(?:data|result|response|json|body|res)\b/g;
+    while ((match = dataVarDestructure.exec(content)) !== null) {
+        const destructuredBody = match[1];
+        const keyPattern = /(\w+)\s*(?::\s*\w+)?/g;
+        let keyMatch;
+        while ((keyMatch = keyPattern.exec(destructuredBody)) !== null) {
+            keys.add(keyMatch[1]);
+        }
+    }
+    // Pattern 3: Property access on common response variable names
+    // Matches: data.key, response.key, result.key, json.key, body.key
+    // Also matches optional chaining: data?.key
+    const propAccessPattern = /\b(?:data|response|result|json|body|res)\s*(?:\?\.|\.)(\w+)/g;
+    while ((match = propAccessPattern.exec(content)) !== null) {
+        const key = match[1];
+        // Skip common method calls that aren't property accesses
+        if (!RESPONSE_ACCESS_BLOCKLIST.has(key)) {
+            keys.add(key);
+        }
+    }
+    return [...keys];
+};
+/**
+ * Create FETCHES edges from extracted fetch() calls to matching Route nodes.
+ * When consumerContents is provided, extracts property access patterns from
+ * consumer files and encodes them in the edge reason field.
+ */
+export const processNextjsFetchRoutes = (graph, fetchCalls, routeRegistry, // routeURL → handlerFilePath
+consumerContents) => {
+    // Pre-count how many routes each consumer file matches (for confidence attribution)
+    const routeCountByFile = new Map();
+    for (const call of fetchCalls) {
+        const normalized = normalizeFetchURL(call.fetchURL);
+        if (!normalized)
+            continue;
+        for (const [routeURL] of routeRegistry) {
+            if (routeMatches(normalized, routeURL)) {
+                routeCountByFile.set(call.filePath, (routeCountByFile.get(call.filePath) ?? 0) + 1);
+                break;
+            }
+        }
+    }
+    for (const call of fetchCalls) {
+        const normalized = normalizeFetchURL(call.fetchURL);
+        if (!normalized)
+            continue;
+        for (const [routeURL] of routeRegistry) {
+            if (routeMatches(normalized, routeURL)) {
+                const sourceId = generateId('File', call.filePath);
+                const routeNodeId = generateId('Route', routeURL);
+                // Extract consumer accessed keys if file content is available
+                let reason = 'fetch-url-match';
+                if (consumerContents) {
+                    const content = consumerContents.get(call.filePath);
+                    if (content) {
+                        const accessedKeys = extractConsumerAccessedKeys(content);
+                        if (accessedKeys.length > 0) {
+                            reason = `fetch-url-match|keys:${accessedKeys.join(',')}`;
+                        }
+                    }
+                }
+                // Encode multi-fetch count so downstream can set confidence
+                const fetchCount = routeCountByFile.get(call.filePath) ?? 1;
+                if (fetchCount > 1) {
+                    reason = `${reason}|fetches:${fetchCount}`;
+                }
+                graph.addRelationship({
+                    id: generateId('FETCHES', `${sourceId}->${routeNodeId}`),
+                    sourceId,
+                    targetId: routeNodeId,
+                    type: 'FETCHES',
+                    confidence: 0.9,
+                    reason,
+                });
+                break;
+            }
+        }
+    }
+};
+/**
+ * Extract fetch() calls from source files (sequential path).
+ * Workers handle this via tree-sitter captures in parse-worker; this function
+ * provides the same extraction for the sequential fallback path.
+ */
+export const extractFetchCallsFromFiles = async (files, astCache) => {
+    const parser = await loadParser();
+    const result = [];
+    for (const file of files) {
+        const language = getLanguageFromFilename(file.path);
+        if (!language)
+            continue;
+        if (!isLanguageAvailable(language))
+            continue;
+        const provider = getProvider(language);
+        const queryStr = provider.treeSitterQueries;
+        if (!queryStr)
+            continue;
+        await loadLanguage(language, file.path);
+        let tree = astCache.get(file.path);
+        if (!tree) {
+            try {
+                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+            }
+            catch {
+                continue;
+            }
+            astCache.set(file.path, tree);
+        }
+        let matches;
+        try {
+            const lang = parser.getLanguage();
+            const query = new Parser.Query(lang, queryStr);
+            matches = query.matches(tree.rootNode);
+        }
+        catch {
+            continue;
+        }
+        for (const match of matches) {
+            const captureMap = {};
+            match.captures.forEach(c => captureMap[c.name] = c.node);
+            if (captureMap['route.fetch']) {
+                const urlNode = captureMap['route.url'] ?? captureMap['route.template_url'];
+                if (urlNode) {
+                    result.push({
+                        filePath: file.path,
+                        fetchURL: urlNode.text,
+                        lineNumber: captureMap['route.fetch'].startPosition.row,
+                    });
+                }
+            }
+            else if (captureMap['http_client'] && captureMap['http_client.url']) {
+                const method = captureMap['http_client.method']?.text;
+                const url = captureMap['http_client.url'].text;
+                const HTTP_CLIENT_ONLY = new Set(['head', 'options', 'request', 'ajax']);
+                if (method && HTTP_CLIENT_ONLY.has(method) && url.startsWith('/')) {
+                    result.push({ filePath: file.path, fetchURL: url, lineNumber: captureMap['http_client'].startPosition.row });
+                }
+            }
+        }
+    }
+    return result;
+};

package/dist/core/ingestion/call-routing.d.ts

@@ -10,6 +10,7 @@
  * two packages have separate build targets (Node native vs WASM/browser).
  * Keep both copies in sync until a shared package is introduced.
  */
+import type { SyntaxNode } from './utils/ast-helpers.js';
 /** null = this call was not routed; fall through to default call handling */
 export type CallRoutingResult = RubyCallRouting | null;
 /**
@@ -18,23 +19,7 @@ export type CallRoutingResult = RubyCallRouting | null;
  * returns an importPath MUST validate it independently (length cap, control-char
  * rejection). See routeRubyCall for the reference implementation.
  */
-export type CallRouter = (calledName: string, callNode: any) => CallRoutingResult;
-/** Per-language call routing. noRouting = no special routing (normal call processing) */
-export declare const callRouters: {
-    javascript: CallRouter;
-    typescript: CallRouter;
-    python: CallRouter;
-    java: CallRouter;
-    kotlin: CallRouter;
-    go: CallRouter;
-    rust: CallRouter;
-    csharp: CallRouter;
-    php: CallRouter;
-    swift: CallRouter;
-    cpp: CallRouter;
-    c: CallRouter;
-    ruby: typeof routeRubyCall;
-};
+export type CallRouter = (calledName: string, callNode: SyntaxNode) => CallRoutingResult;
 export type RubyCallRouting = {
     kind: 'import';
     importPath: string;
@@ -71,4 +56,4 @@ export interface RubyPropertyItem {
  * @param callNode   - The tree-sitter `call` AST node
  * @returns A discriminated union describing the call's semantic role
  */
-export declare function routeRubyCall(calledName: string, callNode: any): RubyCallRouting;
+export declare function routeRubyCall(calledName: string, callNode: SyntaxNode): RubyCallRouting;

package/dist/core/ingestion/call-routing.js

@@ -10,25 +10,6 @@
  * two packages have separate build targets (Node native vs WASM/browser).
  * Keep both copies in sync until a shared package is introduced.
  */
-import { SupportedLanguages } from '../../config/supported-languages.js';
-/** No-op router: returns null for every call (passthrough to normal processing) */
-const noRouting = () => null;
-/** Per-language call routing. noRouting = no special routing (normal call processing) */
-export const callRouters = {
-    [SupportedLanguages.JavaScript]: noRouting,
-    [SupportedLanguages.TypeScript]: noRouting,
-    [SupportedLanguages.Python]: noRouting,
-    [SupportedLanguages.Java]: noRouting,
-    [SupportedLanguages.Kotlin]: noRouting,
-    [SupportedLanguages.Go]: noRouting,
-    [SupportedLanguages.Rust]: noRouting,
-    [SupportedLanguages.CSharp]: noRouting,
-    [SupportedLanguages.PHP]: noRouting,
-    [SupportedLanguages.Swift]: noRouting,
-    [SupportedLanguages.CPlusPlus]: noRouting,
-    [SupportedLanguages.C]: noRouting,
-    [SupportedLanguages.Ruby]: routeRubyCall,
-};
 // ── Pre-allocated singletons for common return values ────────────────────────
 const CALL_RESULT = { kind: 'call' };
 const SKIP_RESULT = { kind: 'skip' };