@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/dist/plugins/analysis/JSASTAnalyzer.js

@@ -4,6 +4,7 @@
  */
 import { readFileSync } from 'fs';
 import { createHash } from 'crypto';
+import { basename } from 'path';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import * as t from '@babel/types';
@@ -25,19 +26,25 @@ import { ImportExportVisitor, VariableVisitor, FunctionVisitor, ClassVisitor, Ca
 import { Task } from '../../core/Task.js';
 import { PriorityQueue } from '../../core/PriorityQueue.js';
 import { WorkerPool } from '../../core/WorkerPool.js';
+import { ASTWorkerPool } from '../../core/ASTWorkerPool.js';
 import { ConditionParser } from './ast/ConditionParser.js';
+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 { ExpressionNode } from '../../core/nodes/ExpressionNode.js';
+import { ConstructorCallNode } from '../../core/nodes/ConstructorCallNode.js';
+import { ObjectLiteralNode } from '../../core/nodes/ObjectLiteralNode.js';
+import { NodeFactory } from '../../core/NodeFactory.js';
 export class JSASTAnalyzer extends Plugin {
     graphBuilder;
     analyzedModules;
     profiler;
-    _cacheCleared;
     constructor() {
         super();
         this.graphBuilder = new GraphBuilder();
         this.analyzedModules = new Set();
         this.profiler = new Profiler('JSASTAnalyzer');
-        this._cacheCleared = false;
     }
     get metadata() {
         return {
@@ -57,7 +64,9 @@ export class JSASTAnalyzer extends Plugin {
                     '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',
+                    // Promise data flow
+                    'RESOLVES_TO'
                 ]
             },
             dependencies: ['JSModuleIndexer']
@@ -110,12 +119,12 @@ export class JSASTAnalyzer extends Plugin {
         return true;
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { manifest, graph, forceAnalysis = false } = context;
             const projectPath = manifest?.projectPath ?? '';
-            if (forceAnalysis && !this._cacheCleared) {
+            if (forceAnalysis) {
                 this.analyzedModules.clear();
-                this._cacheCleared = true;
             }
             const allModules = await this.getModuleNodes(graph);
             const modulesToAnalyze = [];
@@ -132,11 +141,15 @@ export class JSASTAnalyzer extends Plugin {
                     skippedCount++;
                 }
             }
-            console.log(`[JSASTAnalyzer] Starting parallel analysis of ${modulesToAnalyze.length} modules (${skippedCount} cached)...`);
+            logger.info('Starting module analysis', { toAnalyze: modulesToAnalyze.length, cached: skippedCount });
             if (modulesToAnalyze.length === 0) {
-                console.log(`[JSASTAnalyzer] All modules are up-to-date, skipping analysis`);
+                logger.info('All modules up-to-date, skipping analysis');
                 return createSuccessResult({ nodes: 0, edges: 0 });
             }
+            // Use ASTWorkerPool for true parallel parsing with worker_threads if enabled
+            if (context.parallelParsing) {
+                return await this.executeParallel(modulesToAnalyze, graph, projectPath, context);
+            }
             const queue = new PriorityQueue();
             const pool = new WorkerPool(context.workerCount || 10);
             pool.registerHandler('ANALYZE_MODULE', async (task) => {
@@ -171,7 +184,7 @@ export class JSASTAnalyzer extends Plugin {
             pool.on('worker:task:completed', () => {
                 completed++;
                 if (completed % 10 === 0 || completed === modulesToAnalyze.length) {
-                    console.log(`[JSASTAnalyzer] Progress: ${completed}/${modulesToAnalyze.length}`);
+                    logger.debug('Analysis progress', { completed, total: modulesToAnalyze.length });
                 }
             });
             await pool.processQueue(queue);
@@ -193,17 +206,86 @@ export class JSASTAnalyzer extends Plugin {
                     edgesCreated += task.result.edges;
                 }
             }
-            console.log(`[JSASTAnalyzer] Analyzed ${modulesToAnalyze.length} modules, created ${nodesCreated} nodes`);
-            console.log(`[JSASTAnalyzer] Stats:`, stats);
+            logger.info('Analysis complete', { modulesAnalyzed: modulesToAnalyze.length, nodesCreated });
+            logger.debug('Worker stats', { ...stats });
             this.profiler.printSummary();
             return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { modulesAnalyzed: modulesToAnalyze.length, workerStats: stats });
         }
         catch (error) {
-            console.error(`[JSASTAnalyzer] Error:`, error);
+            logger.error('Analysis failed', { error: error instanceof Error ? error.message : String(error) });
             const err = error instanceof Error ? error : new Error(String(error));
             return createErrorResult(err);
         }
     }
+    /**
+     * Execute parallel analysis using ASTWorkerPool (worker_threads).
+     *
+     * This method uses actual OS threads for true parallel CPU-intensive parsing.
+     * Workers generate semantic IDs using ScopeTracker, matching sequential behavior.
+     *
+     * @param modules - Modules to analyze
+     * @param graph - Graph backend for writing results
+     * @param projectPath - Project root path
+     * @param context - Analysis context with options
+     * @returns Plugin result with node/edge counts
+     */
+    async executeParallel(modules, graph, projectPath, context) {
+        const logger = this.log(context);
+        const workerCount = context.workerCount || 4;
+        const pool = new ASTWorkerPool(workerCount);
+        logger.debug('Starting parallel parsing', { workerCount });
+        try {
+            await pool.init();
+            // Convert ModuleNode to ASTModuleInfo format
+            const moduleInfos = modules.map(m => ({
+                id: m.id,
+                file: m.file,
+                name: m.name
+            }));
+            // Parse all modules in parallel using worker threads
+            const results = await pool.parseModules(moduleInfos);
+            let nodesCreated = 0;
+            let edgesCreated = 0;
+            let errors = 0;
+            // Process results - collections already have semantic IDs from workers
+            for (const result of results) {
+                if (result.error) {
+                    logger.warn('Parse error', { file: result.module.file, error: result.error.message });
+                    errors++;
+                    continue;
+                }
+                if (result.collections) {
+                    // Find original module for metadata
+                    const module = modules.find(m => m.id === result.module.id);
+                    if (!module)
+                        continue;
+                    // Pass collections directly to GraphBuilder - IDs already semantic
+                    // Cast is safe because ASTWorker.ASTCollections is structurally compatible
+                    // with ast/types.ASTCollections (METHOD extends FUNCTION semantically)
+                    const buildResult = await this.graphBuilder.build(module, graph, projectPath, result.collections);
+                    if (typeof buildResult === 'object' && buildResult !== null) {
+                        nodesCreated += buildResult.nodes || 0;
+                        edgesCreated += buildResult.edges || 0;
+                    }
+                }
+                // Report progress
+                if (context.onProgress) {
+                    context.onProgress({
+                        phase: 'analysis',
+                        currentPlugin: 'JSASTAnalyzer',
+                        message: `Processed ${result.module.file.replace(projectPath, '')}`,
+                        totalFiles: modules.length,
+                        processedFiles: results.indexOf(result) + 1
+                    });
+                }
+            }
+            logger.info('Parallel parsing complete', { nodesCreated, edgesCreated, errors });
+            return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { modulesAnalyzed: modules.length - errors, parallelParsing: true });
+        }
+        finally {
+            await pool.terminate();
+        }
+    }
     /**
      * Extract variable names from destructuring patterns
      * Uses t.isX() type guards to avoid casts
@@ -278,14 +360,30 @@ export class JSASTAnalyzer extends Plugin {
     /**
      * Отслеживает присваивание переменной для data flow анализа
      */
-    trackVariableAssignment(initNode, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef) {
+    trackVariableAssignment(initNode, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef) {
         if (!initNode)
             return;
         // initNode is already typed as t.Expression
         const initExpression = initNode;
         // 0. AwaitExpression
         if (initExpression.type === 'AwaitExpression') {
-            return this.trackVariableAssignment(initExpression.argument, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
+            return this.trackVariableAssignment(initExpression.argument, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
+        }
+        // 0.5. ObjectExpression (REG-328) - must be before literal check
+        if (initExpression.type === 'ObjectExpression') {
+            const column = initExpression.loc?.start.column ?? 0;
+            const objectNode = ObjectLiteralNode.create(module.file, line, column, { counter: objectLiteralCounterRef.value++ });
+            // Add to objectLiterals collection for GraphBuilder to create the node
+            objectLiterals.push(objectNode);
+            // Extract properties from the object literal
+            this.extractObjectProperties(initExpression, objectNode.id, module, objectProperties, objectLiterals, objectLiteralCounterRef, literals, literalCounterRef);
+            // Create ASSIGNED_FROM edge: VARIABLE -> OBJECT_LITERAL
+            variableAssignments.push({
+                variableId,
+                sourceId: objectNode.id,
+                sourceType: 'OBJECT_LITERAL'
+            });
+            return;
         }
         // 1. Literal
         const literalValue = ExpressionEvaluator.extractLiteralValue(initExpression);
@@ -313,8 +411,8 @@ export class JSASTAnalyzer extends Plugin {
                 sourceId: null,
                 sourceType: 'CALL_SITE',
                 callName: initExpression.callee.name,
-                callLine: initExpression.loc.start.line,
-                callColumn: initExpression.loc.start.column
+                callLine: getLine(initExpression),
+                callColumn: getColumn(initExpression)
             });
             return;
         }
@@ -324,7 +422,7 @@ export class JSASTAnalyzer extends Plugin {
             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}#${initExpression.loc.start.line}:${initExpression.loc.start.column}:inline`;
+            const methodCallId = `CALL#${fullName}#${module.file}#${getLine(initExpression)}:${getColumn(initExpression)}:inline`;
             const existing = variableAssignments.find(a => a.sourceId === methodCallId);
             if (!existing) {
                 const extractedArgs = [];
@@ -332,15 +430,15 @@ export class JSASTAnalyzer extends Plugin {
                     if (arg.type !== 'SpreadElement') {
                         const argLiteralValue = ExpressionEvaluator.extractLiteralValue(arg);
                         if (argLiteralValue !== null) {
-                            const literalId = `LITERAL#arg${index}#${module.file}#${initExpression.loc.start.line}:${initExpression.loc.start.column}:${literalCounterRef.value++}`;
+                            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 || initExpression.loc.start.line,
-                                column: arg.loc?.start.column || initExpression.loc.start.column,
+                                line: arg.loc?.start.line || getLine(initExpression),
+                                column: arg.loc?.start.column || getColumn(initExpression),
                                 parentCallId: methodCallId,
                                 argIndex: index
                             });
@@ -359,8 +457,8 @@ export class JSASTAnalyzer extends Plugin {
                     method: methodName,
                     file: module.file,
                     arguments: extractedArgs,
-                    line: initExpression.loc.start.line,
-                    column: initExpression.loc.start.column
+                    line: getLine(initExpression),
+                    column: getColumn(initExpression)
                 });
             }
             variableAssignments.push({
@@ -380,17 +478,31 @@ export class JSASTAnalyzer extends Plugin {
             });
             return;
         }
-        // 5. NewExpression
+        // 5. NewExpression -> CONSTRUCTOR_CALL
         if (initExpression.type === 'NewExpression') {
             const callee = initExpression.callee;
+            let className;
             if (callee.type === 'Identifier') {
-                variableAssignments.push({
-                    variableId,
-                    sourceType: 'CLASS',
-                    className: callee.name,
-                    line: line
-                });
+                className = callee.name;
+            }
+            else if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier') {
+                // Handle: new module.ClassName()
+                className = callee.property.name;
             }
+            else {
+                // Unknown callee type, skip
+                return;
+            }
+            const callLine = initExpression.loc?.start.line ?? line;
+            const callColumn = initExpression.loc?.start.column ?? 0;
+            variableAssignments.push({
+                variableId,
+                sourceType: 'CONSTRUCTOR_CALL',
+                className,
+                file: module.file,
+                line: callLine,
+                column: callColumn
+            });
             return;
         }
         // 6. ArrowFunctionExpression or FunctionExpression
@@ -414,7 +526,8 @@ export class JSASTAnalyzer extends Plugin {
             const computedPropertyVar = initExpression.computed && initExpression.property.type === 'Identifier'
                 ? initExpression.property.name
                 : null;
-            const expressionId = `EXPRESSION#${objectName}.${propertyName}#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('MemberExpression', module.file, line, column);
             variableAssignments.push({
                 variableId,
                 sourceType: 'EXPRESSION',
@@ -426,13 +539,15 @@ export class JSASTAnalyzer extends Plugin {
                 computedPropertyVar,
                 objectSourceName: initExpression.object.type === 'Identifier' ? initExpression.object.name : null,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
             return;
         }
         // 8. BinaryExpression
         if (initExpression.type === 'BinaryExpression') {
-            const expressionId = `EXPRESSION#binary#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('BinaryExpression', module.file, line, column);
             variableAssignments.push({
                 variableId,
                 sourceType: 'EXPRESSION',
@@ -442,13 +557,15 @@ export class JSASTAnalyzer extends Plugin {
                 leftSourceName: initExpression.left.type === 'Identifier' ? initExpression.left.name : null,
                 rightSourceName: initExpression.right.type === 'Identifier' ? initExpression.right.name : null,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
             return;
         }
         // 9. ConditionalExpression
         if (initExpression.type === 'ConditionalExpression') {
-            const expressionId = `EXPRESSION#conditional#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('ConditionalExpression', module.file, line, column);
             variableAssignments.push({
                 variableId,
                 sourceType: 'EXPRESSION',
@@ -457,15 +574,17 @@ export class JSASTAnalyzer extends Plugin {
                 consequentSourceName: initExpression.consequent.type === 'Identifier' ? initExpression.consequent.name : null,
                 alternateSourceName: initExpression.alternate.type === 'Identifier' ? initExpression.alternate.name : null,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
-            this.trackVariableAssignment(initExpression.consequent, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
-            this.trackVariableAssignment(initExpression.alternate, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
+            this.trackVariableAssignment(initExpression.consequent, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
+            this.trackVariableAssignment(initExpression.alternate, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
             return;
         }
         // 10. LogicalExpression
         if (initExpression.type === 'LogicalExpression') {
-            const expressionId = `EXPRESSION#logical#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('LogicalExpression', module.file, line, column);
             variableAssignments.push({
                 variableId,
                 sourceType: 'EXPRESSION',
@@ -475,15 +594,17 @@ export class JSASTAnalyzer extends Plugin {
                 leftSourceName: initExpression.left.type === 'Identifier' ? initExpression.left.name : null,
                 rightSourceName: initExpression.right.type === 'Identifier' ? initExpression.right.name : null,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
-            this.trackVariableAssignment(initExpression.left, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
-            this.trackVariableAssignment(initExpression.right, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
+            this.trackVariableAssignment(initExpression.left, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
+            this.trackVariableAssignment(initExpression.right, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
             return;
         }
         // 11. TemplateLiteral
         if (initExpression.type === 'TemplateLiteral' && initExpression.expressions.length > 0) {
-            const expressionId = `EXPRESSION#template#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('TemplateLiteral', module.file, line, column);
             const expressionSourceNames = initExpression.expressions
                 .filter((expr) => expr.type === 'Identifier')
                 .map(expr => expr.name);
@@ -494,16 +615,365 @@ export class JSASTAnalyzer extends Plugin {
                 expressionType: 'TemplateLiteral',
                 expressionSourceNames,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
             for (const expr of initExpression.expressions) {
                 // Filter out TSType nodes (only in TypeScript code)
                 if (t.isExpression(expr)) {
-                    this.trackVariableAssignment(expr, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
+                    this.trackVariableAssignment(expr, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
+                }
+            }
+            return;
+        }
+    }
+    /**
+     * Extract object properties and create ObjectPropertyInfo records.
+     * Handles nested object/array literals recursively. (REG-328)
+     */
+    extractObjectProperties(objectExpr, objectId, module, objectProperties, objectLiterals, objectLiteralCounterRef, literals, literalCounterRef) {
+        for (const prop of objectExpr.properties) {
+            const propLine = prop.loc?.start.line || 0;
+            const propColumn = prop.loc?.start.column || 0;
+            // Handle spread properties: { ...other }
+            if (prop.type === 'SpreadElement') {
+                const spreadArg = prop.argument;
+                const propertyInfo = {
+                    objectId,
+                    propertyName: '<spread>',
+                    valueType: 'SPREAD',
+                    file: module.file,
+                    line: propLine,
+                    column: propColumn
+                };
+                if (spreadArg.type === 'Identifier') {
+                    propertyInfo.valueName = spreadArg.name;
+                    propertyInfo.valueType = 'VARIABLE';
+                }
+                objectProperties.push(propertyInfo);
+                continue;
+            }
+            // Handle regular properties
+            if (prop.type === 'ObjectProperty') {
+                let propertyName;
+                // Get property name
+                if (prop.key.type === 'Identifier') {
+                    propertyName = prop.key.name;
+                }
+                else if (prop.key.type === 'StringLiteral') {
+                    propertyName = prop.key.value;
                 }
+                else if (prop.key.type === 'NumericLiteral') {
+                    propertyName = String(prop.key.value);
+                }
+                else {
+                    propertyName = '<computed>';
+                }
+                const propertyInfo = {
+                    objectId,
+                    propertyName,
+                    file: module.file,
+                    line: propLine,
+                    column: propColumn,
+                    valueType: 'EXPRESSION'
+                };
+                const value = prop.value;
+                // Nested object literal - check BEFORE extractLiteralValue
+                if (value.type === 'ObjectExpression') {
+                    const nestedObjectNode = ObjectLiteralNode.create(module.file, value.loc?.start.line || 0, value.loc?.start.column || 0, { counter: objectLiteralCounterRef.value++ });
+                    objectLiterals.push(nestedObjectNode);
+                    const nestedObjectId = nestedObjectNode.id;
+                    // Recursively extract nested properties
+                    this.extractObjectProperties(value, nestedObjectId, module, objectProperties, objectLiterals, objectLiteralCounterRef, literals, literalCounterRef);
+                    propertyInfo.valueType = 'OBJECT_LITERAL';
+                    propertyInfo.nestedObjectId = nestedObjectId;
+                    propertyInfo.valueNodeId = nestedObjectId;
+                }
+                // Literal value (primitives only - objects/arrays handled above)
+                else {
+                    const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+                    // Handle both non-null literals AND explicit null literals (NullLiteral)
+                    if (literalValue !== null || value.type === 'NullLiteral') {
+                        const literalId = `LITERAL#${propertyName}#${module.file}#${propLine}:${propColumn}:${literalCounterRef.value++}`;
+                        literals.push({
+                            id: literalId,
+                            type: 'LITERAL',
+                            value: literalValue,
+                            valueType: typeof literalValue,
+                            file: module.file,
+                            line: propLine,
+                            column: propColumn,
+                            parentCallId: objectId,
+                            argIndex: 0
+                        });
+                        propertyInfo.valueType = 'LITERAL';
+                        propertyInfo.valueNodeId = literalId;
+                        propertyInfo.literalValue = literalValue;
+                    }
+                    // Variable reference
+                    else if (value.type === 'Identifier') {
+                        propertyInfo.valueType = 'VARIABLE';
+                        propertyInfo.valueName = value.name;
+                    }
+                    // Call expression
+                    else if (value.type === 'CallExpression') {
+                        propertyInfo.valueType = 'CALL';
+                        propertyInfo.callLine = value.loc?.start.line;
+                        propertyInfo.callColumn = value.loc?.start.column;
+                    }
+                    // Other expressions
+                    else {
+                        propertyInfo.valueType = 'EXPRESSION';
+                    }
+                }
+                objectProperties.push(propertyInfo);
+            }
+            // Handle object methods: { foo() {} }
+            else if (prop.type === 'ObjectMethod') {
+                const propertyName = prop.key.type === 'Identifier' ? prop.key.name : '<computed>';
+                objectProperties.push({
+                    objectId,
+                    propertyName,
+                    valueType: 'EXPRESSION',
+                    file: module.file,
+                    line: propLine,
+                    column: propColumn
+                });
             }
+        }
+    }
+    /**
+     * Recursively unwrap AwaitExpression to get the underlying expression.
+     * await await fetch() -> fetch()
+     */
+    unwrapAwaitExpression(node) {
+        if (node.type === 'AwaitExpression' && node.argument) {
+            return this.unwrapAwaitExpression(node.argument);
+        }
+        return node;
+    }
+    /**
+     * Extract call site information from CallExpression.
+     * Returns null if not a valid CallExpression.
+     */
+    extractCallInfo(node) {
+        if (node.type !== 'CallExpression') {
+            return null;
+        }
+        const callee = node.callee;
+        let name;
+        let isMethodCall = false;
+        // Direct call: fetchUser()
+        if (t.isIdentifier(callee)) {
+            name = callee.name;
+        }
+        // Method call: obj.fetchUser() or arr.map()
+        else if (t.isMemberExpression(callee)) {
+            isMethodCall = true;
+            const objectName = t.isIdentifier(callee.object)
+                ? callee.object.name
+                : (t.isThisExpression(callee.object) ? 'this' : 'unknown');
+            const methodName = t.isIdentifier(callee.property)
+                ? callee.property.name
+                : 'unknown';
+            name = `${objectName}.${methodName}`;
+        }
+        else {
+            return null;
+        }
+        return {
+            line: node.loc?.start.line ?? 0,
+            column: node.loc?.start.column ?? 0,
+            name,
+            isMethodCall
+        };
+    }
+    /**
+     * Check if expression is CallExpression or AwaitExpression wrapping a call.
+     */
+    isCallOrAwaitExpression(node) {
+        const unwrapped = this.unwrapAwaitExpression(node);
+        return unwrapped.type === 'CallExpression';
+    }
+    /**
+     * Tracks destructuring assignments for data flow analysis.
+     *
+     * For ObjectPattern: creates EXPRESSION nodes representing source.property
+     * For ArrayPattern: creates EXPRESSION nodes representing source[index]
+     *
+     * Supports:
+     * - Phase 1 (REG-201): Identifier init expressions (const { x } = obj)
+     * - Phase 2 (REG-223): CallExpression/AwaitExpression init (const { x } = getConfig())
+     *
+     * @param pattern - The destructuring pattern (ObjectPattern or ArrayPattern)
+     * @param initNode - The init expression (right-hand side)
+     * @param variables - Extracted variables with propertyPath/arrayIndex metadata and IDs
+     * @param module - Module context
+     * @param variableAssignments - Collection to push assignment info to
+     */
+    trackDestructuringAssignment(pattern, initNode, variables, module, variableAssignments) {
+        if (!initNode)
             return;
+        // Phase 1: Simple Identifier init expressions (REG-201)
+        // Examples: const { x } = obj, const [a] = arr
+        if (t.isIdentifier(initNode)) {
+            const sourceBaseName = initNode.name;
+            // Process each extracted variable
+            for (const varInfo of variables) {
+                const variableId = varInfo.id;
+                // Handle rest elements specially - create edge to whole source
+                if (varInfo.isRest) {
+                    variableAssignments.push({
+                        variableId,
+                        sourceType: 'VARIABLE',
+                        sourceName: sourceBaseName,
+                        line: varInfo.loc.start.line
+                    });
+                    continue;
+                }
+                // ObjectPattern: const { headers } = req → headers ASSIGNED_FROM req.headers
+                if (t.isObjectPattern(pattern) && varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                    const propertyPath = varInfo.propertyPath;
+                    const expressionLine = varInfo.loc.start.line;
+                    const expressionColumn = varInfo.loc.start.column;
+                    // Build property path string (e.g., "req.headers.contentType" for nested)
+                    const fullPath = [sourceBaseName, ...propertyPath].join('.');
+                    const expressionId = ExpressionNode.generateId('MemberExpression', module.file, expressionLine, expressionColumn);
+                    variableAssignments.push({
+                        variableId,
+                        sourceType: 'EXPRESSION',
+                        sourceId: expressionId,
+                        expressionType: 'MemberExpression',
+                        object: sourceBaseName,
+                        property: propertyPath[propertyPath.length - 1], // Last property for simple display
+                        computed: false,
+                        path: fullPath,
+                        objectSourceName: sourceBaseName, // Use objectSourceName for DERIVES_FROM edge creation
+                        propertyPath: propertyPath,
+                        file: module.file,
+                        line: expressionLine,
+                        column: expressionColumn
+                    });
+                }
+                // ArrayPattern: const [first, second] = arr → first ASSIGNED_FROM arr[0]
+                else if (t.isArrayPattern(pattern) && varInfo.arrayIndex !== undefined) {
+                    const arrayIndex = varInfo.arrayIndex;
+                    const expressionLine = varInfo.loc.start.line;
+                    const expressionColumn = varInfo.loc.start.column;
+                    // Check if we also have propertyPath (mixed destructuring: { items: [first] } = data)
+                    const hasPropertyPath = varInfo.propertyPath && varInfo.propertyPath.length > 0;
+                    const expressionId = ExpressionNode.generateId('MemberExpression', module.file, expressionLine, expressionColumn);
+                    variableAssignments.push({
+                        variableId,
+                        sourceType: 'EXPRESSION',
+                        sourceId: expressionId,
+                        expressionType: 'MemberExpression',
+                        object: sourceBaseName,
+                        property: String(arrayIndex),
+                        computed: true,
+                        objectSourceName: sourceBaseName, // Use objectSourceName for DERIVES_FROM edge creation
+                        arrayIndex: arrayIndex,
+                        propertyPath: hasPropertyPath ? varInfo.propertyPath : undefined,
+                        file: module.file,
+                        line: expressionLine,
+                        column: expressionColumn
+                    });
+                }
+            }
+        }
+        // Phase 2: CallExpression or AwaitExpression (REG-223)
+        else if (this.isCallOrAwaitExpression(initNode)) {
+            const unwrapped = this.unwrapAwaitExpression(initNode);
+            const callInfo = this.extractCallInfo(unwrapped);
+            if (!callInfo) {
+                // Unsupported call pattern (computed callee, etc.)
+                return;
+            }
+            const callRepresentation = `${callInfo.name}()`;
+            // Process each extracted variable
+            for (const varInfo of variables) {
+                const variableId = varInfo.id;
+                // Handle rest elements - create direct CALL_SITE assignment
+                if (varInfo.isRest) {
+                    variableAssignments.push({
+                        variableId,
+                        sourceType: 'CALL_SITE',
+                        callName: callInfo.name,
+                        callLine: callInfo.line,
+                        callColumn: callInfo.column,
+                        callSourceLine: callInfo.line,
+                        callSourceColumn: callInfo.column,
+                        callSourceFile: module.file,
+                        callSourceName: callInfo.name,
+                        line: varInfo.loc.start.line
+                    });
+                    continue;
+                }
+                // ObjectPattern: const { data } = fetchUser() → data ASSIGNED_FROM fetchUser().data
+                if (t.isObjectPattern(pattern) && varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                    const propertyPath = varInfo.propertyPath;
+                    const expressionLine = varInfo.loc.start.line;
+                    const expressionColumn = varInfo.loc.start.column;
+                    // Build property path string: "fetchUser().data" or "fetchUser().user.name"
+                    const fullPath = [callRepresentation, ...propertyPath].join('.');
+                    const expressionId = ExpressionNode.generateId('MemberExpression', module.file, expressionLine, expressionColumn);
+                    variableAssignments.push({
+                        variableId,
+                        sourceType: 'EXPRESSION',
+                        sourceId: expressionId,
+                        expressionType: 'MemberExpression',
+                        object: callRepresentation, // "fetchUser()" - display name
+                        property: propertyPath[propertyPath.length - 1],
+                        computed: false,
+                        path: fullPath, // "fetchUser().data"
+                        propertyPath: propertyPath, // ["data"]
+                        // Call source for DERIVES_FROM lookup (REG-223)
+                        callSourceLine: callInfo.line,
+                        callSourceColumn: callInfo.column,
+                        callSourceFile: module.file,
+                        callSourceName: callInfo.name,
+                        sourceMetadata: {
+                            sourceType: callInfo.isMethodCall ? 'method-call' : 'call'
+                        },
+                        file: module.file,
+                        line: expressionLine,
+                        column: expressionColumn
+                    });
+                }
+                // ArrayPattern: const [first] = arr.map(fn) → first ASSIGNED_FROM arr.map(fn)[0]
+                else if (t.isArrayPattern(pattern) && varInfo.arrayIndex !== undefined) {
+                    const arrayIndex = varInfo.arrayIndex;
+                    const expressionLine = varInfo.loc.start.line;
+                    const expressionColumn = varInfo.loc.start.column;
+                    const hasPropertyPath = varInfo.propertyPath && varInfo.propertyPath.length > 0;
+                    const expressionId = ExpressionNode.generateId('MemberExpression', module.file, expressionLine, expressionColumn);
+                    variableAssignments.push({
+                        variableId,
+                        sourceType: 'EXPRESSION',
+                        sourceId: expressionId,
+                        expressionType: 'MemberExpression',
+                        object: callRepresentation,
+                        property: String(arrayIndex),
+                        computed: true,
+                        arrayIndex: arrayIndex,
+                        propertyPath: hasPropertyPath ? varInfo.propertyPath : undefined,
+                        // Call source for DERIVES_FROM lookup (REG-223)
+                        callSourceLine: callInfo.line,
+                        callSourceColumn: callInfo.column,
+                        callSourceFile: module.file,
+                        callSourceName: callInfo.name,
+                        sourceMetadata: {
+                            sourceType: callInfo.isMethodCall ? 'method-call' : 'call'
+                        },
+                        file: module.file,
+                        line: expressionLine,
+                        column: expressionColumn
+                    });
+                }
+            }
         }
+        // Unsupported init type (MemberExpression without call, etc.)
+        // else: do nothing - skip silently
     }
     /**
      * Получить все MODULE ноды из графа
@@ -531,14 +1001,23 @@ export class JSASTAnalyzer extends Plugin {
                 plugins: ['jsx', 'typescript']
             });
             this.profiler.end('babel_parse');
+            // Create ScopeTracker for semantic ID generation
+            // Use basename for shorter, more readable semantic IDs
+            const scopeTracker = new ScopeTracker(basename(module.file));
             const functions = [];
             const parameters = [];
             const scopes = [];
+            // Branching (switch statements)
+            const branches = [];
+            const cases = [];
+            // Control flow (loops)
+            const loops = [];
             const variableDeclarations = [];
             const callSites = [];
             const methodCalls = [];
             const eventListeners = [];
             const classInstantiations = [];
+            const constructorCalls = [];
             const classDeclarations = [];
             const methodCallbacks = [];
             const callArguments = [];
@@ -552,6 +1031,25 @@ export class JSASTAnalyzer extends Plugin {
             const typeAliases = [];
             const enums = [];
             const decorators = [];
+            // Object/Array literal tracking for data flow
+            const objectLiterals = [];
+            const objectProperties = [];
+            const arrayLiterals = [];
+            const arrayElements = [];
+            // Array mutation tracking for FLOWS_INTO edges
+            const arrayMutations = [];
+            // Object mutation tracking for FLOWS_INTO edges
+            const objectMutations = [];
+            // Variable reassignment tracking for FLOWS_INTO edges (REG-290)
+            const variableReassignments = [];
+            // Return statement tracking for RETURNS edges
+            const returnStatements = [];
+            // Update expression tracking for MODIFIES edges (REG-288, REG-312)
+            const updateExpressions = [];
+            // Promise resolution tracking for RESOLVES_TO edges (REG-334)
+            const promiseResolutions = [];
+            // Promise executor contexts (REG-334) - keyed by executor function's start:end position
+            const promiseExecutorContexts = new Map();
             const ifScopeCounterRef = { value: 0 };
             const scopeCounterRef = { value: 0 };
             const varDeclCounterRef = { value: 0 };
@@ -560,6 +1058,10 @@ export class JSASTAnalyzer extends Plugin {
             const httpRequestCounterRef = { value: 0 };
             const literalCounterRef = { value: 0 };
             const anonymousFunctionCounterRef = { value: 0 };
+            const objectLiteralCounterRef = { value: 0 };
+            const arrayLiteralCounterRef = { value: 0 };
+            const branchCounterRef = { value: 0 };
+            const caseCounterRef = { value: 0 };
             const processedNodes = {
                 functions: new Set(),
                 classes: new Set(),
@@ -579,34 +1081,56 @@ export class JSASTAnalyzer extends Plugin {
             this.profiler.end('traverse_imports');
             // Variables
             this.profiler.start('traverse_variables');
-            const variableVisitor = new VariableVisitor(module, { variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef }, this.extractVariableNamesFromPattern.bind(this), this.trackVariableAssignment.bind(this));
+            const variableVisitor = new VariableVisitor(module, { variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopes, scopeCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef }, this.extractVariableNamesFromPattern.bind(this), this.trackVariableAssignment.bind(this), scopeTracker // Pass ScopeTracker for semantic ID generation
+            );
             traverse(ast, variableVisitor.getHandlers());
             this.profiler.end('traverse_variables');
-            // Module-level scope context for consistent anonymous naming
-            const moduleScopeCtx = {
-                semanticPath: module.name,
-                siblingCounters: new Map()
-            };
             const allCollections = {
-                functions, parameters, scopes, variableDeclarations, callSites, methodCalls,
-                eventListeners, methodCallbacks, callArguments, classInstantiations, classDeclarations,
+                functions, parameters, scopes,
+                // Branching (switch statements)
+                branches, cases,
+                // Control flow (loops)
+                loops,
+                variableDeclarations, callSites, methodCalls,
+                eventListeners, methodCallbacks, callArguments, classInstantiations, constructorCalls, classDeclarations,
                 httpRequests, literals, variableAssignments,
                 // TypeScript-specific collections
                 interfaces, typeAliases, enums, decorators,
+                // Object/Array literal tracking
+                objectLiterals, objectProperties, arrayLiterals, arrayElements,
+                // Array mutation tracking
+                arrayMutations,
+                // Object mutation tracking
+                objectMutations,
+                // Variable reassignment tracking (REG-290)
+                variableReassignments,
+                // Return statement tracking
+                returnStatements,
+                // Update expression tracking (REG-288, REG-312)
+                updateExpressions,
+                // Promise resolution tracking (REG-334)
+                promiseResolutions,
+                promiseExecutorContexts,
+                objectLiteralCounterRef, arrayLiteralCounterRef,
                 ifScopeCounterRef, scopeCounterRef, varDeclCounterRef,
                 callSiteCounterRef, functionCounterRef, httpRequestCounterRef,
-                literalCounterRef, anonymousFunctionCounterRef, processedNodes,
-                imports, exports, moduleScopeCtx, code,
+                literalCounterRef, anonymousFunctionCounterRef,
+                branchCounterRef, caseCounterRef,
+                processedNodes,
+                imports, exports, code,
                 // VisitorCollections compatibility
                 classes: classDeclarations,
                 methods: [],
                 variables: variableDeclarations,
                 sideEffects: [],
-                variableCounterRef: varDeclCounterRef
+                variableCounterRef: varDeclCounterRef,
+                // ScopeTracker for semantic ID generation
+                scopeTracker
             };
             // Functions
             this.profiler.start('traverse_functions');
-            const functionVisitor = new FunctionVisitor(module, allCollections, this.analyzeFunctionBody.bind(this));
+            const functionVisitor = new FunctionVisitor(module, allCollections, this.analyzeFunctionBody.bind(this), scopeTracker // Pass ScopeTracker for semantic ID generation
+            );
             traverse(ast, functionVisitor.getHandlers());
             this.profiler.end('traverse_functions');
             // AssignmentExpression (module-level function assignments)
@@ -631,20 +1155,20 @@ export class JSASTAnalyzer extends Plugin {
                             functionName = assignNode.left.name;
                         }
                         const funcNode = assignNode.right;
-                        const functionId = `FUNCTION#${functionName}#${module.file}#${assignNode.loc.start.line}:${assignNode.loc.start.column}`;
+                        // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+                        const functionId = computeSemanticId('FUNCTION', functionName, scopeTracker.getContext());
                         functions.push({
                             id: functionId,
-                            stableId: functionId,
                             type: 'FUNCTION',
                             name: functionName,
                             file: module.file,
-                            line: assignNode.loc.start.line,
-                            column: assignNode.loc.start.column,
+                            line: getLine(assignNode),
+                            column: getColumn(assignNode),
                             async: funcNode.async || false,
                             generator: funcNode.type === 'FunctionExpression' ? funcNode.generator : false,
                             isAssignment: true
                         });
-                        const funcBodyScopeId = `SCOPE#${functionName}:body#${module.file}#${assignNode.loc.start.line}`;
+                        const funcBodyScopeId = `SCOPE#${functionName}:body#${module.file}#${getLine(assignNode)}`;
                         scopes.push({
                             id: funcBodyScopeId,
                             type: 'SCOPE',
@@ -653,28 +1177,56 @@ export class JSASTAnalyzer extends Plugin {
                             semanticId: `${functionName}:function_body[0]`,
                             conditional: false,
                             file: module.file,
-                            line: assignNode.loc.start.line,
+                            line: getLine(assignNode),
                             parentFunctionId: functionId
                         });
                         const funcPath = assignPath.get('right');
-                        // Create scope context for analyzing the function body
-                        const funcScopeCtx = {
-                            semanticPath: functionName,
-                            siblingCounters: new Map()
-                        };
-                        this.analyzeFunctionBody(funcPath, funcBodyScopeId, module, allCollections, funcScopeCtx);
+                        // Enter function scope for semantic ID generation and analyze
+                        scopeTracker.enterScope(functionName, 'function');
+                        this.analyzeFunctionBody(funcPath, funcBodyScopeId, module, allCollections);
+                        scopeTracker.exitScope();
+                    }
+                    // === VARIABLE REASSIGNMENT (REG-290) ===
+                    // Check if LHS is simple identifier (not obj.prop, not arr[i])
+                    // Must be checked at module level too
+                    if (assignNode.left.type === 'Identifier') {
+                        // Initialize collection if not exists
+                        if (!allCollections.variableReassignments) {
+                            allCollections.variableReassignments = [];
+                        }
+                        const variableReassignments = allCollections.variableReassignments;
+                        this.detectVariableReassignment(assignNode, module, variableReassignments, scopeTracker);
                     }
+                    // === END VARIABLE REASSIGNMENT ===
+                    // Check for indexed array assignment at module level: arr[i] = value
+                    this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker);
+                    // Check for object property assignment at module level: obj.prop = value
+                    this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
                 }
             });
             this.profiler.end('traverse_assignments');
+            // Module-level UpdateExpression (obj.count++, arr[i]++, i++) - REG-288/REG-312
+            this.profiler.start('traverse_updates');
+            traverse(ast, {
+                UpdateExpression: (updatePath) => {
+                    // Skip if inside a function - analyzeFunctionBody handles those
+                    const functionParent = updatePath.getFunctionParent();
+                    if (functionParent)
+                        return;
+                    // Module-level update expression: no parentScopeId
+                    this.collectUpdateExpression(updatePath.node, module, updateExpressions, undefined, scopeTracker);
+                }
+            });
+            this.profiler.end('traverse_updates');
             // Classes
             this.profiler.start('traverse_classes');
-            const classVisitor = new ClassVisitor(module, allCollections, this.analyzeFunctionBody.bind(this));
+            const classVisitor = new ClassVisitor(module, allCollections, this.analyzeFunctionBody.bind(this), scopeTracker // Pass ScopeTracker for semantic ID generation
+            );
             traverse(ast, classVisitor.getHandlers());
             this.profiler.end('traverse_classes');
             // TypeScript-specific constructs (interfaces, type aliases, enums)
             this.profiler.start('traverse_typescript');
-            const typescriptVisitor = new TypeScriptVisitor(module, allCollections);
+            const typescriptVisitor = new TypeScriptVisitor(module, allCollections, scopeTracker);
             traverse(ast, typescriptVisitor.getHandlers());
             this.profiler.end('traverse_typescript');
             // Module-level callbacks
@@ -686,22 +1238,22 @@ export class JSASTAnalyzer extends Plugin {
                     if (functionParent)
                         return;
                     if (funcPath.parent && funcPath.parent.type === 'CallExpression') {
-                        const funcName = funcNode.id ? funcNode.id.name : this.generateAnonymousName(moduleScopeCtx);
-                        const functionId = `FUNCTION#${funcName}#${module.file}#${funcNode.loc.start.line}:${funcNode.loc.start.column}`;
+                        const funcName = funcNode.id ? funcNode.id.name : this.generateAnonymousName(scopeTracker);
+                        // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+                        const functionId = computeSemanticId('FUNCTION', funcName, scopeTracker.getContext());
                         functions.push({
                             id: functionId,
-                            stableId: functionId,
                             type: 'FUNCTION',
                             name: funcName,
                             file: module.file,
-                            line: funcNode.loc.start.line,
-                            column: funcNode.loc.start.column,
+                            line: getLine(funcNode),
+                            column: getColumn(funcNode),
                             async: funcNode.async || false,
                             generator: funcNode.generator || false,
                             isCallback: true,
                             parentScopeId: module.id
                         });
-                        const callbackScopeId = `SCOPE#${funcName}:body#${module.file}#${funcNode.loc.start.line}`;
+                        const callbackScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(funcNode)}`;
                         scopes.push({
                             id: callbackScopeId,
                             type: 'SCOPE',
@@ -710,15 +1262,13 @@ export class JSASTAnalyzer extends Plugin {
                             semanticId: `${funcName}:callback_body[0]`,
                             conditional: false,
                             file: module.file,
-                            line: funcNode.loc.start.line,
+                            line: getLine(funcNode),
                             parentFunctionId: functionId
                         });
-                        // Create scope context for analyzing the callback body
-                        const callbackScopeCtx = {
-                            semanticPath: funcName,
-                            siblingCounters: new Map()
-                        };
-                        this.analyzeFunctionBody(funcPath, callbackScopeId, module, allCollections, callbackScopeCtx);
+                        // Enter callback scope for semantic ID generation and analyze
+                        scopeTracker.enterScope(funcName, 'callback');
+                        this.analyzeFunctionBody(funcPath, callbackScopeId, module, allCollections);
+                        scopeTracker.exitScope();
                         funcPath.skip();
                     }
                 }
@@ -726,9 +1276,75 @@ export class JSASTAnalyzer extends Plugin {
             this.profiler.end('traverse_callbacks');
             // Call expressions
             this.profiler.start('traverse_calls');
-            const callExpressionVisitor = new CallExpressionVisitor(module, allCollections);
+            const callExpressionVisitor = new CallExpressionVisitor(module, allCollections, scopeTracker);
             traverse(ast, callExpressionVisitor.getHandlers());
             this.profiler.end('traverse_calls');
+            // Module-level NewExpression (constructor calls)
+            // This handles top-level code like `const x = new Date()` that's not inside a function
+            this.profiler.start('traverse_new');
+            const processedConstructorCalls = new Set();
+            traverse(ast, {
+                NewExpression: (newPath) => {
+                    const newNode = newPath.node;
+                    const nodeKey = `constructor:new:${newNode.start}:${newNode.end}`;
+                    if (processedConstructorCalls.has(nodeKey)) {
+                        return;
+                    }
+                    processedConstructorCalls.add(nodeKey);
+                    // Determine className from callee
+                    let className = null;
+                    if (newNode.callee.type === 'Identifier') {
+                        className = newNode.callee.name;
+                    }
+                    else if (newNode.callee.type === 'MemberExpression' && newNode.callee.property.type === 'Identifier') {
+                        className = newNode.callee.property.name;
+                    }
+                    if (className) {
+                        const line = getLine(newNode);
+                        const column = getColumn(newNode);
+                        const constructorCallId = ConstructorCallNode.generateId(className, module.file, line, column);
+                        const isBuiltin = ConstructorCallNode.isBuiltinConstructor(className);
+                        constructorCalls.push({
+                            id: constructorCallId,
+                            type: 'CONSTRUCTOR_CALL',
+                            className,
+                            isBuiltin,
+                            file: module.file,
+                            line,
+                            column
+                        });
+                        // REG-334: If this is Promise constructor with executor callback,
+                        // register the context for resolve/reject detection
+                        if (className === 'Promise' && newNode.arguments.length > 0) {
+                            const executorArg = newNode.arguments[0];
+                            // Only handle inline function expressions (not variable references)
+                            if (t.isArrowFunctionExpression(executorArg) || t.isFunctionExpression(executorArg)) {
+                                // Extract resolve/reject parameter names
+                                let resolveName;
+                                let rejectName;
+                                if (executorArg.params.length > 0 && t.isIdentifier(executorArg.params[0])) {
+                                    resolveName = executorArg.params[0].name;
+                                }
+                                if (executorArg.params.length > 1 && t.isIdentifier(executorArg.params[1])) {
+                                    rejectName = executorArg.params[1].name;
+                                }
+                                if (resolveName) {
+                                    // Key by function node position to allow nested Promise detection
+                                    const funcKey = `${executorArg.start}:${executorArg.end}`;
+                                    promiseExecutorContexts.set(funcKey, {
+                                        constructorCallId,
+                                        resolveName,
+                                        rejectName,
+                                        file: module.file,
+                                        line
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            this.profiler.end('traverse_new');
             // Module-level IfStatements
             this.profiler.start('traverse_ifs');
             traverse(ast, {
@@ -739,37 +1355,37 @@ export class JSASTAnalyzer extends Plugin {
                     const ifNode = ifPath.node;
                     const condition = code.substring(ifNode.test.start, ifNode.test.end) || 'condition';
                     const counterId = ifScopeCounterRef.value++;
-                    const ifScopeId = `SCOPE#if#${module.file}#${ifNode.loc.start.line}:${ifNode.loc.start.column}:${counterId}`;
+                    const ifScopeId = `SCOPE#if#${module.file}#${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`;
                     const constraints = ConditionParser.parse(ifNode.test);
-                    const ifSemanticId = this.generateSemanticId('if_statement', moduleScopeCtx);
+                    const ifSemanticId = this.generateSemanticId('if_statement', scopeTracker);
                     scopes.push({
                         id: ifScopeId,
                         type: 'SCOPE',
                         scopeType: 'if_statement',
-                        name: `if:${ifNode.loc.start.line}:${ifNode.loc.start.column}:${counterId}`,
+                        name: `if:${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`,
                         semanticId: ifSemanticId,
                         conditional: true,
                         condition,
                         constraints: constraints.length > 0 ? constraints : undefined,
                         file: module.file,
-                        line: ifNode.loc.start.line,
+                        line: getLine(ifNode),
                         parentScopeId: module.id
                     });
                     if (ifNode.alternate && ifNode.alternate.type !== 'IfStatement') {
                         const elseCounterId = ifScopeCounterRef.value++;
-                        const elseScopeId = `SCOPE#else#${module.file}#${ifNode.alternate.loc.start.line}:${ifNode.alternate.loc.start.column}:${elseCounterId}`;
+                        const 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', moduleScopeCtx);
+                        const elseSemanticId = this.generateSemanticId('else_statement', scopeTracker);
                         scopes.push({
                             id: elseScopeId,
                             type: 'SCOPE',
                             scopeType: 'else_statement',
-                            name: `else:${ifNode.alternate.loc.start.line}:${ifNode.alternate.loc.start.column}:${elseCounterId}`,
+                            name: `else:${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`,
                             semanticId: elseSemanticId,
                             conditional: true,
                             constraints: negatedConstraints,
                             file: module.file,
-                            line: ifNode.alternate.loc.start.line,
+                            line: getLine(ifNode.alternate),
                             parentScopeId: module.id
                         });
                     }
@@ -781,14 +1397,25 @@ export class JSASTAnalyzer extends Plugin {
             const result = await this.graphBuilder.build(module, graph, projectPath, {
                 functions,
                 scopes,
+                // Branching (switch statements) - use allCollections refs as they're populated by analyzeFunctionBody
+                branches: allCollections.branches || branches,
+                cases: allCollections.cases || cases,
+                // Control flow (loops) - use allCollections refs as they're populated by analyzeFunctionBody
+                loops: allCollections.loops || loops,
+                // Control flow (try/catch/finally) - Phase 4
+                tryBlocks: allCollections.tryBlocks,
+                catchBlocks: allCollections.catchBlocks,
+                finallyBlocks: allCollections.finallyBlocks,
                 variableDeclarations,
                 callSites,
                 methodCalls,
                 eventListeners,
                 classInstantiations,
+                constructorCalls,
                 classDeclarations,
                 methodCallbacks,
-                callArguments,
+                // REG-334: Use allCollections.callArguments to include function-level resolve/reject arguments
+                callArguments: allCollections.callArguments || callArguments,
                 imports,
                 exports,
                 httpRequests,
@@ -799,308 +1426,1720 @@ export class JSASTAnalyzer extends Plugin {
                 interfaces,
                 typeAliases,
                 enums,
-                decorators
+                decorators,
+                // Array mutation tracking
+                arrayMutations,
+                // Object mutation tracking
+                objectMutations,
+                // Variable reassignment tracking (REG-290)
+                variableReassignments,
+                // Return statement tracking
+                returnStatements,
+                // Update expression tracking (REG-288, REG-312)
+                updateExpressions,
+                // Promise resolution tracking (REG-334)
+                promiseResolutions: allCollections.promiseResolutions || promiseResolutions,
+                // Object/Array literal tracking - use allCollections refs as visitors may have created new arrays
+                objectLiterals: allCollections.objectLiterals || objectLiterals,
+                objectProperties: allCollections.objectProperties || objectProperties,
+                arrayLiterals: allCollections.arrayLiterals || arrayLiterals
             });
             this.profiler.end('graph_build');
             nodesCreated = result.nodes;
             edgesCreated = result.edges;
         }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            console.error(`[JSASTAnalyzer] Error analyzing ${module.file}:`, err.message);
-            console.error(err.stack);
+        catch {
+            // Error analyzing module - silently skip, caller handles the result
         }
         return { nodes: nodesCreated, edges: edgesCreated };
     }
     /**
-     * Helper to generate semantic ID for a scope and update counters
-     */
-    generateSemanticId(scopeType, scopeCtx) {
-        if (!scopeCtx)
-            return undefined;
-        const siblingIndex = scopeCtx.siblingCounters.get(scopeType) || 0;
-        scopeCtx.siblingCounters.set(scopeType, siblingIndex + 1);
-        return `${scopeCtx.semanticPath}:${scopeType}[${siblingIndex}]`;
-    }
-    /**
-     * Helper to create child scope context from a semantic ID
+     * Helper to generate semantic ID for a scope using ScopeTracker.
+     * Format: "scopePath:scopeType[index]" e.g. "MyClass->myMethod:if_statement[0]"
      */
-    createChildScopeContext(semanticId) {
-        if (!semanticId)
+    generateSemanticId(scopeType, scopeTracker) {
+        if (!scopeTracker)
             return undefined;
-        return {
-            semanticPath: semanticId,
-            siblingCounters: new Map()
-        };
+        const scopePath = scopeTracker.getScopePath();
+        const siblingIndex = scopeTracker.getItemCounter(`semanticId:${scopeType}`);
+        return `${scopePath}:${scopeType}[${siblingIndex}]`;
     }
     /**
-     * Generate a unique anonymous function name within the current scope
-     * Uses scopeCtx.siblingCounters to ensure stability across JS/TS versions
+     * Generate a unique anonymous function name within the current scope.
+     * Uses ScopeTracker.getSiblingIndex() for stable naming.
      */
-    generateAnonymousName(scopeCtx) {
-        if (!scopeCtx)
+    generateAnonymousName(scopeTracker) {
+        if (!scopeTracker)
             return 'anonymous';
-        const index = scopeCtx.siblingCounters.get('anonymous') || 0;
-        scopeCtx.siblingCounters.set('anonymous', index + 1);
+        const index = scopeTracker.getSiblingIndex('anonymous');
         return `anonymous[${index}]`;
     }
     /**
-     * Анализирует тело функции и извлекает переменные, вызовы, условные блоки
+     * Factory method to create loop scope handlers.
+     * All loop statements (for, for-in, for-of, while, do-while) follow the same pattern:
+     * 1. Create scope with SCOPE#<scopeType>#file#line:counter
+     * 2. Generate semantic ID
+     * 3. Push to scopes array
+     * 4. Enter/exit scope tracker
+     *
+     * @param trackerScopeType - Scope type for ScopeTracker (e.g., 'for', 'for-in', 'while')
+     * @param scopeType - Scope type for the graph node (e.g., 'for-loop', 'for-in-loop')
+     * @param parentScopeId - Parent scope ID for the scope node
+     * @param module - Module context
+     * @param scopes - Collection to push scope nodes to
+     * @param scopeCounterRef - Counter for unique scope IDs
+     * @param scopeTracker - Tracker for semantic ID generation
      */
-    analyzeFunctionBody(funcPath, parentScopeId, module, collections, scopeCtx) {
-        // Extract with defaults for optional properties
-        const functions = (collections.functions ?? []);
-        const scopes = (collections.scopes ?? []);
-        const variableDeclarations = (collections.variableDeclarations ?? []);
-        const callSites = (collections.callSites ?? []);
-        const methodCalls = (collections.methodCalls ?? []);
-        const eventListeners = (collections.eventListeners ?? []);
-        const methodCallbacks = (collections.methodCallbacks ?? []);
-        const classInstantiations = (collections.classInstantiations ?? []);
-        const httpRequests = (collections.httpRequests ?? []);
-        const literals = (collections.literals ?? []);
-        const variableAssignments = (collections.variableAssignments ?? []);
-        const ifScopeCounterRef = (collections.ifScopeCounterRef ?? { value: 0 });
-        const scopeCounterRef = (collections.scopeCounterRef ?? { value: 0 });
-        const varDeclCounterRef = (collections.varDeclCounterRef ?? { value: 0 });
-        const callSiteCounterRef = (collections.callSiteCounterRef ?? { value: 0 });
-        const functionCounterRef = (collections.functionCounterRef ?? { value: 0 });
-        const httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 });
-        const literalCounterRef = (collections.literalCounterRef ?? { value: 0 });
-        const anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 });
-        const processedNodes = collections.processedNodes ?? {
-            functions: new Set(),
-            classes: new Set(),
-            imports: new Set(),
-            exports: new Set(),
-            variables: new Set(),
-            callSites: new Set(),
-            methodCalls: new Set(),
-            varDecls: new Set(),
-            eventListeners: new Set()
-        };
-        const parentScopeVariables = new Set();
-        const processedCallSites = processedNodes.callSites;
-        const processedVarDecls = processedNodes.varDecls;
-        const processedMethodCalls = processedNodes.methodCalls;
-        const processedEventListeners = processedNodes.eventListeners;
-        funcPath.traverse({
-            VariableDeclaration: (varPath) => {
-                const varNode = varPath.node;
-                const isConst = varNode.kind === 'const';
-                varNode.declarations.forEach(declarator => {
-                    const variables = this.extractVariableNamesFromPattern(declarator.id);
-                    variables.forEach(varInfo => {
-                        const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
-                        const isLiteral = literalValue !== null;
-                        const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
-                        const shouldBeConstant = isConst && (isLiteral || isNewExpression);
-                        const varId = shouldBeConstant
-                            ? `CONSTANT#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`
-                            : `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
-                        parentScopeVariables.add({
-                            name: varInfo.name,
-                            id: varId,
-                            scopeId: parentScopeId
+    /**
+     * Handles VariableDeclaration nodes within function bodies.
+     *
+     * Extracts variable names from patterns (including destructuring), determines
+     * if the variable should be CONSTANT or VARIABLE, generates semantic or legacy IDs,
+     * and tracks class instantiations and variable assignments.
+     *
+     * @param varPath - The NodePath for the VariableDeclaration
+     * @param parentScopeId - Parent scope ID for the variable
+     * @param module - Module context with file info
+     * @param variableDeclarations - Collection to push variable declarations to
+     * @param classInstantiations - Collection to push class instantiations to
+     * @param literals - Collection for literal tracking
+     * @param variableAssignments - Collection for variable assignment tracking
+     * @param varDeclCounterRef - Counter for unique variable declaration IDs
+     * @param literalCounterRef - Counter for unique literal IDs
+     * @param scopeTracker - Tracker for semantic ID generation
+     * @param parentScopeVariables - Set to track variables for closure analysis
+     * @param objectLiterals - Collection for object literal nodes (REG-328)
+     * @param objectProperties - Collection for object property edges (REG-328)
+     * @param objectLiteralCounterRef - Counter for unique object literal IDs (REG-328)
+     */
+    handleVariableDeclaration(varPath, parentScopeId, module, variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker, parentScopeVariables, objectLiterals, objectProperties, objectLiteralCounterRef) {
+        const varNode = varPath.node;
+        const isConst = varNode.kind === 'const';
+        // Check if this is a loop variable (for...of or for...in)
+        const parent = varPath.parent;
+        const isLoopVariable = (t.isForOfStatement(parent) || t.isForInStatement(parent)) && parent.left === varNode;
+        varNode.declarations.forEach(declarator => {
+            const variables = this.extractVariableNamesFromPattern(declarator.id);
+            const variablesWithIds = [];
+            variables.forEach(varInfo => {
+                const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
+                const isLiteral = literalValue !== null;
+                const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
+                // Loop variables with const should be CONSTANT (they can't be reassigned in loop body)
+                // Regular variables with const are CONSTANT only if initialized with literal or new expression
+                const shouldBeConstant = isConst && (isLoopVariable || isLiteral || isNewExpression);
+                const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+                // Generate semantic ID (primary) or legacy ID (fallback)
+                const legacyId = `${nodeType}#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+                const varId = scopeTracker
+                    ? computeSemanticId(nodeType, varInfo.name, scopeTracker.getContext())
+                    : legacyId;
+                // Collect variable info with ID for destructuring tracking
+                variablesWithIds.push({ ...varInfo, id: varId });
+                parentScopeVariables.add({
+                    name: varInfo.name,
+                    id: varId,
+                    scopeId: parentScopeId
+                });
+                if (shouldBeConstant) {
+                    const constantData = {
+                        id: varId,
+                        type: 'CONSTANT',
+                        name: varInfo.name,
+                        file: module.file,
+                        line: varInfo.loc.start.line,
+                        parentScopeId
+                    };
+                    if (isLiteral) {
+                        constantData.value = literalValue;
+                    }
+                    variableDeclarations.push(constantData);
+                    const init = declarator.init;
+                    if (isNewExpression && t.isNewExpression(init) && t.isIdentifier(init.callee)) {
+                        const className = init.callee.name;
+                        classInstantiations.push({
+                            variableId: varId,
+                            variableName: varInfo.name,
+                            className: className,
+                            line: varInfo.loc.start.line,
+                            parentScopeId
                         });
-                        if (shouldBeConstant) {
-                            const constantData = {
-                                id: varId,
-                                type: 'CONSTANT',
-                                name: varInfo.name,
-                                file: module.file,
-                                line: varInfo.loc.start.line,
-                                parentScopeId
-                            };
-                            if (isLiteral) {
-                                constantData.value = literalValue;
-                            }
-                            variableDeclarations.push(constantData);
-                            const init = declarator.init;
-                            if (isNewExpression && t.isNewExpression(init) && t.isIdentifier(init.callee)) {
-                                const className = init.callee.name;
-                                classInstantiations.push({
-                                    variableId: varId,
-                                    variableName: varInfo.name,
-                                    className: className,
-                                    line: varInfo.loc.start.line,
-                                    parentScopeId
-                                });
-                            }
-                        }
-                        else {
-                            variableDeclarations.push({
-                                id: varId,
-                                type: 'VARIABLE',
-                                name: varInfo.name,
+                    }
+                }
+                else {
+                    variableDeclarations.push({
+                        id: varId,
+                        type: 'VARIABLE',
+                        name: varInfo.name,
+                        file: module.file,
+                        line: varInfo.loc.start.line,
+                        parentScopeId
+                    });
+                }
+            });
+            // Track assignments after all variables are created
+            if (isLoopVariable) {
+                // For loop variables, track assignment from the source collection (right side of for...of/for...in)
+                const loopParent = parent;
+                const sourceExpression = loopParent.right;
+                if (t.isObjectPattern(declarator.id) || t.isArrayPattern(declarator.id)) {
+                    // Destructuring in loop: track each variable separately
+                    this.trackDestructuringAssignment(declarator.id, sourceExpression, variablesWithIds, module, variableAssignments);
+                }
+                else {
+                    // Simple loop variable: create DERIVES_FROM edges (not ASSIGNED_FROM)
+                    // Loop variables derive their values from the collection (semantic difference)
+                    variablesWithIds.forEach(varInfo => {
+                        if (t.isIdentifier(sourceExpression)) {
+                            variableAssignments.push({
+                                variableId: varInfo.id,
+                                sourceType: 'DERIVES_FROM_VARIABLE',
+                                sourceName: sourceExpression.name,
                                 file: module.file,
-                                line: varInfo.loc.start.line,
-                                parentScopeId
+                                line: varInfo.loc.start.line
                             });
                         }
-                        if (declarator.init) {
-                            this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
+                        else {
+                            // Fallback to regular tracking for non-identifier expressions
+                            this.trackVariableAssignment(sourceExpression, varInfo.id, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
                         }
                     });
+                }
+            }
+            else if (declarator.init) {
+                // Regular variable declaration with initializer
+                if (t.isObjectPattern(declarator.id) || t.isArrayPattern(declarator.id)) {
+                    // Destructuring: use specialized tracking
+                    this.trackDestructuringAssignment(declarator.id, declarator.init, variablesWithIds, module, variableAssignments);
+                }
+                else {
+                    // Simple assignment: use existing tracking
+                    const varInfo = variablesWithIds[0];
+                    this.trackVariableAssignment(declarator.init, varInfo.id, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
+                }
+            }
+        });
+    }
+    createLoopScopeHandler(trackerScopeType, scopeType, loopType, parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState) {
+        return {
+            enter: (path) => {
+                const node = path.node;
+                // Phase 6 (REG-267): Increment loop count for cyclomatic complexity
+                if (controlFlowState) {
+                    controlFlowState.loopCount++;
+                }
+                // 1. Create LOOP node
+                const loopCounter = loopCounterRef.value++;
+                const legacyLoopId = `${module.file}:LOOP:${loopType}:${getLine(node)}:${loopCounter}`;
+                const loopId = scopeTracker
+                    ? computeSemanticId('LOOP', loopType, scopeTracker.getContext(), { discriminator: loopCounter })
+                    : legacyLoopId;
+                // 2. Extract iteration target for for-in/for-of
+                let iteratesOverName;
+                let iteratesOverLine;
+                let iteratesOverColumn;
+                if (loopType === 'for-in' || loopType === 'for-of') {
+                    const loopNode = node;
+                    if (t.isIdentifier(loopNode.right)) {
+                        iteratesOverName = loopNode.right.name;
+                        iteratesOverLine = getLine(loopNode.right);
+                        iteratesOverColumn = getColumn(loopNode.right);
+                    }
+                    else if (t.isMemberExpression(loopNode.right)) {
+                        iteratesOverName = this.memberExpressionToString(loopNode.right);
+                        iteratesOverLine = getLine(loopNode.right);
+                        iteratesOverColumn = getColumn(loopNode.right);
+                    }
+                }
+                // 2b. Extract init/test/update for classic for loops and test for while/do-while (REG-282)
+                let initVariableName;
+                let initLine;
+                let testExpressionId;
+                let testExpressionType;
+                let testLine;
+                let testColumn;
+                let updateExpressionId;
+                let updateExpressionType;
+                let updateLine;
+                let updateColumn;
+                if (loopType === 'for') {
+                    const forNode = node;
+                    // Extract init: let i = 0
+                    if (forNode.init) {
+                        initLine = getLine(forNode.init);
+                        if (t.isVariableDeclaration(forNode.init)) {
+                            // Get name of first declared variable
+                            const firstDeclarator = forNode.init.declarations[0];
+                            if (t.isIdentifier(firstDeclarator.id)) {
+                                initVariableName = firstDeclarator.id.name;
+                            }
+                        }
+                    }
+                    // Extract test: i < 10
+                    if (forNode.test) {
+                        testLine = getLine(forNode.test);
+                        testColumn = getColumn(forNode.test);
+                        testExpressionType = forNode.test.type;
+                        testExpressionId = ExpressionNode.generateId(forNode.test.type, module.file, testLine, testColumn);
+                    }
+                    // Extract update: i++
+                    if (forNode.update) {
+                        updateLine = getLine(forNode.update);
+                        updateColumn = getColumn(forNode.update);
+                        updateExpressionType = forNode.update.type;
+                        updateExpressionId = ExpressionNode.generateId(forNode.update.type, module.file, updateLine, updateColumn);
+                    }
+                }
+                // Extract test condition for while and do-while loops
+                if (loopType === 'while' || loopType === 'do-while') {
+                    const condLoop = node;
+                    if (condLoop.test) {
+                        testLine = getLine(condLoop.test);
+                        testColumn = getColumn(condLoop.test);
+                        testExpressionType = condLoop.test.type;
+                        testExpressionId = ExpressionNode.generateId(condLoop.test.type, module.file, testLine, testColumn);
+                    }
+                }
+                // Extract async flag for for-await-of (REG-284)
+                let isAsync;
+                if (loopType === 'for-of') {
+                    const forOfNode = node;
+                    isAsync = forOfNode.await === true ? true : undefined;
+                }
+                // 3. Determine actual parent - use stack for nested loops, otherwise original parentScopeId
+                const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+                    ? scopeIdStack[scopeIdStack.length - 1]
+                    : parentScopeId;
+                // 3.5. Extract condition expression for while/do-while/for loops (REG-280)
+                // Note: for-in and for-of don't have test expressions (they use ITERATES_OVER instead)
+                let conditionExpressionId;
+                let conditionExpressionType;
+                let conditionLine;
+                let conditionColumn;
+                if (loopType === 'while' || loopType === 'do-while') {
+                    const testNode = node.test;
+                    if (testNode) {
+                        const condResult = this.extractDiscriminantExpression(testNode, module);
+                        conditionExpressionId = condResult.id;
+                        conditionExpressionType = condResult.expressionType;
+                        conditionLine = condResult.line;
+                        conditionColumn = condResult.column;
+                    }
+                }
+                else if (loopType === 'for') {
+                    const forNode = node;
+                    // for loop test may be null (infinite loop: for(;;))
+                    if (forNode.test) {
+                        const condResult = this.extractDiscriminantExpression(forNode.test, module);
+                        conditionExpressionId = condResult.id;
+                        conditionExpressionType = condResult.expressionType;
+                        conditionLine = condResult.line;
+                        conditionColumn = condResult.column;
+                    }
+                }
+                // 4. Push LOOP info
+                loops.push({
+                    id: loopId,
+                    semanticId: loopId,
+                    type: 'LOOP',
+                    loopType,
+                    file: module.file,
+                    line: getLine(node),
+                    column: getColumn(node),
+                    parentScopeId: actualParentScopeId,
+                    iteratesOverName,
+                    iteratesOverLine,
+                    iteratesOverColumn,
+                    conditionExpressionId,
+                    conditionExpressionType,
+                    conditionLine,
+                    conditionColumn,
+                    // REG-282: init/test/update for classic for loops
+                    initVariableName,
+                    initLine,
+                    testExpressionId,
+                    testExpressionType,
+                    testLine,
+                    testColumn,
+                    updateExpressionId,
+                    updateExpressionType,
+                    updateLine,
+                    updateColumn,
+                    // REG-284: async flag for for-await-of
+                    async: isAsync
                 });
-            },
-            ForStatement: (forPath) => {
-                const forNode = forPath.node;
-                const scopeId = `SCOPE#for-loop#${module.file}#${forNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('for-loop', scopeCtx);
+                // 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: 'for-loop',
+                    scopeType,
                     semanticId,
                     file: module.file,
-                    line: forNode.loc.start.line,
-                    parentScopeId
+                    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);
+                }
             },
-            ForInStatement: (forPath) => {
-                const forNode = forPath.node;
-                const scopeId = `SCOPE#for-in-loop#${module.file}#${forNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('for-in-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'for-in-loop',
-                    semanticId,
+            exit: () => {
+                // Pop loop scope from stack
+                if (scopeIdStack) {
+                    scopeIdStack.pop();
+                }
+                // Exit scope
+                if (scopeTracker) {
+                    scopeTracker.exitScope();
+                }
+            }
+        };
+    }
+    /**
+     * Factory method to create TryStatement handler.
+     * Creates TRY_BLOCK, CATCH_BLOCK, FINALLY_BLOCK nodes and body SCOPEs.
+     * Does NOT use skip() - allows normal traversal for CallExpression/NewExpression visitors.
+     *
+     * Phase 4 (REG-267): Creates control flow nodes with HAS_CATCH and HAS_FINALLY edges.
+     *
+     * @param parentScopeId - Parent scope ID for the scope nodes
+     * @param module - Module context
+     * @param scopes - Collection to push scope nodes to
+     * @param tryBlocks - Collection to push TRY_BLOCK nodes to
+     * @param catchBlocks - Collection to push CATCH_BLOCK nodes to
+     * @param finallyBlocks - Collection to push FINALLY_BLOCK nodes to
+     * @param scopeCounterRef - Counter for unique scope IDs
+     * @param tryBlockCounterRef - Counter for unique TRY_BLOCK IDs
+     * @param catchBlockCounterRef - Counter for unique CATCH_BLOCK IDs
+     * @param finallyBlockCounterRef - Counter for unique FINALLY_BLOCK IDs
+     * @param scopeTracker - Tracker for semantic ID generation
+     * @param tryScopeMap - Map to track try/catch/finally scope transitions
+     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
+     */
+    createTryStatementHandler(parentScopeId, module, scopes, tryBlocks, catchBlocks, finallyBlocks, scopeCounterRef, tryBlockCounterRef, catchBlockCounterRef, finallyBlockCounterRef, scopeTracker, tryScopeMap, scopeIdStack, controlFlowState) {
+        return {
+            enter: (tryPath) => {
+                const tryNode = tryPath.node;
+                // Phase 6 (REG-267): Mark that this function has try/catch
+                if (controlFlowState) {
+                    controlFlowState.hasTryCatch = true;
+                }
+                // 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: forNode.loc.start.line,
-                    parentScopeId
+                    line: getLine(tryNode),
+                    column: getColumn(tryNode),
+                    parentScopeId: actualParentScopeId
                 });
-            },
-            ForOfStatement: (forPath) => {
-                const forNode = forPath.node;
-                const scopeId = `SCOPE#for-of-loop#${module.file}#${forNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('for-of-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'for-of-loop',
-                    semanticId,
-                    file: module.file,
-                    line: forNode.loc.start.line,
-                    parentScopeId
-                });
-            },
-            WhileStatement: (whilePath) => {
-                const whileNode = whilePath.node;
-                const scopeId = `SCOPE#while-loop#${module.file}#${whileNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('while-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'while-loop',
-                    semanticId,
-                    file: module.file,
-                    line: whileNode.loc.start.line,
-                    parentScopeId
-                });
-            },
-            DoWhileStatement: (doPath) => {
-                const doNode = doPath.node;
-                const scopeId = `SCOPE#do-while-loop#${module.file}#${doNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('do-while-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'do-while-loop',
-                    semanticId,
-                    file: module.file,
-                    line: doNode.loc.start.line,
-                    parentScopeId
-                });
-            },
-            TryStatement: (tryPath) => {
-                const tryNode = tryPath.node;
-                const tryScopeId = `SCOPE#try-block#${module.file}#${tryNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const trySemanticId = this.generateSemanticId('try-block', scopeCtx);
+                // 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: tryNode.loc.start.line,
-                    parentScopeId
+                    line: getLine(tryNode),
+                    parentScopeId: tryBlockId // Parent is TRY_BLOCK
                 });
+                // 3. Create CATCH_BLOCK and catch-body SCOPE if handler exists
+                let catchBlockId = null;
+                let catchScopeId = null;
                 if (tryNode.handler) {
-                    const catchBlock = tryNode.handler;
-                    const catchScopeId = `SCOPE#catch-block#${module.file}#${catchBlock.loc.start.line}:${scopeCounterRef.value++}`;
-                    const catchSemanticId = this.generateSemanticId('catch-block', scopeCtx);
+                    const catchClause = tryNode.handler;
+                    const catchBlockCounter = catchBlockCounterRef.value++;
+                    const legacyCatchBlockId = `${module.file}:CATCH_BLOCK:${getLine(catchClause)}:${catchBlockCounter}`;
+                    catchBlockId = scopeTracker
+                        ? computeSemanticId('CATCH_BLOCK', 'catch', scopeTracker.getContext(), { discriminator: catchBlockCounter })
+                        : legacyCatchBlockId;
+                    // Extract parameter name if present
+                    let parameterName;
+                    if (catchClause.param && t.isIdentifier(catchClause.param)) {
+                        parameterName = catchClause.param.name;
+                    }
+                    catchBlocks.push({
+                        id: catchBlockId,
+                        semanticId: catchBlockId,
+                        type: 'CATCH_BLOCK',
+                        file: module.file,
+                        line: getLine(catchClause),
+                        column: getColumn(catchClause),
+                        parentScopeId,
+                        parentTryBlockId: tryBlockId,
+                        parameterName
+                    });
+                    // Create catch-body SCOPE (backward compatibility)
+                    catchScopeId = `SCOPE#catch-block#${module.file}#${getLine(catchClause)}:${scopeCounterRef.value++}`;
+                    const catchSemanticId = this.generateSemanticId('catch-block', scopeTracker);
                     scopes.push({
                         id: catchScopeId,
                         type: 'SCOPE',
                         scopeType: 'catch-block',
                         semanticId: catchSemanticId,
                         file: module.file,
-                        line: catchBlock.loc.start.line,
-                        parentScopeId
+                        line: getLine(catchClause),
+                        parentScopeId: catchBlockId // Parent is CATCH_BLOCK
                     });
-                    if (catchBlock.param) {
-                        const errorVarInfo = this.extractVariableNamesFromPattern(catchBlock.param);
-                        errorVarInfo.forEach(varInfo => {
-                            const varId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
-                            variableDeclarations.push({
-                                id: varId,
-                                type: 'VARIABLE',
-                                name: varInfo.name,
-                                file: module.file,
-                                line: varInfo.loc.start.line,
-                                parentScopeId: catchScopeId
-                            });
+                }
+                // 4. Create FINALLY_BLOCK and finally-body SCOPE if finalizer exists
+                let finallyBlockId = null;
+                let finallyScopeId = null;
+                if (tryNode.finalizer) {
+                    const finallyBlockCounter = finallyBlockCounterRef.value++;
+                    const legacyFinallyBlockId = `${module.file}:FINALLY_BLOCK:${getLine(tryNode.finalizer)}:${finallyBlockCounter}`;
+                    finallyBlockId = scopeTracker
+                        ? computeSemanticId('FINALLY_BLOCK', 'finally', scopeTracker.getContext(), { discriminator: finallyBlockCounter })
+                        : legacyFinallyBlockId;
+                    finallyBlocks.push({
+                        id: finallyBlockId,
+                        semanticId: finallyBlockId,
+                        type: 'FINALLY_BLOCK',
+                        file: module.file,
+                        line: getLine(tryNode.finalizer),
+                        column: getColumn(tryNode.finalizer),
+                        parentScopeId,
+                        parentTryBlockId: tryBlockId
+                    });
+                    // Create finally-body SCOPE (backward compatibility)
+                    finallyScopeId = `SCOPE#finally-block#${module.file}#${getLine(tryNode.finalizer)}:${scopeCounterRef.value++}`;
+                    const finallySemanticId = this.generateSemanticId('finally-block', scopeTracker);
+                    scopes.push({
+                        id: finallyScopeId,
+                        type: 'SCOPE',
+                        scopeType: 'finally-block',
+                        semanticId: finallySemanticId,
+                        file: module.file,
+                        line: getLine(tryNode.finalizer),
+                        parentScopeId: finallyBlockId // Parent is FINALLY_BLOCK
+                    });
+                }
+                // 5. Push try scope onto stack for CONTAINS edges
+                if (scopeIdStack) {
+                    scopeIdStack.push(tryScopeId);
+                }
+                // Enter try scope for semantic ID generation
+                if (scopeTracker) {
+                    scopeTracker.enterCountedScope('try');
+                }
+                // 6. Store scope info for catch/finally transitions
+                tryScopeMap.set(tryNode, {
+                    tryScopeId,
+                    catchScopeId,
+                    finallyScopeId,
+                    currentBlock: 'try',
+                    tryBlockId,
+                    catchBlockId,
+                    finallyBlockId
+                });
+            },
+            exit: (tryPath) => {
+                const tryNode = tryPath.node;
+                const scopeInfo = tryScopeMap.get(tryNode);
+                // Pop the current scope from stack (could be try, catch, or finally)
+                if (scopeIdStack) {
+                    scopeIdStack.pop();
+                }
+                // Exit the current scope
+                if (scopeTracker) {
+                    scopeTracker.exitScope();
+                }
+                // Clean up
+                tryScopeMap.delete(tryNode);
+            }
+        };
+    }
+    /**
+     * Factory method to create CatchClause handler.
+     * Handles scope transition from try to catch and processes catch parameter.
+     *
+     * @param module - Module context
+     * @param variableDeclarations - Collection to push variable declarations to
+     * @param varDeclCounterRef - Counter for unique variable declaration IDs
+     * @param scopeTracker - Tracker for semantic ID generation
+     * @param tryScopeMap - Map to track try/catch/finally scope transitions
+     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
+     */
+    createCatchClauseHandler(module, variableDeclarations, varDeclCounterRef, scopeTracker, tryScopeMap, scopeIdStack) {
+        return {
+            enter: (catchPath) => {
+                const catchNode = catchPath.node;
+                const parent = catchPath.parent;
+                if (!t.isTryStatement(parent))
+                    return;
+                const scopeInfo = tryScopeMap.get(parent);
+                if (!scopeInfo || !scopeInfo.catchScopeId)
+                    return;
+                // Transition from try scope to catch scope
+                if (scopeInfo.currentBlock === 'try') {
+                    // Pop try scope, push catch scope
+                    if (scopeIdStack) {
+                        scopeIdStack.pop();
+                        scopeIdStack.push(scopeInfo.catchScopeId);
+                    }
+                    // Exit try scope, enter catch scope for semantic ID
+                    if (scopeTracker) {
+                        scopeTracker.exitScope();
+                        scopeTracker.enterCountedScope('catch');
+                    }
+                    scopeInfo.currentBlock = 'catch';
+                }
+                // Handle catch parameter (e.g., catch (e) or catch ({ message }))
+                if (catchNode.param) {
+                    const errorVarInfo = this.extractVariableNamesFromPattern(catchNode.param);
+                    errorVarInfo.forEach(varInfo => {
+                        const legacyId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+                        const varId = scopeTracker
+                            ? computeSemanticId('VARIABLE', varInfo.name, scopeTracker.getContext())
+                            : legacyId;
+                        variableDeclarations.push({
+                            id: varId,
+                            type: 'VARIABLE',
+                            name: varInfo.name,
+                            file: module.file,
+                            line: varInfo.loc.start.line,
+                            parentScopeId: scopeInfo.catchScopeId
                         });
+                    });
+                }
+            }
+        };
+    }
+    /**
+     * Handles SwitchStatement nodes.
+     * Creates BRANCH node for switch, CASE nodes for each case clause,
+     * and EXPRESSION node for discriminant.
+     *
+     * @param switchPath - The NodePath for the SwitchStatement
+     * @param parentScopeId - Parent scope ID
+     * @param module - Module context
+     * @param collections - AST collections
+     * @param scopeTracker - Tracker for semantic ID generation
+     */
+    handleSwitchStatement(switchPath, parentScopeId, module, collections, scopeTracker, controlFlowState) {
+        const switchNode = switchPath.node;
+        // Phase 6 (REG-267): Count branch and non-default cases for cyclomatic complexity
+        if (controlFlowState) {
+            controlFlowState.branchCount++; // switch itself is a branch
+            // Count non-default cases
+            for (const caseNode of switchNode.cases) {
+                if (caseNode.test !== null) { // Not default case
+                    controlFlowState.caseCount++;
+                }
+            }
+        }
+        // Initialize collections if not exist
+        if (!collections.branches) {
+            collections.branches = [];
+        }
+        if (!collections.cases) {
+            collections.cases = [];
+        }
+        if (!collections.branchCounterRef) {
+            collections.branchCounterRef = { value: 0 };
+        }
+        if (!collections.caseCounterRef) {
+            collections.caseCounterRef = { value: 0 };
+        }
+        const branches = collections.branches;
+        const cases = collections.cases;
+        const branchCounterRef = collections.branchCounterRef;
+        const caseCounterRef = collections.caseCounterRef;
+        // Create BRANCH node
+        const branchCounter = branchCounterRef.value++;
+        const legacyBranchId = `${module.file}:BRANCH:switch:${getLine(switchNode)}:${branchCounter}`;
+        const branchId = scopeTracker
+            ? computeSemanticId('BRANCH', 'switch', scopeTracker.getContext(), { discriminator: branchCounter })
+            : legacyBranchId;
+        // Handle discriminant expression - store metadata directly (Linus improvement)
+        let discriminantExpressionId;
+        let discriminantExpressionType;
+        let discriminantLine;
+        let discriminantColumn;
+        if (switchNode.discriminant) {
+            const discResult = this.extractDiscriminantExpression(switchNode.discriminant, module);
+            discriminantExpressionId = discResult.id;
+            discriminantExpressionType = discResult.expressionType;
+            discriminantLine = discResult.line;
+            discriminantColumn = discResult.column;
+        }
+        branches.push({
+            id: branchId,
+            semanticId: branchId,
+            type: 'BRANCH',
+            branchType: 'switch',
+            file: module.file,
+            line: getLine(switchNode),
+            parentScopeId,
+            discriminantExpressionId,
+            discriminantExpressionType,
+            discriminantLine,
+            discriminantColumn
+        });
+        // Process each case clause
+        for (let i = 0; i < switchNode.cases.length; i++) {
+            const caseNode = switchNode.cases[i];
+            const isDefault = caseNode.test === null;
+            const isEmpty = caseNode.consequent.length === 0;
+            // Detect fall-through: no break/return/throw at end of consequent
+            const fallsThrough = isEmpty || !this.caseTerminates(caseNode);
+            // Extract case value
+            const value = isDefault ? null : this.extractCaseValue(caseNode.test ?? null);
+            const caseCounter = caseCounterRef.value++;
+            const valueName = isDefault ? 'default' : String(value);
+            const legacyCaseId = `${module.file}:CASE:${valueName}:${getLine(caseNode)}:${caseCounter}`;
+            const caseId = scopeTracker
+                ? computeSemanticId('CASE', valueName, scopeTracker.getContext(), { discriminator: caseCounter })
+                : legacyCaseId;
+            cases.push({
+                id: caseId,
+                semanticId: caseId,
+                type: 'CASE',
+                value,
+                isDefault,
+                fallsThrough,
+                isEmpty,
+                file: module.file,
+                line: getLine(caseNode),
+                parentBranchId: branchId
+            });
+        }
+    }
+    /**
+     * Extract EXPRESSION node ID and metadata for switch discriminant
+     */
+    extractDiscriminantExpression(discriminant, module) {
+        const line = getLine(discriminant);
+        const column = getColumn(discriminant);
+        if (t.isIdentifier(discriminant)) {
+            // Simple identifier: switch(x) - create EXPRESSION node
+            return {
+                id: ExpressionNode.generateId('Identifier', module.file, line, column),
+                expressionType: 'Identifier',
+                line,
+                column
+            };
+        }
+        else if (t.isMemberExpression(discriminant)) {
+            // Member expression: switch(action.type)
+            return {
+                id: ExpressionNode.generateId('MemberExpression', module.file, line, column),
+                expressionType: 'MemberExpression',
+                line,
+                column
+            };
+        }
+        else if (t.isCallExpression(discriminant)) {
+            // Call expression: switch(getType())
+            const callee = t.isIdentifier(discriminant.callee) ? discriminant.callee.name : '<complex>';
+            // Return CALL node ID instead of EXPRESSION (reuse existing call tracking)
+            return {
+                id: `${module.file}:CALL:${callee}:${line}:${column}`,
+                expressionType: 'CallExpression',
+                line,
+                column
+            };
+        }
+        // Default: create generic EXPRESSION
+        return {
+            id: ExpressionNode.generateId(discriminant.type, module.file, line, column),
+            expressionType: discriminant.type,
+            line,
+            column
+        };
+    }
+    /**
+     * Extract case test value as a primitive
+     */
+    extractCaseValue(test) {
+        if (!test)
+            return null;
+        if (t.isStringLiteral(test)) {
+            return test.value;
+        }
+        else if (t.isNumericLiteral(test)) {
+            return test.value;
+        }
+        else if (t.isBooleanLiteral(test)) {
+            return test.value;
+        }
+        else if (t.isNullLiteral(test)) {
+            return null;
+        }
+        else if (t.isIdentifier(test)) {
+            // Constant reference: case CONSTANTS.ADD
+            return test.name;
+        }
+        else if (t.isMemberExpression(test)) {
+            // Member expression: case Action.ADD
+            return this.memberExpressionToString(test);
+        }
+        return '<complex>';
+    }
+    /**
+     * Check if case clause terminates (has break, return, throw)
+     */
+    caseTerminates(caseNode) {
+        const statements = caseNode.consequent;
+        if (statements.length === 0)
+            return false;
+        // Check last statement (or any statement for early returns)
+        for (const stmt of statements) {
+            if (t.isBreakStatement(stmt))
+                return true;
+            if (t.isReturnStatement(stmt))
+                return true;
+            if (t.isThrowStatement(stmt))
+                return true;
+            if (t.isContinueStatement(stmt))
+                return true; // In switch inside loop
+            // Check for nested blocks (if last statement is block, check inside)
+            if (t.isBlockStatement(stmt)) {
+                const lastInBlock = stmt.body[stmt.body.length - 1];
+                if (lastInBlock && (t.isBreakStatement(lastInBlock) ||
+                    t.isReturnStatement(lastInBlock) ||
+                    t.isThrowStatement(lastInBlock))) {
+                    return true;
+                }
+            }
+            // Check for if-else where both branches terminate
+            if (t.isIfStatement(stmt) && stmt.alternate) {
+                const ifTerminates = this.blockTerminates(stmt.consequent);
+                const elseTerminates = this.blockTerminates(stmt.alternate);
+                if (ifTerminates && elseTerminates)
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a block/statement terminates
+     */
+    blockTerminates(node) {
+        if (t.isBreakStatement(node))
+            return true;
+        if (t.isReturnStatement(node))
+            return true;
+        if (t.isThrowStatement(node))
+            return true;
+        if (t.isBlockStatement(node)) {
+            const last = node.body[node.body.length - 1];
+            return last ? this.blockTerminates(last) : false;
+        }
+        return false;
+    }
+    /**
+     * Count logical operators (&& and ||) in a condition expression.
+     * Used for cyclomatic complexity calculation (Phase 6 REG-267).
+     *
+     * @param node - The condition expression to analyze
+     * @returns Number of logical operators found
+     */
+    countLogicalOperators(node) {
+        let count = 0;
+        const traverse = (expr) => {
+            if (t.isLogicalExpression(expr)) {
+                // Count && and || operators
+                if (expr.operator === '&&' || expr.operator === '||') {
+                    count++;
+                }
+                traverse(expr.left);
+                traverse(expr.right);
+            }
+            else if (t.isConditionalExpression(expr)) {
+                // Handle ternary conditions: test ? consequent : alternate
+                traverse(expr.test);
+                traverse(expr.consequent);
+                traverse(expr.alternate);
+            }
+            else if (t.isUnaryExpression(expr)) {
+                traverse(expr.argument);
+            }
+            else if (t.isBinaryExpression(expr)) {
+                traverse(expr.left);
+                traverse(expr.right);
+            }
+            else if (t.isSequenceExpression(expr)) {
+                for (const e of expr.expressions) {
+                    traverse(e);
+                }
+            }
+            else if (t.isParenthesizedExpression(expr)) {
+                traverse(expr.expression);
+            }
+        };
+        traverse(node);
+        return count;
+    }
+    /**
+     * Convert MemberExpression to string representation
+     */
+    memberExpressionToString(expr) {
+        const parts = [];
+        let current = expr;
+        while (t.isMemberExpression(current)) {
+            if (t.isIdentifier(current.property)) {
+                parts.unshift(current.property.name);
+            }
+            else {
+                parts.unshift('<computed>');
+            }
+            current = current.object;
+        }
+        if (t.isIdentifier(current)) {
+            parts.unshift(current.name);
+        }
+        return parts.join('.');
+    }
+    /**
+     * Factory method to create IfStatement handler.
+     * Creates BRANCH node for if statement and SCOPE nodes for if/else bodies.
+     * Tracks if/else scope transitions via ifElseScopeMap.
+     *
+     * Phase 3 (REG-267): Creates BRANCH node with branchType='if' and
+     * HAS_CONSEQUENT/HAS_ALTERNATE edges to body SCOPEs.
+     *
+     * @param parentScopeId - Parent scope ID for the scope nodes
+     * @param module - Module context
+     * @param scopes - Collection to push scope nodes to
+     * @param branches - Collection to push BRANCH nodes to
+     * @param ifScopeCounterRef - Counter for unique if scope IDs
+     * @param branchCounterRef - Counter for unique BRANCH IDs
+     * @param scopeTracker - Tracker for semantic ID generation
+     * @param sourceCode - Source code for extracting condition text
+     * @param ifElseScopeMap - Map to track if/else scope transitions
+     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
+     */
+    createIfStatementHandler(parentScopeId, module, scopes, branches, ifScopeCounterRef, branchCounterRef, scopeTracker, sourceCode, ifElseScopeMap, scopeIdStack, controlFlowState, countLogicalOperators) {
+        return {
+            enter: (ifPath) => {
+                const ifNode = ifPath.node;
+                const condition = sourceCode.substring(ifNode.test.start, ifNode.test.end) || 'condition';
+                // Phase 6 (REG-267): Increment branch count and count logical operators
+                if (controlFlowState) {
+                    controlFlowState.branchCount++;
+                    if (countLogicalOperators) {
+                        controlFlowState.logicalOpCount += countLogicalOperators(ifNode.test);
+                    }
+                }
+                // Check if this if-statement is an else-if (alternate of parent IfStatement)
+                const isElseIf = t.isIfStatement(ifPath.parent) && ifPath.parentKey === 'alternate';
+                // Determine actual parent scope
+                let actualParentScopeId;
+                if (isElseIf) {
+                    // For else-if, parent should be the outer BRANCH (stored in ifElseScopeMap)
+                    const parentIfInfo = ifElseScopeMap.get(ifPath.parent);
+                    if (parentIfInfo) {
+                        actualParentScopeId = parentIfInfo.branchId;
+                    }
+                    else {
+                        // Fallback to stack
+                        actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+                            ? scopeIdStack[scopeIdStack.length - 1]
+                            : parentScopeId;
+                    }
+                }
+                else {
+                    // For regular if statements, use stack or original parentScopeId
+                    actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+                        ? scopeIdStack[scopeIdStack.length - 1]
+                        : parentScopeId;
+                }
+                // 1. Create BRANCH node for if statement
+                const branchCounter = branchCounterRef.value++;
+                const legacyBranchId = `${module.file}:BRANCH:if:${getLine(ifNode)}:${branchCounter}`;
+                const branchId = scopeTracker
+                    ? computeSemanticId('BRANCH', 'if', scopeTracker.getContext(), { discriminator: branchCounter })
+                    : legacyBranchId;
+                // 2. Extract condition expression info for HAS_CONDITION edge
+                const conditionResult = this.extractDiscriminantExpression(ifNode.test, module);
+                // For else-if, get the parent branch ID
+                const isAlternateOfBranchId = isElseIf
+                    ? ifElseScopeMap.get(ifPath.parent)?.branchId
+                    : undefined;
+                branches.push({
+                    id: branchId,
+                    semanticId: branchId,
+                    type: 'BRANCH',
+                    branchType: 'if',
+                    file: module.file,
+                    line: getLine(ifNode),
+                    parentScopeId: actualParentScopeId,
+                    discriminantExpressionId: conditionResult.id,
+                    discriminantExpressionType: conditionResult.expressionType,
+                    discriminantLine: conditionResult.line,
+                    discriminantColumn: conditionResult.column,
+                    isAlternateOfBranchId
+                });
+                // 3. Create if-body SCOPE (backward compatibility)
+                // Parent is now BRANCH, not original parentScopeId
+                const counterId = ifScopeCounterRef.value++;
+                const ifScopeId = `SCOPE#if#${module.file}#${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`;
+                // Parse condition to extract constraints
+                const constraints = ConditionParser.parse(ifNode.test);
+                const ifSemanticId = this.generateSemanticId('if_statement', scopeTracker);
+                scopes.push({
+                    id: ifScopeId,
+                    type: 'SCOPE',
+                    scopeType: 'if_statement',
+                    name: `if:${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`,
+                    semanticId: ifSemanticId,
+                    conditional: true,
+                    condition,
+                    constraints: constraints.length > 0 ? constraints : undefined,
+                    file: module.file,
+                    line: getLine(ifNode),
+                    parentScopeId: branchId // Parent is BRANCH, not original parentScopeId
+                });
+                // 4. Push if scope onto stack for CONTAINS edges
+                if (scopeIdStack) {
+                    scopeIdStack.push(ifScopeId);
+                }
+                // Enter scope for semantic ID generation
+                if (scopeTracker) {
+                    scopeTracker.enterCountedScope('if');
+                }
+                // 5. Handle else branch if present
+                let elseScopeId = null;
+                if (ifNode.alternate && !t.isIfStatement(ifNode.alternate)) {
+                    // Only create else scope for actual else block, not else-if
+                    const elseCounterId = ifScopeCounterRef.value++;
+                    elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
+                    const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
+                    const elseSemanticId = this.generateSemanticId('else_statement', scopeTracker);
+                    scopes.push({
+                        id: elseScopeId,
+                        type: 'SCOPE',
+                        scopeType: 'else_statement',
+                        name: `else:${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`,
+                        semanticId: elseSemanticId,
+                        conditional: true,
+                        constraints: negatedConstraints,
+                        file: module.file,
+                        line: getLine(ifNode.alternate),
+                        parentScopeId: branchId // Parent is BRANCH, not original parentScopeId
+                    });
+                    // Store info to switch to else scope when we enter alternate
+                    ifElseScopeMap.set(ifNode, { inElse: false, hasElse: true, ifScopeId, elseScopeId, branchId });
+                }
+                else {
+                    ifElseScopeMap.set(ifNode, { inElse: false, hasElse: false, ifScopeId, elseScopeId: null, branchId });
+                }
+            },
+            exit: (ifPath) => {
+                const ifNode = ifPath.node;
+                // Pop scope from stack (either if or else, depending on what we're exiting)
+                if (scopeIdStack) {
+                    scopeIdStack.pop();
+                }
+                // Exit the current scope (either if or else)
+                if (scopeTracker) {
+                    scopeTracker.exitScope();
+                }
+                // If we were in else, we already exited else scope
+                // If we only had if, we exit if scope (done above)
+                ifElseScopeMap.delete(ifNode);
+            }
+        };
+    }
+    /**
+     * Factory method to create ConditionalExpression (ternary) handler.
+     * Creates BRANCH nodes with branchType='ternary' and increments branchCount for cyclomatic complexity.
+     *
+     * Key difference from IfStatement: ternary has EXPRESSIONS as branches, not SCOPE blocks.
+     * We store consequentExpressionId and alternateExpressionId in BranchInfo for HAS_CONSEQUENT/HAS_ALTERNATE edges.
+     *
+     * @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
+     */
+    createConditionalExpressionHandler(parentScopeId, module, branches, branchCounterRef, scopeTracker, scopeIdStack, controlFlowState, countLogicalOperators) {
+        return (condPath) => {
+            const condNode = condPath.node;
+            // Increment branch count for cyclomatic complexity
+            if (controlFlowState) {
+                controlFlowState.branchCount++;
+                // Count logical operators in the test condition (e.g., a && b ? x : y)
+                if (countLogicalOperators) {
+                    controlFlowState.logicalOpCount += countLogicalOperators(condNode.test);
+                }
+            }
+            // Determine parent scope from stack or fallback
+            const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+                ? scopeIdStack[scopeIdStack.length - 1]
+                : parentScopeId;
+            // Create BRANCH node with branchType='ternary'
+            const branchCounter = branchCounterRef.value++;
+            const legacyBranchId = `${module.file}:BRANCH:ternary:${getLine(condNode)}:${branchCounter}`;
+            const branchId = scopeTracker
+                ? computeSemanticId('BRANCH', 'ternary', scopeTracker.getContext(), { discriminator: branchCounter })
+                : legacyBranchId;
+            // Extract condition expression info for HAS_CONDITION edge
+            const conditionResult = this.extractDiscriminantExpression(condNode.test, module);
+            // Generate expression IDs for consequent and alternate
+            const consequentLine = getLine(condNode.consequent);
+            const consequentColumn = getColumn(condNode.consequent);
+            const consequentExpressionId = ExpressionNode.generateId(condNode.consequent.type, module.file, consequentLine, consequentColumn);
+            const alternateLine = getLine(condNode.alternate);
+            const alternateColumn = getColumn(condNode.alternate);
+            const alternateExpressionId = ExpressionNode.generateId(condNode.alternate.type, module.file, alternateLine, alternateColumn);
+            branches.push({
+                id: branchId,
+                semanticId: branchId,
+                type: 'BRANCH',
+                branchType: 'ternary',
+                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
+     */
+    createBlockStatementHandler(scopeTracker, ifElseScopeMap, tryScopeMap, scopeIdStack) {
+        return {
+            enter: (blockPath) => {
+                const parent = blockPath.parent;
+                // Check if this block is the alternate of an IfStatement
+                if (t.isIfStatement(parent) && parent.alternate === blockPath.node) {
+                    const scopeInfo = ifElseScopeMap.get(parent);
+                    if (scopeInfo && scopeInfo.hasElse && !scopeInfo.inElse) {
+                        // Swap if-scope for else-scope on the stack
+                        if (scopeIdStack && scopeInfo.elseScopeId) {
+                            scopeIdStack.pop(); // Remove if-scope
+                            scopeIdStack.push(scopeInfo.elseScopeId); // Push else-scope
+                        }
+                        // Exit if scope, enter else scope for semantic ID tracking
+                        if (scopeTracker) {
+                            scopeTracker.exitScope();
+                            scopeTracker.enterCountedScope('else');
+                        }
+                        scopeInfo.inElse = true;
+                    }
+                }
+                // Check if this block is the finalizer of a TryStatement
+                if (t.isTryStatement(parent) && parent.finalizer === blockPath.node) {
+                    const scopeInfo = tryScopeMap.get(parent);
+                    if (scopeInfo && scopeInfo.finallyScopeId && scopeInfo.currentBlock !== 'finally') {
+                        // Pop current scope (try or catch), push finally scope
+                        if (scopeIdStack) {
+                            scopeIdStack.pop();
+                            scopeIdStack.push(scopeInfo.finallyScopeId);
+                        }
+                        // Exit current scope, enter finally scope for semantic ID tracking
+                        if (scopeTracker) {
+                            scopeTracker.exitScope();
+                            scopeTracker.enterCountedScope('finally');
+                        }
+                        scopeInfo.currentBlock = 'finally';
+                    }
+                }
+            }
+        };
+    }
+    /**
+     * Анализирует тело функции и извлекает переменные, вызовы, условные блоки.
+     * Uses ScopeTracker from collections for semantic ID generation.
+     */
+    analyzeFunctionBody(funcPath, parentScopeId, module, collections) {
+        // Extract with defaults for optional properties
+        const functions = (collections.functions ?? []);
+        const scopes = (collections.scopes ?? []);
+        const variableDeclarations = (collections.variableDeclarations ?? []);
+        const callSites = (collections.callSites ?? []);
+        const methodCalls = (collections.methodCalls ?? []);
+        const eventListeners = (collections.eventListeners ?? []);
+        const methodCallbacks = (collections.methodCallbacks ?? []);
+        const classInstantiations = (collections.classInstantiations ?? []);
+        const constructorCalls = (collections.constructorCalls ?? []);
+        const httpRequests = (collections.httpRequests ?? []);
+        const literals = (collections.literals ?? []);
+        const variableAssignments = (collections.variableAssignments ?? []);
+        const ifScopeCounterRef = (collections.ifScopeCounterRef ?? { value: 0 });
+        const scopeCounterRef = (collections.scopeCounterRef ?? { value: 0 });
+        const varDeclCounterRef = (collections.varDeclCounterRef ?? { value: 0 });
+        const callSiteCounterRef = (collections.callSiteCounterRef ?? { value: 0 });
+        const functionCounterRef = (collections.functionCounterRef ?? { value: 0 });
+        const httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 });
+        const literalCounterRef = (collections.literalCounterRef ?? { value: 0 });
+        const anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 });
+        const scopeTracker = collections.scopeTracker;
+        // Object literal tracking (REG-328)
+        if (!collections.objectLiterals) {
+            collections.objectLiterals = [];
+        }
+        if (!collections.objectProperties) {
+            collections.objectProperties = [];
+        }
+        if (!collections.objectLiteralCounterRef) {
+            collections.objectLiteralCounterRef = { value: 0 };
+        }
+        const objectLiterals = collections.objectLiterals;
+        const objectProperties = collections.objectProperties;
+        const objectLiteralCounterRef = collections.objectLiteralCounterRef;
+        const returnStatements = (collections.returnStatements ?? []);
+        const parameters = (collections.parameters ?? []);
+        // Control flow collections (Phase 2: LOOP nodes)
+        // Initialize if not exist to ensure nested function calls share same arrays
+        if (!collections.loops) {
+            collections.loops = [];
+        }
+        if (!collections.loopCounterRef) {
+            collections.loopCounterRef = { value: 0 };
+        }
+        const loops = collections.loops;
+        const loopCounterRef = collections.loopCounterRef;
+        const updateExpressions = (collections.updateExpressions ?? []);
+        const processedNodes = collections.processedNodes ?? {
+            functions: new Set(),
+            classes: new Set(),
+            imports: new Set(),
+            exports: new Set(),
+            variables: new Set(),
+            callSites: new Set(),
+            methodCalls: new Set(),
+            varDecls: new Set(),
+            eventListeners: new Set()
+        };
+        const parentScopeVariables = new Set();
+        const processedCallSites = processedNodes.callSites;
+        const processedVarDecls = processedNodes.varDecls;
+        const processedMethodCalls = processedNodes.methodCalls;
+        const processedEventListeners = processedNodes.eventListeners;
+        // Track if/else scope transitions (Phase 3: extended with branchId)
+        const ifElseScopeMap = new Map();
+        // Ensure branches and branchCounterRef are initialized (used by IfStatement and SwitchStatement)
+        if (!collections.branches) {
+            collections.branches = [];
+        }
+        if (!collections.branchCounterRef) {
+            collections.branchCounterRef = { value: 0 };
+        }
+        const branches = collections.branches;
+        const branchCounterRef = collections.branchCounterRef;
+        // Phase 4: Initialize try/catch/finally collections and counters
+        if (!collections.tryBlocks) {
+            collections.tryBlocks = [];
+        }
+        if (!collections.catchBlocks) {
+            collections.catchBlocks = [];
+        }
+        if (!collections.finallyBlocks) {
+            collections.finallyBlocks = [];
+        }
+        if (!collections.tryBlockCounterRef) {
+            collections.tryBlockCounterRef = { value: 0 };
+        }
+        if (!collections.catchBlockCounterRef) {
+            collections.catchBlockCounterRef = { value: 0 };
+        }
+        if (!collections.finallyBlockCounterRef) {
+            collections.finallyBlockCounterRef = { value: 0 };
+        }
+        const tryBlocks = collections.tryBlocks;
+        const catchBlocks = collections.catchBlocks;
+        const finallyBlocks = collections.finallyBlocks;
+        const tryBlockCounterRef = collections.tryBlockCounterRef;
+        const catchBlockCounterRef = collections.catchBlockCounterRef;
+        const finallyBlockCounterRef = collections.finallyBlockCounterRef;
+        // Track try/catch/finally scope transitions
+        const tryScopeMap = new Map();
+        // REG-334: Use shared Promise executor contexts from collections.
+        // These are populated by module-level NewExpression handler and function-level NewExpression handler.
+        if (!collections.promiseExecutorContexts) {
+            collections.promiseExecutorContexts = new Map();
+        }
+        const promiseExecutorContexts = collections.promiseExecutorContexts;
+        // Initialize promiseResolutions array if not exists
+        if (!collections.promiseResolutions) {
+            collections.promiseResolutions = [];
+        }
+        const promiseResolutions = collections.promiseResolutions;
+        // Dynamic scope ID stack for CONTAINS edges
+        // Starts with the function body scope, gets updated as we enter/exit conditional scopes
+        const scopeIdStack = [parentScopeId];
+        const getCurrentScopeId = () => scopeIdStack[scopeIdStack.length - 1];
+        // Determine the ID of the function we're analyzing for RETURNS edges
+        // Find by matching file/line/column in functions collection (it was just added by the visitor)
+        const funcNode = funcPath.node;
+        const funcLine = getLine(funcNode);
+        const funcColumn = getColumn(funcNode);
+        let currentFunctionId = null;
+        const matchingFunction = functions.find(f => f.file === module.file &&
+            f.line === funcLine &&
+            (f.column === undefined || f.column === funcColumn));
+        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
+        };
+        // 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);
+            const returnInfo = {
+                parentFunctionId: currentFunctionId,
+                file: module.file,
+                line: bodyLine,
+                column: bodyColumn,
+                returnValueType: 'NONE',
+                isImplicitReturn: true
+            };
+            // Apply type detection logic for the implicit return
+            if (t.isIdentifier(bodyExpr)) {
+                returnInfo.returnValueType = 'VARIABLE';
+                returnInfo.returnValueName = bodyExpr.name;
+            }
+            // TemplateLiteral must come BEFORE isLiteral (TemplateLiteral extends Literal)
+            else if (t.isTemplateLiteral(bodyExpr)) {
+                returnInfo.returnValueType = 'EXPRESSION';
+                returnInfo.expressionType = 'TemplateLiteral';
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                returnInfo.returnValueId = NodeFactory.generateExpressionId('TemplateLiteral', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                const sourceNames = [];
+                for (const expr of bodyExpr.expressions) {
+                    if (t.isIdentifier(expr))
+                        sourceNames.push(expr.name);
+                }
+                if (sourceNames.length > 0)
+                    returnInfo.expressionSourceNames = sourceNames;
+            }
+            else if (t.isLiteral(bodyExpr)) {
+                returnInfo.returnValueType = 'LITERAL';
+                const literalId = `LITERAL#implicit_return#${module.file}#${funcLine}:${funcColumn}:${literalCounterRef.value++}`;
+                returnInfo.returnValueId = literalId;
+                literals.push({
+                    id: literalId,
+                    type: 'LITERAL',
+                    value: ExpressionEvaluator.extractLiteralValue(bodyExpr),
+                    valueType: typeof ExpressionEvaluator.extractLiteralValue(bodyExpr),
+                    file: module.file,
+                    line: bodyLine,
+                    column: bodyColumn
+                });
+            }
+            else if (t.isCallExpression(bodyExpr) && t.isIdentifier(bodyExpr.callee)) {
+                returnInfo.returnValueType = 'CALL_SITE';
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                returnInfo.returnValueCallName = bodyExpr.callee.name;
+            }
+            else if (t.isCallExpression(bodyExpr) && t.isMemberExpression(bodyExpr.callee)) {
+                returnInfo.returnValueType = 'METHOD_CALL';
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                if (t.isIdentifier(bodyExpr.callee.property)) {
+                    returnInfo.returnValueCallName = bodyExpr.callee.property.name;
+                }
+            }
+            // REG-276: Detailed EXPRESSION handling for implicit arrow returns
+            else if (t.isBinaryExpression(bodyExpr)) {
+                returnInfo.returnValueType = 'EXPRESSION';
+                returnInfo.expressionType = 'BinaryExpression';
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                returnInfo.operator = bodyExpr.operator;
+                returnInfo.returnValueId = NodeFactory.generateExpressionId('BinaryExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                if (t.isIdentifier(bodyExpr.left))
+                    returnInfo.leftSourceName = bodyExpr.left.name;
+                if (t.isIdentifier(bodyExpr.right))
+                    returnInfo.rightSourceName = bodyExpr.right.name;
+            }
+            else if (t.isLogicalExpression(bodyExpr)) {
+                returnInfo.returnValueType = 'EXPRESSION';
+                returnInfo.expressionType = 'LogicalExpression';
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                returnInfo.operator = bodyExpr.operator;
+                returnInfo.returnValueId = NodeFactory.generateExpressionId('LogicalExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                if (t.isIdentifier(bodyExpr.left))
+                    returnInfo.leftSourceName = bodyExpr.left.name;
+                if (t.isIdentifier(bodyExpr.right))
+                    returnInfo.rightSourceName = bodyExpr.right.name;
+            }
+            else if (t.isConditionalExpression(bodyExpr)) {
+                returnInfo.returnValueType = 'EXPRESSION';
+                returnInfo.expressionType = 'ConditionalExpression';
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                returnInfo.returnValueId = NodeFactory.generateExpressionId('ConditionalExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                if (t.isIdentifier(bodyExpr.consequent))
+                    returnInfo.consequentSourceName = bodyExpr.consequent.name;
+                if (t.isIdentifier(bodyExpr.alternate))
+                    returnInfo.alternateSourceName = bodyExpr.alternate.name;
+            }
+            else if (t.isUnaryExpression(bodyExpr)) {
+                returnInfo.returnValueType = 'EXPRESSION';
+                returnInfo.expressionType = 'UnaryExpression';
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                returnInfo.operator = bodyExpr.operator;
+                returnInfo.returnValueId = NodeFactory.generateExpressionId('UnaryExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                if (t.isIdentifier(bodyExpr.argument))
+                    returnInfo.unaryArgSourceName = bodyExpr.argument.name;
+            }
+            else if (t.isMemberExpression(bodyExpr)) {
+                returnInfo.returnValueType = 'EXPRESSION';
+                returnInfo.expressionType = 'MemberExpression';
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                returnInfo.returnValueId = NodeFactory.generateExpressionId('MemberExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                if (t.isIdentifier(bodyExpr.object)) {
+                    returnInfo.object = bodyExpr.object.name;
+                    returnInfo.objectSourceName = bodyExpr.object.name;
+                }
+                if (t.isIdentifier(bodyExpr.property))
+                    returnInfo.property = bodyExpr.property.name;
+                returnInfo.computed = bodyExpr.computed;
+            }
+            else {
+                // Fallback: any other expression type
+                returnInfo.returnValueType = 'EXPRESSION';
+                returnInfo.expressionType = bodyExpr.type;
+                returnInfo.returnValueLine = getLine(bodyExpr);
+                returnInfo.returnValueColumn = getColumn(bodyExpr);
+                returnInfo.returnValueId = NodeFactory.generateExpressionId(bodyExpr.type, module.file, getLine(bodyExpr), getColumn(bodyExpr));
+            }
+            returnStatements.push(returnInfo);
+        }
+        funcPath.traverse({
+            VariableDeclaration: (varPath) => {
+                this.handleVariableDeclaration(varPath, getCurrentScopeId(), module, variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker, parentScopeVariables, objectLiterals, objectProperties, objectLiteralCounterRef);
+            },
+            // Detect indexed array assignments: arr[i] = value
+            AssignmentExpression: (assignPath) => {
+                const assignNode = assignPath.node;
+                // === VARIABLE REASSIGNMENT (REG-290) ===
+                // Check if LHS is simple identifier (not obj.prop, not arr[i])
+                // Must be checked FIRST before array/object mutation handlers
+                if (assignNode.left.type === 'Identifier') {
+                    // Initialize collection if not exists
+                    if (!collections.variableReassignments) {
+                        collections.variableReassignments = [];
+                    }
+                    const variableReassignments = collections.variableReassignments;
+                    this.detectVariableReassignment(assignNode, module, variableReassignments, scopeTracker);
+                }
+                // === END VARIABLE REASSIGNMENT ===
+                // Initialize collection if not exists
+                if (!collections.arrayMutations) {
+                    collections.arrayMutations = [];
+                }
+                const arrayMutations = collections.arrayMutations;
+                // Check for indexed array assignment: arr[i] = value
+                this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker);
+                // Initialize object mutations collection if not exists
+                if (!collections.objectMutations) {
+                    collections.objectMutations = [];
+                }
+                const objectMutations = collections.objectMutations;
+                // Check for object property assignment: obj.prop = value
+                this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
+            },
+            // Handle return statements for RETURNS edges
+            ReturnStatement: (returnPath) => {
+                // Skip if we couldn't determine the function ID
+                if (!currentFunctionId) {
+                    return;
+                }
+                // Skip if this return is inside a nested function (not the function we're analyzing)
+                // Check if there's a function ancestor BETWEEN us and funcNode
+                // Stop checking once we reach funcNode - parents above funcNode are outside scope
+                let parent = returnPath.parentPath;
+                let isInsideConditional = false;
+                while (parent) {
+                    // If we've reached funcNode, we're done checking - this return belongs to funcNode
+                    if (parent.node === funcNode) {
+                        break;
+                    }
+                    if (t.isFunction(parent.node)) {
+                        // Found a function between returnPath and funcNode - this return is inside a nested function
+                        return;
+                    }
+                    // Track if return is inside a conditional block (if/else, switch case, loop, try/catch)
+                    if (t.isIfStatement(parent.node) ||
+                        t.isSwitchCase(parent.node) ||
+                        t.isLoop(parent.node) ||
+                        t.isTryStatement(parent.node) ||
+                        t.isCatchClause(parent.node)) {
+                        isInsideConditional = true;
+                    }
+                    parent = parent.parentPath;
+                }
+                // Phase 6 (REG-267): Track return count and early return detection
+                controlFlowState.returnCount++;
+                // A return is "early" if it's inside a conditional structure
+                // (More returns after this one indicate the function doesn't always end here)
+                if (isInsideConditional) {
+                    controlFlowState.hasEarlyReturn = true;
+                }
+                const returnNode = returnPath.node;
+                const returnLine = getLine(returnNode);
+                const returnColumn = getColumn(returnNode);
+                // Handle bare return; (no value)
+                if (!returnNode.argument) {
+                    // Skip - no data flow value
+                    return;
+                }
+                const arg = returnNode.argument;
+                // Determine return value type and extract relevant info
+                const returnInfo = {
+                    parentFunctionId: currentFunctionId,
+                    file: module.file,
+                    line: returnLine,
+                    column: returnColumn,
+                    returnValueType: 'NONE'
+                };
+                // Identifier (variable reference)
+                if (t.isIdentifier(arg)) {
+                    returnInfo.returnValueType = 'VARIABLE';
+                    returnInfo.returnValueName = arg.name;
+                }
+                // TemplateLiteral must come BEFORE isLiteral (TemplateLiteral extends Literal)
+                else if (t.isTemplateLiteral(arg)) {
+                    returnInfo.returnValueType = 'EXPRESSION';
+                    returnInfo.expressionType = 'TemplateLiteral';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.returnValueId = NodeFactory.generateExpressionId('TemplateLiteral', module.file, getLine(arg), getColumn(arg));
+                    // Extract all embedded expression identifiers
+                    const sourceNames = [];
+                    for (const expr of arg.expressions) {
+                        if (t.isIdentifier(expr)) {
+                            sourceNames.push(expr.name);
+                        }
+                    }
+                    if (sourceNames.length > 0) {
+                        returnInfo.expressionSourceNames = sourceNames;
+                    }
+                }
+                // Literal values (after TemplateLiteral check)
+                else if (t.isLiteral(arg)) {
+                    returnInfo.returnValueType = 'LITERAL';
+                    // Create a LITERAL node ID for this return value
+                    const literalId = `LITERAL#return#${module.file}#${returnLine}:${returnColumn}:${literalCounterRef.value++}`;
+                    returnInfo.returnValueId = literalId;
+                    // Also add to literals collection for node creation
+                    literals.push({
+                        id: literalId,
+                        type: 'LITERAL',
+                        value: ExpressionEvaluator.extractLiteralValue(arg),
+                        valueType: typeof ExpressionEvaluator.extractLiteralValue(arg),
+                        file: module.file,
+                        line: returnLine,
+                        column: returnColumn
+                    });
+                }
+                // Direct function call: return foo()
+                else if (t.isCallExpression(arg) && t.isIdentifier(arg.callee)) {
+                    returnInfo.returnValueType = 'CALL_SITE';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.returnValueCallName = arg.callee.name;
+                }
+                // Method call: return obj.method()
+                else if (t.isCallExpression(arg) && t.isMemberExpression(arg.callee)) {
+                    returnInfo.returnValueType = 'METHOD_CALL';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    // Extract method name for lookup
+                    if (t.isIdentifier(arg.callee.property)) {
+                        returnInfo.returnValueCallName = arg.callee.property.name;
+                    }
+                }
+                // BinaryExpression: return a + b
+                else if (t.isBinaryExpression(arg)) {
+                    returnInfo.returnValueType = 'EXPRESSION';
+                    returnInfo.expressionType = 'BinaryExpression';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.operator = arg.operator;
+                    // Generate stable ID for the EXPRESSION node
+                    returnInfo.returnValueId = NodeFactory.generateExpressionId('BinaryExpression', module.file, getLine(arg), getColumn(arg));
+                    // Extract left operand source
+                    if (t.isIdentifier(arg.left)) {
+                        returnInfo.leftSourceName = arg.left.name;
+                    }
+                    // Extract right operand source
+                    if (t.isIdentifier(arg.right)) {
+                        returnInfo.rightSourceName = arg.right.name;
+                    }
+                }
+                // LogicalExpression: return a && b, return a || b
+                else if (t.isLogicalExpression(arg)) {
+                    returnInfo.returnValueType = 'EXPRESSION';
+                    returnInfo.expressionType = 'LogicalExpression';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.operator = arg.operator;
+                    returnInfo.returnValueId = NodeFactory.generateExpressionId('LogicalExpression', module.file, getLine(arg), getColumn(arg));
+                    if (t.isIdentifier(arg.left)) {
+                        returnInfo.leftSourceName = arg.left.name;
+                    }
+                    if (t.isIdentifier(arg.right)) {
+                        returnInfo.rightSourceName = arg.right.name;
+                    }
+                }
+                // ConditionalExpression: return condition ? a : b
+                else if (t.isConditionalExpression(arg)) {
+                    returnInfo.returnValueType = 'EXPRESSION';
+                    returnInfo.expressionType = 'ConditionalExpression';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.returnValueId = NodeFactory.generateExpressionId('ConditionalExpression', module.file, getLine(arg), getColumn(arg));
+                    // Extract consequent (then branch) source
+                    if (t.isIdentifier(arg.consequent)) {
+                        returnInfo.consequentSourceName = arg.consequent.name;
+                    }
+                    // Extract alternate (else branch) source
+                    if (t.isIdentifier(arg.alternate)) {
+                        returnInfo.alternateSourceName = arg.alternate.name;
+                    }
+                }
+                // UnaryExpression: return !x, return -x
+                else if (t.isUnaryExpression(arg)) {
+                    returnInfo.returnValueType = 'EXPRESSION';
+                    returnInfo.expressionType = 'UnaryExpression';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.operator = arg.operator;
+                    returnInfo.returnValueId = NodeFactory.generateExpressionId('UnaryExpression', module.file, getLine(arg), getColumn(arg));
+                    if (t.isIdentifier(arg.argument)) {
+                        returnInfo.unaryArgSourceName = arg.argument.name;
+                    }
+                }
+                // MemberExpression (property access): return obj.prop
+                else if (t.isMemberExpression(arg)) {
+                    returnInfo.returnValueType = 'EXPRESSION';
+                    returnInfo.expressionType = 'MemberExpression';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.returnValueId = NodeFactory.generateExpressionId('MemberExpression', module.file, getLine(arg), getColumn(arg));
+                    // Extract object.property info
+                    if (t.isIdentifier(arg.object)) {
+                        returnInfo.object = arg.object.name;
+                        returnInfo.objectSourceName = arg.object.name;
                     }
+                    if (t.isIdentifier(arg.property)) {
+                        returnInfo.property = arg.property.name;
+                    }
+                    returnInfo.computed = arg.computed;
                 }
-                if (tryNode.finalizer) {
-                    const finallyScopeId = `SCOPE#finally-block#${module.file}#${tryNode.finalizer.loc.start.line}:${scopeCounterRef.value++}`;
-                    const finallySemanticId = this.generateSemanticId('finally-block', scopeCtx);
-                    scopes.push({
-                        id: finallyScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'finally-block',
-                        semanticId: finallySemanticId,
-                        file: module.file,
-                        line: tryNode.finalizer.loc.start.line,
-                        parentScopeId
-                    });
+                // NewExpression: return new Foo()
+                else if (t.isNewExpression(arg)) {
+                    returnInfo.returnValueType = 'EXPRESSION';
+                    returnInfo.expressionType = 'NewExpression';
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.returnValueId = NodeFactory.generateExpressionId('NewExpression', module.file, getLine(arg), getColumn(arg));
+                }
+                // Fallback for other expression types
+                else {
+                    returnInfo.returnValueType = 'EXPRESSION';
+                    returnInfo.expressionType = arg.type;
+                    returnInfo.returnValueLine = getLine(arg);
+                    returnInfo.returnValueColumn = getColumn(arg);
+                    returnInfo.returnValueId = NodeFactory.generateExpressionId(arg.type, module.file, getLine(arg), getColumn(arg));
+                }
+                returnStatements.push(returnInfo);
+            },
+            // Phase 6 (REG-267): Track throw statements for control flow metadata
+            ThrowStatement: (throwPath) => {
+                // Skip if this throw is inside a nested function (not the function we're analyzing)
+                let parent = throwPath.parentPath;
+                while (parent) {
+                    if (t.isFunction(parent.node) && parent.node !== funcNode) {
+                        // This throw is inside a nested function - skip it
+                        return;
+                    }
+                    parent = parent.parentPath;
                 }
+                controlFlowState.hasThrow = true;
             },
+            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),
             SwitchStatement: (switchPath) => {
-                const switchNode = switchPath.node;
-                const scopeId = `SCOPE#switch-case#${module.file}#${switchNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('switch-case', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'switch-case',
-                    semanticId,
-                    file: module.file,
-                    line: switchNode.loc.start.line,
-                    parentScopeId
-                });
+                this.handleSwitchStatement(switchPath, parentScopeId, module, collections, scopeTracker, controlFlowState);
             },
             FunctionExpression: (funcPath) => {
                 const node = funcPath.node;
-                const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeCtx);
-                const functionId = `FUNCTION#${funcName}#${module.file}#${node.loc.start.line}:${node.loc.start.column}:${functionCounterRef.value++}`;
+                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,
-                    stableId: functionId,
                     type: 'FUNCTION',
                     name: funcName,
                     file: module.file,
-                    line: node.loc.start.line,
-                    column: node.loc.start.column,
+                    line: getLine(node),
+                    column: getColumn(node),
                     async: node.async || false,
                     generator: node.generator || false,
                     parentScopeId
                 });
-                const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${node.loc.start.line}`;
-                const closureSemanticId = this.generateSemanticId('closure', scopeCtx);
+                const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(node)}`;
+                const closureSemanticId = this.generateSemanticId('closure', scopeTracker);
                 scopes.push({
                     id: nestedScopeId,
                     type: 'SCOPE',
@@ -1109,22 +3148,24 @@ export class JSASTAnalyzer extends Plugin {
                     semanticId: closureSemanticId,
                     conditional: false,
                     file: module.file,
-                    line: node.loc.start.line,
+                    line: getLine(node),
                     parentFunctionId: functionId,
                     capturesFrom: parentScopeId
                 });
-                // For nested function, create new context with function name as semantic path
-                const nestedFuncCtx = {
-                    semanticPath: scopeCtx ? `${scopeCtx.semanticPath}.${funcName}` : funcName,
-                    siblingCounters: new Map()
-                };
-                this.analyzeFunctionBody(funcPath, nestedScopeId, module, collections, nestedFuncCtx);
+                // Enter nested function scope for semantic ID generation
+                if (scopeTracker) {
+                    scopeTracker.enterScope(funcName, 'function');
+                }
+                this.analyzeFunctionBody(funcPath, nestedScopeId, module, collections);
+                if (scopeTracker) {
+                    scopeTracker.exitScope();
+                }
                 funcPath.skip();
             },
             ArrowFunctionExpression: (arrowPath) => {
                 const node = arrowPath.node;
-                const line = node.loc.start.line;
-                const column = node.loc.start.column;
+                const line = getLine(node);
+                const column = getColumn(node);
                 // Определяем имя (anonymous если не присвоено переменной)
                 const parent = arrowPath.parent;
                 let funcName;
@@ -1133,12 +3174,15 @@ export class JSASTAnalyzer extends Plugin {
                 }
                 else {
                     // Используем scope-level счётчик для стабильного semanticId
-                    funcName = this.generateAnonymousName(scopeCtx);
+                    funcName = this.generateAnonymousName(scopeTracker);
                 }
-                const functionId = `FUNCTION#${funcName}:${line}:${column}:${functionCounterRef.value++}`;
+                // 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,
-                    stableId: functionId,
                     type: 'FUNCTION',
                     name: funcName,
                     file: module.file,
@@ -1150,7 +3194,7 @@ export class JSASTAnalyzer extends Plugin {
                 });
                 if (node.body.type === 'BlockStatement') {
                     const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${line}`;
-                    const arrowSemanticId = this.generateSemanticId('arrow_body', scopeCtx);
+                    const arrowSemanticId = this.generateSemanticId('arrow_body', scopeTracker);
                     scopes.push({
                         id: nestedScopeId,
                         type: 'SCOPE',
@@ -1163,17 +3207,153 @@ export class JSASTAnalyzer extends Plugin {
                         parentFunctionId: functionId,
                         capturesFrom: parentScopeId
                     });
-                    // For arrow function, create new context with function name as semantic path
-                    const arrowFuncCtx = {
-                        semanticPath: scopeCtx ? `${scopeCtx.semanticPath}.${funcName}` : funcName,
-                        siblingCounters: new Map()
+                    // 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);
+                    const returnInfo = {
+                        parentFunctionId: functionId,
+                        file: module.file,
+                        line: bodyLine,
+                        column: bodyColumn,
+                        returnValueType: 'NONE',
+                        isImplicitReturn: true
                     };
-                    this.analyzeFunctionBody(arrowPath, nestedScopeId, module, collections, arrowFuncCtx);
+                    // Apply same type detection logic as ReturnStatement handler
+                    if (t.isIdentifier(bodyExpr)) {
+                        returnInfo.returnValueType = 'VARIABLE';
+                        returnInfo.returnValueName = bodyExpr.name;
+                    }
+                    // TemplateLiteral must come BEFORE isLiteral (TemplateLiteral extends Literal)
+                    else if (t.isTemplateLiteral(bodyExpr)) {
+                        returnInfo.returnValueType = 'EXPRESSION';
+                        returnInfo.expressionType = 'TemplateLiteral';
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        returnInfo.returnValueId = NodeFactory.generateExpressionId('TemplateLiteral', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                        const sourceNames = [];
+                        for (const expr of bodyExpr.expressions) {
+                            if (t.isIdentifier(expr))
+                                sourceNames.push(expr.name);
+                        }
+                        if (sourceNames.length > 0)
+                            returnInfo.expressionSourceNames = sourceNames;
+                    }
+                    else if (t.isLiteral(bodyExpr)) {
+                        returnInfo.returnValueType = 'LITERAL';
+                        const literalId = `LITERAL#implicit_return#${module.file}#${line}:${column}:${literalCounterRef.value++}`;
+                        returnInfo.returnValueId = literalId;
+                        literals.push({
+                            id: literalId,
+                            type: 'LITERAL',
+                            value: ExpressionEvaluator.extractLiteralValue(bodyExpr),
+                            valueType: typeof ExpressionEvaluator.extractLiteralValue(bodyExpr),
+                            file: module.file,
+                            line: bodyLine,
+                            column: bodyColumn
+                        });
+                    }
+                    else if (t.isCallExpression(bodyExpr) && t.isIdentifier(bodyExpr.callee)) {
+                        returnInfo.returnValueType = 'CALL_SITE';
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        returnInfo.returnValueCallName = bodyExpr.callee.name;
+                    }
+                    else if (t.isCallExpression(bodyExpr) && t.isMemberExpression(bodyExpr.callee)) {
+                        returnInfo.returnValueType = 'METHOD_CALL';
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        if (t.isIdentifier(bodyExpr.callee.property)) {
+                            returnInfo.returnValueCallName = bodyExpr.callee.property.name;
+                        }
+                    }
+                    // REG-276: Detailed EXPRESSION handling for nested implicit arrow returns
+                    else if (t.isBinaryExpression(bodyExpr)) {
+                        returnInfo.returnValueType = 'EXPRESSION';
+                        returnInfo.expressionType = 'BinaryExpression';
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        returnInfo.operator = bodyExpr.operator;
+                        returnInfo.returnValueId = NodeFactory.generateExpressionId('BinaryExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                        if (t.isIdentifier(bodyExpr.left))
+                            returnInfo.leftSourceName = bodyExpr.left.name;
+                        if (t.isIdentifier(bodyExpr.right))
+                            returnInfo.rightSourceName = bodyExpr.right.name;
+                    }
+                    else if (t.isLogicalExpression(bodyExpr)) {
+                        returnInfo.returnValueType = 'EXPRESSION';
+                        returnInfo.expressionType = 'LogicalExpression';
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        returnInfo.operator = bodyExpr.operator;
+                        returnInfo.returnValueId = NodeFactory.generateExpressionId('LogicalExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                        if (t.isIdentifier(bodyExpr.left))
+                            returnInfo.leftSourceName = bodyExpr.left.name;
+                        if (t.isIdentifier(bodyExpr.right))
+                            returnInfo.rightSourceName = bodyExpr.right.name;
+                    }
+                    else if (t.isConditionalExpression(bodyExpr)) {
+                        returnInfo.returnValueType = 'EXPRESSION';
+                        returnInfo.expressionType = 'ConditionalExpression';
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        returnInfo.returnValueId = NodeFactory.generateExpressionId('ConditionalExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                        if (t.isIdentifier(bodyExpr.consequent))
+                            returnInfo.consequentSourceName = bodyExpr.consequent.name;
+                        if (t.isIdentifier(bodyExpr.alternate))
+                            returnInfo.alternateSourceName = bodyExpr.alternate.name;
+                    }
+                    else if (t.isUnaryExpression(bodyExpr)) {
+                        returnInfo.returnValueType = 'EXPRESSION';
+                        returnInfo.expressionType = 'UnaryExpression';
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        returnInfo.operator = bodyExpr.operator;
+                        returnInfo.returnValueId = NodeFactory.generateExpressionId('UnaryExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                        if (t.isIdentifier(bodyExpr.argument))
+                            returnInfo.unaryArgSourceName = bodyExpr.argument.name;
+                    }
+                    else if (t.isMemberExpression(bodyExpr)) {
+                        returnInfo.returnValueType = 'EXPRESSION';
+                        returnInfo.expressionType = 'MemberExpression';
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        returnInfo.returnValueId = NodeFactory.generateExpressionId('MemberExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                        if (t.isIdentifier(bodyExpr.object)) {
+                            returnInfo.object = bodyExpr.object.name;
+                            returnInfo.objectSourceName = bodyExpr.object.name;
+                        }
+                        if (t.isIdentifier(bodyExpr.property))
+                            returnInfo.property = bodyExpr.property.name;
+                        returnInfo.computed = bodyExpr.computed;
+                    }
+                    else {
+                        returnInfo.returnValueType = 'EXPRESSION';
+                        returnInfo.expressionType = bodyExpr.type;
+                        returnInfo.returnValueLine = getLine(bodyExpr);
+                        returnInfo.returnValueColumn = getColumn(bodyExpr);
+                        returnInfo.returnValueId = NodeFactory.generateExpressionId(bodyExpr.type, module.file, getLine(bodyExpr), getColumn(bodyExpr));
+                    }
+                    returnStatements.push(returnInfo);
                 }
                 arrowPath.skip();
             },
             UpdateExpression: (updatePath) => {
                 const updateNode = updatePath.node;
+                // REG-288/REG-312: Collect update expression info for graph building
+                this.collectUpdateExpression(updateNode, module, updateExpressions, getCurrentScopeId(), scopeTracker);
+                // Legacy behavior: update scope.modifies for IDENTIFIER targets
                 if (updateNode.argument.type === 'Identifier') {
                     const varName = updateNode.argument.name;
                     // Find variable by name - could be from parent scope or declarations
@@ -1188,191 +3368,938 @@ export class JSASTAnalyzer extends Plugin {
                             scope.modifies.push({
                                 variableId: variable.id,
                                 variableName: varName,
-                                line: updateNode.loc.start.line
+                                line: getLine(updateNode)
                             });
                         }
                     }
                 }
             },
             // IF statements - создаём условные scope и обходим содержимое для CALL узлов
-            IfStatement: (ifPath) => {
-                const ifNode = ifPath.node;
-                const sourceCode = collections.code ?? '';
-                const condition = sourceCode.substring(ifNode.test.start, ifNode.test.end) || 'condition';
-                const counterId = ifScopeCounterRef.value++;
-                const ifScopeId = `SCOPE#if#${module.file}#${ifNode.loc.start.line}:${ifNode.loc.start.column}:${counterId}`;
-                // Parse condition to extract constraints
-                const constraints = ConditionParser.parse(ifNode.test);
-                const ifSemanticId = this.generateSemanticId('if_statement', scopeCtx);
-                scopes.push({
-                    id: ifScopeId,
-                    type: 'SCOPE',
-                    scopeType: 'if_statement',
-                    name: `if:${ifNode.loc.start.line}:${ifNode.loc.start.column}:${counterId}`,
-                    semanticId: ifSemanticId,
-                    conditional: true,
-                    condition,
-                    constraints: constraints.length > 0 ? constraints : undefined,
-                    file: module.file,
-                    line: ifNode.loc.start.line,
-                    parentScopeId
-                });
-                // Обходим содержимое if-блока (consequent)
-                ifPath.get('consequent').traverse({
-                    CallExpression: (callPath) => {
-                        const callNode = callPath.node;
-                        if (callNode.callee.type === 'Identifier') {
-                            const nodeKey = `${callNode.start}:${callNode.end}`;
-                            if (processedCallSites.has(nodeKey)) {
-                                return;
-                            }
-                            processedCallSites.add(nodeKey);
-                            callSites.push({
-                                id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                                type: 'CALL',
-                                name: callNode.callee.name,
-                                file: module.file,
-                                line: callNode.loc.start.line,
-                                parentScopeId: ifScopeId,
-                                targetFunctionName: callNode.callee.name
-                            });
-                        }
-                    },
-                    NewExpression: (newPath) => {
-                        const newNode = newPath.node;
-                        if (newNode.callee.type === 'Identifier') {
-                            const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                            if (processedCallSites.has(nodeKey)) {
-                                return;
+            // 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) => {
+                this.handleCallExpression(callPath.node, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, getCurrentScopeId(), collections);
+                // REG-334: Check for resolve/reject calls inside Promise executors
+                const callNode = callPath.node;
+                if (t.isIdentifier(callNode.callee)) {
+                    const calleeName = callNode.callee.name;
+                    // Walk up function parents to find Promise executor context
+                    // This handles nested callbacks like: new Promise((resolve) => { db.query((err, data) => { resolve(data); }); });
+                    let funcParent = callPath.getFunctionParent();
+                    while (funcParent) {
+                        const funcNode = funcParent.node;
+                        const funcKey = `${funcNode.start}:${funcNode.end}`;
+                        const context = promiseExecutorContexts.get(funcKey);
+                        if (context) {
+                            const isResolve = calleeName === context.resolveName;
+                            const isReject = calleeName === context.rejectName;
+                            if (isResolve || isReject) {
+                                // Find the CALL node ID for this resolve/reject call
+                                // It was just added by handleCallExpression
+                                const callLine = getLine(callNode);
+                                const callColumn = getColumn(callNode);
+                                // Find matching call site that was just added
+                                const resolveCall = callSites.find(cs => cs.name === calleeName &&
+                                    cs.file === module.file &&
+                                    cs.line === callLine &&
+                                    cs.column === callColumn);
+                                if (resolveCall) {
+                                    promiseResolutions.push({
+                                        callId: resolveCall.id,
+                                        constructorCallId: context.constructorCallId,
+                                        isReject,
+                                        file: module.file,
+                                        line: callLine
+                                    });
+                                    // REG-334: Collect arguments for resolve/reject calls
+                                    // This enables traceValues to follow PASSES_ARGUMENT edges
+                                    if (!collections.callArguments) {
+                                        collections.callArguments = [];
+                                    }
+                                    const callArgumentsArr = collections.callArguments;
+                                    // Process arguments (typically just one: resolve(value))
+                                    callNode.arguments.forEach((arg, argIndex) => {
+                                        const argInfo = {
+                                            callId: resolveCall.id,
+                                            argIndex,
+                                            file: module.file,
+                                            line: getLine(arg),
+                                            column: getColumn(arg)
+                                        };
+                                        // Handle different argument types
+                                        if (t.isIdentifier(arg)) {
+                                            argInfo.targetType = 'VARIABLE';
+                                            argInfo.targetName = arg.name;
+                                        }
+                                        else if (t.isLiteral(arg) && !t.isTemplateLiteral(arg)) {
+                                            // Create LITERAL node for the argument value
+                                            const literalValue = ExpressionEvaluator.extractLiteralValue(arg);
+                                            if (literalValue !== null) {
+                                                const argLine = getLine(arg);
+                                                const argColumn = getColumn(arg);
+                                                const literalId = `LITERAL#arg${argIndex}#${module.file}#${argLine}:${argColumn}:${literalCounterRef.value++}`;
+                                                literals.push({
+                                                    id: literalId,
+                                                    type: 'LITERAL',
+                                                    value: literalValue,
+                                                    valueType: typeof literalValue,
+                                                    file: module.file,
+                                                    line: argLine,
+                                                    column: argColumn,
+                                                    parentCallId: resolveCall.id,
+                                                    argIndex
+                                                });
+                                                argInfo.targetType = 'LITERAL';
+                                                argInfo.targetId = literalId;
+                                                argInfo.literalValue = literalValue;
+                                            }
+                                        }
+                                        else if (t.isCallExpression(arg)) {
+                                            argInfo.targetType = 'CALL';
+                                            argInfo.nestedCallLine = getLine(arg);
+                                            argInfo.nestedCallColumn = getColumn(arg);
+                                        }
+                                        else {
+                                            argInfo.targetType = 'EXPRESSION';
+                                            argInfo.expressionType = arg.type;
+                                        }
+                                        callArgumentsArr.push(argInfo);
+                                    });
+                                }
+                                break; // Found context, stop searching
                             }
-                            processedCallSites.add(nodeKey);
-                            callSites.push({
-                                id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                                type: 'CALL',
-                                name: newNode.callee.name,
-                                file: module.file,
-                                line: newNode.loc.start.line,
-                                parentScopeId: ifScopeId,
-                                targetFunctionName: newNode.callee.name,
-                                isNew: true
-                            });
                         }
+                        funcParent = funcParent.getFunctionParent();
                     }
-                });
-                // Handle else branch if present
-                if (ifNode.alternate) {
-                    const elseCounterId = ifScopeCounterRef.value++;
-                    const elseScopeId = `SCOPE#else#${module.file}#${ifNode.alternate.loc.start.line}:${ifNode.alternate.loc.start.column}:${elseCounterId}`;
-                    // Negate constraints for else branch
-                    const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
-                    const elseSemanticId = this.generateSemanticId('else_statement', scopeCtx);
-                    scopes.push({
-                        id: elseScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'else_statement',
-                        name: `else:${ifNode.alternate.loc.start.line}:${ifNode.alternate.loc.start.column}:${elseCounterId}`,
-                        semanticId: elseSemanticId,
-                        conditional: true,
-                        constraints: negatedConstraints,
-                        file: module.file,
-                        line: ifNode.alternate.loc.start.line,
-                        parentScopeId
-                    });
-                    // Traverse else block
-                    ifPath.get('alternate').traverse({
-                        CallExpression: (callPath) => {
-                            const callNode = callPath.node;
-                            if (callNode.callee.type === 'Identifier') {
-                                const nodeKey = `${callNode.start}:${callNode.end}`;
-                                if (processedCallSites.has(nodeKey)) {
-                                    return;
+                }
+            },
+            // NewExpression (constructor calls)
+            NewExpression: (newPath) => {
+                const newNode = newPath.node;
+                const nodeKey = `new:${newNode.start}:${newNode.end}`;
+                // Determine className from callee
+                let className = null;
+                if (newNode.callee.type === 'Identifier') {
+                    className = newNode.callee.name;
+                }
+                else if (newNode.callee.type === 'MemberExpression' && newNode.callee.property.type === 'Identifier') {
+                    className = newNode.callee.property.name;
+                }
+                // Create CONSTRUCTOR_CALL node (always, for all NewExpressions)
+                if (className) {
+                    const constructorKey = `constructor:${nodeKey}`;
+                    if (!processedCallSites.has(constructorKey)) {
+                        processedCallSites.add(constructorKey);
+                        const line = getLine(newNode);
+                        const column = getColumn(newNode);
+                        const constructorCallId = ConstructorCallNode.generateId(className, module.file, line, column);
+                        const isBuiltin = ConstructorCallNode.isBuiltinConstructor(className);
+                        constructorCalls.push({
+                            id: constructorCallId,
+                            type: 'CONSTRUCTOR_CALL',
+                            className,
+                            isBuiltin,
+                            file: module.file,
+                            line,
+                            column
+                        });
+                        // REG-334: If this is Promise constructor with executor callback,
+                        // register the context for resolve/reject detection
+                        if (className === 'Promise' && newNode.arguments.length > 0) {
+                            const executorArg = newNode.arguments[0];
+                            // Only handle inline function expressions (not variable references)
+                            if (t.isArrowFunctionExpression(executorArg) || t.isFunctionExpression(executorArg)) {
+                                // Extract resolve/reject parameter names
+                                let resolveName;
+                                let rejectName;
+                                if (executorArg.params.length > 0 && t.isIdentifier(executorArg.params[0])) {
+                                    resolveName = executorArg.params[0].name;
                                 }
-                                processedCallSites.add(nodeKey);
-                                callSites.push({
-                                    id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                                    type: 'CALL',
-                                    name: callNode.callee.name,
-                                    file: module.file,
-                                    line: callNode.loc.start.line,
-                                    parentScopeId: elseScopeId,
-                                    targetFunctionName: callNode.callee.name
-                                });
-                            }
-                        },
-                        NewExpression: (newPath) => {
-                            const newNode = newPath.node;
-                            if (newNode.callee.type === 'Identifier') {
-                                const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                                if (processedCallSites.has(nodeKey)) {
-                                    return;
+                                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
+                                    });
                                 }
-                                processedCallSites.add(nodeKey);
-                                callSites.push({
-                                    id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                                    type: 'CALL',
-                                    name: newNode.callee.name,
-                                    file: module.file,
-                                    line: newNode.loc.start.line,
-                                    parentScopeId: elseScopeId,
-                                    targetFunctionName: newNode.callee.name,
-                                    isNew: true
-                                });
                             }
                         }
+                    }
+                }
+                // 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
                     });
                 }
-                // Останавливаем дальнейший обход, чтобы не обрабатывать вызовы дважды
-                ifPath.skip();
-            },
-            // Вызовы функций на безусловном уровне (вне if/for/while)
-            CallExpression: (callPath) => {
-                // Проверяем что вызов не внутри if/for/while (их мы обрабатываем отдельно)
-                const parent = callPath.parent;
-                if (parent.type !== 'IfStatement' && parent.type !== 'ForStatement' && parent.type !== 'WhileStatement') {
-                    const callNode = callPath.node;
-                    // Обычные вызовы функций (greet(), main())
-                    if (callNode.callee.type === 'Identifier') {
-                        const nodeKey = `${callNode.start}:${callNode.end}`;
-                        if (processedCallSites.has(nodeKey)) {
+                // 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;
                         }
-                        processedCallSites.add(nodeKey);
-                        callSites.push({
-                            id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`,
+                        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: callNode.callee.name,
+                            name: fullName,
+                            object: objectName,
+                            method: constructorName,
                             file: module.file,
-                            line: callNode.loc.start.line,
-                            parentScopeId,
-                            targetFunctionName: callNode.callee.name
+                            line: getLine(newNode),
+                            column: getColumn(newNode),
+                            parentScopeId: getCurrentScopeId(),
+                            isNew: true
                         });
                     }
                 }
-            },
-            // NewExpression на безусловном уровне
-            NewExpression: (newPath) => {
-                const parent = newPath.parent;
-                if (parent.type !== 'IfStatement' && parent.type !== 'ForStatement' && parent.type !== 'WhileStatement') {
-                    const newNode = newPath.node;
-                    if (newNode.callee.type === 'Identifier') {
-                        const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                        if (processedCallSites.has(nodeKey)) {
-                            return;
+            }
+        });
+        // 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;
+            matchingFunction.controlFlow = {
+                hasBranches: controlFlowState.branchCount > 0,
+                hasLoops: controlFlowState.loopCount > 0,
+                hasTryCatch: controlFlowState.hasTryCatch,
+                hasEarlyReturn: controlFlowState.hasEarlyReturn,
+                hasThrow: controlFlowState.hasThrow,
+                cyclomaticComplexity
+            };
+        }
+    }
+    /**
+     * Handle CallExpression nodes: direct function calls (greet(), main())
+     * and method calls (obj.method(), data.process()).
+     *
+     * Handles:
+     * - Direct function calls (Identifier callee) → callSites collection
+     * - Method calls (MemberExpression callee) → methodCalls collection
+     * - Array mutation detection (push, unshift, splice)
+     * - Object.assign() detection
+     *
+     * @param callNode - The call expression AST node
+     * @param processedCallSites - Set of already processed call site keys to avoid duplicates
+     * @param processedMethodCalls - Set of already processed method call keys to avoid duplicates
+     * @param callSites - Collection for direct function calls
+     * @param methodCalls - Collection for method calls
+     * @param module - Current module being analyzed
+     * @param callSiteCounterRef - Counter for legacy ID generation
+     * @param scopeTracker - Optional scope tracker for semantic ID generation
+     * @param parentScopeId - ID of the parent scope containing this call
+     * @param collections - Full collections object for array/object mutations
+     */
+    handleCallExpression(callNode, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, parentScopeId, collections) {
+        // Handle direct function calls (greet(), main())
+        if (callNode.callee.type === 'Identifier') {
+            const nodeKey = `${callNode.start}:${callNode.end}`;
+            if (processedCallSites.has(nodeKey)) {
+                return;
+            }
+            processedCallSites.add(nodeKey);
+            // Generate semantic ID (primary) or legacy ID (fallback)
+            const calleeName = callNode.callee.name;
+            const legacyId = `CALL#${calleeName}#${module.file}#${getLine(callNode)}:${getColumn(callNode)}:${callSiteCounterRef.value++}`;
+            let callId = legacyId;
+            if (scopeTracker) {
+                const discriminator = scopeTracker.getItemCounter(`CALL:${calleeName}`);
+                callId = computeSemanticId('CALL', calleeName, scopeTracker.getContext(), { discriminator });
+            }
+            callSites.push({
+                id: callId,
+                type: 'CALL',
+                name: calleeName,
+                file: module.file,
+                line: getLine(callNode),
+                column: getColumn(callNode), // REG-223: Add column for coordinate-based lookup
+                parentScopeId,
+                targetFunctionName: calleeName
+            });
+        }
+        // Handle method calls (obj.method(), data.process())
+        else if (callNode.callee.type === 'MemberExpression') {
+            const memberCallee = callNode.callee;
+            const object = memberCallee.object;
+            const property = memberCallee.property;
+            const isComputed = memberCallee.computed;
+            if ((object.type === 'Identifier' || object.type === 'ThisExpression') && property.type === 'Identifier') {
+                const nodeKey = `${callNode.start}:${callNode.end}`;
+                if (processedMethodCalls.has(nodeKey)) {
+                    return;
+                }
+                processedMethodCalls.add(nodeKey);
+                const objectName = object.type === 'Identifier' ? object.name : 'this';
+                const methodName = isComputed ? '<computed>' : property.name;
+                const fullName = `${objectName}.${methodName}`;
+                // Generate semantic ID (primary) or legacy ID (fallback)
+                const legacyId = `CALL#${fullName}#${module.file}#${getLine(callNode)}:${getColumn(callNode)}:${callSiteCounterRef.value++}`;
+                let methodCallId = legacyId;
+                if (scopeTracker) {
+                    const discriminator = scopeTracker.getItemCounter(`CALL:${fullName}`);
+                    methodCallId = computeSemanticId('CALL', fullName, scopeTracker.getContext(), { discriminator });
+                }
+                methodCalls.push({
+                    id: methodCallId,
+                    type: 'CALL',
+                    name: fullName,
+                    object: objectName,
+                    method: methodName,
+                    computed: isComputed,
+                    computedPropertyVar: isComputed ? property.name : null,
+                    file: module.file,
+                    line: getLine(callNode),
+                    column: getColumn(callNode),
+                    parentScopeId
+                });
+                // Check for array mutation methods (push, unshift, splice)
+                const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+                if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+                    // Initialize collection if not exists
+                    if (!collections.arrayMutations) {
+                        collections.arrayMutations = [];
+                    }
+                    const arrayMutations = collections.arrayMutations;
+                    this.detectArrayMutationInFunction(callNode, objectName, methodName, module, arrayMutations, scopeTracker);
+                }
+                // Check for Object.assign() calls
+                if (objectName === 'Object' && methodName === 'assign') {
+                    // Initialize collection if not exists
+                    if (!collections.objectMutations) {
+                        collections.objectMutations = [];
+                    }
+                    const objectMutations = collections.objectMutations;
+                    this.detectObjectAssignInFunction(callNode, module, objectMutations, scopeTracker);
+                }
+            }
+            // REG-117: Nested array mutations like obj.arr.push(item)
+            // object is MemberExpression, property is the method name
+            else if (object.type === 'MemberExpression' && property.type === 'Identifier') {
+                const nestedMember = object;
+                const methodName = property.name;
+                const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+                if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+                    // Extract base object and property from nested MemberExpression
+                    const base = nestedMember.object;
+                    const prop = nestedMember.property;
+                    // Only handle single-level nesting: obj.arr.push() or this.items.push()
+                    if ((base.type === 'Identifier' || base.type === 'ThisExpression') &&
+                        !nestedMember.computed &&
+                        prop.type === 'Identifier') {
+                        const baseObjectName = base.type === 'Identifier' ? base.name : 'this';
+                        const propertyName = prop.name;
+                        // Initialize collection if not exists
+                        if (!collections.arrayMutations) {
+                            collections.arrayMutations = [];
                         }
-                        processedCallSites.add(nodeKey);
-                        callSites.push({
-                            id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                            type: 'CALL',
-                            name: newNode.callee.name,
-                            file: module.file,
-                            line: newNode.loc.start.line,
-                            parentScopeId,
-                            targetFunctionName: newNode.callee.name,
-                            isNew: true
-                        });
+                        const arrayMutations = collections.arrayMutations;
+                        this.detectArrayMutationInFunction(callNode, `${baseObjectName}.${propertyName}`, // arrayName for ID purposes
+                        methodName, module, arrayMutations, scopeTracker, true, // isNested
+                        baseObjectName, propertyName);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Detect array mutation calls (push, unshift, splice) inside functions
+     * and collect mutation info for FLOWS_INTO edge creation in GraphBuilder
+     *
+     * REG-117: Added isNested, baseObjectName, propertyName for nested mutations
+     *
+     * @param callNode - The call expression node
+     * @param arrayName - Name of the array being mutated
+     * @param method - The mutation method (push, unshift, splice)
+     * @param module - Current module being analyzed
+     * @param arrayMutations - Collection to push mutation info into
+     * @param scopeTracker - Optional scope tracker for semantic IDs
+     * @param isNested - REG-117: true if this is a nested mutation (obj.arr.push)
+     * @param baseObjectName - REG-117: base object name for nested mutations
+     * @param propertyName - REG-117: property name for nested mutations
+     */
+    detectArrayMutationInFunction(callNode, arrayName, method, module, arrayMutations, scopeTracker, isNested, baseObjectName, propertyName) {
+        const mutationArgs = [];
+        // For splice, only arguments from index 2 onwards are insertions
+        // splice(start, deleteCount, item1, item2, ...)
+        callNode.arguments.forEach((arg, index) => {
+            // Skip start and deleteCount for splice
+            if (method === 'splice' && index < 2)
+                return;
+            const argInfo = {
+                argIndex: method === 'splice' ? index - 2 : index,
+                isSpread: arg.type === 'SpreadElement',
+                valueType: 'EXPRESSION' // Default
+            };
+            let actualArg = arg;
+            if (arg.type === 'SpreadElement') {
+                actualArg = arg.argument;
+            }
+            // Determine value type
+            const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
+            if (literalValue !== null) {
+                argInfo.valueType = 'LITERAL';
+                argInfo.literalValue = literalValue;
+            }
+            else if (actualArg.type === 'Identifier') {
+                argInfo.valueType = 'VARIABLE';
+                argInfo.valueName = actualArg.name;
+            }
+            else if (actualArg.type === 'ObjectExpression') {
+                argInfo.valueType = 'OBJECT_LITERAL';
+            }
+            else if (actualArg.type === 'ArrayExpression') {
+                argInfo.valueType = 'ARRAY_LITERAL';
+            }
+            else if (actualArg.type === 'CallExpression') {
+                argInfo.valueType = 'CALL';
+                argInfo.callLine = actualArg.loc?.start.line;
+                argInfo.callColumn = actualArg.loc?.start.column;
+            }
+            mutationArgs.push(argInfo);
+        });
+        // Only record if there are actual insertions
+        if (mutationArgs.length > 0) {
+            const line = callNode.loc?.start.line ?? 0;
+            const column = callNode.loc?.start.column ?? 0;
+            // Generate semantic ID for array mutation if scopeTracker available
+            let mutationId;
+            if (scopeTracker) {
+                const discriminator = scopeTracker.getItemCounter(`ARRAY_MUTATION:${arrayName}.${method}`);
+                mutationId = computeSemanticId('ARRAY_MUTATION', `${arrayName}.${method}`, scopeTracker.getContext(), { discriminator });
+            }
+            arrayMutations.push({
+                id: mutationId,
+                arrayName,
+                mutationMethod: method,
+                file: module.file,
+                line,
+                column,
+                insertedValues: mutationArgs,
+                // REG-117: Nested mutation fields
+                isNested,
+                baseObjectName,
+                propertyName
+            });
+        }
+    }
+    /**
+     * Detect indexed array assignment: arr[i] = value
+     * Creates ArrayMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+     *
+     * @param assignNode - The assignment expression node
+     * @param module - Current module being analyzed
+     * @param arrayMutations - Collection to push mutation info into
+     */
+    detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker) {
+        // Check for indexed array assignment: arr[i] = value
+        if (assignNode.left.type === 'MemberExpression' && assignNode.left.computed) {
+            const memberExpr = assignNode.left;
+            // Only process NumericLiteral keys - those are clearly array indexed assignments
+            // e.g., arr[0] = value, arr[1] = value
+            // All other computed keys (StringLiteral, Identifier, expressions) are handled as object mutations
+            // This avoids duplicate edge creation for ambiguous cases like obj[key] = value
+            if (memberExpr.property.type !== 'NumericLiteral') {
+                return;
+            }
+            // Get array name (only simple identifiers for now)
+            if (memberExpr.object.type === 'Identifier') {
+                const arrayName = memberExpr.object.name;
+                const value = assignNode.right;
+                const argInfo = {
+                    argIndex: 0,
+                    isSpread: false,
+                    valueType: 'EXPRESSION'
+                };
+                // Determine value type
+                const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+                if (literalValue !== null) {
+                    argInfo.valueType = 'LITERAL';
+                    argInfo.literalValue = literalValue;
+                }
+                else if (value.type === 'Identifier') {
+                    argInfo.valueType = 'VARIABLE';
+                    argInfo.valueName = value.name;
+                }
+                else if (value.type === 'ObjectExpression') {
+                    argInfo.valueType = 'OBJECT_LITERAL';
+                }
+                else if (value.type === 'ArrayExpression') {
+                    argInfo.valueType = 'ARRAY_LITERAL';
+                }
+                else if (value.type === 'CallExpression') {
+                    argInfo.valueType = 'CALL';
+                    argInfo.callLine = value.loc?.start.line;
+                    argInfo.callColumn = value.loc?.start.column;
+                }
+                // Use defensive loc checks instead of ! assertions
+                const line = assignNode.loc?.start.line ?? 0;
+                const column = assignNode.loc?.start.column ?? 0;
+                // Capture scope path for scope-aware lookup (REG-309)
+                const scopePath = scopeTracker?.getContext().scopePath ?? [];
+                arrayMutations.push({
+                    arrayName,
+                    mutationScopePath: scopePath,
+                    mutationMethod: 'indexed',
+                    file: module.file,
+                    line: line,
+                    column: column,
+                    insertedValues: [argInfo]
+                });
+            }
+        }
+    }
+    /**
+     * Detect object property assignment: obj.prop = value, obj['prop'] = value
+     * Creates ObjectMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+     *
+     * @param assignNode - The assignment expression node
+     * @param module - Current module being analyzed
+     * @param objectMutations - Collection to push mutation info into
+     * @param scopeTracker - Optional scope tracker for semantic IDs
+     */
+    detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker) {
+        // Check for property assignment: obj.prop = value or obj['prop'] = value
+        if (assignNode.left.type !== 'MemberExpression')
+            return;
+        const memberExpr = assignNode.left;
+        // Skip NumericLiteral indexed assignment (handled by array mutation handler)
+        // Array mutation handler processes: arr[0] (numeric literal index)
+        // Object mutation handler processes: obj.prop, obj['prop'], obj[key], obj[expr]
+        if (memberExpr.computed && memberExpr.property.type === 'NumericLiteral') {
+            return; // Let array mutation handler deal with this
+        }
+        // Get object name and enclosing class context for 'this'
+        let objectName;
+        let enclosingClassName;
+        if (memberExpr.object.type === 'Identifier') {
+            objectName = memberExpr.object.name;
+        }
+        else if (memberExpr.object.type === 'ThisExpression') {
+            objectName = 'this';
+            // REG-152: Extract enclosing class name from scope context
+            if (scopeTracker) {
+                enclosingClassName = scopeTracker.getEnclosingScope('CLASS');
+            }
+        }
+        else {
+            // Complex expressions like obj.nested.prop = value
+            // For now, skip these (documented limitation)
+            return;
+        }
+        // Get property name
+        let propertyName;
+        let mutationType;
+        let computedPropertyVar;
+        if (!memberExpr.computed) {
+            // obj.prop
+            if (memberExpr.property.type === 'Identifier') {
+                propertyName = memberExpr.property.name;
+                mutationType = 'property';
+            }
+            else {
+                return; // Unexpected property type
+            }
+        }
+        else {
+            // obj['prop'] or obj[key]
+            if (memberExpr.property.type === 'StringLiteral') {
+                propertyName = memberExpr.property.value;
+                mutationType = 'property'; // String literal is effectively a property name
+            }
+            else {
+                propertyName = '<computed>';
+                mutationType = 'computed';
+                // Capture variable name for later resolution in enrichment phase
+                if (memberExpr.property.type === 'Identifier') {
+                    computedPropertyVar = memberExpr.property.name;
+                }
+            }
+        }
+        // Extract value info
+        const value = assignNode.right;
+        const valueInfo = this.extractMutationValue(value);
+        // Use defensive loc checks
+        const line = assignNode.loc?.start.line ?? 0;
+        const column = assignNode.loc?.start.column ?? 0;
+        // Capture scope path for scope-aware lookup (REG-309)
+        const scopePath = scopeTracker?.getContext().scopePath ?? [];
+        // Generate semantic ID if scopeTracker available
+        let mutationId;
+        if (scopeTracker) {
+            const discriminator = scopeTracker.getItemCounter(`OBJECT_MUTATION:${objectName}.${propertyName}`);
+            mutationId = computeSemanticId('OBJECT_MUTATION', `${objectName}.${propertyName}`, scopeTracker.getContext(), { discriminator });
+        }
+        objectMutations.push({
+            id: mutationId,
+            objectName,
+            mutationScopePath: scopePath,
+            enclosingClassName, // REG-152: Class name for 'this' mutations
+            propertyName,
+            mutationType,
+            computedPropertyVar,
+            file: module.file,
+            line,
+            column,
+            value: valueInfo
+        });
+    }
+    /**
+     * Collect update expression info for graph building (i++, obj.prop++, arr[i]++).
+     *
+     * REG-288: Simple identifiers (i++, --count)
+     * REG-312: Member expressions (obj.prop++, arr[i]++, this.count++)
+     *
+     * Creates UpdateExpressionInfo entries that GraphBuilder uses to create:
+     * - UPDATE_EXPRESSION nodes
+     * - MODIFIES edges to target variables/objects
+     * - READS_FROM self-loops
+     * - CONTAINS edges for scope hierarchy
+     */
+    collectUpdateExpression(updateNode, module, updateExpressions, parentScopeId, scopeTracker) {
+        const operator = updateNode.operator;
+        const prefix = updateNode.prefix;
+        const line = getLine(updateNode);
+        const column = getColumn(updateNode);
+        // CASE 1: Simple identifier (i++, --count) - REG-288 behavior
+        if (updateNode.argument.type === 'Identifier') {
+            const variableName = updateNode.argument.name;
+            updateExpressions.push({
+                targetType: 'IDENTIFIER',
+                variableName,
+                variableLine: getLine(updateNode.argument),
+                operator,
+                prefix,
+                file: module.file,
+                line,
+                column,
+                parentScopeId
+            });
+            return;
+        }
+        // CASE 2: Member expression (obj.prop++, arr[i]++) - REG-312 new
+        if (updateNode.argument.type === 'MemberExpression') {
+            const memberExpr = updateNode.argument;
+            // Extract object name (reuses detectObjectPropertyAssignment pattern)
+            let objectName;
+            let enclosingClassName;
+            if (memberExpr.object.type === 'Identifier') {
+                objectName = memberExpr.object.name;
+            }
+            else if (memberExpr.object.type === 'ThisExpression') {
+                objectName = 'this';
+                // REG-152: Extract enclosing class name from scope context
+                if (scopeTracker) {
+                    enclosingClassName = scopeTracker.getEnclosingScope('CLASS');
+                }
+            }
+            else {
+                // Complex expressions: obj.nested.prop++, (obj || fallback).count++
+                // Skip for now (documented limitation, same as detectObjectPropertyAssignment)
+                return;
+            }
+            // Extract property name (reuses detectObjectPropertyAssignment pattern)
+            let propertyName;
+            let mutationType;
+            let computedPropertyVar;
+            if (!memberExpr.computed) {
+                // obj.prop++
+                if (memberExpr.property.type === 'Identifier') {
+                    propertyName = memberExpr.property.name;
+                    mutationType = 'property';
+                }
+                else {
+                    return; // Unexpected property type
+                }
+            }
+            else {
+                // obj['prop']++ or obj[key]++
+                if (memberExpr.property.type === 'StringLiteral') {
+                    // obj['prop']++ - static string
+                    propertyName = memberExpr.property.value;
+                    mutationType = 'property';
+                }
+                else {
+                    // obj[key]++, arr[i]++ - computed property
+                    propertyName = '<computed>';
+                    mutationType = 'computed';
+                    if (memberExpr.property.type === 'Identifier') {
+                        computedPropertyVar = memberExpr.property.name;
                     }
                 }
             }
+            updateExpressions.push({
+                targetType: 'MEMBER_EXPRESSION',
+                objectName,
+                objectLine: getLine(memberExpr.object),
+                enclosingClassName,
+                propertyName,
+                mutationType,
+                computedPropertyVar,
+                operator,
+                prefix,
+                file: module.file,
+                line,
+                column,
+                parentScopeId
+            });
+        }
+    }
+    /**
+     * Detect variable reassignment for FLOWS_INTO edge creation.
+     * Handles all assignment operators: =, +=, -=, *=, /=, etc.
+     *
+     * Captures COMPLETE metadata for:
+     * - LITERAL values (literalValue field)
+     * - EXPRESSION nodes (expressionType, expressionMetadata fields)
+     * - VARIABLE, CALL_SITE, METHOD_CALL references
+     *
+     * REG-290: No deferred functionality - all value types captured.
+     */
+    detectVariableReassignment(assignNode, module, variableReassignments, scopeTracker) {
+        // LHS must be simple identifier (checked by caller)
+        const leftId = assignNode.left;
+        const variableName = leftId.name;
+        const operator = assignNode.operator; // '=', '+=', '-=', etc.
+        // Get RHS value info
+        const rightExpr = assignNode.right;
+        const line = getLine(assignNode);
+        const column = getColumn(assignNode);
+        // Extract value source (similar to VariableVisitor pattern)
+        let valueType;
+        let valueName;
+        let valueId = null;
+        let callLine;
+        let callColumn;
+        // Complete metadata for node creation
+        let literalValue;
+        let expressionType;
+        let expressionMetadata;
+        // 1. Literal value
+        const extractedLiteralValue = ExpressionEvaluator.extractLiteralValue(rightExpr);
+        if (extractedLiteralValue !== null) {
+            valueType = 'LITERAL';
+            valueId = `LITERAL#${line}:${rightExpr.start}#${module.file}`;
+            literalValue = extractedLiteralValue; // Store for GraphBuilder
+        }
+        // 2. Simple identifier (variable reference)
+        else if (rightExpr.type === 'Identifier') {
+            valueType = 'VARIABLE';
+            valueName = rightExpr.name;
+        }
+        // 3. CallExpression (function call)
+        else if (rightExpr.type === 'CallExpression' && rightExpr.callee.type === 'Identifier') {
+            valueType = 'CALL_SITE';
+            valueName = rightExpr.callee.name;
+            callLine = getLine(rightExpr);
+            callColumn = getColumn(rightExpr);
+        }
+        // 4. MemberExpression (method call: obj.method())
+        else if (rightExpr.type === 'CallExpression' && rightExpr.callee.type === 'MemberExpression') {
+            valueType = 'METHOD_CALL';
+            callLine = getLine(rightExpr);
+            callColumn = getColumn(rightExpr);
+        }
+        // 5. Everything else is EXPRESSION
+        else {
+            valueType = 'EXPRESSION';
+            expressionType = rightExpr.type; // Store AST node type
+            // Use correct EXPRESSION ID format: {file}:EXPRESSION:{type}:{line}:{column}
+            valueId = `${module.file}:EXPRESSION:${expressionType}:${line}:${column}`;
+            // Extract type-specific metadata (matches VariableAssignmentInfo pattern)
+            expressionMetadata = {};
+            // MemberExpression: obj.prop or obj[key]
+            if (rightExpr.type === 'MemberExpression') {
+                const objName = rightExpr.object.type === 'Identifier' ? rightExpr.object.name : undefined;
+                const propName = rightExpr.property.type === 'Identifier' ? rightExpr.property.name : undefined;
+                const computed = rightExpr.computed;
+                expressionMetadata.object = objName;
+                expressionMetadata.property = propName;
+                expressionMetadata.computed = computed;
+                // Computed property variable: obj[varName]
+                if (computed && rightExpr.property.type === 'Identifier') {
+                    expressionMetadata.computedPropertyVar = rightExpr.property.name;
+                }
+            }
+            // BinaryExpression: a + b, a - b, etc.
+            else if (rightExpr.type === 'BinaryExpression' || rightExpr.type === 'LogicalExpression') {
+                expressionMetadata.operator = rightExpr.operator;
+                expressionMetadata.leftSourceName = rightExpr.left.type === 'Identifier' ? rightExpr.left.name : undefined;
+                expressionMetadata.rightSourceName = rightExpr.right.type === 'Identifier' ? rightExpr.right.name : undefined;
+            }
+            // ConditionalExpression: condition ? a : b
+            else if (rightExpr.type === 'ConditionalExpression') {
+                expressionMetadata.consequentSourceName = rightExpr.consequent.type === 'Identifier' ? rightExpr.consequent.name : undefined;
+                expressionMetadata.alternateSourceName = rightExpr.alternate.type === 'Identifier' ? rightExpr.alternate.name : undefined;
+            }
+            // Add more expression types as needed
+        }
+        // Capture scope path for scope-aware lookup (REG-309)
+        const scopePath = scopeTracker?.getContext().scopePath ?? [];
+        // Push reassignment info to collection
+        variableReassignments.push({
+            variableName,
+            variableLine: getLine(leftId),
+            mutationScopePath: scopePath,
+            valueType,
+            valueName,
+            valueId,
+            callLine,
+            callColumn,
+            operator,
+            // Complete metadata
+            literalValue,
+            expressionType,
+            expressionMetadata,
+            file: module.file,
+            line,
+            column
         });
     }
+    /**
+     * Extract value information from an expression for mutation tracking
+     */
+    extractMutationValue(value) {
+        const valueInfo = {
+            valueType: 'EXPRESSION' // Default
+        };
+        const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+        if (literalValue !== null) {
+            valueInfo.valueType = 'LITERAL';
+            valueInfo.literalValue = literalValue;
+        }
+        else if (value.type === 'Identifier') {
+            valueInfo.valueType = 'VARIABLE';
+            valueInfo.valueName = value.name;
+        }
+        else if (value.type === 'ObjectExpression') {
+            valueInfo.valueType = 'OBJECT_LITERAL';
+        }
+        else if (value.type === 'ArrayExpression') {
+            valueInfo.valueType = 'ARRAY_LITERAL';
+        }
+        else if (value.type === 'CallExpression') {
+            valueInfo.valueType = 'CALL';
+            valueInfo.callLine = value.loc?.start.line;
+            valueInfo.callColumn = value.loc?.start.column;
+        }
+        return valueInfo;
+    }
+    /**
+     * Detect Object.assign() calls inside functions
+     * Creates ObjectMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+     */
+    detectObjectAssignInFunction(callNode, module, objectMutations, scopeTracker) {
+        // Need at least 2 arguments: target and at least one source
+        if (callNode.arguments.length < 2)
+            return;
+        // First argument is target
+        const targetArg = callNode.arguments[0];
+        let targetName;
+        if (targetArg.type === 'Identifier') {
+            targetName = targetArg.name;
+        }
+        else if (targetArg.type === 'ObjectExpression') {
+            targetName = '<anonymous>';
+        }
+        else {
+            return;
+        }
+        const line = callNode.loc?.start.line ?? 0;
+        const column = callNode.loc?.start.column ?? 0;
+        for (let i = 1; i < callNode.arguments.length; i++) {
+            let arg = callNode.arguments[i];
+            let isSpread = false;
+            if (arg.type === 'SpreadElement') {
+                isSpread = true;
+                arg = arg.argument;
+            }
+            const valueInfo = {
+                valueType: 'EXPRESSION',
+                argIndex: i - 1,
+                isSpread
+            };
+            const literalValue = ExpressionEvaluator.extractLiteralValue(arg);
+            if (literalValue !== null) {
+                valueInfo.valueType = 'LITERAL';
+                valueInfo.literalValue = literalValue;
+            }
+            else if (arg.type === 'Identifier') {
+                valueInfo.valueType = 'VARIABLE';
+                valueInfo.valueName = arg.name;
+            }
+            else if (arg.type === 'ObjectExpression') {
+                valueInfo.valueType = 'OBJECT_LITERAL';
+            }
+            else if (arg.type === 'ArrayExpression') {
+                valueInfo.valueType = 'ARRAY_LITERAL';
+            }
+            else if (arg.type === 'CallExpression') {
+                valueInfo.valueType = 'CALL';
+                valueInfo.callLine = arg.loc?.start.line;
+                valueInfo.callColumn = arg.loc?.start.column;
+            }
+            let mutationId;
+            if (scopeTracker) {
+                const discriminator = scopeTracker.getItemCounter(`OBJECT_MUTATION:Object.assign:${targetName}`);
+                mutationId = computeSemanticId('OBJECT_MUTATION', `Object.assign:${targetName}`, scopeTracker.getContext(), { discriminator });
+            }
+            objectMutations.push({
+                id: mutationId,
+                objectName: targetName,
+                propertyName: '<assign>',
+                mutationType: 'assign',
+                file: module.file,
+                line,
+                column,
+                value: valueInfo
+            });
+        }
+    }
 }