@grafema/core 0.1.1-alpha → 0.2.0-beta

package/dist/plugins/analysis/JSASTAnalyzer.js

@@ -33,6 +33,9 @@ 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;
@@ -61,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']
@@ -355,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);
@@ -457,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
@@ -542,8 +577,8 @@ export class JSASTAnalyzer extends Plugin {
                 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
@@ -562,8 +597,8 @@ export class JSASTAnalyzer extends Plugin {
                 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
@@ -586,12 +621,360 @@ export class JSASTAnalyzer extends Plugin {
             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 ноды из графа
      */
@@ -624,11 +1007,17 @@ export class JSASTAnalyzer extends Plugin {
             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 = [];
@@ -651,6 +1040,16 @@ export class JSASTAnalyzer extends Plugin {
             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 };
@@ -661,6 +1060,8 @@ export class JSASTAnalyzer extends Plugin {
             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(),
@@ -680,13 +1081,18 @@ 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), scopeTracker // Pass ScopeTracker for semantic ID generation
+            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');
             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,
@@ -696,10 +1102,21 @@ export class JSASTAnalyzer extends Plugin {
                 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,
+                literalCounterRef, anonymousFunctionCounterRef,
+                branchCounterRef, caseCounterRef,
+                processedNodes,
                 imports, exports, code,
                 // VisitorCollections compatibility
                 classes: classDeclarations,
@@ -769,13 +1186,38 @@ export class JSASTAnalyzer extends Plugin {
                         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);
+                    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), scopeTracker // Pass ScopeTracker for semantic ID generation
@@ -837,6 +1279,72 @@ export class JSASTAnalyzer extends Plugin {
             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, {
@@ -889,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,
@@ -912,8 +1431,17 @@ export class JSASTAnalyzer extends Plugin {
                 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');
@@ -980,23 +1508,34 @@ export class JSASTAnalyzer extends Plugin {
      * @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) {
+    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';
-                const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+                // 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,
@@ -1037,16 +1576,199 @@ export class JSASTAnalyzer extends Plugin {
                         parentScopeId
                     });
                 }
-                if (declarator.init) {
-                    this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
-                }
             });
+            // 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
+                            });
+                        }
+                        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, parentScopeId, module, scopes, scopeCounterRef, scopeTracker) {
+    createLoopScopeHandler(trackerScopeType, scopeType, loopType, parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState) {
         return {
             enter: (path) => {
                 const node = path.node;
+                // Phase 6 (REG-267): Increment loop count for cyclomatic complexity
+                if (controlFlowState) {
+                    controlFlowState.loopCount++;
+                }
+                // 1. Create LOOP node
+                const loopCounter = loopCounterRef.value++;
+                const legacyLoopId = `${module.file}:LOOP:${loopType}:${getLine(node)}:${loopCounter}`;
+                const loopId = scopeTracker
+                    ? computeSemanticId('LOOP', loopType, scopeTracker.getContext(), { discriminator: loopCounter })
+                    : legacyLoopId;
+                // 2. Extract iteration target for for-in/for-of
+                let iteratesOverName;
+                let iteratesOverLine;
+                let iteratesOverColumn;
+                if (loopType === 'for-in' || loopType === 'for-of') {
+                    const loopNode = node;
+                    if (t.isIdentifier(loopNode.right)) {
+                        iteratesOverName = loopNode.right.name;
+                        iteratesOverLine = getLine(loopNode.right);
+                        iteratesOverColumn = getColumn(loopNode.right);
+                    }
+                    else if (t.isMemberExpression(loopNode.right)) {
+                        iteratesOverName = this.memberExpressionToString(loopNode.right);
+                        iteratesOverLine = getLine(loopNode.right);
+                        iteratesOverColumn = getColumn(loopNode.right);
+                    }
+                }
+                // 2b. Extract init/test/update for classic for loops and test for while/do-while (REG-282)
+                let initVariableName;
+                let initLine;
+                let testExpressionId;
+                let testExpressionType;
+                let testLine;
+                let testColumn;
+                let updateExpressionId;
+                let updateExpressionType;
+                let updateLine;
+                let updateColumn;
+                if (loopType === 'for') {
+                    const forNode = node;
+                    // Extract init: let i = 0
+                    if (forNode.init) {
+                        initLine = getLine(forNode.init);
+                        if (t.isVariableDeclaration(forNode.init)) {
+                            // Get name of first declared variable
+                            const firstDeclarator = forNode.init.declarations[0];
+                            if (t.isIdentifier(firstDeclarator.id)) {
+                                initVariableName = firstDeclarator.id.name;
+                            }
+                        }
+                    }
+                    // Extract test: i < 10
+                    if (forNode.test) {
+                        testLine = getLine(forNode.test);
+                        testColumn = getColumn(forNode.test);
+                        testExpressionType = forNode.test.type;
+                        testExpressionId = ExpressionNode.generateId(forNode.test.type, module.file, testLine, testColumn);
+                    }
+                    // Extract update: i++
+                    if (forNode.update) {
+                        updateLine = getLine(forNode.update);
+                        updateColumn = getColumn(forNode.update);
+                        updateExpressionType = forNode.update.type;
+                        updateExpressionId = ExpressionNode.generateId(forNode.update.type, module.file, updateLine, updateColumn);
+                    }
+                }
+                // Extract test condition for while and do-while loops
+                if (loopType === 'while' || loopType === 'do-while') {
+                    const condLoop = node;
+                    if (condLoop.test) {
+                        testLine = getLine(condLoop.test);
+                        testColumn = getColumn(condLoop.test);
+                        testExpressionType = condLoop.test.type;
+                        testExpressionId = ExpressionNode.generateId(condLoop.test.type, module.file, testLine, testColumn);
+                    }
+                }
+                // Extract async flag for for-await-of (REG-284)
+                let isAsync;
+                if (loopType === 'for-of') {
+                    const forOfNode = node;
+                    isAsync = forOfNode.await === true ? true : undefined;
+                }
+                // 3. Determine actual parent - use stack for nested loops, otherwise original parentScopeId
+                const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+                    ? scopeIdStack[scopeIdStack.length - 1]
+                    : parentScopeId;
+                // 3.5. Extract condition expression for while/do-while/for loops (REG-280)
+                // Note: for-in and for-of don't have test expressions (they use ITERATES_OVER instead)
+                let conditionExpressionId;
+                let conditionExpressionType;
+                let conditionLine;
+                let conditionColumn;
+                if (loopType === 'while' || loopType === 'do-while') {
+                    const testNode = node.test;
+                    if (testNode) {
+                        const condResult = this.extractDiscriminantExpression(testNode, module);
+                        conditionExpressionId = condResult.id;
+                        conditionExpressionType = condResult.expressionType;
+                        conditionLine = condResult.line;
+                        conditionColumn = condResult.column;
+                    }
+                }
+                else if (loopType === 'for') {
+                    const forNode = node;
+                    // for loop test may be null (infinite loop: for(;;))
+                    if (forNode.test) {
+                        const condResult = this.extractDiscriminantExpression(forNode.test, module);
+                        conditionExpressionId = condResult.id;
+                        conditionExpressionType = condResult.expressionType;
+                        conditionLine = condResult.line;
+                        conditionColumn = condResult.column;
+                    }
+                }
+                // 4. Push LOOP info
+                loops.push({
+                    id: loopId,
+                    semanticId: loopId,
+                    type: 'LOOP',
+                    loopType,
+                    file: module.file,
+                    line: getLine(node),
+                    column: getColumn(node),
+                    parentScopeId: actualParentScopeId,
+                    iteratesOverName,
+                    iteratesOverLine,
+                    iteratesOverColumn,
+                    conditionExpressionId,
+                    conditionExpressionType,
+                    conditionLine,
+                    conditionColumn,
+                    // REG-282: init/test/update for classic for loops
+                    initVariableName,
+                    initLine,
+                    testExpressionId,
+                    testExpressionType,
+                    testLine,
+                    testColumn,
+                    updateExpressionId,
+                    updateExpressionType,
+                    updateLine,
+                    updateColumn,
+                    // REG-284: async flag for for-await-of
+                    async: isAsync
+                });
+                // 5. Create body SCOPE (backward compatibility)
                 const scopeId = `SCOPE#${scopeType}#${module.file}#${getLine(node)}:${scopeCounterRef.value++}`;
                 const semanticId = this.generateSemanticId(scopeType, scopeTracker);
                 scopes.push({
@@ -1056,14 +1778,23 @@ export class JSASTAnalyzer extends Plugin {
                     semanticId,
                     file: module.file,
                     line: getLine(node),
-                    parentScopeId
+                    parentScopeId: loopId // Parent is LOOP, not original parentScopeId
                 });
+                // 6. Push body SCOPE to scopeIdStack (for CONTAINS edges to nested items)
+                // The body scope is the container for nested loops, not the LOOP itself
+                if (scopeIdStack) {
+                    scopeIdStack.push(scopeId);
+                }
                 // Enter scope for semantic ID generation
                 if (scopeTracker) {
                     scopeTracker.enterCountedScope(trackerScopeType);
                 }
             },
             exit: () => {
+                // Pop loop scope from stack
+                if (scopeIdStack) {
+                    scopeIdStack.pop();
+                }
                 // Exit scope
                 if (scopeTracker) {
                     scopeTracker.exitScope();
@@ -1072,174 +1803,596 @@ export class JSASTAnalyzer extends Plugin {
         };
     }
     /**
-     * Process VariableDeclarations within a try/catch/finally block.
-     * This is a simplified version that doesn't track parentScopeVariables or class instantiations.
+     * 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: getLine(tryNode),
+                    column: getColumn(tryNode),
+                    parentScopeId: actualParentScopeId
+                });
+                // 2. Create try-body SCOPE (backward compatibility)
+                // Parent is now TRY_BLOCK, not original parentScopeId
+                const tryScopeId = `SCOPE#try-block#${module.file}#${getLine(tryNode)}:${scopeCounterRef.value++}`;
+                const trySemanticId = this.generateSemanticId('try-block', scopeTracker);
+                scopes.push({
+                    id: tryScopeId,
+                    type: 'SCOPE',
+                    scopeType: 'try-block',
+                    semanticId: trySemanticId,
+                    file: module.file,
+                    line: getLine(tryNode),
+                    parentScopeId: tryBlockId // Parent is TRY_BLOCK
+                });
+                // 3. Create CATCH_BLOCK and catch-body SCOPE if handler exists
+                let catchBlockId = null;
+                let catchScopeId = null;
+                if (tryNode.handler) {
+                    const catchClause = tryNode.handler;
+                    const catchBlockCounter = catchBlockCounterRef.value++;
+                    const legacyCatchBlockId = `${module.file}:CATCH_BLOCK:${getLine(catchClause)}:${catchBlockCounter}`;
+                    catchBlockId = scopeTracker
+                        ? computeSemanticId('CATCH_BLOCK', 'catch', scopeTracker.getContext(), { discriminator: catchBlockCounter })
+                        : legacyCatchBlockId;
+                    // Extract parameter name if present
+                    let parameterName;
+                    if (catchClause.param && t.isIdentifier(catchClause.param)) {
+                        parameterName = catchClause.param.name;
+                    }
+                    catchBlocks.push({
+                        id: catchBlockId,
+                        semanticId: catchBlockId,
+                        type: 'CATCH_BLOCK',
+                        file: module.file,
+                        line: getLine(catchClause),
+                        column: getColumn(catchClause),
+                        parentScopeId,
+                        parentTryBlockId: tryBlockId,
+                        parameterName
+                    });
+                    // Create catch-body SCOPE (backward compatibility)
+                    catchScopeId = `SCOPE#catch-block#${module.file}#${getLine(catchClause)}:${scopeCounterRef.value++}`;
+                    const catchSemanticId = this.generateSemanticId('catch-block', scopeTracker);
+                    scopes.push({
+                        id: catchScopeId,
+                        type: 'SCOPE',
+                        scopeType: 'catch-block',
+                        semanticId: catchSemanticId,
+                        file: module.file,
+                        line: getLine(catchClause),
+                        parentScopeId: catchBlockId // Parent is CATCH_BLOCK
+                    });
+                }
+                // 4. Create FINALLY_BLOCK and finally-body SCOPE if finalizer exists
+                let finallyBlockId = null;
+                let finallyScopeId = null;
+                if (tryNode.finalizer) {
+                    const finallyBlockCounter = finallyBlockCounterRef.value++;
+                    const legacyFinallyBlockId = `${module.file}:FINALLY_BLOCK:${getLine(tryNode.finalizer)}:${finallyBlockCounter}`;
+                    finallyBlockId = scopeTracker
+                        ? computeSemanticId('FINALLY_BLOCK', 'finally', scopeTracker.getContext(), { discriminator: finallyBlockCounter })
+                        : legacyFinallyBlockId;
+                    finallyBlocks.push({
+                        id: finallyBlockId,
+                        semanticId: finallyBlockId,
+                        type: 'FINALLY_BLOCK',
+                        file: module.file,
+                        line: getLine(tryNode.finalizer),
+                        column: getColumn(tryNode.finalizer),
+                        parentScopeId,
+                        parentTryBlockId: tryBlockId
+                    });
+                    // Create finally-body SCOPE (backward compatibility)
+                    finallyScopeId = `SCOPE#finally-block#${module.file}#${getLine(tryNode.finalizer)}:${scopeCounterRef.value++}`;
+                    const finallySemanticId = this.generateSemanticId('finally-block', scopeTracker);
+                    scopes.push({
+                        id: finallyScopeId,
+                        type: 'SCOPE',
+                        scopeType: 'finally-block',
+                        semanticId: finallySemanticId,
+                        file: module.file,
+                        line: getLine(tryNode.finalizer),
+                        parentScopeId: finallyBlockId // Parent is FINALLY_BLOCK
+                    });
+                }
+                // 5. Push try scope onto stack for CONTAINS edges
+                if (scopeIdStack) {
+                    scopeIdStack.push(tryScopeId);
+                }
+                // Enter try scope for semantic ID generation
+                if (scopeTracker) {
+                    scopeTracker.enterCountedScope('try');
+                }
+                // 6. Store scope info for catch/finally transitions
+                tryScopeMap.set(tryNode, {
+                    tryScopeId,
+                    catchScopeId,
+                    finallyScopeId,
+                    currentBlock: 'try',
+                    tryBlockId,
+                    catchBlockId,
+                    finallyBlockId
+                });
+            },
+            exit: (tryPath) => {
+                const tryNode = tryPath.node;
+                const scopeInfo = tryScopeMap.get(tryNode);
+                // 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 blockPath - The NodePath for the block to process
-     * @param blockScopeId - The scope ID for variables in this block
      * @param module - Module context
      * @param variableDeclarations - Collection to push variable declarations 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 tryScopeMap - Map to track try/catch/finally scope transitions
+     * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
      */
-    processBlockVariables(blockPath, blockScopeId, module, variableDeclarations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker) {
-        blockPath.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 nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
-                        const legacyId = `${nodeType}#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+    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(nodeType, varInfo.name, scopeTracker.getContext())
+                            ? computeSemanticId('VARIABLE', varInfo.name, scopeTracker.getContext())
                             : legacyId;
                         variableDeclarations.push({
                             id: varId,
-                            type: nodeType,
+                            type: 'VARIABLE',
                             name: varInfo.name,
                             file: module.file,
                             line: varInfo.loc.start.line,
-                            parentScopeId: blockScopeId
+                            parentScopeId: scopeInfo.catchScopeId
                         });
-                        if (declarator.init) {
-                            this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
-                        }
                     });
-                });
+                }
             }
-        });
+        };
     }
     /**
-     * Handles TryStatement nodes within function bodies.
-     * Creates try, catch (with optional error parameter), and finally scopes,
-     * and processes variable declarations within each block.
+     * Handles SwitchStatement nodes.
+     * Creates BRANCH node for switch, CASE nodes for each case clause,
+     * and EXPRESSION node for discriminant.
      *
-     * @param tryPath - The NodePath for the TryStatement
-     * @param parentScopeId - Parent scope ID for the scope nodes
+     * @param switchPath - The NodePath for the SwitchStatement
+     * @param parentScopeId - Parent scope ID
      * @param module - Module context
-     * @param scopes - Collection to push scope nodes to
-     * @param variableDeclarations - Collection to push variable declarations to
-     * @param literals - Collection for literal tracking
-     * @param variableAssignments - Collection for variable assignment tracking
-     * @param scopeCounterRef - Counter for unique scope IDs
-     * @param varDeclCounterRef - Counter for unique variable declaration IDs
-     * @param literalCounterRef - Counter for unique literal IDs
+     * @param collections - AST collections
      * @param scopeTracker - Tracker for semantic ID generation
      */
-    handleTryStatement(tryPath, parentScopeId, module, scopes, variableDeclarations, literals, variableAssignments, scopeCounterRef, varDeclCounterRef, literalCounterRef, scopeTracker) {
-        const tryNode = tryPath.node;
-        // Create and process try block
-        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,
+    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(tryNode),
-            parentScopeId
+            line: getLine(switchNode),
+            parentScopeId,
+            discriminantExpressionId,
+            discriminantExpressionType,
+            discriminantLine,
+            discriminantColumn
         });
-        if (scopeTracker) {
-            scopeTracker.enterCountedScope('try');
-        }
-        this.processBlockVariables(tryPath.get('block'), tryScopeId, module, variableDeclarations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker);
-        if (scopeTracker) {
-            scopeTracker.exitScope();
-        }
-        // Create and process catch block if present
-        if (tryNode.handler) {
-            const catchBlock = tryNode.handler;
-            const catchScopeId = `SCOPE#catch-block#${module.file}#${getLine(catchBlock)}:${scopeCounterRef.value++}`;
-            const catchSemanticId = this.generateSemanticId('catch-block', scopeTracker);
-            scopes.push({
-                id: catchScopeId,
-                type: 'SCOPE',
-                scopeType: 'catch-block',
-                semanticId: catchSemanticId,
+        // 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(catchBlock),
-                parentScopeId
+                line: getLine(caseNode),
+                parentBranchId: branchId
             });
-            if (scopeTracker) {
-                scopeTracker.enterCountedScope('catch');
-            }
-            // Handle catch parameter (e.g., catch (e))
-            if (catchBlock.param) {
-                const errorVarInfo = this.extractVariableNamesFromPattern(catchBlock.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: catchScopeId
-                    });
-                });
+        }
+    }
+    /**
+     * 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);
             }
-            this.processBlockVariables(tryPath.get('handler.body'), catchScopeId, module, variableDeclarations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker);
-            if (scopeTracker) {
-                scopeTracker.exitScope();
-            }
-        }
-        // Create and process finally block if present
-        if (tryNode.finalizer) {
-            const 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
-            });
-            if (scopeTracker) {
-                scopeTracker.enterCountedScope('finally');
+            else if (t.isConditionalExpression(expr)) {
+                // Handle ternary conditions: test ? consequent : alternate
+                traverse(expr.test);
+                traverse(expr.consequent);
+                traverse(expr.alternate);
             }
-            const finalizerPath = tryPath.get('finalizer');
-            if (finalizerPath.node) {
-                this.processBlockVariables(finalizerPath, finallyScopeId, module, variableDeclarations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker);
+            else if (t.isUnaryExpression(expr)) {
+                traverse(expr.argument);
             }
-            if (scopeTracker) {
-                scopeTracker.exitScope();
+            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;
         }
-        tryPath.skip();
+        if (t.isIdentifier(current)) {
+            parts.unshift(current.name);
+        }
+        return parts.join('.');
     }
     /**
      * Factory method to create IfStatement handler.
-     * Creates if scope with condition parsing and optional else scope.
+     * 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, ifScopeCounterRef, scopeTracker, sourceCode, ifElseScopeMap) {
+    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
@@ -1256,17 +2409,22 @@ export class JSASTAnalyzer extends Plugin {
                     constraints: constraints.length > 0 ? constraints : undefined,
                     file: module.file,
                     line: getLine(ifNode),
-                    parentScopeId
+                    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');
                 }
-                // Handle else branch if present
+                // 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++;
-                    const elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
+                    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({
@@ -1279,17 +2437,21 @@ export class JSASTAnalyzer extends Plugin {
                         constraints: negatedConstraints,
                         file: module.file,
                         line: getLine(ifNode.alternate),
-                        parentScopeId
+                        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 });
+                    ifElseScopeMap.set(ifNode, { inElse: false, hasElse: true, ifScopeId, elseScopeId, branchId });
                 }
                 else {
-                    ifElseScopeMap.set(ifNode, { inElse: false, hasElse: false });
+                    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();
@@ -1301,26 +2463,116 @@ export class JSASTAnalyzer extends Plugin {
         };
     }
     /**
-     * Factory method to create BlockStatement handler for tracking if/else transitions.
+     * 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
      */
-    createIfElseBlockStatementHandler(scopeTracker, ifElseScopeMap) {
+    createBlockStatementHandler(scopeTracker, ifElseScopeMap, tryScopeMap, scopeIdStack) {
         return {
             enter: (blockPath) => {
-                // Check if this block is the alternate of an IfStatement
                 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 && scopeTracker) {
-                        // Exit if scope, enter else scope
-                        scopeTracker.exitScope();
-                        scopeTracker.enterCountedScope('else');
+                    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';
+                    }
+                }
             }
         };
     }
@@ -1338,6 +2590,7 @@ export class JSASTAnalyzer extends Plugin {
         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 ?? []);
@@ -1350,6 +2603,32 @@ export class JSASTAnalyzer extends Plugin {
         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(),
@@ -1366,22 +2645,241 @@ export class JSASTAnalyzer extends Plugin {
         const processedVarDecls = processedNodes.varDecls;
         const processedMethodCalls = processedNodes.methodCalls;
         const processedEventListeners = processedNodes.eventListeners;
-        // Track if/else scope transitions
+        // 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, parentScopeId, module, variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker, parentScopeVariables);
+                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);
+                this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker);
                 // Initialize object mutations collection if not exists
                 if (!collections.objectMutations) {
                     collections.objectMutations = [];
@@ -1390,27 +2888,236 @@ export class JSASTAnalyzer extends Plugin {
                 // Check for object property assignment: obj.prop = value
                 this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
             },
-            ForStatement: this.createLoopScopeHandler('for', 'for-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-            ForInStatement: this.createLoopScopeHandler('for-in', 'for-in-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-            ForOfStatement: this.createLoopScopeHandler('for-of', 'for-of-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-            WhileStatement: this.createLoopScopeHandler('while', 'while-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-            DoWhileStatement: this.createLoopScopeHandler('do-while', 'do-while-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-            TryStatement: (tryPath) => {
-                this.handleTryStatement(tryPath, parentScopeId, module, scopes, variableDeclarations, literals, variableAssignments, scopeCounterRef, varDeclCounterRef, literalCounterRef, 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;
+                }
+                // 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}#${getLine(switchNode)}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('switch-case', scopeTracker);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'switch-case',
-                    semanticId,
-                    file: module.file,
-                    line: getLine(switchNode),
-                    parentScopeId
-                });
+                this.handleSwitchStatement(switchPath, parentScopeId, module, collections, scopeTracker, controlFlowState);
             },
             FunctionExpression: (funcPath) => {
                 const node = funcPath.node;
@@ -1509,10 +3216,144 @@ export class JSASTAnalyzer extends Plugin {
                         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
+                    };
+                    // 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
@@ -1534,19 +3375,171 @@ export class JSASTAnalyzer extends Plugin {
                 }
             },
             // IF statements - создаём условные scope и обходим содержимое для CALL узлов
-            IfStatement: this.createIfStatementHandler(parentScopeId, module, scopes, ifScopeCounterRef, scopeTracker, collections.code ?? '', ifElseScopeMap),
+            // 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.createIfElseBlockStatementHandler(scopeTracker, ifElseScopeMap),
+            BlockStatement: this.createBlockStatementHandler(scopeTracker, ifElseScopeMap, tryScopeMap, scopeIdStack),
             // Function call expressions
             CallExpression: (callPath) => {
-                this.handleCallExpression(callPath.node, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, parentScopeId, collections);
+                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
+                            }
+                        }
+                        funcParent = funcParent.getFunctionParent();
+                    }
+                }
             },
             // NewExpression (constructor calls)
             NewExpression: (newPath) => {
                 const newNode = newPath.node;
+                const nodeKey = `new:${newNode.start}:${newNode.end}`;
+                // Determine className from callee
+                let className = null;
+                if (newNode.callee.type === 'Identifier') {
+                    className = newNode.callee.name;
+                }
+                else if (newNode.callee.type === 'MemberExpression' && newNode.callee.property.type === 'Identifier') {
+                    className = newNode.callee.property.name;
+                }
+                // Create CONSTRUCTOR_CALL node (always, for all NewExpressions)
+                if (className) {
+                    const constructorKey = `constructor:${nodeKey}`;
+                    if (!processedCallSites.has(constructorKey)) {
+                        processedCallSites.add(constructorKey);
+                        const line = getLine(newNode);
+                        const column = getColumn(newNode);
+                        const constructorCallId = ConstructorCallNode.generateId(className, module.file, line, column);
+                        const isBuiltin = ConstructorCallNode.isBuiltinConstructor(className);
+                        constructorCalls.push({
+                            id: constructorCallId,
+                            type: 'CONSTRUCTOR_CALL',
+                            className,
+                            isBuiltin,
+                            file: module.file,
+                            line,
+                            column
+                        });
+                        // REG-334: If this is Promise constructor with executor callback,
+                        // register the context for resolve/reject detection
+                        if (className === 'Promise' && newNode.arguments.length > 0) {
+                            const executorArg = newNode.arguments[0];
+                            // Only handle inline function expressions (not variable references)
+                            if (t.isArrowFunctionExpression(executorArg) || t.isFunctionExpression(executorArg)) {
+                                // Extract resolve/reject parameter names
+                                let resolveName;
+                                let rejectName;
+                                if (executorArg.params.length > 0 && t.isIdentifier(executorArg.params[0])) {
+                                    resolveName = executorArg.params[0].name;
+                                }
+                                if (executorArg.params.length > 1 && t.isIdentifier(executorArg.params[1])) {
+                                    rejectName = executorArg.params[1].name;
+                                }
+                                if (resolveName) {
+                                    // Key by function node position to allow nested Promise detection
+                                    const funcKey = `${executorArg.start}:${executorArg.end}`;
+                                    promiseExecutorContexts.set(funcKey, {
+                                        constructorCallId,
+                                        resolveName,
+                                        rejectName,
+                                        file: module.file,
+                                        line
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
                 // Handle simple constructor: new Foo()
                 if (newNode.callee.type === 'Identifier') {
-                    const nodeKey = `new:${newNode.start}:${newNode.end}`;
                     if (processedCallSites.has(nodeKey)) {
                         return;
                     }
@@ -1565,7 +3558,7 @@ export class JSASTAnalyzer extends Plugin {
                         name: constructorName,
                         file: module.file,
                         line: getLine(newNode),
-                        parentScopeId,
+                        parentScopeId: getCurrentScopeId(),
                         targetFunctionName: constructorName,
                         isNew: true
                     });
@@ -1576,7 +3569,6 @@ export class JSASTAnalyzer extends Plugin {
                     const object = memberCallee.object;
                     const property = memberCallee.property;
                     if (object.type === 'Identifier' && property.type === 'Identifier') {
-                        const nodeKey = `new:${newNode.start}:${newNode.end}`;
                         if (processedMethodCalls.has(nodeKey)) {
                             return;
                         }
@@ -1600,13 +3592,29 @@ export class JSASTAnalyzer extends Plugin {
                             file: module.file,
                             line: getLine(newNode),
                             column: getColumn(newNode),
-                            parentScopeId,
+                            parentScopeId: getCurrentScopeId(),
                             isNew: true
                         });
                     }
                 }
             }
         });
+        // 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())
@@ -1651,6 +3659,7 @@ export class JSASTAnalyzer extends Plugin {
                 name: calleeName,
                 file: module.file,
                 line: getLine(callNode),
+                column: getColumn(callNode), // REG-223: Add column for coordinate-based lookup
                 parentScopeId,
                 targetFunctionName: calleeName
             });
@@ -1828,7 +3837,7 @@ export class JSASTAnalyzer extends Plugin {
      * @param module - Current module being analyzed
      * @param arrayMutations - Collection to push mutation info into
      */
-    detectIndexedArrayAssignment(assignNode, module, arrayMutations) {
+    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;
@@ -1872,8 +3881,11 @@ export class JSASTAnalyzer extends Plugin {
                 // 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,
@@ -1956,6 +3968,8 @@ export class JSASTAnalyzer extends Plugin {
         // 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) {
@@ -1965,6 +3979,7 @@ export class JSASTAnalyzer extends Plugin {
         objectMutations.push({
             id: mutationId,
             objectName,
+            mutationScopePath: scopePath,
             enclosingClassName, // REG-152: Class name for 'this' mutations
             propertyName,
             mutationType,
@@ -1975,6 +3990,218 @@ export class JSASTAnalyzer extends Plugin {
             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
      */