@grafema/core 0.2.5-beta → 0.2.7

package/src/plugins/analysis/JSASTAnalyzer.ts

@@ -8,7 +8,7 @@ import { createHash } from 'crypto';
 import { basename } from 'path';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
-import type { NodePath, TraverseOptions } from '@babel/traverse';
+import type { NodePath, TraverseOptions, Visitor } from '@babel/traverse';
 import * as t from '@babel/types';
 
 // Type for CJS/ESM interop - @babel/traverse exports a function but @types defines it as namespace
@@ -54,11 +54,15 @@ 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 type { PluginContext, PluginResult, PluginMetadata, GraphBackend } from '@grafema/types';
 import type {
   ModuleNode,
@@ -106,11 +110,29 @@ import type {
   RejectionPatternInfo,
   CatchesFromInfo,
   PropertyAccessInfo,
+  TypeParameterInfo,
   CounterRef,
   ProcessedNodes,
   ASTCollections,
   ExtractedVariable,
 } from './ast/types.js';
+import { extractNamesFromPattern } from './ast/utils/extractNamesFromPattern.js';
+import { createFunctionBodyContext } from './ast/FunctionBodyContext.js';
+import type { FunctionBodyContext } from './ast/FunctionBodyContext.js';
+import {
+  VariableHandler,
+  ReturnYieldHandler,
+  ThrowHandler,
+  NestedFunctionHandler,
+  PropertyAccessHandler,
+  NewExpressionHandler,
+  CallExpressionHandler,
+  LoopHandler,
+  TryCatchHandler,
+  BranchHandler,
+} from './ast/handlers/index.js';
+import type { AnalyzerDelegate } from './ast/handlers/index.js';
+import type { FunctionBodyHandler } from './ast/handlers/index.js';
 
 // === LOCAL TYPES ===
 
@@ -152,6 +174,8 @@ interface Collections {
   typeAliases: TypeAliasInfo[];
   enums: EnumDeclarationInfo[];
   decorators: DecoratorInfo[];
+  // Type parameter tracking for generics (REG-303)
+  typeParameters: TypeParameterInfo[];
   // Object/Array literal tracking
   objectLiterals: ObjectLiteralInfo[];
   objectProperties: ObjectPropertyInfo[];
@@ -201,35 +225,6 @@ interface Collections {
   [key: string]: unknown;
 }
 
-/**
- * Tracks try/catch/finally scope transitions during traversal.
- * Used by createTryStatementHandler and createBlockStatementHandler.
- */
-interface TryScopeInfo {
-  tryScopeId: string;
-  catchScopeId: string | null;
-  finallyScopeId: string | null;
-  currentBlock: 'try' | 'catch' | 'finally';
-  // Phase 4: Control flow node IDs
-  tryBlockId: string;
-  catchBlockId: string | null;
-  finallyBlockId: string | null;
-}
-
-/**
- * Tracks if/else scope transitions during traversal.
- * Used by createIfStatementHandler and createBlockStatementHandler.
- * Phase 3: Extended to include branchId for control flow BRANCH nodes.
- */
-interface IfElseScopeInfo {
-  inElse: boolean;
-  hasElse: boolean;
-  ifScopeId: string;
-  elseScopeId: string | null;
-  // Phase 3: Control flow BRANCH node ID
-  branchId: string;
-}
-
 interface AnalysisManifest {
   projectPath: string;
   [key: string]: unknown;
@@ -267,14 +262,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'
         ]
@@ -295,9 +290,9 @@ export class JSASTAnalyzer extends Plugin {
   /**
    * Вычисляет хеш содержимого файла
    */
-  calculateFileHash(filePath: string): string | null {
+  calculateFileHash(filePath: string, projectPath: string = ''): string | null {
     try {
-      const content = readFileSync(filePath, 'utf-8');
+      const content = readFileSync(resolveNodeFile(filePath, projectPath), 'utf-8');
       return createHash('sha256').update(content).digest('hex');
     } catch {
       return null;
@@ -307,7 +302,7 @@ export class JSASTAnalyzer extends Plugin {
   /**
    * Проверяет нужно ли анализировать модуль (сравнивает хеши)
    */
-  async shouldAnalyzeModule(module: ModuleNode, graph: GraphBackend, forceAnalysis: boolean): Promise<boolean> {
+  async shouldAnalyzeModule(module: ModuleNode, graph: GraphBackend, forceAnalysis: boolean, projectPath: string = ""): Promise<boolean> {
     if (forceAnalysis) {
       return true;
     }
@@ -316,19 +311,19 @@ export class JSASTAnalyzer extends Plugin {
       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',
+        type: 'MODULE' as const,
         name: module.name,
         file: module.file,
         contentHash: currentHash
-      });
+      }));
       return true;
     }
 
@@ -365,7 +360,7 @@ export class JSASTAnalyzer extends Plugin {
           continue;
         }
 
-        if (await this.shouldAnalyzeModule(module, graph, forceAnalysis)) {
+        if (await this.shouldAnalyzeModule(module, graph, forceAnalysis, projectPath)) {
           modulesToAnalyze.push(module);
         } else {
           skippedCount++;
@@ -501,7 +496,7 @@ export class JSASTAnalyzer extends Plugin {
       // Convert ModuleNode to ASTModuleInfo format
       const moduleInfos: ASTModuleInfo[] = modules.map(m => ({
         id: m.id,
-        file: m.file,
+        file: resolveNodeFile(m.file, projectPath),
         name: m.name
       }));
 
@@ -546,7 +541,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
           });
@@ -567,68 +562,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: t.Node | null | undefined, variables: ExtractedVariable[] = [], propertyPath: string[] = []): ExtractedVariable[] {
-    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);
   }
 
   /**
@@ -725,57 +665,15 @@ export class JSASTAnalyzer extends Plugin {
     }
 
     // 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: unknown[] = [];
-        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;
     }
@@ -1417,13 +1315,13 @@ export class JSASTAnalyzer extends Plugin {
 
     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');
 
@@ -1431,6 +1329,9 @@ export class JSASTAnalyzer extends Plugin {
       // 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: FunctionInfo[] = [];
       const parameters: ParameterInfo[] = [];
       const scopes: ScopeInfo[] = [];
@@ -1458,6 +1359,8 @@ export class JSASTAnalyzer extends Plugin {
       const typeAliases: TypeAliasInfo[] = [];
       const enums: EnumDeclarationInfo[] = [];
       const decorators: DecoratorInfo[] = [];
+      // Type parameter tracking for generics (REG-303)
+      const typeParameters: TypeParameterInfo[] = [];
       // Object/Array literal tracking for data flow
       const objectLiterals: ObjectLiteralInfo[] = [];
       const objectProperties: ObjectPropertyInfo[] = [];
@@ -1545,6 +1448,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
@@ -1759,10 +1664,30 @@ export class JSASTAnalyzer extends Plugin {
 
       // 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: NodePath<t.AwaitExpression>) {
+          if (!awaitPath.getFunctionParent()) {
+            hasTopLevelAwait = true;
+            awaitPath.stop();
+          }
+        },
+        // for-await-of uses ForOfStatement.await, not AwaitExpression
+        ForOfStatement(forOfPath: NodePath<t.ForOfStatement>) {
+          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);
@@ -1897,6 +1822,39 @@ 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<{ id: string }, string>();
+        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<string, string>();
+        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 as Array<{ callId: string }> | undefined;
+          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, {
@@ -1932,6 +1890,8 @@ export class JSASTAnalyzer extends Plugin {
         typeAliases,
         enums,
         decorators,
+        // Type parameter tracking for generics (REG-303)
+        typeParameters,
         // Array mutation tracking
         arrayMutations,
         // Object mutation tracking
@@ -1958,7 +1918,9 @@ export class JSASTAnalyzer extends Plugin {
           ? allCollections.catchesFromInfos as CatchesFromInfo[]
           : 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');
 
@@ -2205,506 +2167,6 @@ export class JSASTAnalyzer extends Plugin {
     });
   }
 
-  private createLoopScopeHandler(
-    trackerScopeType: string,
-    scopeType: string,
-    loopType: 'for' | 'for-in' | 'for-of' | 'while' | 'do-while',
-    parentScopeId: string,
-    module: VisitorModule,
-    scopes: ScopeInfo[],
-    loops: LoopInfo[],
-    scopeCounterRef: CounterRef,
-    loopCounterRef: CounterRef,
-    scopeTracker: ScopeTracker | undefined,
-    scopeIdStack?: string[],
-    controlFlowState?: { loopCount: number }
-  ): { enter: (path: NodePath<t.Loop>) => void; exit: () => void } {
-    return {
-      enter: (path: NodePath<t.Loop>) => {
-        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: string | undefined;
-        let iteratesOverLine: number | undefined;
-        let iteratesOverColumn: number | undefined;
-
-        if (loopType === 'for-in' || loopType === 'for-of') {
-          const loopNode = node as t.ForInStatement | t.ForOfStatement;
-          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: string | undefined;
-        let initLine: number | undefined;
-
-        let testExpressionId: string | undefined;
-        let testExpressionType: string | undefined;
-        let testLine: number | undefined;
-        let testColumn: number | undefined;
-
-        let updateExpressionId: string | undefined;
-        let updateExpressionType: string | undefined;
-        let updateLine: number | undefined;
-        let updateColumn: number | undefined;
-
-        if (loopType === 'for') {
-          const forNode = node as t.ForStatement;
-
-          // 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 as t.WhileStatement | t.DoWhileStatement;
-          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: boolean | undefined;
-        if (loopType === 'for-of') {
-          const forOfNode = node as t.ForOfStatement;
-          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: string | undefined;
-        let conditionExpressionType: string | undefined;
-        let conditionLine: number | undefined;
-        let conditionColumn: number | undefined;
-
-        if (loopType === 'while' || loopType === 'do-while') {
-          const testNode = (node as t.WhileStatement | t.DoWhileStatement).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 as t.ForStatement;
-          // 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
-   */
-  private createTryStatementHandler(
-    parentScopeId: string,
-    module: VisitorModule,
-    scopes: ScopeInfo[],
-    tryBlocks: TryBlockInfo[],
-    catchBlocks: CatchBlockInfo[],
-    finallyBlocks: FinallyBlockInfo[],
-    scopeCounterRef: CounterRef,
-    tryBlockCounterRef: CounterRef,
-    catchBlockCounterRef: CounterRef,
-    finallyBlockCounterRef: CounterRef,
-    scopeTracker: ScopeTracker | undefined,
-    tryScopeMap: Map<t.TryStatement, TryScopeInfo>,
-    scopeIdStack?: string[],
-    controlFlowState?: { hasTryCatch: boolean; tryBlockDepth: number }
-  ): { enter: (tryPath: NodePath<t.TryStatement>) => void; exit: (tryPath: NodePath<t.TryStatement>) => void } {
-    return {
-      enter: (tryPath: NodePath<t.TryStatement>) => {
-        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: string | null = null;
-        let catchScopeId: string | null = 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: string | undefined;
-          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: string | null = null;
-        let finallyScopeId: string | null = 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: NodePath<t.TryStatement>) => {
-        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
-   */
-  private createCatchClauseHandler(
-    module: VisitorModule,
-    variableDeclarations: VariableDeclarationInfo[],
-    varDeclCounterRef: CounterRef,
-    scopeTracker: ScopeTracker | undefined,
-    tryScopeMap: Map<t.TryStatement, TryScopeInfo>,
-    scopeIdStack?: string[],
-    controlFlowState?: { hasTryCatch: boolean; tryBlockDepth: number }
-  ): { enter: (catchPath: NodePath<t.CatchClause>) => void } {
-    return {
-      enter: (catchPath: NodePath<t.CatchClause>) => {
-        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.
@@ -3219,1635 +2681,144 @@ 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.
+   * Анализирует тело функции и извлекает переменные, вызовы, условные блоки.
+   * Uses ScopeTracker from collections for semantic ID generation.
    *
-   * @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
+   * 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.
    */
-  private createIfStatementHandler(
+  analyzeFunctionBody(
+    funcPath: NodePath<t.Function | t.StaticBlock>,
     parentScopeId: string,
     module: VisitorModule,
-    scopes: ScopeInfo[],
-    branches: BranchInfo[],
-    ifScopeCounterRef: CounterRef,
-    branchCounterRef: CounterRef,
-    scopeTracker: ScopeTracker | undefined,
-    sourceCode: string,
-    ifElseScopeMap: Map<t.IfStatement, IfElseScopeInfo>,
-    scopeIdStack?: string[],
-    controlFlowState?: { branchCount: number; logicalOpCount: number },
-    countLogicalOperators?: (node: t.Expression) => number
-  ): { enter: (ifPath: NodePath<t.IfStatement>) => void; exit: (ifPath: NodePath<t.IfStatement>) => void } {
-    return {
-      enter: (ifPath: NodePath<t.IfStatement>) => {
-        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);
-          }
-        }
+    collections: VisitorCollections
+  ): void {
+    // 1. Create context (replaces ~260 lines of local var declarations)
+    const ctx = createFunctionBodyContext(
+      funcPath, parentScopeId, module, collections,
+      (collections.functions ?? []) as FunctionInfo[],
+      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(bodyExpr),
+        column: getColumn(bodyExpr),
+        returnValueType: 'NONE',
+        isImplicitReturn: true,
+        ...exprInfo,
+      });
+    }
 
-        // 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: string;
-        if (isElseIf) {
-          // For else-if, parent should be the outer BRANCH (stored in ifElseScopeMap)
-          const parentIfInfo = ifElseScopeMap.get(ifPath.parent as t.IfStatement);
-          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;
-        }
+    // 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 as unknown as AnalyzerDelegate;
+    const handlers: FunctionBodyHandler[] = [
+      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: Visitor = {};
+    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
+      );
+    }
 
-        // 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 as t.IfStatement)?.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
-        });
+    // 6. Post-traverse: Attach control flow metadata to the function node
+    this.attachControlFlowMetadata(ctx);
+  }
 
-        // 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
-        });
+  /**
+   * Attach control flow metadata (cyclomatic complexity, error tracking, HOF bindings)
+   * to the matching function node after traversal completes.
+   */
+  private attachControlFlowMetadata(ctx: FunctionBodyContext): void {
+    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
+    };
 
-        // 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: string | null = 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: NodePath<t.IfStatement>) => {
-        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.
-   *
-   * @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
-   */
-  private createConditionalExpressionHandler(
-    parentScopeId: string,
-    module: VisitorModule,
-    branches: BranchInfo[],
-    branchCounterRef: CounterRef,
-    scopeTracker: ScopeTracker | undefined,
-    scopeIdStack?: string[],
-    controlFlowState?: { branchCount: number; logicalOpCount: number },
-    countLogicalOperators?: (node: t.Expression) => number
-  ): (condPath: NodePath<t.ConditionalExpression>) => void {
-    return (condPath: NodePath<t.ConditionalExpression>) => {
-      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',
-        file: module.file,
-        line: getLine(condNode),
-        parentScopeId: actualParentScopeId,
-        discriminantExpressionId: conditionResult.id,
-        discriminantExpressionType: conditionResult.expressionType,
-        discriminantLine: conditionResult.line,
-        discriminantColumn: conditionResult.column,
-        consequentExpressionId,
-        alternateExpressionId
-      });
-    };
-  }
-
-  /**
-   * 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
-   */
-  private createBlockStatementHandler(
-    scopeTracker: ScopeTracker | undefined,
-    ifElseScopeMap: Map<t.IfStatement, IfElseScopeInfo>,
-    tryScopeMap: Map<t.TryStatement, TryScopeInfo>,
-    scopeIdStack?: string[]
-  ): { enter: (blockPath: NodePath<t.BlockStatement>) => void } {
-    return {
-      enter: (blockPath: NodePath<t.BlockStatement>) => {
-        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';
-          }
-        }
-      }
-    };
-  }
-
-  /**
-   * Анализирует тело функции и извлекает переменные, вызовы, условные блоки.
-   * Uses ScopeTracker from collections for semantic ID generation.
-   */
-  analyzeFunctionBody(
-    funcPath: NodePath<t.Function | t.StaticBlock>,
-    parentScopeId: string,
-    module: VisitorModule,
-    collections: VisitorCollections
-  ): void {
-    // Extract with defaults for optional properties
-    const functions = (collections.functions ?? []) as FunctionInfo[];
-    const scopes = (collections.scopes ?? []) as ScopeInfo[];
-    const variableDeclarations = (collections.variableDeclarations ?? []) as VariableDeclarationInfo[];
-    const callSites = (collections.callSites ?? []) as CallSiteInfo[];
-    const methodCalls = (collections.methodCalls ?? []) as MethodCallInfo[];
-    const _eventListeners = (collections.eventListeners ?? []) as EventListenerInfo[];
-    const _methodCallbacks = (collections.methodCallbacks ?? []) as MethodCallbackInfo[];
-    const classInstantiations = (collections.classInstantiations ?? []) as ClassInstantiationInfo[];
-    const constructorCalls = (collections.constructorCalls ?? []) as ConstructorCallInfo[];
-    const _httpRequests = (collections.httpRequests ?? []) as HttpRequestInfo[];
-    const literals = (collections.literals ?? []) as LiteralInfo[];
-    const variableAssignments = (collections.variableAssignments ?? []) as VariableAssignmentInfo[];
-    const ifScopeCounterRef = (collections.ifScopeCounterRef ?? { value: 0 }) as CounterRef;
-    const scopeCounterRef = (collections.scopeCounterRef ?? { value: 0 }) as CounterRef;
-    const varDeclCounterRef = (collections.varDeclCounterRef ?? { value: 0 }) as CounterRef;
-    const callSiteCounterRef = (collections.callSiteCounterRef ?? { value: 0 }) as CounterRef;
-    const functionCounterRef = (collections.functionCounterRef ?? { value: 0 }) as CounterRef;
-    const _httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 }) as CounterRef;
-    const literalCounterRef = (collections.literalCounterRef ?? { value: 0 }) as CounterRef;
-    const _anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 }) as CounterRef;
-    const scopeTracker = collections.scopeTracker as ScopeTracker | undefined;
-    // 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 as ObjectLiteralInfo[];
-    const objectProperties = collections.objectProperties as ObjectPropertyInfo[];
-    const objectLiteralCounterRef = collections.objectLiteralCounterRef as CounterRef;
-    const returnStatements = (collections.returnStatements ?? []) as ReturnStatementInfo[];
-    // Initialize yieldExpressions if not exist to ensure nested function calls share same array
-    if (!collections.yieldExpressions) {
-      collections.yieldExpressions = [];
-    }
-    const yieldExpressions = collections.yieldExpressions as YieldExpressionInfo[];
-    const _parameters = (collections.parameters ?? []) as ParameterInfo[];
-    // 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 as LoopInfo[];
-    const loopCounterRef = collections.loopCounterRef as CounterRef;
-    const updateExpressions = (collections.updateExpressions ?? []) as UpdateExpressionInfo[];
-    const processedNodes = collections.processedNodes ?? {
-      functions: new Set<string>(),
-      classes: new Set<string>(),
-      imports: new Set<string>(),
-      exports: new Set<string>(),
-      variables: new Set<string>(),
-      callSites: new Set<string>(),
-      methodCalls: new Set<string>(),
-      varDecls: new Set<string>(),
-      eventListeners: new Set<string>()
-    };
-
-    const parentScopeVariables = new Set<{ name: string; id: string; scopeId: string }>();
-
-    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<t.IfStatement, IfElseScopeInfo>();
-
-    // 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 as BranchInfo[];
-    const branchCounterRef = collections.branchCounterRef as CounterRef;
-
-    // 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 as TryBlockInfo[];
-    const catchBlocks = collections.catchBlocks as CatchBlockInfo[];
-    const finallyBlocks = collections.finallyBlocks as FinallyBlockInfo[];
-    const tryBlockCounterRef = collections.tryBlockCounterRef as CounterRef;
-    const catchBlockCounterRef = collections.catchBlockCounterRef as CounterRef;
-    const finallyBlockCounterRef = collections.finallyBlockCounterRef as CounterRef;
-
-    // Track try/catch/finally scope transitions
-    const tryScopeMap = new Map<t.TryStatement, TryScopeInfo>();
-
-    // 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<string, PromiseExecutorContext>();
-    }
-    const promiseExecutorContexts = collections.promiseExecutorContexts as Map<string, PromiseExecutorContext>;
-
-    // Initialize promiseResolutions array if not exists
-    if (!collections.promiseResolutions) {
-      collections.promiseResolutions = [];
-    }
-    const promiseResolutions = collections.promiseResolutions as PromiseResolutionInfo[];
-
-    // REG-311: Initialize rejectionPatterns and catchesFromInfos collections
-    if (!collections.rejectionPatterns) {
-      collections.rejectionPatterns = [];
-    }
-    if (!collections.catchesFromInfos) {
-      collections.catchesFromInfos = [];
-    }
-    const rejectionPatterns = collections.rejectionPatterns as RejectionPatternInfo[];
-    const catchesFromInfos = collections.catchesFromInfos as CatchesFromInfo[];
-
-    // Dynamic scope ID stack for CONTAINS edges
-    // Starts with the function body scope, gets updated as we enter/exit conditional scopes
-    const scopeIdStack: string[] = [parentScopeId];
-    const getCurrentScopeId = (): string => 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 as NodePath<t.Function>) : null;
-    const funcLine = getLine(funcNode);
-    const funcColumn = getColumn(funcNode);
-    let currentFunctionId: string | null = 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: ReturnStatementInfo = {
-        parentFunctionId: currentFunctionId,
-        file: module.file,
-        line: bodyLine,
-        column: bodyColumn,
-        returnValueType: 'NONE',
-        isImplicitReturn: true,
-        ...exprInfo,
-      };
-
-      returnStatements.push(returnInfo);
-    }
-
-    funcPath.traverse({
-      VariableDeclaration: (varPath: NodePath<t.VariableDeclaration>) => {
-        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: NodePath<t.AssignmentExpression>) => {
-        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 as VariableReassignmentInfo[];
-
-          this.detectVariableReassignment(assignNode, module, variableReassignments, scopeTracker);
-        }
-        // === END VARIABLE REASSIGNMENT ===
-
-        // Initialize collection if not exists
-        if (!collections.arrayMutations) {
-          collections.arrayMutations = [];
-        }
-        const arrayMutations = collections.arrayMutations as ArrayMutationInfo[];
-
-        // 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 as ObjectMutationInfo[];
-
-        // Check for object property assignment: obj.prop = value
-        this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
-      },
-
-      // Handle return statements for RETURNS edges
-      ReturnStatement: (returnPath: NodePath<t.ReturnStatement>) => {
-        // 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: NodePath | null = 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: ReturnStatementInfo = {
-          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: NodePath<t.ThrowStatement>) => {
-        // Skip if this throw is inside a nested function (not the function we're analyzing)
-        let parent: NodePath | null = 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: NodePath<t.YieldExpression>) => {
-        // 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: NodePath | null = 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: YieldExpressionInfo = {
-          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: NodePath<t.SwitchStatement>) => {
-        this.handleSwitchStatement(
-          switchPath,
-          parentScopeId,
-          module,
-          collections,
-          scopeTracker,
-          controlFlowState
-        );
-      },
-
-      FunctionDeclaration: (funcDeclPath: NodePath<t.FunctionDeclaration>) => {
-        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: NodePath<t.FunctionExpression>) => {
-        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: NodePath<t.ArrowFunctionExpression>) => {
-        const node = arrowPath.node;
-        const line = getLine(node);
-        const column = getColumn(node);
-
-        // Определяем имя (anonymous если не присвоено переменной)
-        const parent = arrowPath.parent;
-        let funcName: string;
-        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: ReturnStatementInfo = {
-            parentFunctionId: functionId,
-            file: module.file,
-            line: bodyLine,
-            column: bodyColumn,
-            returnValueType: 'NONE',
-            isImplicitReturn: true,
-            ...exprInfo,
-          };
-
-          returnStatements.push(returnInfo);
-        }
-
-        arrowPath.skip();
-      },
-
-      UpdateExpression: (updatePath: NodePath<t.UpdateExpression>) => {
-        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: NodePath<t.CallExpression>) => {
-        // 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 as CallArgumentInfo[];
-
-                  // Process arguments (typically just one: resolve(value))
-                  callNode.arguments.forEach((arg, argIndex) => {
-                    const argInfo: CallArgumentInfo = {
-                      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 as t.Literal);
-                      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: NodePath<t.Node> | null = 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 as NodePath<t.Function>,
-                    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: NodePath<t.NewExpression>) => {
-        const newNode = newPath.node;
-        const nodeKey = `new:${newNode.start}:${newNode.end}`;
-
-        // Determine className from callee
-        let className: string | null = 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: string | undefined;
-                let rejectName: string | undefined;
-
-                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: NodePath<t.MemberExpression>) => {
-        // Initialize collections if needed
-        if (!collections.propertyAccesses) {
-          collections.propertyAccesses = [];
-        }
-        if (!collections.propertyAccessCounterRef) {
-          collections.propertyAccessCounterRef = { value: 0 };
-        }
-
-        PropertyAccessVisitor.extractPropertyAccesses(
-          memberPath,
-          memberPath.node,
-          module,
-          collections.propertyAccesses as PropertyAccessInfo[],
-          collections.propertyAccessCounterRef as CounterRef,
-          scopeTracker,
-          currentFunctionId || getCurrentScopeId()
-        );
-      },
-      // OptionalMemberExpression: obj?.prop (same logic as MemberExpression)
-      OptionalMemberExpression: (memberPath: NodePath) => {
-        // Initialize collections if needed
-        if (!collections.propertyAccesses) {
-          collections.propertyAccesses = [];
-        }
-        if (!collections.propertyAccessCounterRef) {
-          collections.propertyAccessCounterRef = { value: 0 };
-        }
-
-        PropertyAccessVisitor.extractPropertyAccesses(
-          memberPath,
-          memberPath.node as t.MemberExpression,
-          module,
-          collections.propertyAccesses as PropertyAccessInfo[],
-          collections.propertyAccessCounterRef as CounterRef,
-          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
-      };
-    }
-  }
+    // 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;
+    }
+  }
 
   /**
    * Handle CallExpression nodes: direct function calls (greet(), main())
@@ -4885,7 +2856,8 @@ export class JSASTAnalyzer extends Plugin {
     parentScopeId: string,
     collections: VisitorCollections,
     isAwaited: boolean = false,
-    isInsideTry: boolean = false
+    isInsideTry: boolean = false,
+    isInsideLoop: boolean = false
   ): void {
     // Handle direct function calls (greet(), main())
     if (callNode.callee.type === 'Identifier') {
@@ -4916,7 +2888,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())
@@ -4961,9 +2935,16 @@ 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)) {
@@ -5065,12 +3046,112 @@ 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.
+   */
+  private extractMethodCallArguments(
+    callNode: t.CallExpression,
+    methodCallId: string,
+    module: VisitorModule,
+    collections: VisitorCollections
+  ): void {
+    if (!collections.callArguments) {
+      collections.callArguments = [];
+    }
+    const callArguments = collections.callArguments as CallArgumentInfo[];
+    const literals = (collections.literals ?? []) as LiteralInfo[];
+    const literalCounterRef = (collections.literalCounterRef ?? { value: 0 }) as CounterRef;
+
+    callNode.arguments.forEach((arg, argIndex) => {
+      const argInfo: CallArgumentInfo = {
+        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 as t.Literal);
+        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 as ScopeTracker | undefined;
+          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.
@@ -5461,34 +3542,12 @@ export class JSASTAnalyzer extends Plugin {
           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 as CounterRef;
-            const literalId = `LITERAL#indexed#${module.file}#${valueLine}:${valueColumn}:${literalCounterRef.value++}`;
-            (collections.literals as LiteralInfo[]).push({
-              id: literalId,
-              type: 'LITERAL',
-              value: literalValue,
-              valueType: typeof literalValue,
-              file: module.file,
-              line: valueLine,
-              column: valueColumn,
-              parentCallId: undefined,
-              argIndex: 0
-            } as LiteralInfo);
-            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;
@@ -5518,10 +3577,38 @@ export class JSASTAnalyzer extends Plugin {
             (collections.arrayLiterals as ArrayLiteralInfo[]).push(arrayNode as unknown as ArrayLiteralInfo);
             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 as CounterRef;
+              const literalId = `LITERAL#indexed#${module.file}#${valueLine}:${valueColumn}:${literalCounterRef.value++}`;
+              (collections.literals as LiteralInfo[]).push({
+                id: literalId,
+                type: 'LITERAL',
+                value: literalValue,
+                valueType: typeof literalValue,
+                file: module.file,
+                line: valueLine,
+                column: valueColumn,
+                parentCallId: undefined,
+                argIndex: 0
+              } as LiteralInfo);
+              argInfo.valueNodeId = literalId;
+            }
+          }
         }
 
         // Capture scope path for scope-aware lookup (REG-309)