gitnexus 1.4.10 → 1.5.0

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

@@ -1,8 +1,8 @@
-import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES } from './utils/ast-helpers.js';
+import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { CALL_EXPRESSION_TYPES } from './utils/call-analysis.js';
 import { TYPED_PARAMETER_TYPES } from './type-extractors/shared.js';
 import { getProvider } from './languages/index.js';
-import { extractSimpleTypeName, extractVarName, stripNullable, extractReturnTypeName } from './type-extractors/shared.js';
+import { extractSimpleTypeName, extractVarName, stripNullable, extractReturnTypeName, } from './type-extractors/shared.js';
 /** File-level scope key */
 const FILE_SCOPE = '';
 /** Shared empty map for files with no file-scope bindings. */
@@ -48,7 +48,7 @@ const FAST_NULLABLE_KEYWORDS = new Set(['null', 'undefined', 'void', 'None', 'ni
 const fastStripNullable = (typeName) => {
     if (FAST_NULLABLE_KEYWORDS.has(typeName))
         return undefined;
-    return (typeName.indexOf('|') === -1 && typeName.indexOf('?') === -1)
+    return typeName.indexOf('|') === -1 && typeName.indexOf('?') === -1
         ? typeName
         : stripNullable(typeName);
 };
@@ -107,8 +107,7 @@ const findEnclosingClassName = (node) => {
     let current = node.parent;
     while (current) {
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
-            const nameNode = current.childForFieldName('name')
-                ?? findTypeIdentifierChild(current);
+            const nameNode = current.childForFieldName('name') ?? findTypeIdentifierChild(current);
             if (nameNode) {
                 enclosingClassNameCache.set(node, nameNode.text);
                 return nameNode.text;
@@ -172,9 +171,7 @@ const extractParentClassFromNode = (classNode) => {
     const superclassNode = classNode.childForFieldName('superclass');
     if (superclassNode) {
         // Java: superclass > type_identifier or generic_type, Ruby: superclass > constant
-        const inner = superclassNode.childForFieldName('type')
-            ?? superclassNode.firstNamedChild
-            ?? superclassNode;
+        const inner = superclassNode.childForFieldName('type') ?? superclassNode.firstNamedChild ?? superclassNode;
         return extractSimpleTypeName(inner) ?? inner.text;
     }
     const superclassesNode = classNode.childForFieldName('superclasses');
@@ -316,7 +313,9 @@ const createClassNameLookup = (localNames, symbolTable) => {
             const cached = memo.get(name);
             if (cached !== undefined)
                 return cached;
-            const result = symbolTable.lookupFuzzy(name).some(def => def.type === 'Class' || def.type === 'Enum' || def.type === 'Struct');
+            const result = symbolTable
+                .lookupFuzzy(name)
+                .some((def) => def.type === 'Class' || def.type === 'Enum' || def.type === 'Struct');
             memo.set(name, result);
             return result;
         },
@@ -341,15 +340,25 @@ const createClassNameLookup = (localNames, symbolTable) => {
 const SKIP_SUBTREE_TYPES = new Set([
     // Plain string literals (NOT template_string — it contains interpolated expressions
     // that can hold arrow functions with typed parameters, e.g. `${(x: T) => x}`)
-    'string', 'string_literal',
-    'string_content', 'string_fragment', 'heredoc_body',
+    'string',
+    'string_literal',
+    'string_content',
+    'string_fragment',
+    'heredoc_body',
     // Comments
-    'comment', 'line_comment', 'block_comment',
+    'comment',
+    'line_comment',
+    'block_comment',
     // Numeric/boolean/null literals
-    'number', 'integer_literal', 'float_literal',
-    'true', 'false', 'null',
+    'number',
+    'integer_literal',
+    'float_literal',
+    'true',
+    'false',
+    'null',
     // Regex
-    'regex', 'regex_pattern',
+    'regex',
+    'regex_pattern',
 ]);
 const CLASS_LIKE_TYPES = new Set(['Class', 'Struct', 'Interface']);
 /** Memoize class definition lookups during fixpoint iteration.
@@ -361,7 +370,7 @@ const createClassDefCache = (symbolTable) => {
         let result = cache.get(typeName);
         if (result === undefined) {
             result = symbolTable
-                ? symbolTable.lookupFuzzy(typeName).filter(d => CLASS_LIKE_TYPES.has(d.type))
+                ? symbolTable.lookupFuzzy(typeName).filter((d) => CLASS_LIKE_TYPES.has(d.type))
                 : [];
             cache.set(typeName, result);
         }
@@ -402,8 +411,9 @@ const extractConstructorTypeName = (node, depth = 0) => {
             continue;
         // Don't descend into nested functions/classes or call expressions (prevents
         // finding constructor args inside method calls, e.g. processAll(new Dog()))
-        if (FUNCTION_NODE_TYPES.has(child.type) || CLASS_CONTAINER_TYPES.has(child.type)
-            || CALL_EXPRESSION_TYPES.has(child.type))
+        if (FUNCTION_NODE_TYPES.has(child.type) ||
+            CLASS_CONTAINER_TYPES.has(child.type) ||
+            CALL_EXPRESSION_TYPES.has(child.type))
             continue;
         const result = extractConstructorTypeName(child, depth + 1);
         if (result)
@@ -480,8 +490,8 @@ const resolveFieldType = (receiver, field, scopeEnv, symbolTable, getClassDefs,
     const receiverType = scopeEnv.get(receiver);
     if (!receiverType)
         return undefined;
-    const lookup = getClassDefs
-        ?? ((name) => symbolTable.lookupFuzzy(name).filter(d => CLASS_LIKE_TYPES.has(d.type)));
+    const lookup = getClassDefs ??
+        ((name) => symbolTable.lookupFuzzy(name).filter((d) => CLASS_LIKE_TYPES.has(d.type)));
     const classDefs = lookup(receiverType);
     if (classDefs.length !== 1)
         return undefined;
@@ -506,23 +516,25 @@ const resolveMethodReturnType = (receiver, method, scopeEnv, symbolTable, getCla
     const receiverType = scopeEnv.get(receiver);
     if (!receiverType)
         return undefined;
-    const lookup = getClassDefs
-        ?? ((name) => symbolTable.lookupFuzzy(name).filter(d => CLASS_LIKE_TYPES.has(d.type)));
+    const lookup = getClassDefs ??
+        ((name) => symbolTable.lookupFuzzy(name).filter((d) => CLASS_LIKE_TYPES.has(d.type)));
     const classDefs = lookup(receiverType);
     if (classDefs.length === 0)
         return undefined;
     // Direct lookup first
-    const classNodeIds = new Set(classDefs.map(d => d.nodeId));
-    const methods = symbolTable.lookupFuzzyCallable(method)
-        .filter(d => d.ownerId && classNodeIds.has(d.ownerId));
+    const classNodeIds = new Set(classDefs.map((d) => d.nodeId));
+    const methods = symbolTable
+        .lookupFuzzyCallable(method)
+        .filter((d) => d.ownerId && classNodeIds.has(d.ownerId));
     if (methods.length === 1 && methods[0].returnType) {
         return extractReturnTypeName(methods[0].returnType);
     }
     // MRO parent chain walking on miss
     if (methods.length === 0) {
         const inherited = walkParentChain(receiverType, parentMap, lookup, (nodeId) => {
-            const parentMethods = symbolTable.lookupFuzzyCallable(method)
-                .filter(d => d.ownerId === nodeId);
+            const parentMethods = symbolTable
+                .lookupFuzzyCallable(method)
+                .filter((d) => d.ownerId === nodeId);
             if (parentMethods.length !== 1 || !parentMethods[0].returnType)
                 return undefined;
             return extractReturnTypeName(parentMethods[0].returnType);
@@ -667,14 +679,14 @@ export const buildTypeEnv = (tree, language, options) => {
             // Cross-file fallback uses importedRawReturnTypes (raw declared types, e.g., 'User[]')
             // NOT importedReturnTypes (which contains processed/simple types via extractReturnTypeName)
             return options?.importedRawReturnTypes?.get(callee);
-        }
+        },
     };
     // Pre-compute combined set of node types that need extractTypeBinding.
     // Single Set.has() replaces 3 separate checks per node in walk().
     const interestingNodeTypes = new Set();
-    TYPED_PARAMETER_TYPES.forEach(t => interestingNodeTypes.add(t));
-    config.declarationNodeTypes.forEach(t => interestingNodeTypes.add(t));
-    config.forLoopNodeTypes?.forEach(t => interestingNodeTypes.add(t));
+    TYPED_PARAMETER_TYPES.forEach((t) => interestingNodeTypes.add(t));
+    config.declarationNodeTypes.forEach((t) => interestingNodeTypes.add(t));
+    config.forLoopNodeTypes?.forEach((t) => interestingNodeTypes.add(t));
     // Tier 2: unified fixpoint propagation — collects copy, callResult, fieldAccess, and
     // methodCallResult items during walk(), then iterates until no new bindings are produced.
     // Handles arbitrary-depth mixed chains: callResult → fieldAccess → methodCallResult → copy.
@@ -708,12 +720,12 @@ export const buildTypeEnv = (tree, language, options) => {
             // Most languages use 'name' field; Rust uses 'pattern'; TS uses 'pattern' for some param types.
             // Kotlin `parameter` nodes use positional children instead of named fields,
             // so we fall back to scanning children by type when childForFieldName returns null.
-            let typeNode = node.childForFieldName('type');
+            const typeNode = node.childForFieldName('type');
             if (typeNode) {
-                const nameNode = node.childForFieldName('name')
-                    ?? node.childForFieldName('pattern')
+                const nameNode = node.childForFieldName('name') ??
+                    node.childForFieldName('pattern') ??
                     // Python typed_parameter: name is a positional child (identifier), not a named field
-                    ?? (node.firstNamedChild?.type === 'identifier' ? node.firstNamedChild : null);
+                    (node.firstNamedChild?.type === 'identifier' ? node.firstNamedChild : null);
                 if (nameNode) {
                     const varName = extractVarName(nameNode);
                     if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) {
@@ -729,12 +741,16 @@ export const buildTypeEnv = (tree, language, options) => {
                     const child = node.namedChild(i);
                     if (!child)
                         continue;
-                    if (!fallbackName && (child.type === 'simple_identifier' || child.type === 'identifier')) {
+                    if (!fallbackName &&
+                        (child.type === 'simple_identifier' || child.type === 'identifier')) {
                         fallbackName = child;
                     }
-                    if (!fallbackType && (child.type === 'user_type' || child.type === 'type_identifier'
-                        || child.type === 'generic_type' || child.type === 'parameterized_type'
-                        || child.type === 'nullable_type')) {
+                    if (!fallbackType &&
+                        (child.type === 'user_type' ||
+                            child.type === 'type_identifier' ||
+                            child.type === 'generic_type' ||
+                            child.type === 'parameterized_type' ||
+                            child.type === 'nullable_type')) {
                         fallbackType = child;
                     }
                 }
@@ -753,7 +769,12 @@ export const buildTypeEnv = (tree, language, options) => {
         if (config.forLoopNodeTypes?.has(node.type)) {
             if (config.extractForLoopBinding) {
                 const sizeBefore = scopeEnv.size;
-                const forLoopCtx = { scopeEnv, declarationTypeNodes, scope, returnTypeLookup };
+                const forLoopCtx = {
+                    scopeEnv,
+                    declarationTypeNodes,
+                    scope,
+                    returnTypeLookup,
+                };
                 config.extractForLoopBinding(node, forLoopCtx);
                 // If no new binding was produced, the iterable's type may not yet be resolved.
                 // Store for post-fixpoint replay (Phase 10 / ex-9B loop-fixpoint bridge).
@@ -813,9 +834,9 @@ export const buildTypeEnv = (tree, language, options) => {
                 }
             }
             if (typeNode) {
-                const nameNode = node.childForFieldName('name')
-                    ?? node.childForFieldName('left')
-                    ?? node.childForFieldName('pattern');
+                const nameNode = node.childForFieldName('name') ??
+                    node.childForFieldName('left') ??
+                    node.childForFieldName('pattern');
                 if (nameNode) {
                     const varName = extractVarName(nameNode);
                     if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) {
@@ -863,14 +884,13 @@ export const buildTypeEnv = (tree, language, options) => {
                     const declaredType = scopeEnv.get(varName);
                     if (!declaredType)
                         continue;
-                    const ctorType = extractConstructorTypeName(node)
-                        ?? config.detectConstructorType?.(node, classNames);
+                    const ctorType = extractConstructorTypeName(node) ?? config.detectConstructorType?.(node, classNames);
                     if (!ctorType || ctorType === declaredType)
                         continue;
                     // Unwrap wrapper types (e.g., C++ shared_ptr<Animal> → Animal) for an
                     // accurate isSubclassOf comparison. Language-specific via config hook.
                     const declTypeNode = declarationTypeNodes.get(`${scope}\0${varName}`);
-                    const effectiveDeclaredType = (declTypeNode && config.unwrapDeclaredType)
+                    const effectiveDeclaredType = declTypeNode && config.unwrapDeclaredType
                         ? (config.unwrapDeclaredType(declaredType, declTypeNode) ?? declaredType)
                         : declaredType;
                     if (ctorType !== effectiveDeclaredType) {
@@ -889,8 +909,7 @@ export const buildTypeEnv = (tree, language, options) => {
         // Currently only C++ uses this locally; other languages rely on the SymbolTable path.
         if (CLASS_CONTAINER_TYPES.has(node.type)) {
             // Most languages use 'name' field; Kotlin uses a type_identifier child instead
-            const nameNode = node.childForFieldName('name')
-                ?? findTypeIdentifierChild(node);
+            const nameNode = node.childForFieldName('name') ?? findTypeIdentifierChild(node);
             if (nameNode)
                 localClassNames.add(nameNode.text);
         }
@@ -914,7 +933,8 @@ export const buildTypeEnv = (tree, language, options) => {
         // or narrow existing variables within a branch (null-check narrowing).
         // Runs after Tier 0/1 so scopeEnv already contains the source variable's type.
         // Conservative: extractor returns undefined when source type is unknown.
-        if (config.extractPatternBinding && (!config.patternBindingNodeTypes || config.patternBindingNodeTypes.has(node.type))) {
+        if (config.extractPatternBinding &&
+            (!config.patternBindingNodeTypes || config.patternBindingNodeTypes.has(node.type))) {
             // Ensure scopeEnv exists for pattern binding reads/writes
             if (!env.has(scope))
                 env.set(scope, new Map());
@@ -1020,7 +1040,12 @@ export const buildTypeEnv = (tree, language, options) => {
             if (!env.has(scope))
                 env.set(scope, new Map());
             const scopeEnv = env.get(scope);
-            config.extractForLoopBinding(node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup });
+            config.extractForLoopBinding(node, {
+                scopeEnv,
+                declarationTypeNodes,
+                scope,
+                returnTypeLookup,
+            });
         }
         // Re-run the main fixpoint to resolve items that depended on loop variables.
         // Only needed if replay actually produced new bindings.

package/dist/core/ingestion/type-extractors/c-cpp.js

@@ -1,11 +1,7 @@
-import { extractSimpleTypeName, extractVarName, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
-const DECLARATION_NODE_TYPES = new Set([
-    'declaration',
-]);
+import { extractSimpleTypeName, extractVarName, resolveIterableElementType, methodToTypeArgPosition, } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set(['declaration']);
 /** Smart pointer factory function names that create a typed object. */
-const SMART_PTR_FACTORIES = new Set([
-    'make_shared', 'make_unique', 'make_shared_for_overwrite',
-]);
+const SMART_PTR_FACTORIES = new Set(['make_shared', 'make_unique', 'make_shared_for_overwrite']);
 /** Smart pointer wrapper type names. When the declared type is a smart pointer,
  *  the inner template type is extracted for virtual dispatch comparison. */
 const SMART_PTR_WRAPPERS = new Set(['shared_ptr', 'unique_ptr', 'weak_ptr']);
@@ -36,9 +32,7 @@ const extractDeclaration = (node, env) => {
     if (!declarator)
         return;
     // init_declarator: Type x = value
-    const nameNode = declarator.type === 'init_declarator'
-        ? declarator.childForFieldName('declarator')
-        : declarator;
+    const nameNode = declarator.type === 'init_declarator' ? declarator.childForFieldName('declarator') : declarator;
     if (!nameNode)
         return;
     // Handle pointer/reference declarators
@@ -117,14 +111,14 @@ const extractInitializer = (node, env, classNames) => {
             //   or: call_expression > function: template_function (unqualified)
             const templateFunc = func.type === 'template_function'
                 ? func
-                : (func.type === 'qualified_identifier' || func.type === 'scoped_identifier')
-                    ? func.namedChildren.find((c) => c.type === 'template_function') ?? null
+                : func.type === 'qualified_identifier' || func.type === 'scoped_identifier'
+                    ? (func.namedChildren.find((c) => c.type === 'template_function') ?? null)
                     : null;
             if (templateFunc) {
                 const nameNode = templateFunc.firstNamedChild;
                 if (nameNode) {
-                    const funcName = (nameNode.type === 'qualified_identifier' || nameNode.type === 'scoped_identifier')
-                        ? nameNode.lastNamedChild?.text ?? ''
+                    const funcName = nameNode.type === 'qualified_identifier' || nameNode.type === 'scoped_identifier'
+                        ? (nameNode.lastNamedChild?.text ?? '')
                         : nameNode.text;
                     if (SMART_PTR_FACTORIES.has(funcName)) {
                         const typeName = extractFirstTemplateTypeArg(templateFunc);
@@ -153,9 +147,10 @@ const extractParameter = (node, env) => {
         typeNode = node.childForFieldName('type');
         const declarator = node.childForFieldName('declarator');
         if (declarator) {
-            nameNode = declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator'
-                ? declarator.firstNamedChild
-                : declarator;
+            nameNode =
+                declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator'
+                    ? declarator.firstNamedChild
+                    : declarator;
         }
     }
     else {
@@ -177,7 +172,9 @@ const scanConstructorBinding = (node) => {
     if (!typeNode)
         return undefined;
     const typeText = typeNode.text;
-    if (typeText !== 'auto' && typeText !== 'decltype(auto)' && typeNode.type !== 'placeholder_type_specifier')
+    if (typeText !== 'auto' &&
+        typeText !== 'decltype(auto)' &&
+        typeNode.type !== 'placeholder_type_specifier')
         return undefined;
     const declarator = node.childForFieldName('declarator');
     if (!declarator || declarator.type !== 'init_declarator')
@@ -196,7 +193,8 @@ const scanConstructorBinding = (node) => {
         if (!nameNode)
             return undefined;
         const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
-            ? nameNode.firstNamedChild : nameNode;
+            ? nameNode.firstNamedChild
+            : nameNode;
         if (!finalName)
             return undefined;
         return { varName: finalName.text, calleeName: last.text };
@@ -207,7 +205,8 @@ const scanConstructorBinding = (node) => {
     if (!nameNode)
         return undefined;
     const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
-        ? nameNode.firstNamedChild : nameNode;
+        ? nameNode.firstNamedChild
+        : nameNode;
     if (!finalName)
         return undefined;
     const varName = finalName.text;
@@ -224,8 +223,9 @@ const extractPendingAssignment = (node, scopeEnv) => {
         return undefined;
     // Only handle auto — typed declarations already resolved by extractDeclaration
     const typeText = typeNode.text;
-    if (typeText !== 'auto' && typeText !== 'decltype(auto)'
-        && typeNode.type !== 'placeholder_type_specifier')
+    if (typeText !== 'auto' &&
+        typeText !== 'decltype(auto)' &&
+        typeNode.type !== 'placeholder_type_specifier')
         return undefined;
     const declarator = node.childForFieldName('declarator');
     if (!declarator || declarator.type !== 'init_declarator')
@@ -237,7 +237,8 @@ const extractPendingAssignment = (node, scopeEnv) => {
     if (!nameNode)
         return undefined;
     const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
-        ? nameNode.firstNamedChild : nameNode;
+        ? nameNode.firstNamedChild
+        : nameNode;
     if (!finalName)
         return undefined;
     const lhs = extractVarName(finalName);
@@ -309,8 +310,9 @@ const extractCppElementTypeFromTypeNode = (typeNode, pos = 'last', depth = 0) =>
             return pos === 'first' ? args[0] : args[args.length - 1];
     }
     // reference/pointer types: unwrap and recurse (vector<User>& → vector<User>)
-    if (typeNode.type === 'reference_type' || typeNode.type === 'pointer_type'
-        || typeNode.type === 'type_descriptor') {
+    if (typeNode.type === 'reference_type' ||
+        typeNode.type === 'pointer_type' ||
+        typeNode.type === 'type_descriptor') {
         const inner = typeNode.lastNamedChild;
         if (inner)
             return extractCppElementTypeFromTypeNode(inner, pos, depth + 1);
@@ -342,7 +344,8 @@ const findCppParamElementType = (iterableName, startNode, pos = 'last') => {
                         continue;
                     // Unwrap reference/pointer declarators: vector<User>& users → &users
                     let identNode = paramDeclarator;
-                    if (identNode.type === 'reference_declarator' || identNode.type === 'pointer_declarator') {
+                    if (identNode.type === 'reference_declarator' ||
+                        identNode.type === 'pointer_declarator') {
                         identNode = identNode.firstNamedChild ?? identNode;
                     }
                     if (identNode.text !== iterableName)
@@ -393,10 +396,10 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope })
     if (!varName)
         return;
     // Check if the type is auto/placeholder — if not, use the explicit type directly
-    const isAuto = typeNode.type === 'placeholder_type_specifier'
-        || typeNode.text === 'auto'
-        || typeNode.text === 'const auto'
-        || typeNode.text === 'decltype(auto)';
+    const isAuto = typeNode.type === 'placeholder_type_specifier' ||
+        typeNode.text === 'auto' ||
+        typeNode.text === 'const auto' ||
+        typeNode.text === 'decltype(auto)';
     if (!isAuto) {
         // Explicit type: for (User& user : users) — extract directly
         const typeName = extractSimpleTypeName(typeNode);

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

@@ -1,5 +1,5 @@
 import { findChild } from '../utils/ast-helpers.js';
-import { extractSimpleTypeName, extractVarName, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
+import { extractSimpleTypeName, extractVarName, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, } from './shared.js';
 /** Known container property accessors that operate on the container itself (e.g., dict.Keys, dict.Values) */
 const KNOWN_CONTAINER_PROPS = new Set(['Keys', 'Values']);
 const DECLARATION_NODE_TYPES = new Set([
@@ -44,8 +44,8 @@ const extractDeclaration = (node, env) => {
         // 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 = findChild(declarators[0], 'object_creation_expression')
-                ?? findChild(declarators[0], 'equals_value_clause')?.firstNamedChild;
+            const initializer = findChild(declarators[0], 'object_creation_expression') ??
+                findChild(declarators[0], 'equals_value_clause')?.firstNamedChild;
             if (initializer?.type === 'object_creation_expression') {
                 const ctorType = initializer.childForFieldName('type');
                 if (ctorType)
@@ -124,7 +124,9 @@ const scanConstructorBinding = (node) => {
             value = child.firstNamedChild;
             break;
         }
-        if (child.type === 'invocation_expression' || child.type === 'object_creation_expression' || child.type === 'await_expression') {
+        if (child.type === 'invocation_expression' ||
+            child.type === 'object_creation_expression' ||
+            child.type === 'await_expression') {
             value = child;
             break;
         }
@@ -148,9 +150,7 @@ const scanConstructorBinding = (node) => {
         return undefined;
     return { varName: nameNode.text, calleeName };
 };
-const FOR_LOOP_NODE_TYPES = new Set([
-    'foreach_statement',
-]);
+const FOR_LOOP_NODE_TYPES = new Set(['foreach_statement']);
 /** Extract element type from a C# type annotation AST node.
  *  Handles generic_name (List<User>), array_type (User[]), nullable_type (?).
  *  `pos` selects which type arg: 'first' for keys, 'last' for values (default). */
@@ -328,9 +328,11 @@ const findCSharpIfConsequenceBlock = (expr) => {
             }
             return undefined;
         }
-        if (current.type === 'block' || current.type === 'method_declaration'
-            || current.type === 'constructor_declaration' || current.type === 'local_function_statement'
-            || current.type === 'lambda_expression')
+        if (current.type === 'block' ||
+            current.type === 'method_declaration' ||
+            current.type === 'constructor_declaration' ||
+            current.type === 'local_function_statement' ||
+            current.type === 'lambda_expression')
             return undefined;
         current = current.parent;
     }
@@ -408,7 +410,7 @@ const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     }
     // Null-check: `x != null` — binary_expression with != operator
     if (node.type === 'binary_expression') {
-        const op = node.children.find(c => !c.isNamed && c.text === '!=');
+        const op = node.children.find((c) => !c.isNamed && c.text === '!=');
         if (!op)
             return undefined;
         const left = node.namedChild(0);
@@ -419,7 +421,8 @@ const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
         if (left.type === 'identifier' && (right.type === 'null_literal' || right.text === 'null')) {
             varNode = left;
         }
-        else if (right.type === 'identifier' && (left.type === 'null_literal' || left.text === 'null')) {
+        else if (right.type === 'identifier' &&
+            (left.type === 'null_literal' || left.text === 'null')) {
             varNode = right;
         }
         if (!varNode)
@@ -468,7 +471,9 @@ const extractPendingAssignment = (node, scopeEnv) => {
             }
         }
         const valueNode = evc?.firstNamedChild ?? child.namedChild(child.namedChildCount - 1);
-        if (valueNode && valueNode !== nameNode && (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')) {
+        if (valueNode &&
+            valueNode !== nameNode &&
+            (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')) {
             return { kind: 'copy', lhs, rhs: valueNode.text };
         }
         // member_access_expression RHS → fieldAccess (a.Field)
@@ -545,7 +550,12 @@ const inferLiteralType = (node) => {
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
     forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
-    patternBindingNodeTypes: new Set(['is_pattern_expression', 'declaration_pattern', 'recursive_pattern', 'binary_expression']),
+    patternBindingNodeTypes: new Set([
+        'is_pattern_expression',
+        'declaration_pattern',
+        'recursive_pattern',
+        'binary_expression',
+    ]),
     extractDeclaration,
     extractParameter,
     scanConstructorBinding,

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

@@ -11,16 +11,14 @@
  *
  * Credit: Type resolution approach adapted from @xFlaviews' PR #83.
  */
-import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, resolveIterableElementType } from './shared.js';
+import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, resolveIterableElementType, } from './shared.js';
 import { findChild } from '../utils/ast-helpers.js';
 // ── Node types ──────────────────────────────────────────────────────────
 const DART_DECLARATION_NODE_TYPES = new Set([
     'initialized_variable_definition',
     'initialized_identifier',
 ]);
-const DART_FOR_LOOP_NODE_TYPES = new Set([
-    'for_statement',
-]);
+const DART_FOR_LOOP_NODE_TYPES = new Set(['for_statement']);
 function parseDartRHSChildren(children) {
     let callee;
     let member;
@@ -31,8 +29,8 @@ function parseDartRHSChildren(children) {
             continue;
         }
         if (child.type === 'selector') {
-            const uas = findChild(child, 'unconditional_assignable_selector')
-                ?? findChild(child, 'conditional_assignable_selector');
+            const uas = findChild(child, 'unconditional_assignable_selector') ??
+                findChild(child, 'conditional_assignable_selector');
             if (uas) {
                 const id = findChild(uas, 'identifier');
                 if (id && !member)
@@ -323,8 +321,8 @@ const extractDartForLoopBinding = (node, ctx) => {
             if (!foundIterable)
                 continue;
             if (child.type === 'selector') {
-                const uas = findChild(child, 'unconditional_assignable_selector')
-                    ?? findChild(child, 'conditional_assignable_selector');
+                const uas = findChild(child, 'unconditional_assignable_selector') ??
+                    findChild(child, 'conditional_assignable_selector');
                 if (uas) {
                     const id = findChild(uas, 'identifier');
                     if (id)

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

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
+import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'var_declaration',
     'var_spec',
@@ -59,7 +59,8 @@ const extractGoShortVarDeclaration = (node, env) => {
     for (let i = 0; i < count; i++) {
         let valueNode = rhsNodes[i];
         // Unwrap &User{} — unary_expression (address-of) wrapping composite_literal
-        if (valueNode.type === 'unary_expression' && valueNode.firstNamedChild?.type === 'composite_literal') {
+        if (valueNode.type === 'unary_expression' &&
+            valueNode.firstNamedChild?.type === 'composite_literal') {
             valueNode = valueNode.firstNamedChild;
         }
         // Go built-in new(User) — call_expression with 'new' callee and type argument
@@ -194,12 +195,12 @@ const scanConstructorBinding = (node) => {
         return undefined;
     return { varName: leftIds[0].text, calleeName };
 };
-const FOR_LOOP_NODE_TYPES = new Set([
-    'for_statement',
-]);
+const FOR_LOOP_NODE_TYPES = new Set(['for_statement']);
 /** Go function/method node types that carry a parameter list. */
 const GO_FUNCTION_NODE_TYPES = new Set([
-    'function_declaration', 'method_declaration', 'func_literal',
+    'function_declaration',
+    'method_declaration',
+    'func_literal',
 ]);
 /**
  * Extract element type from a Go type annotation AST node.