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

package/dist/core/ingestion/tree-sitter-queries.d.ts

@@ -4,8 +4,8 @@
  *   some grammars (typescript vs tsx vs javascript) have slightly different node types
  */
 import { SupportedLanguages } from '../../config/supported-languages.js';
-export declare const TYPESCRIPT_QUERIES = "\n(class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(interface_declaration\n  name: (type_identifier) @name) @definition.interface\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; B3: Dynamic import calls: const { foo } = await import('./module.js')\n(call_expression\n  function: (import) @call.name) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Heritage queries - class extends\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (extends_clause\n      value: (identifier) @heritage.extends))) @heritage\n\n; Heritage queries - class implements interface\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (implements_clause\n      (type_identifier) @heritage.implements))) @heritage.impl\n";
-export declare const JAVASCRIPT_QUERIES = "\n(class_declaration\n  name: (identifier) @name) @definition.class\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; B3: Dynamic import calls: const { foo } = await import('./module.js')\n(call_expression\n  function: (import) @call.name) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Heritage queries - class extends (JavaScript uses different AST than TypeScript)\n; In tree-sitter-javascript, class_heritage directly contains the parent identifier\n(class_declaration\n  name: (identifier) @heritage.class\n  (class_heritage\n    (identifier) @heritage.extends)) @heritage\n";
+export declare const TYPESCRIPT_QUERIES = "\n(class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(abstract_class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(interface_declaration\n  name: (type_identifier) @name) @definition.interface\n\n(type_alias_declaration\n  name: (type_identifier) @name) @definition.type\n\n(enum_declaration\n  name: (identifier) @name) @definition.enum\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; Interface method signatures: interface Foo { method(): void }\n(method_signature\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Namespace / internal module\n(internal_module\n  name: (identifier) @name) @definition.namespace\n\n; Ambient declarations: declare function foo(): void\n(ambient_declaration\n  (function_signature\n    name: (identifier) @name)) @definition.function\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Await calls: await foo() \u2014 tree-sitter wraps await inside the function position\n(call_expression\n  function: (await_expression\n    (identifier) @call.name)) @call\n\n; Await member calls: await obj.method()\n(call_expression\n  function: (await_expression\n    (member_expression\n      property: (property_identifier) @call.name))) @call\n\n; B3: Dynamic import calls: const { foo } = await import('./module.js')\n(call_expression\n  function: (import) @call.name) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Exported const from call: export const Schema = z.object({...})\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression)))) @definition.const\n\n; Exported const from new: export const client = new PrismaClient()\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (new_expression)))) @definition.const\n\n; Module-level const from new: const prisma = new PrismaClient()\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (new_expression))) @definition.const\n\n; Exported const from array: export const EDGE_TYPES = [...] as const\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (as_expression)))) @definition.const\n\n; Exported const from array literal: export const FOO = [1, 2, 3]\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (array)))) @definition.const\n\n; Exported const from object literal: export const CONFIG = { port: 3000 }\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (object)))) @definition.const\n\n; Exported const from number/string: export const MAX_DEPTH = 10\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (number)))) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (string)))) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (template_string)))) @definition.const\n\n; Object literal arrow function methods: const x = { method: () => {} }\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n; Object literal function expression methods: const x = { method: function() {} }\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n; Heritage queries - class extends\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (extends_clause\n      value: (identifier) @heritage.extends))) @heritage\n\n; Heritage queries - class implements interface\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (implements_clause\n      (type_identifier) @heritage.implements))) @heritage.impl\n";
+export declare const JAVASCRIPT_QUERIES = "\n(class_declaration\n  name: (identifier) @name) @definition.class\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Await calls: await foo()\n(call_expression\n  function: (await_expression\n    (identifier) @call.name)) @call\n\n; Await member calls: await obj.method()\n(call_expression\n  function: (await_expression\n    (member_expression\n      property: (property_identifier) @call.name))) @call\n\n; B3: Dynamic import calls: const { foo } = await import('./module.js')\n(call_expression\n  function: (import) @call.name) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Exported const from call: export const schema = z.object({...})\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression)))) @definition.const\n\n; Exported const from new: export const client = new Client()\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (new_expression)))) @definition.const\n\n; Module-level const from new: const instance = new Class()\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (new_expression))) @definition.const\n\n; Exported const from array: export const ITEMS = [...]\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (array)))) @definition.const\n\n; Exported const from object: export const CONFIG = { ... }\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (object)))) @definition.const\n\n; Exported const from number/string\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (number)))) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (string)))) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (template_string)))) @definition.const\n\n; Object literal arrow function methods: const x = { method: () => {} }\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n; Object literal function expression methods: const x = { method: function() {} }\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n; Heritage queries - class extends (JavaScript uses different AST than TypeScript)\n; In tree-sitter-javascript, class_heritage directly contains the parent identifier\n(class_declaration\n  name: (identifier) @heritage.class\n  (class_heritage\n    (identifier) @heritage.extends)) @heritage\n";
 export declare const PYTHON_QUERIES = "\n(class_definition\n  name: (identifier) @name) @definition.class\n\n(function_definition\n  name: (identifier) @name) @definition.function\n\n(import_statement\n  name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (relative_import) @import.source) @import\n\n(call\n  function: (identifier) @call.name) @call\n\n(call\n  function: (attribute\n    attribute: (identifier) @call.name)) @call\n\n; Heritage queries - Python class inheritance\n(class_definition\n  name: (identifier) @heritage.class\n  superclasses: (argument_list\n    (identifier) @heritage.extends)) @heritage\n";
 export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n\n; Constructor calls: new Foo()\n(object_creation_expression type: (type_identifier) @call.name) @call\n\n; Heritage - extends class\n(class_declaration name: (identifier) @heritage.class\n  (superclass (type_identifier) @heritage.extends)) @heritage\n\n; Heritage - implements interfaces\n(class_declaration name: (identifier) @heritage.class\n  (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl\n";
 export declare const C_QUERIES = "\n; Functions (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n\n; Functions returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n\n; Functions returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n\n; Structs, Unions, Enums, Typedefs\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(union_specifier name: (type_identifier) @name) @definition.union\n(enum_specifier name: (type_identifier) @name) @definition.enum\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n";

package/dist/core/ingestion/tree-sitter-queries.js

@@ -10,15 +10,28 @@ export const TYPESCRIPT_QUERIES = `
 (class_declaration
   name: (type_identifier) @name) @definition.class
 
+(abstract_class_declaration
+  name: (type_identifier) @name) @definition.class
+
 (interface_declaration
   name: (type_identifier) @name) @definition.interface
 
+(type_alias_declaration
+  name: (type_identifier) @name) @definition.type
+
+(enum_declaration
+  name: (identifier) @name) @definition.enum
+
 (function_declaration
   name: (identifier) @name) @definition.function
 
 (method_definition
   name: (property_identifier) @name) @definition.method
 
+; Interface method signatures: interface Foo { method(): void }
+(method_signature
+  name: (property_identifier) @name) @definition.method
+
 (lexical_declaration
   (variable_declarator
     name: (identifier) @name
@@ -41,6 +54,15 @@ export const TYPESCRIPT_QUERIES = `
       name: (identifier) @name
       value: (function_expression)))) @definition.function
 
+; Namespace / internal module
+(internal_module
+  name: (identifier) @name) @definition.namespace
+
+; Ambient declarations: declare function foo(): void
+(ambient_declaration
+  (function_signature
+    name: (identifier) @name)) @definition.function
+
 (import_statement
   source: (string) @import.source) @import
 
@@ -55,6 +77,17 @@ export const TYPESCRIPT_QUERIES = `
   function: (member_expression
     property: (property_identifier) @call.name)) @call
 
+; Await calls: await foo() — tree-sitter wraps await inside the function position
+(call_expression
+  function: (await_expression
+    (identifier) @call.name)) @call
+
+; Await member calls: await obj.method()
+(call_expression
+  function: (await_expression
+    (member_expression
+      property: (property_identifier) @call.name))) @call
+
 ; B3: Dynamic import calls: const { foo } = await import('./module.js')
 (call_expression
   function: (import) @call.name) @call
@@ -63,6 +96,76 @@ export const TYPESCRIPT_QUERIES = `
 (new_expression
   constructor: (identifier) @call.name) @call
 
+; Exported const from call: export const Schema = z.object({...})
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (call_expression)))) @definition.const
+
+; Exported const from new: export const client = new PrismaClient()
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (new_expression)))) @definition.const
+
+; Module-level const from new: const prisma = new PrismaClient()
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (new_expression))) @definition.const
+
+; Exported const from array: export const EDGE_TYPES = [...] as const
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (as_expression)))) @definition.const
+
+; Exported const from array literal: export const FOO = [1, 2, 3]
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (array)))) @definition.const
+
+; Exported const from object literal: export const CONFIG = { port: 3000 }
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (object)))) @definition.const
+
+; Exported const from number/string: export const MAX_DEPTH = 10
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (number)))) @definition.const
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (string)))) @definition.const
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (template_string)))) @definition.const
+
+; Object literal arrow function methods: const x = { method: () => {} }
+(pair
+  key: (property_identifier) @name
+  value: (arrow_function)) @definition.function
+
+; Object literal function expression methods: const x = { method: function() {} }
+(pair
+  key: (property_identifier) @name
+  value: (function_expression)) @definition.function
+
 ; Heritage queries - class extends
 (class_declaration
   name: (type_identifier) @heritage.class
@@ -124,6 +227,17 @@ export const JAVASCRIPT_QUERIES = `
   function: (member_expression
     property: (property_identifier) @call.name)) @call
 
+; Await calls: await foo()
+(call_expression
+  function: (await_expression
+    (identifier) @call.name)) @call
+
+; Await member calls: await obj.method()
+(call_expression
+  function: (await_expression
+    (member_expression
+      property: (property_identifier) @call.name))) @call
+
 ; B3: Dynamic import calls: const { foo } = await import('./module.js')
 (call_expression
   function: (import) @call.name) @call
@@ -132,6 +246,69 @@ export const JAVASCRIPT_QUERIES = `
 (new_expression
   constructor: (identifier) @call.name) @call
 
+; Exported const from call: export const schema = z.object({...})
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (call_expression)))) @definition.const
+
+; Exported const from new: export const client = new Client()
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (new_expression)))) @definition.const
+
+; Module-level const from new: const instance = new Class()
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (new_expression))) @definition.const
+
+; Exported const from array: export const ITEMS = [...]
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (array)))) @definition.const
+
+; Exported const from object: export const CONFIG = { ... }
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (object)))) @definition.const
+
+; Exported const from number/string
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (number)))) @definition.const
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (string)))) @definition.const
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (template_string)))) @definition.const
+
+; Object literal arrow function methods: const x = { method: () => {} }
+(pair
+  key: (property_identifier) @name
+  value: (arrow_function)) @definition.function
+
+; Object literal function expression methods: const x = { method: function() {} }
+(pair
+  key: (property_identifier) @name
+  value: (function_expression)) @definition.function
+
 ; Heritage queries - class extends (JavaScript uses different AST than TypeScript)
 ; In tree-sitter-javascript, class_heritage directly contains the parent identifier
 (class_declaration

package/dist/core/ingestion/type-env.js

@@ -6,6 +6,7 @@
  *   Tier 2: single-pass assignment chain propagation
  */
 import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
 import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js';
 import { extractSimpleTypeName, stripNullable } from './type-extractors/shared.js';
 // File-level scope key
@@ -329,6 +330,25 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
         }
     };
     walk(tree.rootNode, FILE_SCOPE);
+    // Tier 1.5: Promote TypeScript constructor parameter properties to file scope.
+    // `constructor(private eventBus: EventBus)` makes `eventBus` a class property
+    // accessible in ALL methods via `this.eventBus`, not just within the constructor.
+    // Walk constructor scopes and find parameters with accessibility modifiers.
+    if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) {
+        const fileEnv = env.get(FILE_SCOPE) ?? new Map();
+        if (!env.has(FILE_SCOPE))
+            env.set(FILE_SCOPE, fileEnv);
+        for (const [scope, scopeEnv] of env) {
+            if (!scope.startsWith('constructor@'))
+                continue;
+            for (const [varName, typeName] of scopeEnv) {
+                // Promote to file scope so all class methods can access via this.varName
+                if (!fileEnv.has(varName)) {
+                    fileEnv.set(varName, typeName);
+                }
+            }
+        }
+    }
     // Tier 2: single-pass assignment chain propagation in source order
     // Resolves `const b = a` where `a` has a known type from Tier 0/1
     // No fixpoint iteration — covers 95%+ of real-world patterns

package/dist/core/ingestion/type-extractors/csharp.js

@@ -59,9 +59,10 @@ const extractDeclaration = (node, env) => {
         // Try to infer from initializer: var x = new Foo()
         // tree-sitter-c-sharp may put object_creation_expression as direct child
         // or inside equals_value_clause depending on grammar version
-        if (declarators.length === 1) {
-            const initializer = findChildByType(declarators[0], 'object_creation_expression')
-                ?? findChildByType(declarators[0], 'equals_value_clause')?.firstNamedChild;
+        const firstDeclarator = declarators.length === 1 ? declarators[0] : undefined;
+        if (firstDeclarator) {
+            const initializer = findChildByType(firstDeclarator, 'object_creation_expression')
+                ?? findChildByType(firstDeclarator, 'equals_value_clause')?.firstNamedChild;
             if (initializer?.type === 'object_creation_expression') {
                 const ctorType = initializer.childForFieldName('type');
                 if (ctorType)

package/dist/core/ingestion/type-extractors/go.js

@@ -61,6 +61,9 @@ const extractGoShortVarDeclaration = (node, env) => {
     const count = Math.min(lhsNodes.length, rhsNodes.length);
     for (let i = 0; i < count; i++) {
         let valueNode = rhsNodes[i];
+        const lhsNode = lhsNodes[i];
+        if (!valueNode || !lhsNode)
+            continue;
         // Unwrap &User{} -- unary_expression (address-of) wrapping composite_literal
         if (valueNode.type === 'unary_expression' && valueNode.firstNamedChild?.type === 'composite_literal') {
             valueNode = valueNode.firstNamedChild;
@@ -73,7 +76,7 @@ const extractGoShortVarDeclaration = (node, env) => {
                 const args = valueNode.childForFieldName('arguments');
                 if (args?.firstNamedChild) {
                     const typeName = extractSimpleTypeName(args.firstNamedChild);
-                    const varName = extractVarName(lhsNodes[i]);
+                    const varName = extractVarName(lhsNode);
                     if (varName && typeName)
                         env.set(varName, typeName);
                 }
@@ -91,7 +94,7 @@ const extractGoShortVarDeclaration = (node, env) => {
                     }
                     if (innerType) {
                         const typeName = extractSimpleTypeName(innerType);
-                        const varName = extractVarName(lhsNodes[i]);
+                        const varName = extractVarName(lhsNode);
                         if (varName && typeName)
                             env.set(varName, typeName);
                     }
@@ -104,7 +107,7 @@ const extractGoShortVarDeclaration = (node, env) => {
             const typeNode = valueNode.childForFieldName('type');
             if (typeNode) {
                 const typeName = extractSimpleTypeName(typeNode);
-                const varName = extractVarName(lhsNodes[i]);
+                const varName = extractVarName(lhsNode);
                 if (varName && typeName)
                     env.set(varName, typeName);
             }
@@ -118,7 +121,7 @@ const extractGoShortVarDeclaration = (node, env) => {
         const typeName = extractSimpleTypeName(typeNode);
         if (!typeName)
             continue;
-        const varName = extractVarName(lhsNodes[i]);
+        const varName = extractVarName(lhsNode);
         if (varName)
             env.set(varName, typeName);
     }
@@ -162,15 +165,19 @@ const scanConstructorBinding = (node) => {
     const rightExprs = right.type === 'expression_list' ? right.namedChildren : [right];
     // Multi-return: user, err := NewUser() -- bind first var when second is err/ok/_
     if (leftIds.length === 2 && rightExprs.length === 1) {
+        const firstVar = leftIds[0];
         const secondVar = leftIds[1];
+        const singleExpr = rightExprs[0];
+        if (!firstVar || !secondVar || !singleExpr)
+            return undefined;
         const isErrorOrDiscard = secondVar.text === '_' ||
             secondVar.text === 'err' ||
             secondVar.text === 'ok' ||
             secondVar.text === 'error';
-        if (isErrorOrDiscard && leftIds[0].type === 'identifier') {
-            if (rightExprs[0].type !== 'call_expression')
+        if (isErrorOrDiscard && firstVar.type === 'identifier') {
+            if (singleExpr.type !== 'call_expression')
                 return undefined;
-            const func = rightExprs[0].childForFieldName('function');
+            const func = singleExpr.childForFieldName('function');
             if (!func)
                 return undefined;
             if (func.text === 'new' || func.text === 'make')
@@ -178,15 +185,19 @@ const scanConstructorBinding = (node) => {
             const calleeName = extractSimpleTypeName(func);
             if (!calleeName)
                 return undefined;
-            return { varName: leftIds[0].text, calleeName };
+            return { varName: firstVar.text, calleeName };
         }
     }
     // Single assignment only
-    if (leftIds.length !== 1 || leftIds[0].type !== 'identifier')
+    const singleLeft = leftIds[0];
+    const singleRight = rightExprs[0];
+    if (!singleLeft || !singleRight)
+        return undefined;
+    if (leftIds.length !== 1 || singleLeft.type !== 'identifier')
         return undefined;
-    if (rightExprs.length !== 1 || rightExprs[0].type !== 'call_expression')
+    if (rightExprs.length !== 1 || singleRight.type !== 'call_expression')
         return undefined;
-    const func = rightExprs[0].childForFieldName('function');
+    const func = singleRight.childForFieldName('function');
     if (!func)
         return undefined;
     // Skip new() and make() -- already handled by extractDeclaration
@@ -195,7 +206,7 @@ const scanConstructorBinding = (node) => {
     const calleeName = extractSimpleTypeName(func);
     if (!calleeName)
         return undefined;
-    return { varName: leftIds[0].text, calleeName };
+    return { varName: singleLeft.text, calleeName };
 };
 // Go: alias := u (short_var_declaration) or var b = u (var_spec)
 const extractPendingAssignment = (node, scopeEnv) => {

package/dist/core/ingestion/type-extractors/php.js

@@ -53,12 +53,15 @@ const normalizePhpType = (raw) => {
     type = type.replace(/\[\]$/, '');
     // Strip union with null/false/void: User|null -> User
     const parts = type.split('|').filter(p => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed');
-    if (parts.length !== 1)
+    if (parts.length !== 1 || !parts[0])
         return undefined;
     type = parts[0];
     // Strip namespace: \App\Models\User -> User
     const segments = type.split('\\');
-    type = segments[segments.length - 1];
+    const lastSegment = segments[segments.length - 1];
+    if (!lastSegment)
+        return undefined;
+    type = lastSegment;
     // Skip uninformative types
     if (type === 'mixed' || type === 'void' || type === 'self' || type === 'static' || type === 'object')
         return undefined;
@@ -96,8 +99,11 @@ const collectPhpDocParams = (methodNode) => {
     PHPDOC_PARAM_RE.lastIndex = 0;
     let match;
     while ((match = PHPDOC_PARAM_RE.exec(commentBlock)) !== null) {
-        const typeName = normalizePhpType(match[1]);
+        const rawType = match[1];
         const paramName = match[2]; // without $ prefix
+        if (!rawType || !paramName)
+            continue;
+        const typeName = normalizePhpType(rawType);
         if (typeName) {
             // Store with $ prefix to match how PHP variables appear in the env
             params.set('$' + paramName, typeName);
@@ -107,9 +113,12 @@ const collectPhpDocParams = (methodNode) => {
     PHPDOC_PARAM_ALT_RE.lastIndex = 0;
     while ((match = PHPDOC_PARAM_ALT_RE.exec(commentBlock)) !== null) {
         const paramName = match[1];
+        const rawType = match[2];
+        if (!paramName || !rawType)
+            continue;
         if (params.has('$' + paramName))
             continue; // standard format takes priority
-        const typeName = normalizePhpType(match[2]);
+        const typeName = normalizePhpType(rawType);
         if (typeName) {
             params.set('$' + paramName, typeName);
         }
@@ -197,7 +206,6 @@ const extractParameter = (node, env) => {
     if (varName && typeName)
         env.set(varName, typeName);
 };
-// PHP: $x = SomeFactory() or $x = $this->getUser() -- bind variable to call return type
 const scanConstructorBinding = (node) => {
     if (node.type !== 'assignment_expression')
         return undefined;
@@ -224,14 +232,14 @@ const scanConstructorBinding = (node) => {
         // When receiver is $this/self/static, qualify with enclosing class for disambiguation
         const receiver = right.childForFieldName('object');
         const receiverText = receiver?.text;
-        let receiverClassName;
         if (receiverText === '$this' || receiverText === 'self' || receiverText === 'static') {
             const cls = findEnclosingClass(node);
             const clsName = cls?.childForFieldName('name');
-            if (clsName)
-                receiverClassName = clsName.text;
+            if (clsName) {
+                return { varName: left.text, calleeName: methodName.text, receiverClassName: clsName.text };
+            }
         }
-        return { varName: left.text, calleeName: methodName.text, receiverClassName };
+        return { varName: left.text, calleeName: methodName.text };
     }
     return undefined;
 };
@@ -243,7 +251,7 @@ const extractReturnType = (node) => {
     while (sibling) {
         if (sibling.type === 'comment') {
             const match = PHPDOC_RETURN_RE.exec(sibling.text);
-            if (match)
+            if (match?.[1])
                 return normalizePhpType(match[1]);
         }
         else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type))

package/dist/core/ingestion/type-extractors/ruby.js

@@ -44,13 +44,21 @@ const extractYardTypeName = (yardType) => {
     if (filtered.length !== 1)
         return undefined; // ambiguous union
     const typePart = filtered[0];
+    if (typePart === undefined)
+        return undefined;
     // Handle qualified: "Models::User" -> "User"
     const segments = typePart.split('::');
     const last = segments[segments.length - 1];
+    if (last === undefined)
+        return undefined;
     // Handle generic: "Array<User>" -> "Array"
     const genericMatch = last.match(/^(\w+)\s*[<{(]/);
-    if (genericMatch)
-        return genericMatch[1];
+    if (genericMatch) {
+        const matched = genericMatch[1];
+        if (matched === undefined)
+            return undefined;
+        return matched;
+    }
     // Simple identifier check
     if (/^\w+$/.test(last))
         return last;
@@ -97,6 +105,8 @@ const collectYardParams = (methodNode) => {
     while ((match = YARD_PARAM_RE.exec(commentBlock)) !== null) {
         const paramName = match[1];
         const rawType = match[2];
+        if (paramName === undefined || rawType === undefined)
+            continue;
         const typeName = extractYardTypeName(rawType);
         if (typeName) {
             params.set(paramName, typeName);
@@ -107,6 +117,8 @@ const collectYardParams = (methodNode) => {
     while ((match = YARD_PARAM_ALT_RE.exec(commentBlock)) !== null) {
         const rawType = match[1];
         const paramName = match[2];
+        if (rawType === undefined || paramName === undefined)
+            continue;
         if (params.has(paramName))
             continue; // standard format takes priority
         const typeName = extractYardTypeName(rawType);
@@ -163,7 +175,7 @@ const extractReturnType = (node) => {
         while (sibling) {
             if (sibling.type === 'comment') {
                 const match = YARD_RETURN_RE.exec(sibling.text);
-                if (match)
+                if (match && match[1] !== undefined)
                     return extractYardTypeName(match[1]);
             }
             else if (sibling.isNamed) {

package/dist/core/ingestion/type-extractors/rust.js

@@ -275,9 +275,10 @@ const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
         return undefined;
     const typeArgs = extractGenericTypeArgs(typeAstNode);
     const argIndex = wrapperName === 'Err' ? 1 : 0;
-    if (typeArgs.length < argIndex + 1)
+    const extractedType = typeArgs[argIndex];
+    if (!extractedType)
         return undefined;
-    return { varName: innerVar, typeName: typeArgs[argIndex] };
+    return { varName: innerVar, typeName: extractedType };
 };
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,

package/dist/core/ingestion/type-extractors/shared.js

@@ -76,8 +76,9 @@ export const extractSimpleTypeName = (typeNode) => {
             nonNullTypes.push(child);
         }
         // Only unwrap if exactly one meaningful type remains
-        if (nonNullTypes.length === 1) {
-            return extractSimpleTypeName(nonNullTypes[0]);
+        const single = nonNullTypes.length === 1 ? nonNullTypes[0] : undefined;
+        if (single) {
+            return extractSimpleTypeName(single);
         }
     }
     // Type annotations that wrap the actual type (TS/Python: `: Foo`, Kotlin: user_type)

package/dist/core/ingestion/type-extractors/typescript.js

@@ -16,7 +16,7 @@ const normalizeJsDocType = (raw) => {
         type = type.slice(1);
     // Strip union with null/undefined/void: User|null -> User
     const parts = type.split('|').map(p => p.trim()).filter(p => p !== 'null' && p !== 'undefined' && p !== 'void');
-    if (parts.length !== 1)
+    if (parts.length !== 1 || !parts[0])
         return undefined; // ambiguous union
     type = parts[0];
     // Strip module: prefix -- module:models.User -> models.User
@@ -24,10 +24,13 @@ const normalizeJsDocType = (raw) => {
         type = type.slice(7);
     // Take last segment of dotted path: models.User -> User
     const segments = type.split('.');
-    type = segments[segments.length - 1];
+    const lastSegment = segments[segments.length - 1];
+    if (!lastSegment)
+        return undefined;
+    type = lastSegment;
     // Strip generic wrapper: Promise<User> -> Promise (base type, not inner)
     const genericMatch = type.match(/^(\w+)\s*</);
-    if (genericMatch)
+    if (genericMatch?.[1])
         type = genericMatch[1];
     // Simple identifier check
     if (/^\w+$/.test(type))
@@ -59,8 +62,11 @@ const collectJsDocParams = (funcNode) => {
     JSDOC_PARAM_RE.lastIndex = 0;
     let match;
     while ((match = JSDOC_PARAM_RE.exec(commentBlock)) !== null) {
-        const typeName = normalizeJsDocType(match[1]);
+        const rawType = match[1];
         const paramName = match[2];
+        if (!rawType || !paramName)
+            continue;
+        const typeName = normalizeJsDocType(rawType);
         if (typeName) {
             params.set(paramName, typeName);
         }
@@ -189,7 +195,7 @@ const extractReturnType = (node) => {
     while (sibling) {
         if (sibling.type === 'comment') {
             const match = JSDOC_RETURN_RE.exec(sibling.text);
-            if (match)
+            if (match?.[1])
                 return sanitizeReturnType(match[1]);
         }
         else if (sibling.isNamed && sibling.type !== 'decorator')

package/dist/core/ingestion/utils.d.ts

@@ -14,10 +14,33 @@ export declare const getDefinitionNodeFromCaptures: (captureMap: Record<string,
 export declare const FUNCTION_NODE_TYPES: Set<string>;
 /** Node types for standard function declarations that need C/C++ declarator handling */
 export declare const FUNCTION_DECLARATION_TYPES: Set<string>;
-/** Built-in function/method names that should not be tracked as call targets */
-export declare const BUILT_IN_NAMES: Set<string>;
-/** Check if a name is a built-in or common noise that should be filtered out */
-export declare const isBuiltInOrNoise: (name: string) => boolean;
+/**
+ * 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 declare const FREE_CALL_BUILTINS: Set<string>;
+/**
+ * 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 declare const MEMBER_NOISE_NAMES: Set<string>;
+/**
+ * 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 declare const isBuiltInOrNoise: (name: string, callForm?: "free" | "member" | "constructor") => boolean;
 /** AST node types representing class-like containers (for HAS_METHOD edges) */
 export declare const CLASS_CONTAINER_TYPES: Set<string>;
 export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;