@grafema/core 0.2.5-beta → 0.2.7

package/dist/plugins/analysis/JSASTAnalyzer.js

@@ -32,11 +32,18 @@ import { getLine, getColumn } from './ast/utils/location.js';
 import { Profiler } from '../../core/Profiler.js';
 import { ScopeTracker } from '../../core/ScopeTracker.js';
 import { computeSemanticId } from '../../core/SemanticId.js';
+import { IdGenerator } from './ast/IdGenerator.js';
+import { CollisionResolver } from './ast/CollisionResolver.js';
 import { ExpressionNode } from '../../core/nodes/ExpressionNode.js';
 import { ConstructorCallNode } from '../../core/nodes/ConstructorCallNode.js';
 import { ObjectLiteralNode } from '../../core/nodes/ObjectLiteralNode.js';
 import { ArrayLiteralNode } from '../../core/nodes/ArrayLiteralNode.js';
 import { NodeFactory } from '../../core/NodeFactory.js';
+import { brandNodeInternal } from '../../core/brandNodeInternal.js';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
+import { extractNamesFromPattern } from './ast/utils/extractNamesFromPattern.js';
+import { createFunctionBodyContext } from './ast/FunctionBodyContext.js';
+import { VariableHandler, ReturnYieldHandler, ThrowHandler, NestedFunctionHandler, PropertyAccessHandler, NewExpressionHandler, CallExpressionHandler, LoopHandler, TryCatchHandler, BranchHandler, } from './ast/handlers/index.js';
 export class JSASTAnalyzer extends Plugin {
     graphBuilder;
     analyzedModules;
@@ -57,14 +64,14 @@ export class JSASTAnalyzer extends Plugin {
                     'CALL', 'IMPORT', 'EXPORT', 'LITERAL', 'EXTERNAL_MODULE',
                     'net:stdio', 'net:request', 'event:listener', 'http:request',
                     // TypeScript-specific nodes
-                    'INTERFACE', 'TYPE', 'ENUM', 'DECORATOR'
+                    'INTERFACE', 'TYPE', 'ENUM', 'DECORATOR', 'TYPE_PARAMETER'
                 ],
                 edges: [
                     'CONTAINS', 'DECLARES', 'CALLS', 'HAS_SCOPE', 'CAPTURES', 'MODIFIES',
                     'WRITES_TO', 'IMPORTS', 'INSTANCE_OF', 'HANDLED_BY', 'HAS_CALLBACK',
                     'PASSES_ARGUMENT', 'MAKES_REQUEST', 'IMPORTS_FROM', 'EXPORTS_TO', 'ASSIGNED_FROM',
                     // TypeScript-specific edges
-                    'IMPLEMENTS', 'EXTENDS', 'DECORATED_BY',
+                    'IMPLEMENTS', 'EXTENDS', 'DECORATED_BY', 'HAS_TYPE_PARAMETER',
                     // Promise data flow
                     'RESOLVES_TO'
                 ]
@@ -84,9 +91,9 @@ export class JSASTAnalyzer extends Plugin {
     /**
      * Вычисляет хеш содержимого файла
      */
-    calculateFileHash(filePath) {
+    calculateFileHash(filePath, projectPath = '') {
         try {
-            const content = readFileSync(filePath, 'utf-8');
+            const content = readFileSync(resolveNodeFile(filePath, projectPath), 'utf-8');
             return createHash('sha256').update(content).digest('hex');
         }
         catch {
@@ -96,25 +103,25 @@ export class JSASTAnalyzer extends Plugin {
     /**
      * Проверяет нужно ли анализировать модуль (сравнивает хеши)
      */
-    async shouldAnalyzeModule(module, graph, forceAnalysis) {
+    async shouldAnalyzeModule(module, graph, forceAnalysis, projectPath = "") {
         if (forceAnalysis) {
             return true;
         }
         if (!module.contentHash) {
             return true;
         }
-        const currentHash = this.calculateFileHash(module.file);
+        const currentHash = this.calculateFileHash(module.file, projectPath);
         if (!currentHash) {
             return true;
         }
         if (currentHash !== module.contentHash) {
-            await graph.addNode({
+            await graph.addNode(brandNodeInternal({
                 id: module.id,
                 type: 'MODULE',
                 name: module.name,
                 file: module.file,
                 contentHash: currentHash
-            });
+            }));
             return true;
         }
         // Hash matches - check if module was actually analyzed (has FUNCTION nodes)
@@ -143,7 +150,7 @@ export class JSASTAnalyzer extends Plugin {
                     skippedCount++;
                     continue;
                 }
-                if (await this.shouldAnalyzeModule(module, graph, forceAnalysis)) {
+                if (await this.shouldAnalyzeModule(module, graph, forceAnalysis, projectPath)) {
                     modulesToAnalyze.push(module);
                 }
                 else {
@@ -248,7 +255,7 @@ export class JSASTAnalyzer extends Plugin {
             // Convert ModuleNode to ASTModuleInfo format
             const moduleInfos = modules.map(m => ({
                 id: m.id,
-                file: m.file,
+                file: resolveNodeFile(m.file, projectPath),
                 name: m.name
             }));
             // Parse all modules in parallel using worker threads
@@ -282,7 +289,7 @@ export class JSASTAnalyzer extends Plugin {
                     context.onProgress({
                         phase: 'analysis',
                         currentPlugin: 'JSASTAnalyzer',
-                        message: `Processed ${result.module.file.replace(projectPath, '')}`,
+                        message: `Processed ${result.module.name}`,
                         totalFiles: modules.length,
                         processedFiles: results.indexOf(result) + 1
                     });
@@ -298,73 +305,13 @@ export class JSASTAnalyzer extends Plugin {
     /**
      * Extract variable names from destructuring patterns
      * Uses t.isX() type guards to avoid casts
+     *
+     * REG-399: Delegated to extractNamesFromPattern utility for code reuse with parameters.
+     * This method maintains the same API for backward compatibility.
      */
     extractVariableNamesFromPattern(pattern, variables = [], propertyPath = []) {
-        if (!pattern)
-            return variables;
-        if (t.isIdentifier(pattern)) {
-            variables.push({
-                name: pattern.name,
-                loc: pattern.loc?.start ? { start: pattern.loc.start } : { start: { line: 0, column: 0 } },
-                propertyPath: propertyPath.length > 0 ? [...propertyPath] : undefined
-            });
-        }
-        else if (t.isObjectPattern(pattern)) {
-            pattern.properties.forEach((prop) => {
-                if (t.isRestElement(prop)) {
-                    const restVars = this.extractVariableNamesFromPattern(prop.argument, [], []);
-                    restVars.forEach(v => {
-                        v.isRest = true;
-                        v.propertyPath = propertyPath.length > 0 ? [...propertyPath] : undefined;
-                        variables.push(v);
-                    });
-                }
-                else if (t.isObjectProperty(prop) && prop.value) {
-                    const key = t.isIdentifier(prop.key) ? prop.key.name :
-                        (t.isStringLiteral(prop.key) || t.isNumericLiteral(prop.key) ? String(prop.key.value) : null);
-                    if (key !== null) {
-                        const newPath = [...propertyPath, key];
-                        this.extractVariableNamesFromPattern(prop.value, variables, newPath);
-                    }
-                    else {
-                        this.extractVariableNamesFromPattern(prop.value, variables, propertyPath);
-                    }
-                }
-            });
-        }
-        else if (t.isArrayPattern(pattern)) {
-            pattern.elements.forEach((element, index) => {
-                if (element) {
-                    if (t.isRestElement(element)) {
-                        const restVars = this.extractVariableNamesFromPattern(element.argument, [], []);
-                        restVars.forEach(v => {
-                            v.isRest = true;
-                            v.arrayIndex = index;
-                            v.propertyPath = propertyPath.length > 0 ? [...propertyPath] : undefined;
-                            variables.push(v);
-                        });
-                    }
-                    else {
-                        const extracted = this.extractVariableNamesFromPattern(element, [], propertyPath);
-                        extracted.forEach(v => {
-                            v.arrayIndex = index;
-                            variables.push(v);
-                        });
-                    }
-                }
-            });
-        }
-        else if (t.isRestElement(pattern)) {
-            const restVars = this.extractVariableNamesFromPattern(pattern.argument, [], propertyPath);
-            restVars.forEach(v => {
-                v.isRest = true;
-                variables.push(v);
-            });
-        }
-        else if (t.isAssignmentPattern(pattern)) {
-            this.extractVariableNamesFromPattern(pattern.left, variables, propertyPath);
-        }
-        return variables;
+        // Delegate to the extracted utility function
+        return extractNamesFromPattern(pattern, variables, propertyPath);
     }
     /**
      * Отслеживает присваивание переменной для data flow анализа
@@ -426,54 +373,15 @@ export class JSASTAnalyzer extends Plugin {
             return;
         }
         // 3. MemberExpression call (e.g., arr.map())
+        // Uses coordinate-based lookup to reference the standard CALL node created by CallExpressionVisitor
         if (initExpression.type === 'CallExpression' && initExpression.callee.type === 'MemberExpression') {
-            const callee = initExpression.callee;
-            const objectName = callee.object.type === 'Identifier' ? callee.object.name : (callee.object.type === 'ThisExpression' ? 'this' : 'unknown');
-            const methodName = callee.property.type === 'Identifier' ? callee.property.name : 'unknown';
-            const fullName = `${objectName}.${methodName}`;
-            const methodCallId = `CALL#${fullName}#${module.file}#${getLine(initExpression)}:${getColumn(initExpression)}:inline`;
-            const existing = variableAssignments.find(a => a.sourceId === methodCallId);
-            if (!existing) {
-                const extractedArgs = [];
-                initExpression.arguments.forEach((arg, index) => {
-                    if (arg.type !== 'SpreadElement') {
-                        const argLiteralValue = ExpressionEvaluator.extractLiteralValue(arg);
-                        if (argLiteralValue !== null) {
-                            const literalId = `LITERAL#arg${index}#${module.file}#${getLine(initExpression)}:${getColumn(initExpression)}:${literalCounterRef.value++}`;
-                            literals.push({
-                                id: literalId,
-                                type: 'LITERAL',
-                                value: argLiteralValue,
-                                valueType: typeof argLiteralValue,
-                                file: module.file,
-                                line: arg.loc?.start.line || getLine(initExpression),
-                                column: arg.loc?.start.column || getColumn(initExpression),
-                                parentCallId: methodCallId,
-                                argIndex: index
-                            });
-                            extractedArgs.push(argLiteralValue);
-                        }
-                        else {
-                            extractedArgs.push(undefined);
-                        }
-                    }
-                });
-                literals.push({
-                    id: methodCallId,
-                    type: 'CALL',
-                    name: fullName,
-                    object: objectName,
-                    method: methodName,
-                    file: module.file,
-                    arguments: extractedArgs,
-                    line: getLine(initExpression),
-                    column: getColumn(initExpression)
-                });
-            }
             variableAssignments.push({
                 variableId,
-                sourceId: methodCallId,
-                sourceType: 'CALL'
+                sourceType: 'METHOD_CALL',
+                sourceLine: getLine(initExpression),
+                sourceColumn: getColumn(initExpression),
+                sourceFile: module.file,
+                line: line
             });
             return;
         }
@@ -1002,17 +910,19 @@ export class JSASTAnalyzer extends Plugin {
         let edgesCreated = 0;
         try {
             this.profiler.start('file_read');
-            const code = readFileSync(module.file, 'utf-8');
+            const code = readFileSync(resolveNodeFile(module.file, projectPath), 'utf-8');
             this.profiler.end('file_read');
             this.profiler.start('babel_parse');
             const ast = parse(code, {
                 sourceType: 'module',
-                plugins: ['jsx', 'typescript']
+                plugins: ['jsx', 'typescript', 'decorators-legacy']
             });
             this.profiler.end('babel_parse');
             // Create ScopeTracker for semantic ID generation
             // Use basename for shorter, more readable semantic IDs
             const scopeTracker = new ScopeTracker(basename(module.file));
+            // REG-464: Shared IdGenerator for v2 collision resolution across visitors
+            const sharedIdGenerator = new IdGenerator(scopeTracker);
             const functions = [];
             const parameters = [];
             const scopes = [];
@@ -1040,6 +950,8 @@ export class JSASTAnalyzer extends Plugin {
             const typeAliases = [];
             const enums = [];
             const decorators = [];
+            // Type parameter tracking for generics (REG-303)
+            const typeParameters = [];
             // Object/Array literal tracking for data flow
             const objectLiterals = [];
             const objectProperties = [];
@@ -1113,6 +1025,8 @@ export class JSASTAnalyzer extends Plugin {
                 httpRequests, literals, variableAssignments,
                 // TypeScript-specific collections
                 interfaces, typeAliases, enums, decorators,
+                // Type parameter tracking for generics (REG-303)
+                typeParameters,
                 // Object/Array literal tracking
                 objectLiterals, objectProperties, arrayLiterals, arrayElements,
                 // Array mutation tracking
@@ -1301,9 +1215,28 @@ export class JSASTAnalyzer extends Plugin {
             this.profiler.end('traverse_callbacks');
             // Call expressions
             this.profiler.start('traverse_calls');
-            const callExpressionVisitor = new CallExpressionVisitor(module, allCollections, scopeTracker);
+            const callExpressionVisitor = new CallExpressionVisitor(module, allCollections, scopeTracker, sharedIdGenerator);
             traverse(ast, callExpressionVisitor.getHandlers());
             this.profiler.end('traverse_calls');
+            // REG-297: Detect top-level await expressions
+            this.profiler.start('traverse_top_level_await');
+            let hasTopLevelAwait = false;
+            traverse(ast, {
+                AwaitExpression(awaitPath) {
+                    if (!awaitPath.getFunctionParent()) {
+                        hasTopLevelAwait = true;
+                        awaitPath.stop();
+                    }
+                },
+                // for-await-of uses ForOfStatement.await, not AwaitExpression
+                ForOfStatement(forOfPath) {
+                    if (forOfPath.node.await && !forOfPath.getFunctionParent()) {
+                        hasTopLevelAwait = true;
+                        forOfPath.stop();
+                    }
+                }
+            });
+            this.profiler.end('traverse_top_level_await');
             // Property access expressions (REG-395)
             this.profiler.start('traverse_property_access');
             const propertyAccessVisitor = new PropertyAccessVisitor(module, allCollections, scopeTracker);
@@ -1424,6 +1357,36 @@ export class JSASTAnalyzer extends Plugin {
                 }
             });
             this.profiler.end('traverse_ifs');
+            // REG-464: Resolve v2 ID collisions after all visitors complete
+            const pendingNodes = sharedIdGenerator.getPendingNodes();
+            if (pendingNodes.length > 0) {
+                // Capture pre-resolution IDs to update callArguments afterward
+                const preResolutionIds = new Map();
+                for (const pn of pendingNodes) {
+                    preResolutionIds.set(pn.collectionRef, pn.collectionRef.id);
+                }
+                const collisionResolver = new CollisionResolver();
+                collisionResolver.resolve(pendingNodes);
+                // Update callArgument.callId references that became stale after resolution
+                const idRemapping = new Map();
+                for (const pn of pendingNodes) {
+                    const oldId = preResolutionIds.get(pn.collectionRef);
+                    if (oldId !== pn.collectionRef.id) {
+                        idRemapping.set(oldId, pn.collectionRef.id);
+                    }
+                }
+                if (idRemapping.size > 0) {
+                    const callArgs = allCollections.callArguments;
+                    if (callArgs) {
+                        for (const arg of callArgs) {
+                            const resolved = idRemapping.get(arg.callId);
+                            if (resolved) {
+                                arg.callId = resolved;
+                            }
+                        }
+                    }
+                }
+            }
             // Build graph
             this.profiler.start('graph_build');
             const result = await this.graphBuilder.build(module, graph, projectPath, {
@@ -1459,6 +1422,8 @@ export class JSASTAnalyzer extends Plugin {
                 typeAliases,
                 enums,
                 decorators,
+                // Type parameter tracking for generics (REG-303)
+                typeParameters,
                 // Array mutation tracking
                 arrayMutations,
                 // Object mutation tracking
@@ -1485,7 +1450,9 @@ export class JSASTAnalyzer extends Plugin {
                     ? allCollections.catchesFromInfos
                     : catchesFromInfos,
                 // Property access tracking (REG-395)
-                propertyAccesses: allCollections.propertyAccesses || propertyAccesses
+                propertyAccesses: allCollections.propertyAccesses || propertyAccesses,
+                // REG-297: Top-level await tracking
+                hasTopLevelAwait
             });
             this.profiler.end('graph_build');
             nodesCreated = result.nodes;
@@ -1663,423 +1630,6 @@ export class JSASTAnalyzer extends Plugin {
             }
         });
     }
-    createLoopScopeHandler(trackerScopeType, scopeType, loopType, parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState) {
-        return {
-            enter: (path) => {
-                const node = path.node;
-                // Phase 6 (REG-267): Increment loop count for cyclomatic complexity
-                if (controlFlowState) {
-                    controlFlowState.loopCount++;
-                }
-                // 1. Create LOOP node
-                const loopCounter = loopCounterRef.value++;
-                const legacyLoopId = `${module.file}:LOOP:${loopType}:${getLine(node)}:${loopCounter}`;
-                const loopId = scopeTracker
-                    ? computeSemanticId('LOOP', loopType, scopeTracker.getContext(), { discriminator: loopCounter })
-                    : legacyLoopId;
-                // 2. Extract iteration target for for-in/for-of
-                let iteratesOverName;
-                let iteratesOverLine;
-                let iteratesOverColumn;
-                if (loopType === 'for-in' || loopType === 'for-of') {
-                    const loopNode = node;
-                    if (t.isIdentifier(loopNode.right)) {
-                        iteratesOverName = loopNode.right.name;
-                        iteratesOverLine = getLine(loopNode.right);
-                        iteratesOverColumn = getColumn(loopNode.right);
-                    }
-                    else if (t.isMemberExpression(loopNode.right)) {
-                        iteratesOverName = this.memberExpressionToString(loopNode.right);
-                        iteratesOverLine = getLine(loopNode.right);
-                        iteratesOverColumn = getColumn(loopNode.right);
-                    }
-                }
-                // 2b. Extract init/test/update for classic for loops and test for while/do-while (REG-282)
-                let initVariableName;
-                let initLine;
-                let testExpressionId;
-                let testExpressionType;
-                let testLine;
-                let testColumn;
-                let updateExpressionId;
-                let updateExpressionType;
-                let updateLine;
-                let updateColumn;
-                if (loopType === 'for') {
-                    const forNode = node;
-                    // Extract init: let i = 0
-                    if (forNode.init) {
-                        initLine = getLine(forNode.init);
-                        if (t.isVariableDeclaration(forNode.init)) {
-                            // Get name of first declared variable
-                            const firstDeclarator = forNode.init.declarations[0];
-                            if (t.isIdentifier(firstDeclarator.id)) {
-                                initVariableName = firstDeclarator.id.name;
-                            }
-                        }
-                    }
-                    // Extract test: i < 10
-                    if (forNode.test) {
-                        testLine = getLine(forNode.test);
-                        testColumn = getColumn(forNode.test);
-                        testExpressionType = forNode.test.type;
-                        testExpressionId = ExpressionNode.generateId(forNode.test.type, module.file, testLine, testColumn);
-                    }
-                    // Extract update: i++
-                    if (forNode.update) {
-                        updateLine = getLine(forNode.update);
-                        updateColumn = getColumn(forNode.update);
-                        updateExpressionType = forNode.update.type;
-                        updateExpressionId = ExpressionNode.generateId(forNode.update.type, module.file, updateLine, updateColumn);
-                    }
-                }
-                // Extract test condition for while and do-while loops
-                if (loopType === 'while' || loopType === 'do-while') {
-                    const condLoop = node;
-                    if (condLoop.test) {
-                        testLine = getLine(condLoop.test);
-                        testColumn = getColumn(condLoop.test);
-                        testExpressionType = condLoop.test.type;
-                        testExpressionId = ExpressionNode.generateId(condLoop.test.type, module.file, testLine, testColumn);
-                    }
-                }
-                // Extract async flag for for-await-of (REG-284)
-                let isAsync;
-                if (loopType === 'for-of') {
-                    const forOfNode = node;
-                    isAsync = forOfNode.await === true ? true : undefined;
-                }
-                // 3. Determine actual parent - use stack for nested loops, otherwise original parentScopeId
-                const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
-                    ? scopeIdStack[scopeIdStack.length - 1]
-                    : parentScopeId;
-                // 3.5. Extract condition expression for while/do-while/for loops (REG-280)
-                // Note: for-in and for-of don't have test expressions (they use ITERATES_OVER instead)
-                let conditionExpressionId;
-                let conditionExpressionType;
-                let conditionLine;
-                let conditionColumn;
-                if (loopType === 'while' || loopType === 'do-while') {
-                    const testNode = node.test;
-                    if (testNode) {
-                        const condResult = this.extractDiscriminantExpression(testNode, module);
-                        conditionExpressionId = condResult.id;
-                        conditionExpressionType = condResult.expressionType;
-                        conditionLine = condResult.line;
-                        conditionColumn = condResult.column;
-                    }
-                }
-                else if (loopType === 'for') {
-                    const forNode = node;
-                    // for loop test may be null (infinite loop: for(;;))
-                    if (forNode.test) {
-                        const condResult = this.extractDiscriminantExpression(forNode.test, module);
-                        conditionExpressionId = condResult.id;
-                        conditionExpressionType = condResult.expressionType;
-                        conditionLine = condResult.line;
-                        conditionColumn = condResult.column;
-                    }
-                }
-                // 4. Push LOOP info
-                loops.push({
-                    id: loopId,
-                    semanticId: loopId,
-                    type: 'LOOP',
-                    loopType,
-                    file: module.file,
-                    line: getLine(node),
-                    column: getColumn(node),
-                    parentScopeId: actualParentScopeId,
-                    iteratesOverName,
-                    iteratesOverLine,
-                    iteratesOverColumn,
-                    conditionExpressionId,
-                    conditionExpressionType,
-                    conditionLine,
-                    conditionColumn,
-                    // REG-282: init/test/update for classic for loops
-                    initVariableName,
-                    initLine,
-                    testExpressionId,
-                    testExpressionType,
-                    testLine,
-                    testColumn,
-                    updateExpressionId,
-                    updateExpressionType,
-                    updateLine,
-                    updateColumn,
-                    // REG-284: async flag for for-await-of
-                    async: isAsync
-                });
-                // 5. Create body SCOPE (backward compatibility)
-                const scopeId = `SCOPE#${scopeType}#${module.file}#${getLine(node)}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId(scopeType, scopeTracker);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType,
-                    semanticId,
-                    file: module.file,
-                    line: getLine(node),
-                    parentScopeId: loopId // Parent is LOOP, not original parentScopeId
-                });
-                // 6. Push body SCOPE to scopeIdStack (for CONTAINS edges to nested items)
-                // The body scope is the container for nested loops, not the LOOP itself
-                if (scopeIdStack) {
-                    scopeIdStack.push(scopeId);
-                }
-                // Enter scope for semantic ID generation
-                if (scopeTracker) {
-                    scopeTracker.enterCountedScope(trackerScopeType);
-                }
-            },
-            exit: () => {
-                // Pop loop scope from stack
-                if (scopeIdStack) {
-                    scopeIdStack.pop();
-                }
-                // Exit scope
-                if (scopeTracker) {
-                    scopeTracker.exitScope();
-                }
-            }
-        };
-    }
-    /**
-     * Factory method to create TryStatement handler.
-     * Creates TRY_BLOCK, CATCH_BLOCK, FINALLY_BLOCK nodes and body SCOPEs.
-     * Does NOT use skip() - allows normal traversal for CallExpression/NewExpression visitors.
-     *
-     * Phase 4 (REG-267): Creates control flow nodes with HAS_CATCH and HAS_FINALLY edges.
-     *
-     * @param parentScopeId - Parent scope ID for the scope nodes
-     * @param module - Module context
-     * @param scopes - Collection to push scope nodes to
-     * @param tryBlocks - Collection to push TRY_BLOCK nodes to
-     * @param catchBlocks - Collection to push CATCH_BLOCK nodes to
-     * @param finallyBlocks - Collection to push FINALLY_BLOCK nodes to
-     * @param scopeCounterRef - Counter for unique scope IDs
-     * @param tryBlockCounterRef - Counter for unique TRY_BLOCK IDs
-     * @param catchBlockCounterRef - Counter for unique CATCH_BLOCK IDs
-     * @param finallyBlockCounterRef - Counter for unique FINALLY_BLOCK IDs
-     * @param scopeTracker - Tracker for semantic ID generation
-     * @param tryScopeMap - Map to track try/catch/finally scope transitions
-     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
-     */
-    createTryStatementHandler(parentScopeId, module, scopes, tryBlocks, catchBlocks, finallyBlocks, scopeCounterRef, tryBlockCounterRef, catchBlockCounterRef, finallyBlockCounterRef, scopeTracker, tryScopeMap, scopeIdStack, controlFlowState) {
-        return {
-            enter: (tryPath) => {
-                const tryNode = tryPath.node;
-                // Phase 6 (REG-267): Mark that this function has try/catch
-                if (controlFlowState) {
-                    controlFlowState.hasTryCatch = true;
-                    // REG-311: Increment try block depth for O(1) isInsideTry detection
-                    controlFlowState.tryBlockDepth++;
-                }
-                // Determine actual parent - use stack for nested structures, otherwise original parentScopeId
-                const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
-                    ? scopeIdStack[scopeIdStack.length - 1]
-                    : parentScopeId;
-                // 1. Create TRY_BLOCK node
-                const tryBlockCounter = tryBlockCounterRef.value++;
-                const legacyTryBlockId = `${module.file}:TRY_BLOCK:${getLine(tryNode)}:${tryBlockCounter}`;
-                const tryBlockId = scopeTracker
-                    ? computeSemanticId('TRY_BLOCK', 'try', scopeTracker.getContext(), { discriminator: tryBlockCounter })
-                    : legacyTryBlockId;
-                tryBlocks.push({
-                    id: tryBlockId,
-                    semanticId: tryBlockId,
-                    type: 'TRY_BLOCK',
-                    file: module.file,
-                    line: getLine(tryNode),
-                    column: getColumn(tryNode),
-                    parentScopeId: actualParentScopeId
-                });
-                // 2. Create try-body SCOPE (backward compatibility)
-                // Parent is now TRY_BLOCK, not original parentScopeId
-                const tryScopeId = `SCOPE#try-block#${module.file}#${getLine(tryNode)}:${scopeCounterRef.value++}`;
-                const trySemanticId = this.generateSemanticId('try-block', scopeTracker);
-                scopes.push({
-                    id: tryScopeId,
-                    type: 'SCOPE',
-                    scopeType: 'try-block',
-                    semanticId: trySemanticId,
-                    file: module.file,
-                    line: getLine(tryNode),
-                    parentScopeId: tryBlockId // Parent is TRY_BLOCK
-                });
-                // 3. Create CATCH_BLOCK and catch-body SCOPE if handler exists
-                let catchBlockId = null;
-                let catchScopeId = null;
-                if (tryNode.handler) {
-                    const catchClause = tryNode.handler;
-                    const catchBlockCounter = catchBlockCounterRef.value++;
-                    const legacyCatchBlockId = `${module.file}:CATCH_BLOCK:${getLine(catchClause)}:${catchBlockCounter}`;
-                    catchBlockId = scopeTracker
-                        ? computeSemanticId('CATCH_BLOCK', 'catch', scopeTracker.getContext(), { discriminator: catchBlockCounter })
-                        : legacyCatchBlockId;
-                    // Extract parameter name if present
-                    let parameterName;
-                    if (catchClause.param && t.isIdentifier(catchClause.param)) {
-                        parameterName = catchClause.param.name;
-                    }
-                    catchBlocks.push({
-                        id: catchBlockId,
-                        semanticId: catchBlockId,
-                        type: 'CATCH_BLOCK',
-                        file: module.file,
-                        line: getLine(catchClause),
-                        column: getColumn(catchClause),
-                        parentScopeId,
-                        parentTryBlockId: tryBlockId,
-                        parameterName
-                    });
-                    // Create catch-body SCOPE (backward compatibility)
-                    catchScopeId = `SCOPE#catch-block#${module.file}#${getLine(catchClause)}:${scopeCounterRef.value++}`;
-                    const catchSemanticId = this.generateSemanticId('catch-block', scopeTracker);
-                    scopes.push({
-                        id: catchScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'catch-block',
-                        semanticId: catchSemanticId,
-                        file: module.file,
-                        line: getLine(catchClause),
-                        parentScopeId: catchBlockId // Parent is CATCH_BLOCK
-                    });
-                }
-                // 4. Create FINALLY_BLOCK and finally-body SCOPE if finalizer exists
-                let finallyBlockId = null;
-                let finallyScopeId = null;
-                if (tryNode.finalizer) {
-                    const finallyBlockCounter = finallyBlockCounterRef.value++;
-                    const legacyFinallyBlockId = `${module.file}:FINALLY_BLOCK:${getLine(tryNode.finalizer)}:${finallyBlockCounter}`;
-                    finallyBlockId = scopeTracker
-                        ? computeSemanticId('FINALLY_BLOCK', 'finally', scopeTracker.getContext(), { discriminator: finallyBlockCounter })
-                        : legacyFinallyBlockId;
-                    finallyBlocks.push({
-                        id: finallyBlockId,
-                        semanticId: finallyBlockId,
-                        type: 'FINALLY_BLOCK',
-                        file: module.file,
-                        line: getLine(tryNode.finalizer),
-                        column: getColumn(tryNode.finalizer),
-                        parentScopeId,
-                        parentTryBlockId: tryBlockId
-                    });
-                    // Create finally-body SCOPE (backward compatibility)
-                    finallyScopeId = `SCOPE#finally-block#${module.file}#${getLine(tryNode.finalizer)}:${scopeCounterRef.value++}`;
-                    const finallySemanticId = this.generateSemanticId('finally-block', scopeTracker);
-                    scopes.push({
-                        id: finallyScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'finally-block',
-                        semanticId: finallySemanticId,
-                        file: module.file,
-                        line: getLine(tryNode.finalizer),
-                        parentScopeId: finallyBlockId // Parent is FINALLY_BLOCK
-                    });
-                }
-                // 5. Push try scope onto stack for CONTAINS edges
-                if (scopeIdStack) {
-                    scopeIdStack.push(tryScopeId);
-                }
-                // Enter try scope for semantic ID generation
-                if (scopeTracker) {
-                    scopeTracker.enterCountedScope('try');
-                }
-                // 6. Store scope info for catch/finally transitions
-                tryScopeMap.set(tryNode, {
-                    tryScopeId,
-                    catchScopeId,
-                    finallyScopeId,
-                    currentBlock: 'try',
-                    tryBlockId,
-                    catchBlockId,
-                    finallyBlockId
-                });
-            },
-            exit: (tryPath) => {
-                const tryNode = tryPath.node;
-                const _scopeInfo = tryScopeMap.get(tryNode);
-                // REG-311: Only decrement try block depth if we're still in 'try' block
-                // (not transitioned to catch/finally, where we already decremented)
-                if (controlFlowState && _scopeInfo?.currentBlock === 'try') {
-                    controlFlowState.tryBlockDepth--;
-                }
-                // Pop the current scope from stack (could be try, catch, or finally)
-                if (scopeIdStack) {
-                    scopeIdStack.pop();
-                }
-                // Exit the current scope
-                if (scopeTracker) {
-                    scopeTracker.exitScope();
-                }
-                // Clean up
-                tryScopeMap.delete(tryNode);
-            }
-        };
-    }
-    /**
-     * Factory method to create CatchClause handler.
-     * Handles scope transition from try to catch and processes catch parameter.
-     *
-     * @param module - Module context
-     * @param variableDeclarations - Collection to push variable declarations to
-     * @param varDeclCounterRef - Counter for unique variable declaration IDs
-     * @param scopeTracker - Tracker for semantic ID generation
-     * @param tryScopeMap - Map to track try/catch/finally scope transitions
-     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
-     */
-    createCatchClauseHandler(module, variableDeclarations, varDeclCounterRef, scopeTracker, tryScopeMap, scopeIdStack, controlFlowState) {
-        return {
-            enter: (catchPath) => {
-                const catchNode = catchPath.node;
-                const parent = catchPath.parent;
-                if (!t.isTryStatement(parent))
-                    return;
-                const scopeInfo = tryScopeMap.get(parent);
-                if (!scopeInfo || !scopeInfo.catchScopeId)
-                    return;
-                // Transition from try scope to catch scope
-                if (scopeInfo.currentBlock === 'try') {
-                    // Pop try scope, push catch scope
-                    if (scopeIdStack) {
-                        scopeIdStack.pop();
-                        scopeIdStack.push(scopeInfo.catchScopeId);
-                    }
-                    // Exit try scope, enter catch scope for semantic ID
-                    if (scopeTracker) {
-                        scopeTracker.exitScope();
-                        scopeTracker.enterCountedScope('catch');
-                    }
-                    // REG-311: Decrement tryBlockDepth when leaving try block for catch
-                    // Calls in catch block should NOT have isInsideTry=true
-                    if (controlFlowState) {
-                        controlFlowState.tryBlockDepth--;
-                    }
-                    scopeInfo.currentBlock = 'catch';
-                }
-                // Handle catch parameter (e.g., catch (e) or catch ({ message }))
-                if (catchNode.param) {
-                    const errorVarInfo = this.extractVariableNamesFromPattern(catchNode.param);
-                    errorVarInfo.forEach(varInfo => {
-                        const legacyId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
-                        const varId = scopeTracker
-                            ? computeSemanticId('VARIABLE', varInfo.name, scopeTracker.getContext())
-                            : legacyId;
-                        variableDeclarations.push({
-                            id: varId,
-                            type: 'VARIABLE',
-                            name: varInfo.name,
-                            file: module.file,
-                            line: varInfo.loc.start.line,
-                            parentScopeId: scopeInfo.catchScopeId
-                        });
-                    });
-                }
-            }
-        };
-    }
     /**
      * Handles SwitchStatement nodes.
      * Creates BRANCH node for switch, CASE nodes for each case clause,
@@ -2533,1331 +2083,134 @@ export class JSASTAnalyzer extends Plugin {
         };
     }
     /**
-     * Factory method to create IfStatement handler.
-     * Creates BRANCH node for if statement and SCOPE nodes for if/else bodies.
-     * Tracks if/else scope transitions via ifElseScopeMap.
-     *
-     * Phase 3 (REG-267): Creates BRANCH node with branchType='if' and
-     * HAS_CONSEQUENT/HAS_ALTERNATE edges to body SCOPEs.
-     *
-     * @param parentScopeId - Parent scope ID for the scope nodes
-     * @param module - Module context
-     * @param scopes - Collection to push scope nodes to
-     * @param branches - Collection to push BRANCH nodes to
-     * @param ifScopeCounterRef - Counter for unique if scope IDs
-     * @param branchCounterRef - Counter for unique BRANCH IDs
-     * @param scopeTracker - Tracker for semantic ID generation
-     * @param sourceCode - Source code for extracting condition text
-     * @param ifElseScopeMap - Map to track if/else scope transitions
-     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
-     */
-    createIfStatementHandler(parentScopeId, module, scopes, branches, ifScopeCounterRef, branchCounterRef, scopeTracker, sourceCode, ifElseScopeMap, scopeIdStack, controlFlowState, countLogicalOperators) {
-        return {
-            enter: (ifPath) => {
-                const ifNode = ifPath.node;
-                const condition = sourceCode.substring(ifNode.test.start, ifNode.test.end) || 'condition';
-                // Phase 6 (REG-267): Increment branch count and count logical operators
-                if (controlFlowState) {
-                    controlFlowState.branchCount++;
-                    if (countLogicalOperators) {
-                        controlFlowState.logicalOpCount += countLogicalOperators(ifNode.test);
-                    }
-                }
-                // Check if this if-statement is an else-if (alternate of parent IfStatement)
-                const isElseIf = t.isIfStatement(ifPath.parent) && ifPath.parentKey === 'alternate';
-                // Determine actual parent scope
-                let actualParentScopeId;
-                if (isElseIf) {
-                    // For else-if, parent should be the outer BRANCH (stored in ifElseScopeMap)
-                    const parentIfInfo = ifElseScopeMap.get(ifPath.parent);
-                    if (parentIfInfo) {
-                        actualParentScopeId = parentIfInfo.branchId;
-                    }
-                    else {
-                        // Fallback to stack
-                        actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
-                            ? scopeIdStack[scopeIdStack.length - 1]
-                            : parentScopeId;
-                    }
-                }
-                else {
-                    // For regular if statements, use stack or original parentScopeId
-                    actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
-                        ? scopeIdStack[scopeIdStack.length - 1]
-                        : parentScopeId;
-                }
-                // 1. Create BRANCH node for if statement
-                const branchCounter = branchCounterRef.value++;
-                const legacyBranchId = `${module.file}:BRANCH:if:${getLine(ifNode)}:${branchCounter}`;
-                const branchId = scopeTracker
-                    ? computeSemanticId('BRANCH', 'if', scopeTracker.getContext(), { discriminator: branchCounter })
-                    : legacyBranchId;
-                // 2. Extract condition expression info for HAS_CONDITION edge
-                const conditionResult = this.extractDiscriminantExpression(ifNode.test, module);
-                // For else-if, get the parent branch ID
-                const isAlternateOfBranchId = isElseIf
-                    ? ifElseScopeMap.get(ifPath.parent)?.branchId
-                    : undefined;
-                branches.push({
-                    id: branchId,
-                    semanticId: branchId,
-                    type: 'BRANCH',
-                    branchType: 'if',
-                    file: module.file,
-                    line: getLine(ifNode),
-                    parentScopeId: actualParentScopeId,
-                    discriminantExpressionId: conditionResult.id,
-                    discriminantExpressionType: conditionResult.expressionType,
-                    discriminantLine: conditionResult.line,
-                    discriminantColumn: conditionResult.column,
-                    isAlternateOfBranchId
-                });
-                // 3. Create if-body SCOPE (backward compatibility)
-                // Parent is now BRANCH, not original parentScopeId
-                const counterId = ifScopeCounterRef.value++;
-                const ifScopeId = `SCOPE#if#${module.file}#${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`;
-                // Parse condition to extract constraints
-                const constraints = ConditionParser.parse(ifNode.test);
-                const ifSemanticId = this.generateSemanticId('if_statement', scopeTracker);
-                scopes.push({
-                    id: ifScopeId,
-                    type: 'SCOPE',
-                    scopeType: 'if_statement',
-                    name: `if:${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`,
-                    semanticId: ifSemanticId,
-                    conditional: true,
-                    condition,
-                    constraints: constraints.length > 0 ? constraints : undefined,
-                    file: module.file,
-                    line: getLine(ifNode),
-                    parentScopeId: branchId // Parent is BRANCH, not original parentScopeId
-                });
-                // 4. Push if scope onto stack for CONTAINS edges
-                if (scopeIdStack) {
-                    scopeIdStack.push(ifScopeId);
-                }
-                // Enter scope for semantic ID generation
-                if (scopeTracker) {
-                    scopeTracker.enterCountedScope('if');
-                }
-                // 5. Handle else branch if present
-                let elseScopeId = null;
-                if (ifNode.alternate && !t.isIfStatement(ifNode.alternate)) {
-                    // Only create else scope for actual else block, not else-if
-                    const elseCounterId = ifScopeCounterRef.value++;
-                    elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
-                    const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
-                    const elseSemanticId = this.generateSemanticId('else_statement', scopeTracker);
-                    scopes.push({
-                        id: elseScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'else_statement',
-                        name: `else:${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`,
-                        semanticId: elseSemanticId,
-                        conditional: true,
-                        constraints: negatedConstraints,
-                        file: module.file,
-                        line: getLine(ifNode.alternate),
-                        parentScopeId: branchId // Parent is BRANCH, not original parentScopeId
-                    });
-                    // Store info to switch to else scope when we enter alternate
-                    ifElseScopeMap.set(ifNode, { inElse: false, hasElse: true, ifScopeId, elseScopeId, branchId });
-                }
-                else {
-                    ifElseScopeMap.set(ifNode, { inElse: false, hasElse: false, ifScopeId, elseScopeId: null, branchId });
-                }
-            },
-            exit: (ifPath) => {
-                const ifNode = ifPath.node;
-                // Pop scope from stack (either if or else, depending on what we're exiting)
-                if (scopeIdStack) {
-                    scopeIdStack.pop();
-                }
-                // Exit the current scope (either if or else)
-                if (scopeTracker) {
-                    scopeTracker.exitScope();
-                }
-                // If we were in else, we already exited else scope
-                // If we only had if, we exit if scope (done above)
-                ifElseScopeMap.delete(ifNode);
-            }
-        };
-    }
-    /**
-     * Factory method to create ConditionalExpression (ternary) handler.
-     * Creates BRANCH nodes with branchType='ternary' and increments branchCount for cyclomatic complexity.
-     *
-     * Key difference from IfStatement: ternary has EXPRESSIONS as branches, not SCOPE blocks.
-     * We store consequentExpressionId and alternateExpressionId in BranchInfo for HAS_CONSEQUENT/HAS_ALTERNATE edges.
+     * Анализирует тело функции и извлекает переменные, вызовы, условные блоки.
+     * Uses ScopeTracker from collections for semantic ID generation.
      *
-     * @param parentScopeId - Parent scope ID for the BRANCH node
-     * @param module - Module context
-     * @param branches - Collection to push BRANCH nodes to
-     * @param branchCounterRef - Counter for unique BRANCH IDs
-     * @param scopeTracker - Tracker for semantic ID generation
-     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
-     * @param controlFlowState - State for tracking control flow metrics (complexity)
-     * @param countLogicalOperators - Function to count logical operators in condition
+     * REG-422: Delegates traversal to extracted handler classes.
+     * Local state is encapsulated in FunctionBodyContext; each handler
+     * contributes a Visitor fragment that is merged into a single traversal.
      */
-    createConditionalExpressionHandler(parentScopeId, module, branches, branchCounterRef, scopeTracker, scopeIdStack, controlFlowState, countLogicalOperators) {
-        return (condPath) => {
-            const condNode = condPath.node;
-            // Increment branch count for cyclomatic complexity
-            if (controlFlowState) {
-                controlFlowState.branchCount++;
-                // Count logical operators in the test condition (e.g., a && b ? x : y)
-                if (countLogicalOperators) {
-                    controlFlowState.logicalOpCount += countLogicalOperators(condNode.test);
-                }
-            }
-            // Determine parent scope from stack or fallback
-            const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
-                ? scopeIdStack[scopeIdStack.length - 1]
-                : parentScopeId;
-            // Create BRANCH node with branchType='ternary'
-            const branchCounter = branchCounterRef.value++;
-            const legacyBranchId = `${module.file}:BRANCH:ternary:${getLine(condNode)}:${branchCounter}`;
-            const branchId = scopeTracker
-                ? computeSemanticId('BRANCH', 'ternary', scopeTracker.getContext(), { discriminator: branchCounter })
-                : legacyBranchId;
-            // Extract condition expression info for HAS_CONDITION edge
-            const conditionResult = this.extractDiscriminantExpression(condNode.test, module);
-            // Generate expression IDs for consequent and alternate
-            const consequentLine = getLine(condNode.consequent);
-            const consequentColumn = getColumn(condNode.consequent);
-            const consequentExpressionId = ExpressionNode.generateId(condNode.consequent.type, module.file, consequentLine, consequentColumn);
-            const alternateLine = getLine(condNode.alternate);
-            const alternateColumn = getColumn(condNode.alternate);
-            const alternateExpressionId = ExpressionNode.generateId(condNode.alternate.type, module.file, alternateLine, alternateColumn);
-            branches.push({
-                id: branchId,
-                semanticId: branchId,
-                type: 'BRANCH',
-                branchType: 'ternary',
+    analyzeFunctionBody(funcPath, parentScopeId, module, collections) {
+        // 1. Create context (replaces ~260 lines of local var declarations)
+        const ctx = createFunctionBodyContext(funcPath, parentScopeId, module, collections, (collections.functions ?? []), extractNamesFromPattern);
+        // 2. Handle implicit return for THIS arrow function if it has an expression body
+        // e.g., `const double = x => x * 2;` — this needs this.extractReturnExpressionInfo,
+        // so it stays here rather than in a handler.
+        if (t.isArrowFunctionExpression(ctx.funcNode) && !t.isBlockStatement(ctx.funcNode.body) && ctx.currentFunctionId) {
+            const bodyExpr = ctx.funcNode.body;
+            const exprInfo = this.extractReturnExpressionInfo(bodyExpr, module, ctx.literals, ctx.literalCounterRef, ctx.funcLine, ctx.funcColumn, 'implicit_return');
+            ctx.returnStatements.push({
+                parentFunctionId: ctx.currentFunctionId,
                 file: module.file,
-                line: getLine(condNode),
-                parentScopeId: actualParentScopeId,
-                discriminantExpressionId: conditionResult.id,
-                discriminantExpressionType: conditionResult.expressionType,
-                discriminantLine: conditionResult.line,
-                discriminantColumn: conditionResult.column,
-                consequentExpressionId,
-                alternateExpressionId
+                line: getLine(bodyExpr),
+                column: getColumn(bodyExpr),
+                returnValueType: 'NONE',
+                isImplicitReturn: true,
+                ...exprInfo,
             });
-        };
+        }
+        // 3. Create handlers and merge their visitors into a single traversal
+        // Cast to AnalyzerDelegate — the interface declares the same methods that exist
+        // on this class as private. The cast is safe because the shape matches exactly.
+        const delegate = this;
+        const handlers = [
+            new VariableHandler(ctx, delegate),
+            new ReturnYieldHandler(ctx, delegate),
+            new ThrowHandler(ctx, delegate),
+            new NestedFunctionHandler(ctx, delegate),
+            new PropertyAccessHandler(ctx, delegate),
+            new NewExpressionHandler(ctx, delegate),
+            new CallExpressionHandler(ctx, delegate),
+            new LoopHandler(ctx, delegate),
+            new TryCatchHandler(ctx, delegate),
+            new BranchHandler(ctx, delegate),
+        ];
+        const mergedVisitor = {};
+        for (const handler of handlers) {
+            Object.assign(mergedVisitor, handler.getHandlers());
+        }
+        // 4. Single traversal over the function body
+        funcPath.traverse(mergedVisitor);
+        // 5. Post-traverse: collect CATCHES_FROM info for try/catch blocks
+        if (ctx.functionPath) {
+            this.collectCatchesFromInfo(ctx.functionPath, ctx.catchBlocks, ctx.callSites, ctx.methodCalls, ctx.constructorCalls, ctx.catchesFromInfos, module);
+        }
+        // 6. Post-traverse: Attach control flow metadata to the function node
+        this.attachControlFlowMetadata(ctx);
     }
     /**
-     * Factory method to create BlockStatement handler for tracking if/else and try/finally transitions.
-     * When entering an else block, switches scope from if to else.
-     * When entering a finally block, switches scope from try/catch to finally.
-     *
-     * @param scopeTracker - Tracker for semantic ID generation
-     * @param ifElseScopeMap - Map to track if/else scope transitions
-     * @param tryScopeMap - Map to track try/catch/finally scope transitions
-     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
+     * Attach control flow metadata (cyclomatic complexity, error tracking, HOF bindings)
+     * to the matching function node after traversal completes.
      */
-    createBlockStatementHandler(scopeTracker, ifElseScopeMap, tryScopeMap, scopeIdStack) {
-        return {
-            enter: (blockPath) => {
-                const parent = blockPath.parent;
-                // Check if this block is the alternate of an IfStatement
-                if (t.isIfStatement(parent) && parent.alternate === blockPath.node) {
-                    const scopeInfo = ifElseScopeMap.get(parent);
-                    if (scopeInfo && scopeInfo.hasElse && !scopeInfo.inElse) {
-                        // Swap if-scope for else-scope on the stack
-                        if (scopeIdStack && scopeInfo.elseScopeId) {
-                            scopeIdStack.pop(); // Remove if-scope
-                            scopeIdStack.push(scopeInfo.elseScopeId); // Push else-scope
-                        }
-                        // Exit if scope, enter else scope for semantic ID tracking
-                        if (scopeTracker) {
-                            scopeTracker.exitScope();
-                            scopeTracker.enterCountedScope('else');
-                        }
-                        scopeInfo.inElse = true;
-                    }
-                }
-                // Check if this block is the finalizer of a TryStatement
-                if (t.isTryStatement(parent) && parent.finalizer === blockPath.node) {
-                    const scopeInfo = tryScopeMap.get(parent);
-                    if (scopeInfo && scopeInfo.finallyScopeId && scopeInfo.currentBlock !== 'finally') {
-                        // Pop current scope (try or catch), push finally scope
-                        if (scopeIdStack) {
-                            scopeIdStack.pop();
-                            scopeIdStack.push(scopeInfo.finallyScopeId);
-                        }
-                        // Exit current scope, enter finally scope for semantic ID tracking
-                        if (scopeTracker) {
-                            scopeTracker.exitScope();
-                            scopeTracker.enterCountedScope('finally');
-                        }
-                        scopeInfo.currentBlock = 'finally';
-                    }
-                }
-            }
+    attachControlFlowMetadata(ctx) {
+        if (!ctx.matchingFunction)
+            return;
+        const cyclomaticComplexity = 1 +
+            ctx.controlFlowState.branchCount +
+            ctx.controlFlowState.loopCount +
+            ctx.controlFlowState.caseCount +
+            ctx.controlFlowState.logicalOpCount;
+        // REG-311: Collect rejection info for this function
+        const functionRejectionPatterns = ctx.rejectionPatterns.filter(p => p.functionId === ctx.matchingFunction.id);
+        const asyncPatterns = functionRejectionPatterns.filter(p => p.isAsync);
+        const syncPatterns = functionRejectionPatterns.filter(p => !p.isAsync);
+        const canReject = asyncPatterns.length > 0;
+        const hasAsyncThrow = asyncPatterns.some(p => p.rejectionType === 'async_throw');
+        const rejectedBuiltinErrors = [...new Set(asyncPatterns
+                .filter(p => p.errorClassName !== null)
+                .map(p => p.errorClassName))];
+        // REG-286: Sync throw error tracking
+        const thrownBuiltinErrors = [...new Set(syncPatterns
+                .filter(p => p.errorClassName !== null)
+                .map(p => p.errorClassName))];
+        ctx.matchingFunction.controlFlow = {
+            hasBranches: ctx.controlFlowState.branchCount > 0,
+            hasLoops: ctx.controlFlowState.loopCount > 0,
+            hasTryCatch: ctx.controlFlowState.hasTryCatch,
+            hasEarlyReturn: ctx.controlFlowState.hasEarlyReturn,
+            hasThrow: ctx.controlFlowState.hasThrow,
+            cyclomaticComplexity,
+            // REG-311: Async error tracking
+            canReject,
+            hasAsyncThrow,
+            rejectedBuiltinErrors: rejectedBuiltinErrors.length > 0 ? rejectedBuiltinErrors : undefined,
+            // REG-286: Sync throw tracking
+            thrownBuiltinErrors: thrownBuiltinErrors.length > 0 ? thrownBuiltinErrors : undefined
         };
+        // REG-401: Store invoked parameter indexes for user-defined HOF detection
+        if (ctx.invokedParamIndexes.size > 0) {
+            ctx.matchingFunction.invokesParamIndexes = [...ctx.invokedParamIndexes];
+        }
+        // REG-417: Store property paths for destructured param bindings
+        if (ctx.invokesParamBindings.length > 0) {
+            ctx.matchingFunction.invokesParamBindings = ctx.invokesParamBindings;
+        }
     }
     /**
-     * Анализирует тело функции и извлекает переменные, вызовы, условные блоки.
-     * Uses ScopeTracker from collections for semantic ID generation.
+     * Handle CallExpression nodes: direct function calls (greet(), main())
+     * and method calls (obj.method(), data.process()).
+     *
+     * Handles:
+     * - Direct function calls (Identifier callee) → callSites collection
+     * - Method calls (MemberExpression callee) → methodCalls collection
+     * - Array mutation detection (push, unshift, splice)
+     * - Object.assign() detection
+     * - REG-311: isAwaited and isInsideTry metadata on CALL nodes
+     *
+     * @param callNode - The call expression AST node
+     * @param processedCallSites - Set of already processed call site keys to avoid duplicates
+     * @param processedMethodCalls - Set of already processed method call keys to avoid duplicates
+     * @param callSites - Collection for direct function calls
+     * @param methodCalls - Collection for method calls
+     * @param module - Current module being analyzed
+     * @param callSiteCounterRef - Counter for legacy ID generation
+     * @param scopeTracker - Optional scope tracker for semantic ID generation
+     * @param parentScopeId - ID of the parent scope containing this call
+     * @param collections - Full collections object for array/object mutations
+     * @param isAwaited - REG-311: true if wrapped in await expression
+     * @param isInsideTry - REG-311: true if inside try block
      */
-    analyzeFunctionBody(funcPath, parentScopeId, module, collections) {
-        // Extract with defaults for optional properties
-        const functions = (collections.functions ?? []);
-        const scopes = (collections.scopes ?? []);
-        const variableDeclarations = (collections.variableDeclarations ?? []);
-        const callSites = (collections.callSites ?? []);
-        const methodCalls = (collections.methodCalls ?? []);
-        const _eventListeners = (collections.eventListeners ?? []);
-        const _methodCallbacks = (collections.methodCallbacks ?? []);
-        const classInstantiations = (collections.classInstantiations ?? []);
-        const constructorCalls = (collections.constructorCalls ?? []);
-        const _httpRequests = (collections.httpRequests ?? []);
-        const literals = (collections.literals ?? []);
-        const variableAssignments = (collections.variableAssignments ?? []);
-        const ifScopeCounterRef = (collections.ifScopeCounterRef ?? { value: 0 });
-        const scopeCounterRef = (collections.scopeCounterRef ?? { value: 0 });
-        const varDeclCounterRef = (collections.varDeclCounterRef ?? { value: 0 });
-        const callSiteCounterRef = (collections.callSiteCounterRef ?? { value: 0 });
-        const functionCounterRef = (collections.functionCounterRef ?? { value: 0 });
-        const _httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 });
-        const literalCounterRef = (collections.literalCounterRef ?? { value: 0 });
-        const _anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 });
-        const scopeTracker = collections.scopeTracker;
-        // Object literal tracking (REG-328)
-        if (!collections.objectLiterals) {
-            collections.objectLiterals = [];
-        }
-        if (!collections.objectProperties) {
-            collections.objectProperties = [];
-        }
-        if (!collections.objectLiteralCounterRef) {
-            collections.objectLiteralCounterRef = { value: 0 };
-        }
-        const objectLiterals = collections.objectLiterals;
-        const objectProperties = collections.objectProperties;
-        const objectLiteralCounterRef = collections.objectLiteralCounterRef;
-        const returnStatements = (collections.returnStatements ?? []);
-        // Initialize yieldExpressions if not exist to ensure nested function calls share same array
-        if (!collections.yieldExpressions) {
-            collections.yieldExpressions = [];
-        }
-        const yieldExpressions = collections.yieldExpressions;
-        const _parameters = (collections.parameters ?? []);
-        // Control flow collections (Phase 2: LOOP nodes)
-        // Initialize if not exist to ensure nested function calls share same arrays
-        if (!collections.loops) {
-            collections.loops = [];
-        }
-        if (!collections.loopCounterRef) {
-            collections.loopCounterRef = { value: 0 };
-        }
-        const loops = collections.loops;
-        const loopCounterRef = collections.loopCounterRef;
-        const updateExpressions = (collections.updateExpressions ?? []);
-        const processedNodes = collections.processedNodes ?? {
-            functions: new Set(),
-            classes: new Set(),
-            imports: new Set(),
-            exports: new Set(),
-            variables: new Set(),
-            callSites: new Set(),
-            methodCalls: new Set(),
-            varDecls: new Set(),
-            eventListeners: new Set()
-        };
-        const parentScopeVariables = new Set();
-        const processedCallSites = processedNodes.callSites;
-        const _processedVarDecls = processedNodes.varDecls;
-        const processedMethodCalls = processedNodes.methodCalls;
-        const _processedEventListeners = processedNodes.eventListeners;
-        // Track if/else scope transitions (Phase 3: extended with branchId)
-        const ifElseScopeMap = new Map();
-        // Ensure branches and branchCounterRef are initialized (used by IfStatement and SwitchStatement)
-        if (!collections.branches) {
-            collections.branches = [];
-        }
-        if (!collections.branchCounterRef) {
-            collections.branchCounterRef = { value: 0 };
-        }
-        const branches = collections.branches;
-        const branchCounterRef = collections.branchCounterRef;
-        // Phase 4: Initialize try/catch/finally collections and counters
-        if (!collections.tryBlocks) {
-            collections.tryBlocks = [];
-        }
-        if (!collections.catchBlocks) {
-            collections.catchBlocks = [];
-        }
-        if (!collections.finallyBlocks) {
-            collections.finallyBlocks = [];
-        }
-        if (!collections.tryBlockCounterRef) {
-            collections.tryBlockCounterRef = { value: 0 };
-        }
-        if (!collections.catchBlockCounterRef) {
-            collections.catchBlockCounterRef = { value: 0 };
-        }
-        if (!collections.finallyBlockCounterRef) {
-            collections.finallyBlockCounterRef = { value: 0 };
-        }
-        const tryBlocks = collections.tryBlocks;
-        const catchBlocks = collections.catchBlocks;
-        const finallyBlocks = collections.finallyBlocks;
-        const tryBlockCounterRef = collections.tryBlockCounterRef;
-        const catchBlockCounterRef = collections.catchBlockCounterRef;
-        const finallyBlockCounterRef = collections.finallyBlockCounterRef;
-        // Track try/catch/finally scope transitions
-        const tryScopeMap = new Map();
-        // REG-334: Use shared Promise executor contexts from collections.
-        // These are populated by module-level NewExpression handler and function-level NewExpression handler.
-        if (!collections.promiseExecutorContexts) {
-            collections.promiseExecutorContexts = new Map();
-        }
-        const promiseExecutorContexts = collections.promiseExecutorContexts;
-        // Initialize promiseResolutions array if not exists
-        if (!collections.promiseResolutions) {
-            collections.promiseResolutions = [];
-        }
-        const promiseResolutions = collections.promiseResolutions;
-        // REG-311: Initialize rejectionPatterns and catchesFromInfos collections
-        if (!collections.rejectionPatterns) {
-            collections.rejectionPatterns = [];
-        }
-        if (!collections.catchesFromInfos) {
-            collections.catchesFromInfos = [];
-        }
-        const rejectionPatterns = collections.rejectionPatterns;
-        const catchesFromInfos = collections.catchesFromInfos;
-        // Dynamic scope ID stack for CONTAINS edges
-        // Starts with the function body scope, gets updated as we enter/exit conditional scopes
-        const scopeIdStack = [parentScopeId];
-        const getCurrentScopeId = () => scopeIdStack[scopeIdStack.length - 1];
-        // Determine the ID of the function we're analyzing for RETURNS edges
-        // Find by matching file/line/column in functions collection (it was just added by the visitor)
-        // REG-271: Skip for StaticBlock (static blocks don't have RETURNS edges or control flow metadata)
-        const funcNode = funcPath.node;
-        const functionNode = t.isFunction(funcNode) ? funcNode : null;
-        const functionPath = functionNode ? funcPath : null;
-        const funcLine = getLine(funcNode);
-        const funcColumn = getColumn(funcNode);
-        let currentFunctionId = null;
-        // StaticBlock is not a function - skip function matching for RETURNS edges
-        // For StaticBlock, matchingFunction will be undefined
-        const matchingFunction = funcNode.type !== 'StaticBlock'
-            ? functions.find(f => f.file === module.file &&
-                f.line === funcLine &&
-                (f.column === undefined || f.column === funcColumn))
-            : undefined;
-        if (matchingFunction) {
-            currentFunctionId = matchingFunction.id;
-        }
-        // Phase 6 (REG-267): Control flow tracking state for cyclomatic complexity
-        const controlFlowState = {
-            branchCount: 0, // if/switch statements
-            loopCount: 0, // for/while/do-while/for-in/for-of
-            caseCount: 0, // switch cases (excluding default)
-            logicalOpCount: 0, // && and || in conditions
-            hasTryCatch: false,
-            hasEarlyReturn: false,
-            hasThrow: false,
-            returnCount: 0, // Track total return count for early return detection
-            totalStatements: 0, // Track if there are statements after returns
-            // REG-311: Try block depth counter for O(1) isInsideTry detection
-            tryBlockDepth: 0
-        };
-        // Handle implicit return for THIS arrow function if it has an expression body
-        // e.g., `const double = x => x * 2;` - the function we're analyzing IS an arrow with expression body
-        if (t.isArrowFunctionExpression(funcNode) && !t.isBlockStatement(funcNode.body) && currentFunctionId) {
-            const bodyExpr = funcNode.body;
-            const bodyLine = getLine(bodyExpr);
-            const bodyColumn = getColumn(bodyExpr);
-            // Extract expression-specific info using shared method
-            const exprInfo = this.extractReturnExpressionInfo(bodyExpr, module, literals, literalCounterRef, funcLine, funcColumn, 'implicit_return');
-            const returnInfo = {
-                parentFunctionId: currentFunctionId,
-                file: module.file,
-                line: bodyLine,
-                column: bodyColumn,
-                returnValueType: 'NONE',
-                isImplicitReturn: true,
-                ...exprInfo,
-            };
-            returnStatements.push(returnInfo);
-        }
-        funcPath.traverse({
-            VariableDeclaration: (varPath) => {
-                this.handleVariableDeclaration(varPath, getCurrentScopeId(), module, variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker, parentScopeVariables, objectLiterals, objectProperties, objectLiteralCounterRef);
-            },
-            // Detect indexed array assignments: arr[i] = value
-            AssignmentExpression: (assignPath) => {
-                const assignNode = assignPath.node;
-                // === VARIABLE REASSIGNMENT (REG-290) ===
-                // Check if LHS is simple identifier (not obj.prop, not arr[i])
-                // Must be checked FIRST before array/object mutation handlers
-                if (assignNode.left.type === 'Identifier') {
-                    // Initialize collection if not exists
-                    if (!collections.variableReassignments) {
-                        collections.variableReassignments = [];
-                    }
-                    const variableReassignments = collections.variableReassignments;
-                    this.detectVariableReassignment(assignNode, module, variableReassignments, scopeTracker);
-                }
-                // === END VARIABLE REASSIGNMENT ===
-                // Initialize collection if not exists
-                if (!collections.arrayMutations) {
-                    collections.arrayMutations = [];
-                }
-                const arrayMutations = collections.arrayMutations;
-                // Check for indexed array assignment: arr[i] = value
-                this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker, collections);
-                // Initialize object mutations collection if not exists
-                if (!collections.objectMutations) {
-                    collections.objectMutations = [];
-                }
-                const objectMutations = collections.objectMutations;
-                // Check for object property assignment: obj.prop = value
-                this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
-            },
-            // Handle return statements for RETURNS edges
-            ReturnStatement: (returnPath) => {
-                // Skip if we couldn't determine the function ID
-                if (!currentFunctionId) {
-                    return;
-                }
-                // Skip if this return is inside a nested function (not the function we're analyzing)
-                // Check if there's a function ancestor BETWEEN us and funcNode
-                // Stop checking once we reach funcNode - parents above funcNode are outside scope
-                let parent = returnPath.parentPath;
-                let isInsideConditional = false;
-                while (parent) {
-                    // If we've reached funcNode, we're done checking - this return belongs to funcNode
-                    if (parent.node === funcNode) {
-                        break;
-                    }
-                    if (t.isFunction(parent.node)) {
-                        // Found a function between returnPath and funcNode - this return is inside a nested function
-                        return;
-                    }
-                    // Track if return is inside a conditional block (if/else, switch case, loop, try/catch)
-                    if (t.isIfStatement(parent.node) ||
-                        t.isSwitchCase(parent.node) ||
-                        t.isLoop(parent.node) ||
-                        t.isTryStatement(parent.node) ||
-                        t.isCatchClause(parent.node)) {
-                        isInsideConditional = true;
-                    }
-                    parent = parent.parentPath;
-                }
-                // Phase 6 (REG-267): Track return count and early return detection
-                controlFlowState.returnCount++;
-                // A return is "early" if it's inside a conditional structure
-                // (More returns after this one indicate the function doesn't always end here)
-                if (isInsideConditional) {
-                    controlFlowState.hasEarlyReturn = true;
-                }
-                const returnNode = returnPath.node;
-                const returnLine = getLine(returnNode);
-                const returnColumn = getColumn(returnNode);
-                // Handle bare return; (no value)
-                if (!returnNode.argument) {
-                    // Skip - no data flow value
-                    return;
-                }
-                const arg = returnNode.argument;
-                // Extract expression-specific info using shared method
-                const exprInfo = this.extractReturnExpressionInfo(arg, module, literals, literalCounterRef, returnLine, returnColumn, 'return');
-                const returnInfo = {
-                    parentFunctionId: currentFunctionId,
-                    file: module.file,
-                    line: returnLine,
-                    column: returnColumn,
-                    returnValueType: 'NONE',
-                    ...exprInfo,
-                };
-                returnStatements.push(returnInfo);
-            },
-            // Phase 6 (REG-267): Track throw statements for control flow metadata
-            // REG-311: Also detect async_throw rejection patterns
-            ThrowStatement: (throwPath) => {
-                // Skip if this throw is inside a nested function (not the function we're analyzing)
-                let parent = throwPath.parentPath;
-                while (parent) {
-                    if (t.isFunction(parent.node) && parent.node !== funcNode) {
-                        // This throw is inside a nested function - skip it
-                        return;
-                    }
-                    parent = parent.parentPath;
-                }
-                controlFlowState.hasThrow = true;
-                // REG-311: Track rejection patterns for async functions
-                const isAsyncFunction = functionNode?.async === true;
-                if (isAsyncFunction && currentFunctionId && functionNode && functionPath) {
-                    const throwNode = throwPath.node;
-                    const arg = throwNode.argument;
-                    const throwLine = getLine(throwNode);
-                    const throwColumn = getColumn(throwNode);
-                    // Case 1: throw new Error() or throw new CustomError()
-                    if (arg && t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
-                        rejectionPatterns.push({
-                            functionId: currentFunctionId,
-                            errorClassName: arg.callee.name,
-                            rejectionType: 'async_throw',
-                            file: module.file,
-                            line: throwLine,
-                            column: throwColumn
-                        });
-                    }
-                    // Case 2: throw identifier - needs micro-trace
-                    else if (arg && t.isIdentifier(arg)) {
-                        const varName = arg.name;
-                        // Check if it's a parameter
-                        const isParameter = functionNode.params.some(param => t.isIdentifier(param) && param.name === varName);
-                        if (isParameter) {
-                            // Parameter forwarding - can't resolve statically
-                            rejectionPatterns.push({
-                                functionId: currentFunctionId,
-                                errorClassName: null,
-                                rejectionType: 'variable_parameter',
-                                file: module.file,
-                                line: throwLine,
-                                column: throwColumn,
-                                sourceVariableName: varName
-                            });
-                        }
-                        else {
-                            // Try micro-trace
-                            const { errorClassName, tracePath } = this.microTraceToErrorClass(varName, functionPath, variableDeclarations);
-                            rejectionPatterns.push({
-                                functionId: currentFunctionId,
-                                errorClassName,
-                                rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
-                                file: module.file,
-                                line: throwLine,
-                                column: throwColumn,
-                                sourceVariableName: varName,
-                                tracePath
-                            });
-                        }
-                    }
-                }
-            },
-            // Handle yield expressions for YIELDS/DELEGATES_TO edges (REG-270)
-            YieldExpression: (yieldPath) => {
-                // Skip if we couldn't determine the function ID
-                if (!currentFunctionId) {
-                    return;
-                }
-                // Skip if this yield is inside a nested function (not the function we're analyzing)
-                // Check if there's a function ancestor BETWEEN us and funcNode
-                let parent = yieldPath.parentPath;
-                while (parent) {
-                    // If we've reached funcNode, we're done checking - this yield belongs to funcNode
-                    if (parent.node === funcNode) {
-                        break;
-                    }
-                    if (t.isFunction(parent.node)) {
-                        // Found a function between yieldPath and funcNode - this yield is inside a nested function
-                        return;
-                    }
-                    parent = parent.parentPath;
-                }
-                const yieldNode = yieldPath.node;
-                const yieldLine = getLine(yieldNode);
-                const yieldColumn = getColumn(yieldNode);
-                const isDelegate = yieldNode.delegate ?? false;
-                // Handle bare yield; (no value) - only valid for non-delegate yield
-                if (!yieldNode.argument && !isDelegate) {
-                    // Skip - no data flow value
-                    return;
-                }
-                // For yield* without argument (syntax error in practice, but handle gracefully)
-                if (!yieldNode.argument) {
-                    return;
-                }
-                const arg = yieldNode.argument;
-                // Extract expression-specific info using shared method
-                // Note: We reuse extractReturnExpressionInfo since yield values have identical semantics
-                const exprInfo = this.extractReturnExpressionInfo(arg, module, literals, literalCounterRef, yieldLine, yieldColumn, 'yield');
-                // Map ReturnStatementInfo fields to YieldExpressionInfo fields
-                const yieldInfo = {
-                    parentFunctionId: currentFunctionId,
-                    file: module.file,
-                    line: yieldLine,
-                    column: yieldColumn,
-                    isDelegate,
-                    yieldValueType: exprInfo.returnValueType ?? 'NONE',
-                    yieldValueName: exprInfo.returnValueName,
-                    yieldValueId: exprInfo.returnValueId,
-                    yieldValueLine: exprInfo.returnValueLine,
-                    yieldValueColumn: exprInfo.returnValueColumn,
-                    yieldValueCallName: exprInfo.returnValueCallName,
-                    expressionType: exprInfo.expressionType,
-                    operator: exprInfo.operator,
-                    leftSourceName: exprInfo.leftSourceName,
-                    rightSourceName: exprInfo.rightSourceName,
-                    consequentSourceName: exprInfo.consequentSourceName,
-                    alternateSourceName: exprInfo.alternateSourceName,
-                    object: exprInfo.object,
-                    property: exprInfo.property,
-                    computed: exprInfo.computed,
-                    objectSourceName: exprInfo.objectSourceName,
-                    expressionSourceNames: exprInfo.expressionSourceNames,
-                    unaryArgSourceName: exprInfo.unaryArgSourceName,
-                };
-                yieldExpressions.push(yieldInfo);
-            },
-            ForStatement: this.createLoopScopeHandler('for', 'for-loop', 'for', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
-            ForInStatement: this.createLoopScopeHandler('for-in', 'for-in-loop', 'for-in', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
-            ForOfStatement: this.createLoopScopeHandler('for-of', 'for-of-loop', 'for-of', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
-            WhileStatement: this.createLoopScopeHandler('while', 'while-loop', 'while', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
-            DoWhileStatement: this.createLoopScopeHandler('do-while', 'do-while-loop', 'do-while', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
-            // Phase 4 (REG-267): Now creates TRY_BLOCK, CATCH_BLOCK, FINALLY_BLOCK nodes
-            TryStatement: this.createTryStatementHandler(parentScopeId, module, scopes, tryBlocks, catchBlocks, finallyBlocks, scopeCounterRef, tryBlockCounterRef, catchBlockCounterRef, finallyBlockCounterRef, scopeTracker, tryScopeMap, scopeIdStack, controlFlowState),
-            CatchClause: this.createCatchClauseHandler(module, variableDeclarations, varDeclCounterRef, scopeTracker, tryScopeMap, scopeIdStack, controlFlowState),
-            SwitchStatement: (switchPath) => {
-                this.handleSwitchStatement(switchPath, parentScopeId, module, collections, scopeTracker, controlFlowState);
-            },
-            FunctionDeclaration: (funcDeclPath) => {
-                const node = funcDeclPath.node;
-                const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeTracker);
-                // Use semantic ID as primary ID when scopeTracker available
-                const legacyId = `FUNCTION#${funcName}#${module.file}#${getLine(node)}:${getColumn(node)}:${functionCounterRef.value++}`;
-                const functionId = scopeTracker
-                    ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
-                    : legacyId;
-                functions.push({
-                    id: functionId,
-                    type: 'FUNCTION',
-                    name: funcName,
-                    file: module.file,
-                    line: getLine(node),
-                    column: getColumn(node),
-                    async: node.async || false,
-                    generator: node.generator || false,
-                    parentScopeId
-                });
-                const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(node)}`;
-                const closureSemanticId = this.generateSemanticId('closure', scopeTracker);
-                scopes.push({
-                    id: nestedScopeId,
-                    type: 'SCOPE',
-                    scopeType: 'closure',
-                    name: `${funcName}:body`,
-                    semanticId: closureSemanticId,
-                    conditional: false,
-                    file: module.file,
-                    line: getLine(node),
-                    parentFunctionId: functionId,
-                    capturesFrom: parentScopeId
-                });
-                // Enter nested function scope for semantic ID generation
-                if (scopeTracker) {
-                    scopeTracker.enterScope(funcName, 'function');
-                }
-                this.analyzeFunctionBody(funcDeclPath, nestedScopeId, module, collections);
-                if (scopeTracker) {
-                    scopeTracker.exitScope();
-                }
-                funcDeclPath.skip();
-            },
-            FunctionExpression: (funcPath) => {
-                const node = funcPath.node;
-                const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeTracker);
-                // Use semantic ID as primary ID when scopeTracker available
-                const legacyId = `FUNCTION#${funcName}#${module.file}#${getLine(node)}:${getColumn(node)}:${functionCounterRef.value++}`;
-                const functionId = scopeTracker
-                    ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
-                    : legacyId;
-                functions.push({
-                    id: functionId,
-                    type: 'FUNCTION',
-                    name: funcName,
-                    file: module.file,
-                    line: getLine(node),
-                    column: getColumn(node),
-                    async: node.async || false,
-                    generator: node.generator || false,
-                    parentScopeId
-                });
-                const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(node)}`;
-                const closureSemanticId = this.generateSemanticId('closure', scopeTracker);
-                scopes.push({
-                    id: nestedScopeId,
-                    type: 'SCOPE',
-                    scopeType: 'closure',
-                    name: `${funcName}:body`,
-                    semanticId: closureSemanticId,
-                    conditional: false,
-                    file: module.file,
-                    line: getLine(node),
-                    parentFunctionId: functionId,
-                    capturesFrom: parentScopeId
-                });
-                // Enter nested function scope for semantic ID generation
-                if (scopeTracker) {
-                    scopeTracker.enterScope(funcName, 'function');
-                }
-                this.analyzeFunctionBody(funcPath, nestedScopeId, module, collections);
-                if (scopeTracker) {
-                    scopeTracker.exitScope();
-                }
-                funcPath.skip();
-            },
-            ArrowFunctionExpression: (arrowPath) => {
-                const node = arrowPath.node;
-                const line = getLine(node);
-                const column = getColumn(node);
-                // Определяем имя (anonymous если не присвоено переменной)
-                const parent = arrowPath.parent;
-                let funcName;
-                if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
-                    funcName = parent.id.name;
-                }
-                else {
-                    // Используем scope-level счётчик для стабильного semanticId
-                    funcName = this.generateAnonymousName(scopeTracker);
-                }
-                // Use semantic ID as primary ID when scopeTracker available
-                const legacyId = `FUNCTION#${funcName}:${line}:${column}:${functionCounterRef.value++}`;
-                const functionId = scopeTracker
-                    ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
-                    : legacyId;
-                functions.push({
-                    id: functionId,
-                    type: 'FUNCTION',
-                    name: funcName,
-                    file: module.file,
-                    line,
-                    column,
-                    async: node.async || false,
-                    arrowFunction: true,
-                    parentScopeId
-                });
-                if (node.body.type === 'BlockStatement') {
-                    const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${line}`;
-                    const arrowSemanticId = this.generateSemanticId('arrow_body', scopeTracker);
-                    scopes.push({
-                        id: nestedScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'arrow_body',
-                        name: `${funcName}:body`,
-                        semanticId: arrowSemanticId,
-                        conditional: false,
-                        file: module.file,
-                        line,
-                        parentFunctionId: functionId,
-                        capturesFrom: parentScopeId
-                    });
-                    // Enter arrow function scope for semantic ID generation
-                    if (scopeTracker) {
-                        scopeTracker.enterScope(funcName, 'arrow');
-                    }
-                    this.analyzeFunctionBody(arrowPath, nestedScopeId, module, collections);
-                    if (scopeTracker) {
-                        scopeTracker.exitScope();
-                    }
-                }
-                else {
-                    // Arrow function with expression body (implicit return)
-                    // e.g., x => x * 2, () => 42
-                    const bodyExpr = node.body;
-                    const bodyLine = getLine(bodyExpr);
-                    const bodyColumn = getColumn(bodyExpr);
-                    // Extract expression-specific info using shared method
-                    const exprInfo = this.extractReturnExpressionInfo(bodyExpr, module, literals, literalCounterRef, line, column, 'implicit_return');
-                    const returnInfo = {
-                        parentFunctionId: functionId,
-                        file: module.file,
-                        line: bodyLine,
-                        column: bodyColumn,
-                        returnValueType: 'NONE',
-                        isImplicitReturn: true,
-                        ...exprInfo,
-                    };
-                    returnStatements.push(returnInfo);
-                }
-                arrowPath.skip();
-            },
-            UpdateExpression: (updatePath) => {
-                const updateNode = updatePath.node;
-                // REG-288/REG-312: Collect update expression info for graph building
-                this.collectUpdateExpression(updateNode, module, updateExpressions, getCurrentScopeId(), scopeTracker);
-                // Legacy behavior: update scope.modifies for IDENTIFIER targets
-                if (updateNode.argument.type === 'Identifier') {
-                    const varName = updateNode.argument.name;
-                    // Find variable by name - could be from parent scope or declarations
-                    const fromParentScope = Array.from(parentScopeVariables).find(v => v.name === varName);
-                    const fromDeclarations = variableDeclarations.find(v => v.name === varName);
-                    const variable = fromParentScope ?? fromDeclarations;
-                    if (variable) {
-                        const scope = scopes.find(s => s.id === parentScopeId);
-                        if (scope) {
-                            if (!scope.modifies)
-                                scope.modifies = [];
-                            scope.modifies.push({
-                                variableId: variable.id,
-                                variableName: varName,
-                                line: getLine(updateNode)
-                            });
-                        }
-                    }
-                }
-            },
-            // IF statements - создаём условные scope и обходим содержимое для CALL узлов
-            // Phase 3 (REG-267): Now creates BRANCH nodes with branchType='if'
-            IfStatement: this.createIfStatementHandler(parentScopeId, module, scopes, branches, ifScopeCounterRef, branchCounterRef, scopeTracker, collections.code ?? '', ifElseScopeMap, scopeIdStack, controlFlowState, this.countLogicalOperators.bind(this)),
-            // Ternary expressions (REG-287): Creates BRANCH nodes with branchType='ternary'
-            ConditionalExpression: this.createConditionalExpressionHandler(parentScopeId, module, branches, branchCounterRef, scopeTracker, scopeIdStack, controlFlowState, this.countLogicalOperators.bind(this)),
-            // Track when we enter the alternate (else) block of an IfStatement
-            BlockStatement: this.createBlockStatementHandler(scopeTracker, ifElseScopeMap, tryScopeMap, scopeIdStack),
-            // Function call expressions
-            CallExpression: (callPath) => {
-                // REG-311: Detect isAwaited (parent is AwaitExpression)
-                const parent = callPath.parentPath;
-                const isAwaited = parent?.isAwaitExpression() ?? false;
-                // REG-311: Detect isInsideTry (O(1) via depth counter)
-                const isInsideTry = controlFlowState.tryBlockDepth > 0;
-                this.handleCallExpression(callPath.node, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, getCurrentScopeId(), collections, isAwaited, isInsideTry);
-                // REG-334: Check for resolve/reject calls inside Promise executors
-                const callNode = callPath.node;
-                if (t.isIdentifier(callNode.callee)) {
-                    const calleeName = callNode.callee.name;
-                    // Walk up function parents to find Promise executor context
-                    // This handles nested callbacks like: new Promise((resolve) => { db.query((err, data) => { resolve(data); }); });
-                    let funcParent = callPath.getFunctionParent();
-                    while (funcParent) {
-                        const funcNode = funcParent.node;
-                        const funcKey = `${funcNode.start}:${funcNode.end}`;
-                        const context = promiseExecutorContexts.get(funcKey);
-                        if (context) {
-                            const isResolve = calleeName === context.resolveName;
-                            const isReject = calleeName === context.rejectName;
-                            if (isResolve || isReject) {
-                                // Find the CALL node ID for this resolve/reject call
-                                // It was just added by handleCallExpression
-                                const callLine = getLine(callNode);
-                                const callColumn = getColumn(callNode);
-                                // Find matching call site that was just added
-                                const resolveCall = callSites.find(cs => cs.name === calleeName &&
-                                    cs.file === module.file &&
-                                    cs.line === callLine &&
-                                    cs.column === callColumn);
-                                if (resolveCall) {
-                                    promiseResolutions.push({
-                                        callId: resolveCall.id,
-                                        constructorCallId: context.constructorCallId,
-                                        isReject,
-                                        file: module.file,
-                                        line: callLine
-                                    });
-                                    // REG-334: Collect arguments for resolve/reject calls
-                                    // This enables traceValues to follow PASSES_ARGUMENT edges
-                                    if (!collections.callArguments) {
-                                        collections.callArguments = [];
-                                    }
-                                    const callArgumentsArr = collections.callArguments;
-                                    // Process arguments (typically just one: resolve(value))
-                                    callNode.arguments.forEach((arg, argIndex) => {
-                                        const argInfo = {
-                                            callId: resolveCall.id,
-                                            argIndex,
-                                            file: module.file,
-                                            line: getLine(arg),
-                                            column: getColumn(arg)
-                                        };
-                                        // Handle different argument types
-                                        if (t.isIdentifier(arg)) {
-                                            argInfo.targetType = 'VARIABLE';
-                                            argInfo.targetName = arg.name;
-                                        }
-                                        else if (t.isLiteral(arg) && !t.isTemplateLiteral(arg)) {
-                                            // Create LITERAL node for the argument value
-                                            const literalValue = ExpressionEvaluator.extractLiteralValue(arg);
-                                            if (literalValue !== null) {
-                                                const argLine = getLine(arg);
-                                                const argColumn = getColumn(arg);
-                                                const literalId = `LITERAL#arg${argIndex}#${module.file}#${argLine}:${argColumn}:${literalCounterRef.value++}`;
-                                                literals.push({
-                                                    id: literalId,
-                                                    type: 'LITERAL',
-                                                    value: literalValue,
-                                                    valueType: typeof literalValue,
-                                                    file: module.file,
-                                                    line: argLine,
-                                                    column: argColumn,
-                                                    parentCallId: resolveCall.id,
-                                                    argIndex
-                                                });
-                                                argInfo.targetType = 'LITERAL';
-                                                argInfo.targetId = literalId;
-                                                argInfo.literalValue = literalValue;
-                                            }
-                                        }
-                                        else if (t.isCallExpression(arg)) {
-                                            argInfo.targetType = 'CALL';
-                                            argInfo.nestedCallLine = getLine(arg);
-                                            argInfo.nestedCallColumn = getColumn(arg);
-                                        }
-                                        else {
-                                            argInfo.targetType = 'EXPRESSION';
-                                            argInfo.expressionType = arg.type;
-                                        }
-                                        callArgumentsArr.push(argInfo);
-                                    });
-                                }
-                                break; // Found context, stop searching
-                            }
-                        }
-                        funcParent = funcParent.getFunctionParent();
-                    }
-                    // REG-311: Detect executor_reject pattern - reject(new Error()) inside Promise executor
-                    // Walk up to find Promise executor context and check if this is reject call with NewExpression arg
-                    funcParent = callPath.getFunctionParent();
-                    while (funcParent && currentFunctionId) {
-                        const funcNode = funcParent.node;
-                        const funcKey = `${funcNode.start}:${funcNode.end}`;
-                        const context = promiseExecutorContexts.get(funcKey);
-                        if (context && calleeName === context.rejectName && callNode.arguments.length > 0) {
-                            // REG-311: Use the creator function's ID (the function that created the Promise),
-                            // not the executor's ID
-                            const targetFunctionId = context.creatorFunctionId || currentFunctionId;
-                            const arg = callNode.arguments[0];
-                            const callLine = getLine(callNode);
-                            const callColumn = getColumn(callNode);
-                            // Case 1: reject(new Error())
-                            if (t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
-                                rejectionPatterns.push({
-                                    functionId: targetFunctionId,
-                                    errorClassName: arg.callee.name,
-                                    rejectionType: 'executor_reject',
-                                    file: module.file,
-                                    line: callLine,
-                                    column: callColumn
-                                });
-                            }
-                            // Case 2: reject(err) where err is variable
-                            else if (t.isIdentifier(arg)) {
-                                const varName = arg.name;
-                                // Check if it's a parameter of ANY containing function (executor, outer, etc.)
-                                // Walk up the function chain to find if varName is a parameter
-                                let isParameter = false;
-                                let checkParent = funcParent;
-                                while (checkParent) {
-                                    if (t.isFunction(checkParent.node)) {
-                                        if (checkParent.node.params.some(p => t.isIdentifier(p) && p.name === varName)) {
-                                            isParameter = true;
-                                            break;
-                                        }
-                                    }
-                                    checkParent = checkParent.getFunctionParent();
-                                }
-                                if (isParameter) {
-                                    rejectionPatterns.push({
-                                        functionId: targetFunctionId,
-                                        errorClassName: null,
-                                        rejectionType: 'variable_parameter',
-                                        file: module.file,
-                                        line: callLine,
-                                        column: callColumn,
-                                        sourceVariableName: varName
-                                    });
-                                }
-                                else {
-                                    // Try micro-trace
-                                    const { errorClassName, tracePath } = this.microTraceToErrorClass(varName, funcParent, variableDeclarations);
-                                    rejectionPatterns.push({
-                                        functionId: targetFunctionId,
-                                        errorClassName,
-                                        rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
-                                        file: module.file,
-                                        line: callLine,
-                                        column: callColumn,
-                                        sourceVariableName: varName,
-                                        tracePath
-                                    });
-                                }
-                            }
-                            break;
-                        }
-                        funcParent = funcParent.getFunctionParent();
-                    }
-                }
-                // REG-311: Detect Promise.reject(new Error()) pattern
-                if (t.isMemberExpression(callNode.callee) && currentFunctionId) {
-                    const memberCallee = callNode.callee;
-                    if (t.isIdentifier(memberCallee.object) &&
-                        memberCallee.object.name === 'Promise' &&
-                        t.isIdentifier(memberCallee.property) &&
-                        memberCallee.property.name === 'reject' &&
-                        callNode.arguments.length > 0) {
-                        const arg = callNode.arguments[0];
-                        const callLine = getLine(callNode);
-                        const callColumn = getColumn(callNode);
-                        // Case 1: Promise.reject(new Error())
-                        if (t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
-                            rejectionPatterns.push({
-                                functionId: currentFunctionId,
-                                errorClassName: arg.callee.name,
-                                rejectionType: 'promise_reject',
-                                file: module.file,
-                                line: callLine,
-                                column: callColumn
-                            });
-                        }
-                        // Case 2: Promise.reject(err) where err is variable
-                        else if (t.isIdentifier(arg)) {
-                            const varName = arg.name;
-                            // Check if it's a parameter of containing function
-                            const isParameter = functionNode
-                                ? functionNode.params.some(param => t.isIdentifier(param) && param.name === varName)
-                                : false;
-                            if (isParameter) {
-                                rejectionPatterns.push({
-                                    functionId: currentFunctionId,
-                                    errorClassName: null,
-                                    rejectionType: 'variable_parameter',
-                                    file: module.file,
-                                    line: callLine,
-                                    column: callColumn,
-                                    sourceVariableName: varName
-                                });
-                            }
-                            else {
-                                // Try micro-trace
-                                if (!functionPath) {
-                                    rejectionPatterns.push({
-                                        functionId: currentFunctionId,
-                                        errorClassName: null,
-                                        rejectionType: 'variable_unknown',
-                                        file: module.file,
-                                        line: callLine,
-                                        column: callColumn,
-                                        sourceVariableName: varName,
-                                        tracePath: [varName]
-                                    });
-                                    return;
-                                }
-                                const { errorClassName, tracePath } = this.microTraceToErrorClass(varName, functionPath, variableDeclarations);
-                                rejectionPatterns.push({
-                                    functionId: currentFunctionId,
-                                    errorClassName,
-                                    rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
-                                    file: module.file,
-                                    line: callLine,
-                                    column: callColumn,
-                                    sourceVariableName: varName,
-                                    tracePath
-                                });
-                            }
-                        }
-                    }
-                }
-            },
-            // NewExpression (constructor calls)
-            NewExpression: (newPath) => {
-                const newNode = newPath.node;
-                const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                // Determine className from callee
-                let className = null;
-                if (newNode.callee.type === 'Identifier') {
-                    className = newNode.callee.name;
-                }
-                else if (newNode.callee.type === 'MemberExpression' && newNode.callee.property.type === 'Identifier') {
-                    className = newNode.callee.property.name;
-                }
-                // Create CONSTRUCTOR_CALL node (always, for all NewExpressions)
-                if (className) {
-                    const constructorKey = `constructor:${nodeKey}`;
-                    if (!processedCallSites.has(constructorKey)) {
-                        processedCallSites.add(constructorKey);
-                        const line = getLine(newNode);
-                        const column = getColumn(newNode);
-                        const constructorCallId = ConstructorCallNode.generateId(className, module.file, line, column);
-                        const isBuiltin = ConstructorCallNode.isBuiltinConstructor(className);
-                        constructorCalls.push({
-                            id: constructorCallId,
-                            type: 'CONSTRUCTOR_CALL',
-                            className,
-                            isBuiltin,
-                            file: module.file,
-                            line,
-                            column
-                        });
-                        // REG-334: If this is Promise constructor with executor callback,
-                        // register the context for resolve/reject detection
-                        if (className === 'Promise' && newNode.arguments.length > 0) {
-                            const executorArg = newNode.arguments[0];
-                            // Only handle inline function expressions (not variable references)
-                            if (t.isArrowFunctionExpression(executorArg) || t.isFunctionExpression(executorArg)) {
-                                // Extract resolve/reject parameter names
-                                let resolveName;
-                                let rejectName;
-                                if (executorArg.params.length > 0 && t.isIdentifier(executorArg.params[0])) {
-                                    resolveName = executorArg.params[0].name;
-                                }
-                                if (executorArg.params.length > 1 && t.isIdentifier(executorArg.params[1])) {
-                                    rejectName = executorArg.params[1].name;
-                                }
-                                if (resolveName) {
-                                    // Key by function node position to allow nested Promise detection
-                                    const funcKey = `${executorArg.start}:${executorArg.end}`;
-                                    promiseExecutorContexts.set(funcKey, {
-                                        constructorCallId,
-                                        resolveName,
-                                        rejectName,
-                                        file: module.file,
-                                        line,
-                                        // REG-311: Store the ID of the function that creates the Promise
-                                        creatorFunctionId: currentFunctionId || undefined
-                                    });
-                                }
-                            }
-                        }
-                    }
-                }
-                // Handle simple constructor: new Foo()
-                if (newNode.callee.type === 'Identifier') {
-                    if (processedCallSites.has(nodeKey)) {
-                        return;
-                    }
-                    processedCallSites.add(nodeKey);
-                    // Generate semantic ID (primary) or legacy ID (fallback)
-                    const constructorName = newNode.callee.name;
-                    const legacyId = `CALL#new:${constructorName}#${module.file}#${getLine(newNode)}:${getColumn(newNode)}:${callSiteCounterRef.value++}`;
-                    let newCallId = legacyId;
-                    if (scopeTracker) {
-                        const discriminator = scopeTracker.getItemCounter(`CALL:new:${constructorName}`);
-                        newCallId = computeSemanticId('CALL', `new:${constructorName}`, scopeTracker.getContext(), { discriminator });
-                    }
-                    callSites.push({
-                        id: newCallId,
-                        type: 'CALL',
-                        name: constructorName,
-                        file: module.file,
-                        line: getLine(newNode),
-                        parentScopeId: getCurrentScopeId(),
-                        targetFunctionName: constructorName,
-                        isNew: true
-                    });
-                }
-                // Handle namespaced constructor: new ns.Constructor()
-                else if (newNode.callee.type === 'MemberExpression') {
-                    const memberCallee = newNode.callee;
-                    const object = memberCallee.object;
-                    const property = memberCallee.property;
-                    if (object.type === 'Identifier' && property.type === 'Identifier') {
-                        if (processedMethodCalls.has(nodeKey)) {
-                            return;
-                        }
-                        processedMethodCalls.add(nodeKey);
-                        const objectName = object.name;
-                        const constructorName = property.name;
-                        const fullName = `${objectName}.${constructorName}`;
-                        // Generate semantic ID for method-style constructor call
-                        const legacyId = `CALL#new:${fullName}#${module.file}#${getLine(newNode)}:${getColumn(newNode)}:${callSiteCounterRef.value++}`;
-                        let newMethodCallId = legacyId;
-                        if (scopeTracker) {
-                            const discriminator = scopeTracker.getItemCounter(`CALL:new:${fullName}`);
-                            newMethodCallId = computeSemanticId('CALL', `new:${fullName}`, scopeTracker.getContext(), { discriminator });
-                        }
-                        methodCalls.push({
-                            id: newMethodCallId,
-                            type: 'CALL',
-                            name: fullName,
-                            object: objectName,
-                            method: constructorName,
-                            file: module.file,
-                            line: getLine(newNode),
-                            column: getColumn(newNode),
-                            parentScopeId: getCurrentScopeId(),
-                            isNew: true
-                        });
-                    }
-                }
-            },
-            // Property access expressions (REG-395)
-            // Shared handler for both MemberExpression and OptionalMemberExpression
-            MemberExpression: (memberPath) => {
-                // Initialize collections if needed
-                if (!collections.propertyAccesses) {
-                    collections.propertyAccesses = [];
-                }
-                if (!collections.propertyAccessCounterRef) {
-                    collections.propertyAccessCounterRef = { value: 0 };
-                }
-                PropertyAccessVisitor.extractPropertyAccesses(memberPath, memberPath.node, module, collections.propertyAccesses, collections.propertyAccessCounterRef, scopeTracker, currentFunctionId || getCurrentScopeId());
-            },
-            // OptionalMemberExpression: obj?.prop (same logic as MemberExpression)
-            OptionalMemberExpression: (memberPath) => {
-                // Initialize collections if needed
-                if (!collections.propertyAccesses) {
-                    collections.propertyAccesses = [];
-                }
-                if (!collections.propertyAccessCounterRef) {
-                    collections.propertyAccessCounterRef = { value: 0 };
-                }
-                PropertyAccessVisitor.extractPropertyAccesses(memberPath, memberPath.node, module, collections.propertyAccesses, collections.propertyAccessCounterRef, scopeTracker, currentFunctionId || getCurrentScopeId());
-            }
-        });
-        // REG-311: Second pass - collect CATCHES_FROM info for try/catch blocks
-        // This links catch blocks to exception sources in their corresponding try blocks
-        if (functionPath) {
-            this.collectCatchesFromInfo(functionPath, catchBlocks, callSites, methodCalls, constructorCalls, catchesFromInfos, module);
-        }
-        // Phase 6 (REG-267): Attach control flow metadata to the function node
-        if (matchingFunction) {
-            const cyclomaticComplexity = 1 +
-                controlFlowState.branchCount +
-                controlFlowState.loopCount +
-                controlFlowState.caseCount +
-                controlFlowState.logicalOpCount;
-            // REG-311: Collect rejection info for this function
-            const functionRejectionPatterns = rejectionPatterns.filter(p => p.functionId === matchingFunction.id);
-            const canReject = functionRejectionPatterns.length > 0;
-            const hasAsyncThrow = functionRejectionPatterns.some(p => p.rejectionType === 'async_throw');
-            const rejectedBuiltinErrors = [...new Set(functionRejectionPatterns
-                    .filter(p => p.errorClassName !== null)
-                    .map(p => p.errorClassName))];
-            matchingFunction.controlFlow = {
-                hasBranches: controlFlowState.branchCount > 0,
-                hasLoops: controlFlowState.loopCount > 0,
-                hasTryCatch: controlFlowState.hasTryCatch,
-                hasEarlyReturn: controlFlowState.hasEarlyReturn,
-                hasThrow: controlFlowState.hasThrow,
-                cyclomaticComplexity,
-                // REG-311: Async error tracking
-                canReject,
-                hasAsyncThrow,
-                rejectedBuiltinErrors: rejectedBuiltinErrors.length > 0 ? rejectedBuiltinErrors : undefined
-            };
-        }
-    }
-    /**
-     * Handle CallExpression nodes: direct function calls (greet(), main())
-     * and method calls (obj.method(), data.process()).
-     *
-     * Handles:
-     * - Direct function calls (Identifier callee) → callSites collection
-     * - Method calls (MemberExpression callee) → methodCalls collection
-     * - Array mutation detection (push, unshift, splice)
-     * - Object.assign() detection
-     * - REG-311: isAwaited and isInsideTry metadata on CALL nodes
-     *
-     * @param callNode - The call expression AST node
-     * @param processedCallSites - Set of already processed call site keys to avoid duplicates
-     * @param processedMethodCalls - Set of already processed method call keys to avoid duplicates
-     * @param callSites - Collection for direct function calls
-     * @param methodCalls - Collection for method calls
-     * @param module - Current module being analyzed
-     * @param callSiteCounterRef - Counter for legacy ID generation
-     * @param scopeTracker - Optional scope tracker for semantic ID generation
-     * @param parentScopeId - ID of the parent scope containing this call
-     * @param collections - Full collections object for array/object mutations
-     * @param isAwaited - REG-311: true if wrapped in await expression
-     * @param isInsideTry - REG-311: true if inside try block
-     */
-    handleCallExpression(callNode, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, parentScopeId, collections, isAwaited = false, isInsideTry = false) {
+    handleCallExpression(callNode, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, parentScopeId, collections, isAwaited = false, isInsideTry = false, isInsideLoop = false) {
         // Handle direct function calls (greet(), main())
         if (callNode.callee.type === 'Identifier') {
             const nodeKey = `${callNode.start}:${callNode.end}`;
@@ -3884,7 +2237,9 @@ export class JSASTAnalyzer extends Plugin {
                 targetFunctionName: calleeName,
                 // REG-311: Async error tracking metadata
                 isAwaited,
-                isInsideTry
+                isInsideTry,
+                // REG-298: Await-in-loop detection
+                ...(isAwaited && isInsideLoop ? { isInsideLoop } : {})
             });
         }
         // Handle method calls (obj.method(), data.process())
@@ -3924,8 +2279,14 @@ export class JSASTAnalyzer extends Plugin {
                     // REG-311: Async error tracking metadata
                     isAwaited,
                     isInsideTry,
+                    // REG-298: Await-in-loop detection
+                    ...(isAwaited && isInsideLoop ? { isInsideLoop } : {}),
                     isMethodCall: true
                 });
+                // REG-400: Extract arguments for method calls (enables callback resolution)
+                if (callNode.arguments.length > 0) {
+                    this.extractMethodCallArguments(callNode, methodCallId, module, collections);
+                }
                 // Check for array mutation methods (push, unshift, splice)
                 const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
                 if (ARRAY_MUTATION_METHODS.includes(methodName)) {
@@ -3998,11 +2359,108 @@ export class JSASTAnalyzer extends Plugin {
                             parentScopeId,
                             isMethodCall: true
                         });
+                        // REG-400: Extract arguments for nested method calls (enables callback resolution)
+                        if (callNode.arguments.length > 0) {
+                            this.extractMethodCallArguments(callNode, methodCallId, module, collections);
+                        }
                     }
                 }
             }
         }
     }
+    /**
+     * REG-400: Extract arguments from method call nodes inside function bodies.
+     * Populates callArguments collection so GraphBuilder.bufferArgumentEdges can
+     * create PASSES_ARGUMENT and callback CALLS edges.
+     *
+     * This mirrors CallExpressionVisitor.extractArguments but is simplified —
+     * handles Identifier, Literal, CallExpression, and Expression types.
+     */
+    extractMethodCallArguments(callNode, methodCallId, module, collections) {
+        if (!collections.callArguments) {
+            collections.callArguments = [];
+        }
+        const callArguments = collections.callArguments;
+        const literals = (collections.literals ?? []);
+        const literalCounterRef = (collections.literalCounterRef ?? { value: 0 });
+        callNode.arguments.forEach((arg, argIndex) => {
+            const argInfo = {
+                callId: methodCallId,
+                argIndex,
+                file: module.file,
+                line: getLine(arg),
+                column: getColumn(arg)
+            };
+            if (t.isSpreadElement(arg)) {
+                const spreadArg = arg.argument;
+                if (t.isIdentifier(spreadArg)) {
+                    argInfo.targetType = 'VARIABLE';
+                    argInfo.targetName = spreadArg.name;
+                    argInfo.isSpread = true;
+                }
+            }
+            else if (t.isIdentifier(arg)) {
+                argInfo.targetType = 'VARIABLE';
+                argInfo.targetName = arg.name;
+            }
+            else if (t.isLiteral(arg) && !t.isTemplateLiteral(arg)) {
+                const literalValue = ExpressionEvaluator.extractLiteralValue(arg);
+                if (literalValue !== null) {
+                    const argLine = getLine(arg);
+                    const argColumn = getColumn(arg);
+                    const literalId = `LITERAL#arg${argIndex}#${module.file}#${argLine}:${argColumn}:${literalCounterRef.value++}`;
+                    literals.push({
+                        id: literalId,
+                        type: 'LITERAL',
+                        value: literalValue,
+                        valueType: typeof literalValue,
+                        file: module.file,
+                        line: argLine,
+                        column: argColumn,
+                        parentCallId: methodCallId,
+                        argIndex
+                    });
+                    argInfo.targetType = 'LITERAL';
+                    argInfo.targetId = literalId;
+                    argInfo.literalValue = literalValue;
+                }
+            }
+            else if (t.isArrowFunctionExpression(arg) || t.isFunctionExpression(arg)) {
+                argInfo.targetType = 'FUNCTION';
+                argInfo.functionLine = getLine(arg);
+                argInfo.functionColumn = getColumn(arg);
+            }
+            else if (t.isCallExpression(arg)) {
+                argInfo.targetType = 'CALL';
+                argInfo.nestedCallLine = getLine(arg);
+                argInfo.nestedCallColumn = getColumn(arg);
+                // REG-402: MemberExpression arguments (this.handler, obj.method)
+            }
+            else if (t.isMemberExpression(arg)) {
+                argInfo.targetType = 'EXPRESSION';
+                argInfo.expressionType = 'MemberExpression';
+                if (t.isIdentifier(arg.object)) {
+                    argInfo.objectName = arg.object.name;
+                }
+                else if (t.isThisExpression(arg.object)) {
+                    argInfo.objectName = 'this';
+                    // Store enclosing class name for direct lookup in GraphBuilder
+                    const scopeTracker = collections.scopeTracker;
+                    if (scopeTracker) {
+                        argInfo.enclosingClassName = scopeTracker.getEnclosingScope('CLASS');
+                    }
+                }
+                if (!arg.computed && t.isIdentifier(arg.property)) {
+                    argInfo.propertyName = arg.property.name;
+                }
+            }
+            else {
+                argInfo.targetType = 'EXPRESSION';
+                argInfo.expressionType = arg.type;
+            }
+            callArguments.push(argInfo);
+        });
+    }
     /**
      * REG-311: Micro-trace - follow variable assignments within function to find error source.
      * Used to resolve reject(err) or throw err where err is a variable.
@@ -4322,36 +2780,12 @@ export class JSASTAnalyzer extends Plugin {
                     isSpread: false,
                     valueType: 'EXPRESSION'
                 };
-                // Determine value type and create value nodes for non-variable types (REG-392)
-                const literalValue = ExpressionEvaluator.extractLiteralValue(value);
-                if (literalValue !== null) {
-                    argInfo.valueType = 'LITERAL';
-                    argInfo.literalValue = literalValue;
-                    const valueLine = value.loc?.start.line ?? line;
-                    const valueColumn = value.loc?.start.column ?? column;
-                    // Create LITERAL node if collections available
-                    if (collections?.literals && collections.literalCounterRef) {
-                        const literalCounterRef = collections.literalCounterRef;
-                        const literalId = `LITERAL#indexed#${module.file}#${valueLine}:${valueColumn}:${literalCounterRef.value++}`;
-                        collections.literals.push({
-                            id: literalId,
-                            type: 'LITERAL',
-                            value: literalValue,
-                            valueType: typeof literalValue,
-                            file: module.file,
-                            line: valueLine,
-                            column: valueColumn,
-                            parentCallId: undefined,
-                            argIndex: 0
-                        });
-                        argInfo.valueNodeId = literalId;
-                    }
-                }
-                else if (value.type === 'Identifier') {
-                    argInfo.valueType = 'VARIABLE';
-                    argInfo.valueName = value.name;
-                }
-                else if (value.type === 'ObjectExpression') {
+                // Determine value type and create value nodes for non-variable types
+                // IMPORTANT: Check ObjectExpression/ArrayExpression BEFORE extractLiteralValue
+                // to match the order in detectArrayMutation and extractArguments (REG-396).
+                // extractLiteralValue returns objects/arrays with all-literal properties as
+                // literal values, but we want OBJECT_LITERAL/ARRAY_LITERAL nodes instead.
+                if (value.type === 'ObjectExpression') {
                     argInfo.valueType = 'OBJECT_LITERAL';
                     const valueLine = value.loc?.start.line ?? line;
                     const valueColumn = value.loc?.start.column ?? column;
@@ -4379,11 +2813,41 @@ export class JSASTAnalyzer extends Plugin {
                         argInfo.valueNodeId = arrayNode.id;
                     }
                 }
+                else if (value.type === 'Identifier') {
+                    argInfo.valueType = 'VARIABLE';
+                    argInfo.valueName = value.name;
+                }
                 else if (value.type === 'CallExpression') {
                     argInfo.valueType = 'CALL';
                     argInfo.callLine = value.loc?.start.line;
                     argInfo.callColumn = value.loc?.start.column;
                 }
+                else {
+                    const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+                    if (literalValue !== null) {
+                        argInfo.valueType = 'LITERAL';
+                        argInfo.literalValue = literalValue;
+                        const valueLine = value.loc?.start.line ?? line;
+                        const valueColumn = value.loc?.start.column ?? column;
+                        // Create LITERAL node if collections available
+                        if (collections?.literals && collections.literalCounterRef) {
+                            const literalCounterRef = collections.literalCounterRef;
+                            const literalId = `LITERAL#indexed#${module.file}#${valueLine}:${valueColumn}:${literalCounterRef.value++}`;
+                            collections.literals.push({
+                                id: literalId,
+                                type: 'LITERAL',
+                                value: literalValue,
+                                valueType: typeof literalValue,
+                                file: module.file,
+                                line: valueLine,
+                                column: valueColumn,
+                                parentCallId: undefined,
+                                argIndex: 0
+                            });
+                            argInfo.valueNodeId = literalId;
+                        }
+                    }
+                }
                 // Capture scope path for scope-aware lookup (REG-309)
                 const scopePath = scopeTracker?.getContext().scopePath ?? [];
                 arrayMutations.push({