@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.0

package/dist/core/ingestion/utils.js

@@ -84,50 +84,44 @@ export const FUNCTION_DECLARATION_TYPES = new Set([
     'generator_function_declaration',
     'function_item',
 ]);
-/** Built-in function/method names that should not be tracked as call targets */
-export const BUILT_IN_NAMES = new Set([
-    // JavaScript/TypeScript
-    'console', 'log', 'warn', 'error', 'info', 'debug',
+/**
+ * Built-in names that are noise when called as FREE functions: `list()`, `print()`, `console()`.
+ * These are ONLY filtered for free calls (callForm !== 'member').
+ * Member calls like `obj.list()`, `obj.set()`, `obj.map()` are NEVER filtered —
+ * they are real method calls on user-defined objects.
+ *
+ * Names that appear in multiple languages are kept only if they are universally noise.
+ * Names that are valid user method names in some languages (list, set, type, get, put,
+ * map, filter, etc.) are excluded — they belong in MEMBER_NOISE_NAMES for member-only filtering.
+ */
+export const FREE_CALL_BUILTINS = new Set([
+    // === Universal (all languages) ===
+    'console',
+    // === JavaScript/TypeScript — free call builtins ===
     'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
     'parseInt', 'parseFloat', 'isNaN', 'isFinite',
     'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
-    'JSON', 'parse', 'stringify',
-    'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
+    'JSON', 'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
     'Map', 'Set', 'WeakMap', 'WeakSet',
-    'Promise', 'resolve', 'reject', 'then', 'catch', 'finally',
-    'Math', 'Date', 'RegExp', 'Error',
+    'Promise', 'Math', 'Date', 'RegExp', 'Error',
     'require', 'import', 'export', 'fetch', 'Response', 'Request',
+    // React hooks (framework built-ins, never user-defined)
     'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
     'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
     'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy',
-    'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every',
-    'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split',
-    'push', 'pop', 'shift', 'unshift', 'sort', 'reverse',
-    'keys', 'values', 'entries', 'assign', 'freeze', 'seal',
-    'hasOwnProperty', 'toString', 'valueOf',
-    // Python
+    // === Python — free call builtins ===
     'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
-    'append', 'extend', 'update',
-    // NOTE: 'open', 'read', 'write', 'close' removed — these are real C POSIX syscalls
     'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr',
     'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs',
-    // Kotlin stdlib
-    'println', 'print', 'readLine', 'require', 'requireNotNull', 'check', 'assert', 'lazy', 'error',
+    // === Kotlin — free call builtins ===
+    'println', 'readLine', 'requireNotNull', 'check',
     'listOf', 'mapOf', 'setOf', 'mutableListOf', 'mutableMapOf', 'mutableSetOf',
-    'arrayOf', 'sequenceOf', 'also', 'apply', 'run', 'with', 'takeIf', 'takeUnless',
+    'arrayOf', 'sequenceOf',
     'TODO', 'buildString', 'buildList', 'buildMap', 'buildSet',
-    'repeat', 'synchronized',
-    // Kotlin coroutine builders & scope functions
-    'launch', 'async', 'runBlocking', 'withContext', 'coroutineScope',
-    'supervisorScope', 'delay',
-    // Kotlin Flow operators
-    'flow', 'flowOf', 'collect', 'emit', 'onEach', 'catch',
-    'buffer', 'conflate', 'distinctUntilChanged',
-    'flatMapLatest', 'flatMapMerge', 'combine',
-    'stateIn', 'shareIn', 'launchIn',
-    // Kotlin infix stdlib functions
-    'to', 'until', 'downTo', 'step',
-    // C/C++ standard library
+    // Kotlin coroutine builders (free calls)
+    'runBlocking', 'withContext', 'coroutineScope', 'supervisorScope',
+    'flow', 'flowOf',
+    // === C/C++ — free call builtins ===
     'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf',
     'scanf', 'fscanf', 'sscanf',
     'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp',
@@ -136,42 +130,23 @@ export const BUILT_IN_NAMES = new Set([
     'sizeof', 'offsetof', 'typeof',
     'assert', 'abort', 'exit', '_exit',
     'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs',
-    // Linux kernel common macros/helpers (not real call targets)
+    // Linux kernel macros (not real call targets)
     'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE',
     'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL',
     'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe',
-    'min', 'max', 'clamp', 'abs', 'swap',
     'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg',
     'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg',
     'GFP_KERNEL', 'GFP_ATOMIC',
     'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore',
     'mutex_lock', 'mutex_unlock', 'mutex_init',
     'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree',
-    'get', 'put',
-    // C# / .NET built-ins
-    'Console', 'WriteLine', 'ReadLine', 'Write',
-    'Task', 'Run', 'Wait', 'WhenAll', 'WhenAny', 'FromResult', 'Delay', 'ContinueWith',
-    'ConfigureAwait', 'GetAwaiter', 'GetResult',
-    'ToString', 'GetType', 'Equals', 'GetHashCode', 'ReferenceEquals',
-    'Add', 'Remove', 'Contains', 'Clear', 'Count', 'Any', 'All',
-    'Where', 'Select', 'SelectMany', 'OrderBy', 'OrderByDescending', 'GroupBy',
-    'First', 'FirstOrDefault', 'Single', 'SingleOrDefault', 'Last', 'LastOrDefault',
-    'ToList', 'ToArray', 'ToDictionary', 'AsEnumerable', 'AsQueryable',
-    'Aggregate', 'Sum', 'Average', 'Min', 'Max', 'Distinct', 'Skip', 'Take',
-    'String', 'Format', 'IsNullOrEmpty', 'IsNullOrWhiteSpace', 'Concat', 'Join',
-    'Trim', 'TrimStart', 'TrimEnd', 'Split', 'Replace', 'StartsWith', 'EndsWith',
-    'Convert', 'ToInt32', 'ToDouble', 'ToBoolean', 'ToByte',
-    'Math', 'Abs', 'Ceiling', 'Floor', 'Round', 'Pow', 'Sqrt',
-    'Dispose', 'Close',
-    'TryParse', 'Parse',
-    'AddRange', 'RemoveAt', 'RemoveAll', 'FindAll', 'Exists', 'TrueForAll',
-    'ContainsKey', 'TryGetValue', 'AddOrUpdate',
-    'Throw', 'ThrowIfNull',
-    // PHP built-ins
-    'echo', 'isset', 'empty', 'unset', 'list', 'array', 'compact', 'extract',
+    // === C# / .NET — free call builtins ===
+    'Console', 'Convert',
+    // === PHP — free call builtins ===
+    'echo', 'isset', 'empty', 'unset', 'array', 'compact', 'extract',
     'count', 'strlen', 'strpos', 'strrpos', 'substr', 'strtolower', 'strtoupper', 'trim',
     'ltrim', 'rtrim', 'str_replace', 'str_contains', 'str_starts_with', 'str_ends_with',
-    'sprintf', 'vsprintf', 'printf', 'number_format',
+    'number_format',
     'array_map', 'array_filter', 'array_reduce', 'array_push', 'array_pop', 'array_shift',
     'array_unshift', 'array_slice', 'array_splice', 'array_merge', 'array_keys', 'array_values',
     'array_key_exists', 'in_array', 'array_search', 'array_unique', 'usort', 'rsort',
@@ -184,66 +159,136 @@ export const BUILT_IN_NAMES = new Set([
     'preg_match', 'preg_match_all', 'preg_replace', 'preg_split',
     'header', 'session_start', 'session_destroy', 'ob_start', 'ob_end_clean', 'ob_get_clean',
     'dd', 'dump',
-    // Swift/iOS built-ins and standard library
-    'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure',
-    'assert', 'assertionFailure', 'NSLog',
-    'abs', 'min', 'max', 'zip', 'stride', 'sequence', 'repeatElement',
-    'swap', 'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes',
+    // === Swift — free call builtins ===
+    'debugPrint', 'fatalError', 'precondition', 'preconditionFailure',
+    'assertionFailure', 'NSLog',
+    'stride', 'sequence', 'repeatElement',
+    'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes',
     'autoreleasepool', 'unsafeBitCast', 'unsafeDowncast', 'numericCast',
-    'type', 'MemoryLayout',
-    // Swift collection/string methods (common noise)
-    'map', 'flatMap', 'compactMap', 'filter', 'reduce', 'forEach', 'contains',
-    'first', 'last', 'prefix', 'suffix', 'dropFirst', 'dropLast',
-    'sorted', 'reversed', 'enumerated', 'joined', 'split',
-    'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast',
+    'MemoryLayout', 'NSLocalizedString', 'Bundle',
+    'DispatchQueue',
+    'withCheckedContinuation', 'withCheckedThrowingContinuation',
+    'NotificationCenter',
+    // === Rust — free call builtins ===
+    'panic', 'unreachable', 'todo', 'unimplemented',
+    'vec', 'println', 'eprintln', 'dbg', 'format',
+    'Some', 'None', 'Ok', 'Err',
+    // === Ruby — free call builtins ===
+    'puts', 'p', 'pp', 'raise', 'fail',
+    'require', 'require_relative', 'load', 'autoload',
+    'include', 'extend', 'prepend',
+    'attr_accessor', 'attr_reader', 'attr_writer',
+    'public', 'private', 'protected', 'module_function',
+    'lambda', 'proc', 'block_given?',
+]);
+/**
+ * Method names that are noise ONLY when called as MEMBER calls on unknown receivers.
+ * These are generic methods on built-in types (Array, Promise, Map, etc.) that would
+ * falsely resolve to user-defined functions of the same name.
+ *
+ * Only filtered when receiver type is unknown — if receiver type IS resolved,
+ * the call is kept because we know it's on a specific user type.
+ */
+export const MEMBER_NOISE_NAMES = new Set([
+    // Array/collection methods
+    'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every',
+    'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split',
+    'push', 'pop', 'shift', 'unshift', 'sort', 'reverse',
+    'keys', 'values', 'entries', 'flat', 'flatMap',
+    // Object methods
+    'assign', 'freeze', 'seal', 'hasOwnProperty', 'toString', 'valueOf',
+    // Promise methods
+    'then', 'catch', 'finally', 'all', 'any', 'race', 'resolve', 'reject', 'allSettled',
+    // Map/Set methods
+    'has', 'get', 'set', 'add', 'delete', 'clear',
+    // Iterator/generator
+    'next', 'return', 'throw',
+    // Console
+    'log', 'warn', 'error', 'info', 'debug',
+    // HTTP response (Express/Fastify/Koa)
+    'json', 'text', 'blob', 'status', 'send', 'end', 'redirect', 'render',
+    // EventEmitter — NOTE: emit/subscribe/on removed; they are real calls on typed event systems
+    'off', 'removeListener', 'removeAllListeners',
+    // Stream
+    'pipe', 'unpipe', 'pause', 'resume', 'destroy',
+    // Kotlin scope functions (member form: obj.also {}, obj.apply {})
+    'also', 'apply', 'run', 'with', 'let', 'takeIf', 'takeUnless',
+    // Kotlin coroutines (member form: scope.launch {})
+    'launch', 'async', 'delay',
+    // Kotlin Flow (member form)
+    'collect', 'onEach', 'buffer', 'conflate', 'distinctUntilChanged',
+    'flatMapLatest', 'flatMapMerge', 'combine', 'stateIn', 'shareIn', 'launchIn',
+    // Rust method noise
+    'unwrap', 'expect', 'unwrap_or', 'unwrap_or_else', 'unwrap_or_default',
+    'ok', 'err', 'is_ok', 'is_err', 'map_err', 'and_then', 'or_else',
+    'clone', 'to_string', 'to_owned', 'into', 'from', 'as_ref', 'as_mut',
+    'iter', 'into_iter', 'collect', 'fold', 'for_each',
+    'len', 'is_empty', 'contains', 'insert', 'remove',
+    'write', 'writeln', 'read', 'lock', 'try_lock',
+    'spawn', 'join', 'sleep',
+    // C# LINQ / collection methods
+    'Where', 'Select', 'SelectMany', 'OrderBy', 'OrderByDescending', 'GroupBy',
+    'First', 'FirstOrDefault', 'Single', 'SingleOrDefault', 'Last', 'LastOrDefault',
+    'ToList', 'ToArray', 'ToDictionary', 'AsEnumerable', 'AsQueryable',
+    'Aggregate', 'Sum', 'Average', 'Min', 'Max', 'Distinct', 'Skip', 'Take',
+    'Add', 'Remove', 'Contains', 'Clear', 'Count', 'Any', 'All',
+    'AddRange', 'RemoveAt', 'RemoveAll', 'FindAll', 'Exists', 'TrueForAll',
+    'ContainsKey', 'TryGetValue', 'AddOrUpdate',
+    'ToString', 'GetType', 'Equals', 'GetHashCode', 'ReferenceEquals',
+    'Dispose', 'Close',
+    'Run', 'Wait', 'WhenAll', 'WhenAny', 'FromResult', 'Delay', 'ContinueWith',
+    'ConfigureAwait', 'GetAwaiter', 'GetResult',
+    'Format', 'IsNullOrEmpty', 'IsNullOrWhiteSpace', 'Concat', 'Join',
+    'Trim', 'TrimStart', 'TrimEnd', 'Split', 'Replace', 'StartsWith', 'EndsWith',
+    'TryParse', 'Parse', 'Throw', 'ThrowIfNull',
+    // Swift collection/string methods
+    'compactMap', 'contains', 'first', 'last', 'prefix', 'suffix',
+    'dropFirst', 'dropLast', 'sorted', 'reversed', 'enumerated', 'joined',
+    'append', 'removeAll', 'removeFirst', 'removeLast',
     'isEmpty', 'count', 'index', 'startIndex', 'endIndex',
-    // UIKit/Foundation common methods (noise in call graph)
+    // Swift UIKit
     'addSubview', 'removeFromSuperview', 'layoutSubviews', 'setNeedsLayout',
     'layoutIfNeeded', 'setNeedsDisplay', 'invalidateIntrinsicContentSize',
     'addTarget', 'removeTarget', 'addGestureRecognizer',
     'addConstraint', 'addConstraints', 'removeConstraint', 'removeConstraints',
-    'NSLocalizedString', 'Bundle',
     'reloadData', 'reloadSections', 'reloadRows', 'performBatchUpdates',
     'register', 'dequeueReusableCell', 'dequeueReusableSupplementaryView',
     'beginUpdates', 'endUpdates', 'insertRows', 'deleteRows', 'insertSections', 'deleteSections',
     'present', 'dismiss', 'pushViewController', 'popViewController', 'popToRootViewController',
     'performSegue', 'prepare',
-    // GCD / async
-    'DispatchQueue', 'async', 'sync', 'asyncAfter',
-    'Task', 'withCheckedContinuation', 'withCheckedThrowingContinuation',
-    // Combine
-    'sink', 'store', 'assign', 'receive', 'subscribe',
-    // Notification / KVO
-    'addObserver', 'removeObserver', 'post', 'NotificationCenter',
-    // Rust standard library (common noise in call graphs)
-    'unwrap', 'expect', 'unwrap_or', 'unwrap_or_else', 'unwrap_or_default',
-    'ok', 'err', 'is_ok', 'is_err', 'map', 'map_err', 'and_then', 'or_else',
-    'clone', 'to_string', 'to_owned', 'into', 'from', 'as_ref', 'as_mut',
-    'iter', 'into_iter', 'collect', 'map', 'filter', 'fold', 'for_each',
-    'len', 'is_empty', 'push', 'pop', 'insert', 'remove', 'contains',
-    'format', 'write', 'writeln', 'panic', 'unreachable', 'todo', 'unimplemented',
-    'vec', 'println', 'eprintln', 'dbg',
-    'lock', 'read', 'write', 'try_lock',
-    'spawn', 'join', 'sleep',
-    'Some', 'None', 'Ok', 'Err',
-    // Ruby built-ins and Kernel methods
-    'puts', 'p', 'pp', 'raise', 'fail',
-    'require', 'require_relative', 'load', 'autoload',
-    'include', 'extend', 'prepend',
-    'attr_accessor', 'attr_reader', 'attr_writer',
-    'public', 'private', 'protected', 'module_function',
-    'lambda', 'proc', 'block_given?',
-    'nil?', 'is_a?', 'kind_of?', 'instance_of?', 'respond_to?',
-    'freeze', 'frozen?', 'dup', 'tap', 'yield_self',
-    // Ruby enumerables
+    // Swift Combine
+    'sink', 'store', 'assign', 'receive',
+    'addObserver', 'removeObserver', 'post',
+    // Ruby enumerables (member form)
     'each', 'select', 'reject', 'detect', 'collect',
     'inject', 'flat_map', 'each_with_object', 'each_with_index',
     'any?', 'all?', 'none?', 'count', 'first', 'last',
     'sort_by', 'min_by', 'max_by',
     'group_by', 'partition', 'compact', 'flatten', 'uniq',
+    'nil?', 'is_a?', 'kind_of?', 'instance_of?', 'respond_to?',
+    'freeze', 'frozen?', 'dup', 'tap', 'yield_self',
+    // PHP method noise
+    'stringify', 'parse',
 ]);
-/** Check if a name is a built-in or common noise that should be filtered out */
-export const isBuiltInOrNoise = (name) => BUILT_IN_NAMES.has(name);
+/** Legacy flat set — kept for backward compatibility with existing `isBuiltInOrNoise` callers */
+const BUILT_IN_NAMES = new Set([...FREE_CALL_BUILTINS, ...MEMBER_NOISE_NAMES]);
+/**
+ * Check if a name should be filtered based on call form.
+ * - Free calls: filtered if name is a known built-in free function
+ * - Member calls: filtered ONLY if name is a known noise method AND receiver type is unknown
+ * - Constructor calls: never filtered
+ */
+export const isBuiltInOrNoise = (name, callForm) => {
+    // Constructor calls are never noise — `new Foo()` is always intentional
+    if (callForm === 'constructor')
+        return false;
+    // Member calls are only noise if the name is in the member noise set
+    // (actual filtering for unknown receivers happens in call-processor, not here)
+    if (callForm === 'member')
+        return MEMBER_NOISE_NAMES.has(name);
+    // Free calls (or unknown form): check both sets
+    return BUILT_IN_NAMES.has(name);
+};
 /** AST node types representing class-like containers (for HAS_METHOD edges) */
 export const CLASS_CONTAINER_TYPES = new Set([
     'class_declaration', 'abstract_class_declaration',
@@ -900,7 +945,7 @@ export const extractReceiverNode = (nameNode) => {
     return receiver ?? undefined;
 };
 export const isVerboseIngestionEnabled = () => {
-    const raw = process.env.CODE_MAPPER_VERBOSE;
+    const raw = process.env['CODE_MAPPER_VERBOSE'];
     if (!raw)
         return false;
     const value = raw.toLowerCase();

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -59,6 +59,7 @@ export interface ExtractedCall {
     receiverTypeName?: string;
     receiverCallChain?: string[];
     callLine?: number;
+    callColumn?: number;
 }
 export interface ExtractedHeritage {
     filePath: string;

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

@@ -203,10 +203,11 @@ const processBatch = (files, onProgress) => {
             regularFiles.push(...langFiles);
         }
         // Process regular files for this language
-        if (regularFiles.length > 0) {
-            if (isLanguageAvailable(language, regularFiles[0].path)) {
+        const firstRegular = regularFiles[0];
+        if (firstRegular !== undefined) {
+            if (isLanguageAvailable(language, firstRegular.path)) {
                 try {
-                    setLanguage(language, regularFiles[0].path);
+                    setLanguage(language, firstRegular.path);
                     processFileGroup(regularFiles, language, queryString, result, onFileProcessed);
                 }
                 catch {
@@ -218,10 +219,11 @@ const processBatch = (files, onProgress) => {
             }
         }
         // Process tsx files separately (different grammar)
-        if (tsxFiles.length > 0) {
-            if (isLanguageAvailable(language, tsxFiles[0].path)) {
+        const firstTsx = tsxFiles[0];
+        if (firstTsx !== undefined) {
+            if (isLanguageAvailable(language, firstTsx.path)) {
                 try {
-                    setLanguage(language, tsxFiles[0].path);
+                    setLanguage(language, firstTsx.path);
                     processFileGroup(tsxFiles, language, queryString, result, onFileProcessed);
                 }
                 catch {
@@ -470,7 +472,7 @@ function extractControllerTarget(argsNode) {
         const text = extractStringContent(handlerNode);
         if (text?.includes('@')) {
             const [controller, method] = text.split('@');
-            return { controller, method };
+            return { controller: controller ?? null, method: method ?? null };
         }
     }
     // Class reference: UserController::class (invokable controller)
@@ -817,43 +819,109 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         }
                         // kind === 'call' — fall through to normal call processing below
                     }
-                    if (!isBuiltInOrNoise(calledName)) {
+                    // RC3: Extract function references from arguments BEFORE the built-in filter
+                    // e.g. router.get('/path', requireAuth, getBooking) — 'get' is built-in noise,
+                    // but requireAuth/getBooking are real function references we must capture
+                    {
                         const callNode = captureMap['call'];
+                        const argsNode = callNode.childForFieldName?.('arguments');
+                        if (argsNode) {
+                            const argSourceId = findEnclosingFunctionId(callNode, file.path)
+                                || generateId('File', file.path);
+                            for (const arg of (argsNode.children ?? [])) {
+                                if (arg.type === 'identifier' && arg.text && !isBuiltInOrNoise(arg.text)) {
+                                    result.calls.push({
+                                        filePath: file.path,
+                                        calledName: arg.text,
+                                        sourceId: argSourceId,
+                                        callForm: 'free',
+                                        callLine: arg.startPosition?.row != null ? arg.startPosition.row + 1 : undefined,
+                                        callColumn: arg.startPosition?.column,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    const callNode_pre = captureMap['call'];
+                    const callForm_pre = inferCallForm(callNode_pre, callNameNode);
+                    if (!isBuiltInOrNoise(calledName, callForm_pre)) {
+                        const callNode = callNode_pre;
                         const sourceId = findEnclosingFunctionId(callNode, file.path)
                             || generateId('File', file.path);
-                        const callForm = inferCallForm(callNode, callNameNode);
+                        const callForm = callForm_pre;
                         let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
                         let receiverTypeName = receiverName ? typeEnv.lookup(receiverName, callNode) : undefined;
                         let receiverCallChain;
-                        // When the receiver is a call_expression (e.g. svc.getUser().save()),
-                        // extractReceiverName refuses complex expressions, so walk the receiver node
-                        // to build a call chain for deferred resolution in processCallsFromExtracted
+                        // When the receiver is complex (call chain or member chain),
+                        // extractReceiverName returns undefined. Walk the AST to extract
+                        // the chain and base receiver for deferred resolution.
                         if (callForm === 'member' && receiverName === undefined && !receiverTypeName) {
                             const receiverNode = extractReceiverNode(callNameNode);
-                            if (receiverNode && CALL_EXPRESSION_TYPES.has(receiverNode.type)) {
-                                const extracted = extractCallChain(receiverNode);
-                                if (extracted) {
-                                    receiverCallChain = extracted.chain;
-                                    // Set receiverName to the base object for constructor binding resolution
-                                    receiverName = extracted.baseReceiverName;
-                                    // Try the type environment immediately for explicitly-typed locals/params
-                                    if (receiverName) {
-                                        receiverTypeName = typeEnv.lookup(receiverName, callNode);
+                            if (receiverNode) {
+                                if (CALL_EXPRESSION_TYPES.has(receiverNode.type)) {
+                                    // Call chain: svc.getUser().save() → chain=['getUser'], base='svc'
+                                    const extracted = extractCallChain(receiverNode);
+                                    if (extracted) {
+                                        receiverCallChain = extracted.chain;
+                                        receiverName = extracted.baseReceiverName;
+                                        if (receiverName) {
+                                            receiverTypeName = typeEnv.lookup(receiverName, callNode);
+                                        }
+                                    }
+                                }
+                                else if (receiverNode.type === 'member_expression') {
+                                    // Member chain: prisma.booking.findMany() → chain=['booking'], base='prisma'
+                                    const innerObject = receiverNode.childForFieldName?.('object');
+                                    const innerProp = receiverNode.childForFieldName?.('property');
+                                    if (innerObject && innerProp) {
+                                        if (innerObject.type === 'identifier' || innerObject.type === 'this') {
+                                            // 3-level: a.b.c() or this.b.c() → base=a/this, chain=[b]
+                                            // For 'this', resolve the property name directly from type env
+                                            receiverCallChain = [innerProp.text];
+                                            receiverName = innerObject.text;
+                                            if (!receiverTypeName) {
+                                                // For this.x.method(), look up 'x' not 'this' in the type env
+                                                const lookupName = innerObject.type === 'this' ? innerProp.text : receiverName;
+                                                receiverTypeName = typeEnv.lookup(lookupName, callNode);
+                                            }
+                                        }
+                                        else if (innerObject.type === 'member_expression') {
+                                            // 4-level: a.b.c.d() → base=a, chain=[b,c]
+                                            const deepObj = innerObject.childForFieldName?.('object');
+                                            const deepProp = innerObject.childForFieldName?.('property');
+                                            if (deepObj?.type === 'identifier' && deepProp) {
+                                                receiverCallChain = [deepProp.text, innerProp.text];
+                                                receiverName = deepObj.text;
+                                                if (!receiverTypeName) {
+                                                    receiverTypeName = typeEnv.lookup(receiverName, callNode);
+                                                }
+                                            }
+                                        }
                                     }
                                 }
                             }
                         }
-                        result.calls.push({
+                        const call = {
                             filePath: file.path,
                             calledName,
                             sourceId,
-                            argCount: countCallArguments(callNode),
-                            callLine: callNode.startPosition?.row != null ? callNode.startPosition.row + 1 : undefined,
-                            ...(callForm !== undefined ? { callForm } : {}),
-                            ...(receiverName !== undefined ? { receiverName } : {}),
-                            ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                            ...(receiverCallChain !== undefined ? { receiverCallChain } : {}),
-                        });
+                        };
+                        const argCount = countCallArguments(callNode);
+                        if (argCount !== undefined)
+                            call.argCount = argCount;
+                        if (callNode.startPosition?.row != null)
+                            call.callLine = callNode.startPosition.row + 1;
+                        if (callNameNode.startPosition?.column !== undefined)
+                            call.callColumn = callNameNode.startPosition.column;
+                        if (callForm !== undefined)
+                            call.callForm = callForm;
+                        if (receiverName !== undefined)
+                            call.receiverName = receiverName;
+                        if (receiverTypeName !== undefined)
+                            call.receiverTypeName = receiverTypeName;
+                        if (receiverCallChain !== undefined)
+                            call.receiverCallChain = receiverCallChain;
+                        result.calls.push(call);
                     }
                 }
                 continue;

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

@@ -31,6 +31,9 @@ export const createWorkerPool = (workerUrl, poolSize) => {
         const workerProgress = new Array(chunks.length).fill(0);
         const promises = chunks.map((chunk, i) => {
             const worker = workers[i];
+            if (worker === undefined) {
+                return Promise.reject(new Error(`Worker ${i} not available`));
+            }
             return new Promise((resolve, reject) => {
                 let settled = false;
                 let subBatchTimer = null;

package/dist/core/search/bm25-index.d.ts

@@ -1,20 +1,27 @@
 /**
  * @file bm25-index.ts
- * @description Symbol-level full-text search via LadybugDB FTS indexes.
+ * @description Symbol-level full-text search via SQLite FTS5 index.
  *
  * Returns individual symbols (functions, classes, methods, interfaces, files)
- * with their nodeId, name, type — NOT just filePaths.
+ * with their nodeId, name, type -- NOT just filePaths.
  * This gives the RRF merge symbol-level granularity for accurate ranking.
  *
- * All FTS tables are driven from FTS_TABLES in types.ts — single source of truth.
+ * Backed by the unified FTS5 index on the `nodes` table (see adapter.searchFTS).
  */
+import type Database from 'better-sqlite3';
 import { type BM25SearchResult } from './types.js';
 export type { BM25SearchResult } from './types.js';
 /**
- * Symbol-level BM25 search via LadybugDB FTS.
+ * Symbol-level BM25 search via SQLite FTS5.
  *
- * Queries all FTS_TABLES in parallel. Returns individual symbols (not filePaths).
- * Deduplicates by nodeId — if the same symbol matches in multiple indexes,
- * take the highest score.
+ * Queries the unified `nodes_fts` virtual table, deduplicates by nodeId,
+ * applies type-based weighting, and returns ranked results.
+ *
+ * Synchronous under the hood (better-sqlite3), but the function is sync --
+ * callers that `await` it still work (await on a non-Promise is a no-op).
+ *
+ * @param query - Search text
+ * @param limit - Max results to return (default 20)
+ * @param db - Open SQLite database instance (required; returns [] if undefined)
  */
-export declare function searchFTSFromLbug(query: string, limit?: number, repoId?: string): Promise<BM25SearchResult[]>;
+export declare function searchFTSSymbols(query: string, limit?: number, db?: Database.Database): BM25SearchResult[];