@grafema/core 0.2.4-beta → 0.2.5-beta

package/dist/plugins/analysis/JSASTAnalyzer.js

@@ -22,7 +22,7 @@ function isAnalysisResult(value) {
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import { ExpressionEvaluator } from './ast/ExpressionEvaluator.js';
 import { GraphBuilder } from './ast/GraphBuilder.js';
-import { ImportExportVisitor, VariableVisitor, FunctionVisitor, ClassVisitor, CallExpressionVisitor, TypeScriptVisitor } from './ast/visitors/index.js';
+import { ImportExportVisitor, VariableVisitor, FunctionVisitor, ClassVisitor, CallExpressionVisitor, TypeScriptVisitor, PropertyAccessVisitor } from './ast/visitors/index.js';
 import { Task } from '../../core/Task.js';
 import { PriorityQueue } from '../../core/PriorityQueue.js';
 import { WorkerPool } from '../../core/WorkerPool.js';
@@ -35,6 +35,7 @@ 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 { ArrayLiteralNode } from '../../core/nodes/ArrayLiteralNode.js';
 import { NodeFactory } from '../../core/NodeFactory.js';
 export class JSASTAnalyzer extends Plugin {
     graphBuilder;
@@ -50,7 +51,6 @@ export class JSASTAnalyzer extends Plugin {
         return {
             name: 'JSASTAnalyzer',
             phase: 'ANALYSIS',
-            priority: 80,
             creates: {
                 nodes: [
                     'FUNCTION', 'CLASS', 'METHOD', 'VARIABLE', 'CONSTANT', 'SCOPE',
@@ -69,7 +69,16 @@ export class JSASTAnalyzer extends Plugin {
                     'RESOLVES_TO'
                 ]
             },
-            dependencies: ['JSModuleIndexer']
+            dependencies: ['JSModuleIndexer'],
+            fields: [
+                { name: 'object', fieldType: 'string', nodeTypes: ['CALL'] },
+                { name: 'method', fieldType: 'string', nodeTypes: ['CALL'] },
+                { name: 'async', fieldType: 'bool', nodeTypes: ['FUNCTION', 'METHOD'] },
+                { name: 'scopeType', fieldType: 'string', nodeTypes: ['SCOPE'] },
+                { name: 'importType', fieldType: 'string', nodeTypes: ['IMPORT'] },
+                { name: 'exportType', fieldType: 'string', nodeTypes: ['EXPORT'] },
+                { name: 'parentScopeId', fieldType: 'id', nodeTypes: ['FUNCTION', 'METHOD', 'SCOPE', 'VARIABLE'] },
+            ]
         };
     }
     /**
@@ -1050,6 +1059,13 @@ export class JSASTAnalyzer extends Plugin {
             const promiseResolutions = [];
             // Promise executor contexts (REG-334) - keyed by executor function's start:end position
             const promiseExecutorContexts = new Map();
+            // Yield expression tracking for YIELDS/DELEGATES_TO edges (REG-270)
+            const yieldExpressions = [];
+            // REG-311: Async error tracking
+            const rejectionPatterns = [];
+            const catchesFromInfos = [];
+            // Property access tracking for PROPERTY_ACCESS nodes (REG-395)
+            const propertyAccesses = [];
             const ifScopeCounterRef = { value: 0 };
             const scopeCounterRef = { value: 0 };
             const varDeclCounterRef = { value: 0 };
@@ -1062,6 +1078,7 @@ export class JSASTAnalyzer extends Plugin {
             const arrayLiteralCounterRef = { value: 0 };
             const branchCounterRef = { value: 0 };
             const caseCounterRef = { value: 0 };
+            const propertyAccessCounterRef = { value: 0 };
             const processedNodes = {
                 functions: new Set(),
                 classes: new Set(),
@@ -1111,6 +1128,14 @@ export class JSASTAnalyzer extends Plugin {
                 // Promise resolution tracking (REG-334)
                 promiseResolutions,
                 promiseExecutorContexts,
+                // Yield expression tracking (REG-270)
+                yieldExpressions,
+                // REG-311: Async error tracking
+                rejectionPatterns,
+                catchesFromInfos,
+                // Property access tracking (REG-395)
+                propertyAccesses,
+                propertyAccessCounterRef,
                 objectLiteralCounterRef, arrayLiteralCounterRef,
                 ifScopeCounterRef, scopeCounterRef, varDeclCounterRef,
                 callSiteCounterRef, functionCounterRef, httpRequestCounterRef,
@@ -1199,7 +1224,7 @@ export class JSASTAnalyzer extends Plugin {
                     }
                     // === END VARIABLE REASSIGNMENT ===
                     // Check for indexed array assignment at module level: arr[i] = value
-                    this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker);
+                    this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker, allCollections);
                     // Check for object property assignment at module level: obj.prop = value
                     this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
                 }
@@ -1279,6 +1304,11 @@ export class JSASTAnalyzer extends Plugin {
             const callExpressionVisitor = new CallExpressionVisitor(module, allCollections, scopeTracker);
             traverse(ast, callExpressionVisitor.getHandlers());
             this.profiler.end('traverse_calls');
+            // Property access expressions (REG-395)
+            this.profiler.start('traverse_property_access');
+            const propertyAccessVisitor = new PropertyAccessVisitor(module, allCollections, scopeTracker);
+            traverse(ast, propertyAccessVisitor.getHandlers());
+            this.profiler.end('traverse_property_access');
             // 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');
@@ -1336,7 +1366,9 @@ export class JSASTAnalyzer extends Plugin {
                                         resolveName,
                                         rejectName,
                                         file: module.file,
-                                        line
+                                        line,
+                                        // REG-311: Module-level Promise has no creator function
+                                        creatorFunctionId: undefined
                                     });
                                 }
                             }
@@ -1435,6 +1467,8 @@ export class JSASTAnalyzer extends Plugin {
                 variableReassignments,
                 // Return statement tracking
                 returnStatements,
+                // Yield expression tracking (REG-270)
+                yieldExpressions,
                 // Update expression tracking (REG-288, REG-312)
                 updateExpressions,
                 // Promise resolution tracking (REG-334)
@@ -1442,7 +1476,16 @@ export class JSASTAnalyzer extends Plugin {
                 // 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
+                arrayLiterals: allCollections.arrayLiterals || arrayLiterals,
+                // REG-311: Async error tracking
+                rejectionPatterns: Array.isArray(allCollections.rejectionPatterns)
+                    ? allCollections.rejectionPatterns
+                    : rejectionPatterns,
+                catchesFromInfos: Array.isArray(allCollections.catchesFromInfos)
+                    ? allCollections.catchesFromInfos
+                    : catchesFromInfos,
+                // Property access tracking (REG-395)
+                propertyAccesses: allCollections.propertyAccesses || propertyAccesses
             });
             this.profiler.end('graph_build');
             nodesCreated = result.nodes;
@@ -1830,6 +1873,8 @@ export class JSASTAnalyzer extends Plugin {
                 // Phase 6 (REG-267): Mark that this function has try/catch
                 if (controlFlowState) {
                     controlFlowState.hasTryCatch = true;
+                    // REG-311: Increment try block depth for O(1) isInsideTry detection
+                    controlFlowState.tryBlockDepth++;
                 }
                 // Determine actual parent - use stack for nested structures, otherwise original parentScopeId
                 const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
@@ -1955,7 +2000,12 @@ export class JSASTAnalyzer extends Plugin {
             },
             exit: (tryPath) => {
                 const tryNode = tryPath.node;
-                const scopeInfo = tryScopeMap.get(tryNode);
+                const _scopeInfo = tryScopeMap.get(tryNode);
+                // REG-311: Only decrement try block depth if we're still in 'try' block
+                // (not transitioned to catch/finally, where we already decremented)
+                if (controlFlowState && _scopeInfo?.currentBlock === 'try') {
+                    controlFlowState.tryBlockDepth--;
+                }
                 // Pop the current scope from stack (could be try, catch, or finally)
                 if (scopeIdStack) {
                     scopeIdStack.pop();
@@ -1980,7 +2030,7 @@ export class JSASTAnalyzer extends Plugin {
      * @param tryScopeMap - Map to track try/catch/finally scope transitions
      * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
      */
-    createCatchClauseHandler(module, variableDeclarations, varDeclCounterRef, scopeTracker, tryScopeMap, scopeIdStack) {
+    createCatchClauseHandler(module, variableDeclarations, varDeclCounterRef, scopeTracker, tryScopeMap, scopeIdStack, controlFlowState) {
         return {
             enter: (catchPath) => {
                 const catchNode = catchPath.node;
@@ -2002,6 +2052,11 @@ export class JSASTAnalyzer extends Plugin {
                         scopeTracker.exitScope();
                         scopeTracker.enterCountedScope('catch');
                     }
+                    // REG-311: Decrement tryBlockDepth when leaving try block for catch
+                    // Calls in catch block should NOT have isInsideTry=true
+                    if (controlFlowState) {
+                        controlFlowState.tryBlockDepth--;
+                    }
                     scopeInfo.currentBlock = 'catch';
                 }
                 // Handle catch parameter (e.g., catch (e) or catch ({ message }))
@@ -2311,6 +2366,172 @@ export class JSASTAnalyzer extends Plugin {
         }
         return parts.join('.');
     }
+    /**
+     * Extract return expression info from an expression node.
+     * Used for both explicit return statements and implicit arrow returns.
+     *
+     * This method consolidates ~450 lines of duplicated expression handling code
+     * from three locations:
+     * 1. Top-level implicit arrow returns (arrow function expression body)
+     * 2. ReturnStatement handler (explicit returns)
+     * 3. Nested arrow function implicit returns
+     *
+     * @param expr - The expression being returned
+     * @param module - Module info for file context
+     * @param literals - Collection to add literal nodes to
+     * @param literalCounterRef - Counter for generating unique literal IDs
+     * @param baseLine - Line number for literal ID generation
+     * @param baseColumn - Column number for literal ID generation
+     * @param literalIdSuffix - 'return' or 'implicit_return'
+     * @returns Partial ReturnStatementInfo with expression-specific fields
+     */
+    extractReturnExpressionInfo(expr, module, literals, literalCounterRef, baseLine, baseColumn, literalIdSuffix = 'return') {
+        const exprLine = getLine(expr);
+        const exprColumn = getColumn(expr);
+        // Identifier (variable reference)
+        if (t.isIdentifier(expr)) {
+            return {
+                returnValueType: 'VARIABLE',
+                returnValueName: expr.name,
+            };
+        }
+        // TemplateLiteral must come BEFORE isLiteral (TemplateLiteral extends Literal)
+        if (t.isTemplateLiteral(expr)) {
+            const sourceNames = [];
+            for (const embedded of expr.expressions) {
+                if (t.isIdentifier(embedded)) {
+                    sourceNames.push(embedded.name);
+                }
+            }
+            return {
+                returnValueType: 'EXPRESSION',
+                expressionType: 'TemplateLiteral',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                returnValueId: NodeFactory.generateExpressionId('TemplateLiteral', module.file, exprLine, exprColumn),
+                ...(sourceNames.length > 0 ? { expressionSourceNames: sourceNames } : {}),
+            };
+        }
+        // Literal values (after TemplateLiteral check)
+        if (t.isLiteral(expr)) {
+            const literalId = `LITERAL#${literalIdSuffix}#${module.file}#${baseLine}:${baseColumn}:${literalCounterRef.value++}`;
+            literals.push({
+                id: literalId,
+                type: 'LITERAL',
+                value: ExpressionEvaluator.extractLiteralValue(expr),
+                valueType: typeof ExpressionEvaluator.extractLiteralValue(expr),
+                file: module.file,
+                line: exprLine,
+                column: exprColumn,
+            });
+            return {
+                returnValueType: 'LITERAL',
+                returnValueId: literalId,
+            };
+        }
+        // Direct function call: return foo()
+        if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) {
+            return {
+                returnValueType: 'CALL_SITE',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                returnValueCallName: expr.callee.name,
+            };
+        }
+        // Method call: return obj.method()
+        if (t.isCallExpression(expr) && t.isMemberExpression(expr.callee)) {
+            return {
+                returnValueType: 'METHOD_CALL',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                returnValueCallName: t.isIdentifier(expr.callee.property)
+                    ? expr.callee.property.name
+                    : undefined,
+            };
+        }
+        // BinaryExpression: return a + b
+        if (t.isBinaryExpression(expr)) {
+            return {
+                returnValueType: 'EXPRESSION',
+                expressionType: 'BinaryExpression',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                operator: expr.operator,
+                returnValueId: NodeFactory.generateExpressionId('BinaryExpression', module.file, exprLine, exprColumn),
+                leftSourceName: t.isIdentifier(expr.left) ? expr.left.name : undefined,
+                rightSourceName: t.isIdentifier(expr.right) ? expr.right.name : undefined,
+            };
+        }
+        // LogicalExpression: return a && b, return a || b
+        if (t.isLogicalExpression(expr)) {
+            return {
+                returnValueType: 'EXPRESSION',
+                expressionType: 'LogicalExpression',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                operator: expr.operator,
+                returnValueId: NodeFactory.generateExpressionId('LogicalExpression', module.file, exprLine, exprColumn),
+                leftSourceName: t.isIdentifier(expr.left) ? expr.left.name : undefined,
+                rightSourceName: t.isIdentifier(expr.right) ? expr.right.name : undefined,
+            };
+        }
+        // ConditionalExpression: return condition ? a : b
+        if (t.isConditionalExpression(expr)) {
+            return {
+                returnValueType: 'EXPRESSION',
+                expressionType: 'ConditionalExpression',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                returnValueId: NodeFactory.generateExpressionId('ConditionalExpression', module.file, exprLine, exprColumn),
+                consequentSourceName: t.isIdentifier(expr.consequent) ? expr.consequent.name : undefined,
+                alternateSourceName: t.isIdentifier(expr.alternate) ? expr.alternate.name : undefined,
+            };
+        }
+        // UnaryExpression: return !x, return -x
+        if (t.isUnaryExpression(expr)) {
+            return {
+                returnValueType: 'EXPRESSION',
+                expressionType: 'UnaryExpression',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                operator: expr.operator,
+                returnValueId: NodeFactory.generateExpressionId('UnaryExpression', module.file, exprLine, exprColumn),
+                unaryArgSourceName: t.isIdentifier(expr.argument) ? expr.argument.name : undefined,
+            };
+        }
+        // MemberExpression (property access): return obj.prop
+        if (t.isMemberExpression(expr)) {
+            return {
+                returnValueType: 'EXPRESSION',
+                expressionType: 'MemberExpression',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                returnValueId: NodeFactory.generateExpressionId('MemberExpression', module.file, exprLine, exprColumn),
+                object: t.isIdentifier(expr.object) ? expr.object.name : undefined,
+                objectSourceName: t.isIdentifier(expr.object) ? expr.object.name : undefined,
+                property: t.isIdentifier(expr.property) ? expr.property.name : undefined,
+                computed: expr.computed,
+            };
+        }
+        // NewExpression: return new Foo()
+        if (t.isNewExpression(expr)) {
+            return {
+                returnValueType: 'EXPRESSION',
+                expressionType: 'NewExpression',
+                returnValueLine: exprLine,
+                returnValueColumn: exprColumn,
+                returnValueId: NodeFactory.generateExpressionId('NewExpression', module.file, exprLine, exprColumn),
+            };
+        }
+        // Fallback for other expression types
+        return {
+            returnValueType: 'EXPRESSION',
+            expressionType: expr.type,
+            returnValueLine: exprLine,
+            returnValueColumn: exprColumn,
+            returnValueId: NodeFactory.generateExpressionId(expr.type, module.file, exprLine, exprColumn),
+        };
+    }
     /**
      * Factory method to create IfStatement handler.
      * Creates BRANCH node for if statement and SCOPE nodes for if/else bodies.
@@ -2587,11 +2808,11 @@ export class JSASTAnalyzer extends Plugin {
         const variableDeclarations = (collections.variableDeclarations ?? []);
         const callSites = (collections.callSites ?? []);
         const methodCalls = (collections.methodCalls ?? []);
-        const eventListeners = (collections.eventListeners ?? []);
-        const methodCallbacks = (collections.methodCallbacks ?? []);
+        const _eventListeners = (collections.eventListeners ?? []);
+        const _methodCallbacks = (collections.methodCallbacks ?? []);
         const classInstantiations = (collections.classInstantiations ?? []);
         const constructorCalls = (collections.constructorCalls ?? []);
-        const httpRequests = (collections.httpRequests ?? []);
+        const _httpRequests = (collections.httpRequests ?? []);
         const literals = (collections.literals ?? []);
         const variableAssignments = (collections.variableAssignments ?? []);
         const ifScopeCounterRef = (collections.ifScopeCounterRef ?? { value: 0 });
@@ -2599,9 +2820,9 @@ export class JSASTAnalyzer extends Plugin {
         const varDeclCounterRef = (collections.varDeclCounterRef ?? { value: 0 });
         const callSiteCounterRef = (collections.callSiteCounterRef ?? { value: 0 });
         const functionCounterRef = (collections.functionCounterRef ?? { value: 0 });
-        const httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 });
+        const _httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 });
         const literalCounterRef = (collections.literalCounterRef ?? { value: 0 });
-        const anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 });
+        const _anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 });
         const scopeTracker = collections.scopeTracker;
         // Object literal tracking (REG-328)
         if (!collections.objectLiterals) {
@@ -2617,7 +2838,12 @@ export class JSASTAnalyzer extends Plugin {
         const objectProperties = collections.objectProperties;
         const objectLiteralCounterRef = collections.objectLiteralCounterRef;
         const returnStatements = (collections.returnStatements ?? []);
-        const parameters = (collections.parameters ?? []);
+        // Initialize yieldExpressions if not exist to ensure nested function calls share same array
+        if (!collections.yieldExpressions) {
+            collections.yieldExpressions = [];
+        }
+        const yieldExpressions = collections.yieldExpressions;
+        const _parameters = (collections.parameters ?? []);
         // Control flow collections (Phase 2: LOOP nodes)
         // Initialize if not exist to ensure nested function calls share same arrays
         if (!collections.loops) {
@@ -2642,9 +2868,9 @@ export class JSASTAnalyzer extends Plugin {
         };
         const parentScopeVariables = new Set();
         const processedCallSites = processedNodes.callSites;
-        const processedVarDecls = processedNodes.varDecls;
+        const _processedVarDecls = processedNodes.varDecls;
         const processedMethodCalls = processedNodes.methodCalls;
-        const processedEventListeners = processedNodes.eventListeners;
+        const _processedEventListeners = processedNodes.eventListeners;
         // Track if/else scope transitions (Phase 3: extended with branchId)
         const ifElseScopeMap = new Map();
         // Ensure branches and branchCounterRef are initialized (used by IfStatement and SwitchStatement)
@@ -2694,19 +2920,35 @@ export class JSASTAnalyzer extends Plugin {
             collections.promiseResolutions = [];
         }
         const promiseResolutions = collections.promiseResolutions;
+        // REG-311: Initialize rejectionPatterns and catchesFromInfos collections
+        if (!collections.rejectionPatterns) {
+            collections.rejectionPatterns = [];
+        }
+        if (!collections.catchesFromInfos) {
+            collections.catchesFromInfos = [];
+        }
+        const rejectionPatterns = collections.rejectionPatterns;
+        const catchesFromInfos = collections.catchesFromInfos;
         // Dynamic scope ID stack for CONTAINS edges
         // Starts with the function body scope, gets updated as we enter/exit conditional scopes
         const scopeIdStack = [parentScopeId];
         const getCurrentScopeId = () => scopeIdStack[scopeIdStack.length - 1];
         // Determine the ID of the function we're analyzing for RETURNS edges
         // Find by matching file/line/column in functions collection (it was just added by the visitor)
+        // REG-271: Skip for StaticBlock (static blocks don't have RETURNS edges or control flow metadata)
         const funcNode = funcPath.node;
+        const functionNode = t.isFunction(funcNode) ? funcNode : null;
+        const functionPath = functionNode ? funcPath : null;
         const funcLine = getLine(funcNode);
         const funcColumn = getColumn(funcNode);
         let currentFunctionId = null;
-        const matchingFunction = functions.find(f => f.file === module.file &&
-            f.line === funcLine &&
-            (f.column === undefined || f.column === funcColumn));
+        // StaticBlock is not a function - skip function matching for RETURNS edges
+        // For StaticBlock, matchingFunction will be undefined
+        const matchingFunction = funcNode.type !== 'StaticBlock'
+            ? functions.find(f => f.file === module.file &&
+                f.line === funcLine &&
+                (f.column === undefined || f.column === funcColumn))
+            : undefined;
         if (matchingFunction) {
             currentFunctionId = matchingFunction.id;
         }
@@ -2720,7 +2962,9 @@ export class JSASTAnalyzer extends Plugin {
             hasEarlyReturn: false,
             hasThrow: false,
             returnCount: 0, // Track total return count for early return detection
-            totalStatements: 0 // Track if there are statements after returns
+            totalStatements: 0, // Track if there are statements after returns
+            // REG-311: Try block depth counter for O(1) isInsideTry detection
+            tryBlockDepth: 0
         };
         // Handle implicit return for THIS arrow function if it has an expression body
         // e.g., `const double = x => x * 2;` - the function we're analyzing IS an arrow with expression body
@@ -2728,130 +2972,17 @@ export class JSASTAnalyzer extends Plugin {
             const bodyExpr = funcNode.body;
             const bodyLine = getLine(bodyExpr);
             const bodyColumn = getColumn(bodyExpr);
+            // Extract expression-specific info using shared method
+            const exprInfo = this.extractReturnExpressionInfo(bodyExpr, module, literals, literalCounterRef, funcLine, funcColumn, 'implicit_return');
             const returnInfo = {
                 parentFunctionId: currentFunctionId,
                 file: module.file,
                 line: bodyLine,
                 column: bodyColumn,
                 returnValueType: 'NONE',
-                isImplicitReturn: true
+                isImplicitReturn: true,
+                ...exprInfo,
             };
-            // 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({
@@ -2879,7 +3010,7 @@ export class JSASTAnalyzer extends Plugin {
                 }
                 const arrayMutations = collections.arrayMutations;
                 // Check for indexed array assignment: arr[i] = value
-                this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker);
+                this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker, collections);
                 // Initialize object mutations collection if not exists
                 if (!collections.objectMutations) {
                     collections.objectMutations = [];
@@ -2934,168 +3065,20 @@ export class JSASTAnalyzer extends Plugin {
                     return;
                 }
                 const arg = returnNode.argument;
-                // Determine return value type and extract relevant info
+                // Extract expression-specific info using shared method
+                const exprInfo = this.extractReturnExpressionInfo(arg, module, literals, literalCounterRef, returnLine, returnColumn, 'return');
                 const returnInfo = {
                     parentFunctionId: currentFunctionId,
                     file: module.file,
                     line: returnLine,
                     column: returnColumn,
-                    returnValueType: 'NONE'
+                    returnValueType: 'NONE',
+                    ...exprInfo,
                 };
-                // 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
+            // REG-311: Also detect async_throw rejection patterns
             ThrowStatement: (throwPath) => {
                 // Skip if this throw is inside a nested function (not the function we're analyzing)
                 let parent = throwPath.parentPath;
@@ -3107,6 +3090,122 @@ export class JSASTAnalyzer extends Plugin {
                     parent = parent.parentPath;
                 }
                 controlFlowState.hasThrow = true;
+                // REG-311: Track rejection patterns for async functions
+                const isAsyncFunction = functionNode?.async === true;
+                if (isAsyncFunction && currentFunctionId && functionNode && functionPath) {
+                    const throwNode = throwPath.node;
+                    const arg = throwNode.argument;
+                    const throwLine = getLine(throwNode);
+                    const throwColumn = getColumn(throwNode);
+                    // Case 1: throw new Error() or throw new CustomError()
+                    if (arg && t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
+                        rejectionPatterns.push({
+                            functionId: currentFunctionId,
+                            errorClassName: arg.callee.name,
+                            rejectionType: 'async_throw',
+                            file: module.file,
+                            line: throwLine,
+                            column: throwColumn
+                        });
+                    }
+                    // Case 2: throw identifier - needs micro-trace
+                    else if (arg && t.isIdentifier(arg)) {
+                        const varName = arg.name;
+                        // Check if it's a parameter
+                        const isParameter = functionNode.params.some(param => t.isIdentifier(param) && param.name === varName);
+                        if (isParameter) {
+                            // Parameter forwarding - can't resolve statically
+                            rejectionPatterns.push({
+                                functionId: currentFunctionId,
+                                errorClassName: null,
+                                rejectionType: 'variable_parameter',
+                                file: module.file,
+                                line: throwLine,
+                                column: throwColumn,
+                                sourceVariableName: varName
+                            });
+                        }
+                        else {
+                            // Try micro-trace
+                            const { errorClassName, tracePath } = this.microTraceToErrorClass(varName, functionPath, variableDeclarations);
+                            rejectionPatterns.push({
+                                functionId: currentFunctionId,
+                                errorClassName,
+                                rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
+                                file: module.file,
+                                line: throwLine,
+                                column: throwColumn,
+                                sourceVariableName: varName,
+                                tracePath
+                            });
+                        }
+                    }
+                }
+            },
+            // Handle yield expressions for YIELDS/DELEGATES_TO edges (REG-270)
+            YieldExpression: (yieldPath) => {
+                // Skip if we couldn't determine the function ID
+                if (!currentFunctionId) {
+                    return;
+                }
+                // Skip if this yield is inside a nested function (not the function we're analyzing)
+                // Check if there's a function ancestor BETWEEN us and funcNode
+                let parent = yieldPath.parentPath;
+                while (parent) {
+                    // If we've reached funcNode, we're done checking - this yield belongs to funcNode
+                    if (parent.node === funcNode) {
+                        break;
+                    }
+                    if (t.isFunction(parent.node)) {
+                        // Found a function between yieldPath and funcNode - this yield is inside a nested function
+                        return;
+                    }
+                    parent = parent.parentPath;
+                }
+                const yieldNode = yieldPath.node;
+                const yieldLine = getLine(yieldNode);
+                const yieldColumn = getColumn(yieldNode);
+                const isDelegate = yieldNode.delegate ?? false;
+                // Handle bare yield; (no value) - only valid for non-delegate yield
+                if (!yieldNode.argument && !isDelegate) {
+                    // Skip - no data flow value
+                    return;
+                }
+                // For yield* without argument (syntax error in practice, but handle gracefully)
+                if (!yieldNode.argument) {
+                    return;
+                }
+                const arg = yieldNode.argument;
+                // Extract expression-specific info using shared method
+                // Note: We reuse extractReturnExpressionInfo since yield values have identical semantics
+                const exprInfo = this.extractReturnExpressionInfo(arg, module, literals, literalCounterRef, yieldLine, yieldColumn, 'yield');
+                // Map ReturnStatementInfo fields to YieldExpressionInfo fields
+                const yieldInfo = {
+                    parentFunctionId: currentFunctionId,
+                    file: module.file,
+                    line: yieldLine,
+                    column: yieldColumn,
+                    isDelegate,
+                    yieldValueType: exprInfo.returnValueType ?? 'NONE',
+                    yieldValueName: exprInfo.returnValueName,
+                    yieldValueId: exprInfo.returnValueId,
+                    yieldValueLine: exprInfo.returnValueLine,
+                    yieldValueColumn: exprInfo.returnValueColumn,
+                    yieldValueCallName: exprInfo.returnValueCallName,
+                    expressionType: exprInfo.expressionType,
+                    operator: exprInfo.operator,
+                    leftSourceName: exprInfo.leftSourceName,
+                    rightSourceName: exprInfo.rightSourceName,
+                    consequentSourceName: exprInfo.consequentSourceName,
+                    alternateSourceName: exprInfo.alternateSourceName,
+                    object: exprInfo.object,
+                    property: exprInfo.property,
+                    computed: exprInfo.computed,
+                    objectSourceName: exprInfo.objectSourceName,
+                    expressionSourceNames: exprInfo.expressionSourceNames,
+                    unaryArgSourceName: exprInfo.unaryArgSourceName,
+                };
+                yieldExpressions.push(yieldInfo);
             },
             ForStatement: this.createLoopScopeHandler('for', 'for-loop', 'for', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
             ForInStatement: this.createLoopScopeHandler('for-in', 'for-in-loop', 'for-in', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
@@ -3115,10 +3214,53 @@ export class JSASTAnalyzer extends Plugin {
             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),
+            CatchClause: this.createCatchClauseHandler(module, variableDeclarations, varDeclCounterRef, scopeTracker, tryScopeMap, scopeIdStack, controlFlowState),
             SwitchStatement: (switchPath) => {
                 this.handleSwitchStatement(switchPath, parentScopeId, module, collections, scopeTracker, controlFlowState);
             },
+            FunctionDeclaration: (funcDeclPath) => {
+                const node = funcDeclPath.node;
+                const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeTracker);
+                // Use semantic ID as primary ID when scopeTracker available
+                const legacyId = `FUNCTION#${funcName}#${module.file}#${getLine(node)}:${getColumn(node)}:${functionCounterRef.value++}`;
+                const functionId = scopeTracker
+                    ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
+                    : legacyId;
+                functions.push({
+                    id: functionId,
+                    type: 'FUNCTION',
+                    name: funcName,
+                    file: module.file,
+                    line: getLine(node),
+                    column: getColumn(node),
+                    async: node.async || false,
+                    generator: node.generator || false,
+                    parentScopeId
+                });
+                const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(node)}`;
+                const closureSemanticId = this.generateSemanticId('closure', scopeTracker);
+                scopes.push({
+                    id: nestedScopeId,
+                    type: 'SCOPE',
+                    scopeType: 'closure',
+                    name: `${funcName}:body`,
+                    semanticId: closureSemanticId,
+                    conditional: false,
+                    file: module.file,
+                    line: getLine(node),
+                    parentFunctionId: functionId,
+                    capturesFrom: parentScopeId
+                });
+                // Enter nested function scope for semantic ID generation
+                if (scopeTracker) {
+                    scopeTracker.enterScope(funcName, 'function');
+                }
+                this.analyzeFunctionBody(funcDeclPath, nestedScopeId, module, collections);
+                if (scopeTracker) {
+                    scopeTracker.exitScope();
+                }
+                funcDeclPath.skip();
+            },
             FunctionExpression: (funcPath) => {
                 const node = funcPath.node;
                 const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeTracker);
@@ -3222,129 +3364,17 @@ export class JSASTAnalyzer extends Plugin {
                     const bodyExpr = node.body;
                     const bodyLine = getLine(bodyExpr);
                     const bodyColumn = getColumn(bodyExpr);
+                    // Extract expression-specific info using shared method
+                    const exprInfo = this.extractReturnExpressionInfo(bodyExpr, module, literals, literalCounterRef, line, column, 'implicit_return');
                     const returnInfo = {
                         parentFunctionId: functionId,
                         file: module.file,
                         line: bodyLine,
                         column: bodyColumn,
                         returnValueType: 'NONE',
-                        isImplicitReturn: true
+                        isImplicitReturn: true,
+                        ...exprInfo,
                     };
-                    // 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();
@@ -3383,7 +3413,12 @@ export class JSASTAnalyzer extends Plugin {
             BlockStatement: this.createBlockStatementHandler(scopeTracker, ifElseScopeMap, tryScopeMap, scopeIdStack),
             // Function call expressions
             CallExpression: (callPath) => {
-                this.handleCallExpression(callPath.node, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, getCurrentScopeId(), collections);
+                // REG-311: Detect isAwaited (parent is AwaitExpression)
+                const parent = callPath.parentPath;
+                const isAwaited = parent?.isAwaitExpression() ?? false;
+                // REG-311: Detect isInsideTry (O(1) via depth counter)
+                const isInsideTry = controlFlowState.tryBlockDepth > 0;
+                this.handleCallExpression(callPath.node, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, getCurrentScopeId(), collections, isAwaited, isInsideTry);
                 // REG-334: Check for resolve/reject calls inside Promise executors
                 const callNode = callPath.node;
                 if (t.isIdentifier(callNode.callee)) {
@@ -3476,6 +3511,147 @@ export class JSASTAnalyzer extends Plugin {
                         }
                         funcParent = funcParent.getFunctionParent();
                     }
+                    // REG-311: Detect executor_reject pattern - reject(new Error()) inside Promise executor
+                    // Walk up to find Promise executor context and check if this is reject call with NewExpression arg
+                    funcParent = callPath.getFunctionParent();
+                    while (funcParent && currentFunctionId) {
+                        const funcNode = funcParent.node;
+                        const funcKey = `${funcNode.start}:${funcNode.end}`;
+                        const context = promiseExecutorContexts.get(funcKey);
+                        if (context && calleeName === context.rejectName && callNode.arguments.length > 0) {
+                            // REG-311: Use the creator function's ID (the function that created the Promise),
+                            // not the executor's ID
+                            const targetFunctionId = context.creatorFunctionId || currentFunctionId;
+                            const arg = callNode.arguments[0];
+                            const callLine = getLine(callNode);
+                            const callColumn = getColumn(callNode);
+                            // Case 1: reject(new Error())
+                            if (t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
+                                rejectionPatterns.push({
+                                    functionId: targetFunctionId,
+                                    errorClassName: arg.callee.name,
+                                    rejectionType: 'executor_reject',
+                                    file: module.file,
+                                    line: callLine,
+                                    column: callColumn
+                                });
+                            }
+                            // Case 2: reject(err) where err is variable
+                            else if (t.isIdentifier(arg)) {
+                                const varName = arg.name;
+                                // Check if it's a parameter of ANY containing function (executor, outer, etc.)
+                                // Walk up the function chain to find if varName is a parameter
+                                let isParameter = false;
+                                let checkParent = funcParent;
+                                while (checkParent) {
+                                    if (t.isFunction(checkParent.node)) {
+                                        if (checkParent.node.params.some(p => t.isIdentifier(p) && p.name === varName)) {
+                                            isParameter = true;
+                                            break;
+                                        }
+                                    }
+                                    checkParent = checkParent.getFunctionParent();
+                                }
+                                if (isParameter) {
+                                    rejectionPatterns.push({
+                                        functionId: targetFunctionId,
+                                        errorClassName: null,
+                                        rejectionType: 'variable_parameter',
+                                        file: module.file,
+                                        line: callLine,
+                                        column: callColumn,
+                                        sourceVariableName: varName
+                                    });
+                                }
+                                else {
+                                    // Try micro-trace
+                                    const { errorClassName, tracePath } = this.microTraceToErrorClass(varName, funcParent, variableDeclarations);
+                                    rejectionPatterns.push({
+                                        functionId: targetFunctionId,
+                                        errorClassName,
+                                        rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
+                                        file: module.file,
+                                        line: callLine,
+                                        column: callColumn,
+                                        sourceVariableName: varName,
+                                        tracePath
+                                    });
+                                }
+                            }
+                            break;
+                        }
+                        funcParent = funcParent.getFunctionParent();
+                    }
+                }
+                // REG-311: Detect Promise.reject(new Error()) pattern
+                if (t.isMemberExpression(callNode.callee) && currentFunctionId) {
+                    const memberCallee = callNode.callee;
+                    if (t.isIdentifier(memberCallee.object) &&
+                        memberCallee.object.name === 'Promise' &&
+                        t.isIdentifier(memberCallee.property) &&
+                        memberCallee.property.name === 'reject' &&
+                        callNode.arguments.length > 0) {
+                        const arg = callNode.arguments[0];
+                        const callLine = getLine(callNode);
+                        const callColumn = getColumn(callNode);
+                        // Case 1: Promise.reject(new Error())
+                        if (t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
+                            rejectionPatterns.push({
+                                functionId: currentFunctionId,
+                                errorClassName: arg.callee.name,
+                                rejectionType: 'promise_reject',
+                                file: module.file,
+                                line: callLine,
+                                column: callColumn
+                            });
+                        }
+                        // Case 2: Promise.reject(err) where err is variable
+                        else if (t.isIdentifier(arg)) {
+                            const varName = arg.name;
+                            // Check if it's a parameter of containing function
+                            const isParameter = functionNode
+                                ? functionNode.params.some(param => t.isIdentifier(param) && param.name === varName)
+                                : false;
+                            if (isParameter) {
+                                rejectionPatterns.push({
+                                    functionId: currentFunctionId,
+                                    errorClassName: null,
+                                    rejectionType: 'variable_parameter',
+                                    file: module.file,
+                                    line: callLine,
+                                    column: callColumn,
+                                    sourceVariableName: varName
+                                });
+                            }
+                            else {
+                                // Try micro-trace
+                                if (!functionPath) {
+                                    rejectionPatterns.push({
+                                        functionId: currentFunctionId,
+                                        errorClassName: null,
+                                        rejectionType: 'variable_unknown',
+                                        file: module.file,
+                                        line: callLine,
+                                        column: callColumn,
+                                        sourceVariableName: varName,
+                                        tracePath: [varName]
+                                    });
+                                    return;
+                                }
+                                const { errorClassName, tracePath } = this.microTraceToErrorClass(varName, functionPath, variableDeclarations);
+                                rejectionPatterns.push({
+                                    functionId: currentFunctionId,
+                                    errorClassName,
+                                    rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
+                                    file: module.file,
+                                    line: callLine,
+                                    column: callColumn,
+                                    sourceVariableName: varName,
+                                    tracePath
+                                });
+                            }
+                        }
+                    }
                 }
             },
             // NewExpression (constructor calls)
@@ -3531,7 +3707,9 @@ export class JSASTAnalyzer extends Plugin {
                                         resolveName,
                                         rejectName,
                                         file: module.file,
-                                        line
+                                        line,
+                                        // REG-311: Store the ID of the function that creates the Promise
+                                        creatorFunctionId: currentFunctionId || undefined
                                     });
                                 }
                             }
@@ -3597,8 +3775,36 @@ export class JSASTAnalyzer extends Plugin {
                         });
                     }
                 }
+            },
+            // Property access expressions (REG-395)
+            // Shared handler for both MemberExpression and OptionalMemberExpression
+            MemberExpression: (memberPath) => {
+                // Initialize collections if needed
+                if (!collections.propertyAccesses) {
+                    collections.propertyAccesses = [];
+                }
+                if (!collections.propertyAccessCounterRef) {
+                    collections.propertyAccessCounterRef = { value: 0 };
+                }
+                PropertyAccessVisitor.extractPropertyAccesses(memberPath, memberPath.node, module, collections.propertyAccesses, collections.propertyAccessCounterRef, scopeTracker, currentFunctionId || getCurrentScopeId());
+            },
+            // OptionalMemberExpression: obj?.prop (same logic as MemberExpression)
+            OptionalMemberExpression: (memberPath) => {
+                // Initialize collections if needed
+                if (!collections.propertyAccesses) {
+                    collections.propertyAccesses = [];
+                }
+                if (!collections.propertyAccessCounterRef) {
+                    collections.propertyAccessCounterRef = { value: 0 };
+                }
+                PropertyAccessVisitor.extractPropertyAccesses(memberPath, memberPath.node, module, collections.propertyAccesses, collections.propertyAccessCounterRef, scopeTracker, currentFunctionId || getCurrentScopeId());
             }
         });
+        // REG-311: Second pass - collect CATCHES_FROM info for try/catch blocks
+        // This links catch blocks to exception sources in their corresponding try blocks
+        if (functionPath) {
+            this.collectCatchesFromInfo(functionPath, catchBlocks, callSites, methodCalls, constructorCalls, catchesFromInfos, module);
+        }
         // Phase 6 (REG-267): Attach control flow metadata to the function node
         if (matchingFunction) {
             const cyclomaticComplexity = 1 +
@@ -3606,13 +3812,24 @@ export class JSASTAnalyzer extends Plugin {
                 controlFlowState.loopCount +
                 controlFlowState.caseCount +
                 controlFlowState.logicalOpCount;
+            // REG-311: Collect rejection info for this function
+            const functionRejectionPatterns = rejectionPatterns.filter(p => p.functionId === matchingFunction.id);
+            const canReject = functionRejectionPatterns.length > 0;
+            const hasAsyncThrow = functionRejectionPatterns.some(p => p.rejectionType === 'async_throw');
+            const rejectedBuiltinErrors = [...new Set(functionRejectionPatterns
+                    .filter(p => p.errorClassName !== null)
+                    .map(p => p.errorClassName))];
             matchingFunction.controlFlow = {
                 hasBranches: controlFlowState.branchCount > 0,
                 hasLoops: controlFlowState.loopCount > 0,
                 hasTryCatch: controlFlowState.hasTryCatch,
                 hasEarlyReturn: controlFlowState.hasEarlyReturn,
                 hasThrow: controlFlowState.hasThrow,
-                cyclomaticComplexity
+                cyclomaticComplexity,
+                // REG-311: Async error tracking
+                canReject,
+                hasAsyncThrow,
+                rejectedBuiltinErrors: rejectedBuiltinErrors.length > 0 ? rejectedBuiltinErrors : undefined
             };
         }
     }
@@ -3625,6 +3842,7 @@ export class JSASTAnalyzer extends Plugin {
      * - Method calls (MemberExpression callee) → methodCalls collection
      * - Array mutation detection (push, unshift, splice)
      * - Object.assign() detection
+     * - REG-311: isAwaited and isInsideTry metadata on CALL nodes
      *
      * @param callNode - The call expression AST node
      * @param processedCallSites - Set of already processed call site keys to avoid duplicates
@@ -3636,8 +3854,10 @@ export class JSASTAnalyzer extends Plugin {
      * @param scopeTracker - Optional scope tracker for semantic ID generation
      * @param parentScopeId - ID of the parent scope containing this call
      * @param collections - Full collections object for array/object mutations
+     * @param isAwaited - REG-311: true if wrapped in await expression
+     * @param isInsideTry - REG-311: true if inside try block
      */
-    handleCallExpression(callNode, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, parentScopeId, collections) {
+    handleCallExpression(callNode, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, parentScopeId, collections, isAwaited = false, isInsideTry = false) {
         // Handle direct function calls (greet(), main())
         if (callNode.callee.type === 'Identifier') {
             const nodeKey = `${callNode.start}:${callNode.end}`;
@@ -3661,7 +3881,10 @@ export class JSASTAnalyzer extends Plugin {
                 line: getLine(callNode),
                 column: getColumn(callNode), // REG-223: Add column for coordinate-based lookup
                 parentScopeId,
-                targetFunctionName: calleeName
+                targetFunctionName: calleeName,
+                // REG-311: Async error tracking metadata
+                isAwaited,
+                isInsideTry
             });
         }
         // Handle method calls (obj.method(), data.process())
@@ -3697,7 +3920,11 @@ export class JSASTAnalyzer extends Plugin {
                     file: module.file,
                     line: getLine(callNode),
                     column: getColumn(callNode),
-                    parentScopeId
+                    parentScopeId,
+                    // REG-311: Async error tracking metadata
+                    isAwaited,
+                    isInsideTry,
+                    isMethodCall: true
                 });
                 // Check for array mutation methods (push, unshift, splice)
                 const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
@@ -3720,6 +3947,7 @@ export class JSASTAnalyzer extends Plugin {
                 }
             }
             // REG-117: Nested array mutations like obj.arr.push(item)
+            // REG-395: General nested method calls like a.b.c() or obj.nested.method()
             // object is MemberExpression, property is the method name
             else if (object.type === 'MemberExpression' && property.type === 'Identifier') {
                 const nestedMember = object;
@@ -3745,8 +3973,238 @@ export class JSASTAnalyzer extends Plugin {
                         baseObjectName, propertyName);
                     }
                 }
+                // REG-395: Create CALL node for nested method calls like a.b.c()
+                const objectName = CallExpressionVisitor.extractMemberExpressionName(nestedMember);
+                if (objectName) {
+                    const nodeKey = `${callNode.start}:${callNode.end}`;
+                    if (!processedMethodCalls.has(nodeKey)) {
+                        processedMethodCalls.add(nodeKey);
+                        const fullName = `${objectName}.${methodName}`;
+                        const legacyId = `CALL#${fullName}#${module.file}#${getLine(callNode)}:${getColumn(callNode)}:${callSiteCounterRef.value++}`;
+                        let methodCallId = legacyId;
+                        if (scopeTracker) {
+                            const discriminator = scopeTracker.getItemCounter(`CALL:${fullName}`);
+                            methodCallId = computeSemanticId('CALL', fullName, scopeTracker.getContext(), { discriminator });
+                        }
+                        methodCalls.push({
+                            id: methodCallId,
+                            type: 'CALL',
+                            name: fullName,
+                            object: objectName,
+                            method: methodName,
+                            file: module.file,
+                            line: getLine(callNode),
+                            column: getColumn(callNode),
+                            parentScopeId,
+                            isMethodCall: true
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * REG-311: Micro-trace - follow variable assignments within function to find error source.
+     * Used to resolve reject(err) or throw err where err is a variable.
+     *
+     * Uses cycle detection via Set<variableName> to avoid infinite loops on circular assignments.
+     *
+     * @param variableName - Name of variable to trace
+     * @param funcPath - NodePath of containing function for AST traversal
+     * @param variableDeclarations - Variable declarations in current scope
+     * @returns Error class name if traced to NewExpression, null otherwise, plus trace path
+     */
+    microTraceToErrorClass(variableName, funcPath, _variableDeclarations) {
+        const tracePath = [variableName];
+        const visited = new Set(); // Cycle detection
+        let currentName = variableName;
+        const funcBody = funcPath.node.body;
+        if (!t.isBlockStatement(funcBody)) {
+            return { errorClassName: null, tracePath };
+        }
+        // Iterate until we find a NewExpression or can't trace further
+        while (!visited.has(currentName)) {
+            visited.add(currentName);
+            let found = false;
+            let foundNewExpression = null;
+            let nextName = null;
+            // Walk AST to find assignments: currentName = newValue
+            funcPath.traverse({
+                VariableDeclarator: (declPath) => {
+                    if (found || foundNewExpression)
+                        return;
+                    if (t.isIdentifier(declPath.node.id) && declPath.node.id.name === currentName) {
+                        const init = declPath.node.init;
+                        if (init) {
+                            // Case 1: const err = new Error()
+                            if (t.isNewExpression(init) && t.isIdentifier(init.callee)) {
+                                tracePath.push(`new ${init.callee.name}()`);
+                                foundNewExpression = init.callee.name;
+                                found = true;
+                                return;
+                            }
+                            // Case 2: const err = otherVar (chain)
+                            if (t.isIdentifier(init)) {
+                                tracePath.push(init.name);
+                                nextName = init.name;
+                                found = true;
+                                return;
+                            }
+                        }
+                    }
+                },
+                AssignmentExpression: (assignPath) => {
+                    if (found || foundNewExpression)
+                        return;
+                    const left = assignPath.node.left;
+                    const right = assignPath.node.right;
+                    if (t.isIdentifier(left) && left.name === currentName) {
+                        if (t.isNewExpression(right) && t.isIdentifier(right.callee)) {
+                            tracePath.push(`new ${right.callee.name}()`);
+                            foundNewExpression = right.callee.name;
+                            found = true;
+                            return;
+                        }
+                        if (t.isIdentifier(right)) {
+                            tracePath.push(right.name);
+                            nextName = right.name;
+                            found = true;
+                            return;
+                        }
+                    }
+                }
+            });
+            // If we found a NewExpression, return the class name
+            if (foundNewExpression) {
+                return { errorClassName: foundNewExpression, tracePath };
             }
+            // If we found another variable to follow, continue
+            if (nextName) {
+                currentName = nextName;
+                continue;
+            }
+            // Couldn't trace further
+            break;
         }
+        return { errorClassName: null, tracePath };
+    }
+    /**
+     * REG-311: Collect CATCHES_FROM info linking catch blocks to exception sources in try blocks.
+     *
+     * Sources include:
+     * - Awaited calls: await foo() in try block
+     * - Sync calls: foo() in try block (any call can throw)
+     * - Throw statements: throw new Error() in try block
+     * - Constructor calls: new SomeClass() in try block
+     *
+     * @param funcPath - Function path to traverse
+     * @param catchBlocks - Collection of CATCH_BLOCK nodes
+     * @param callSites - Collection of CALL nodes (direct function calls)
+     * @param methodCalls - Collection of CALL nodes (method calls)
+     * @param constructorCalls - Collection of CONSTRUCTOR_CALL nodes
+     * @param catchesFromInfos - Collection to push CatchesFromInfo to
+     * @param module - Module context
+     */
+    collectCatchesFromInfo(funcPath, catchBlocks, callSites, methodCalls, constructorCalls, catchesFromInfos, module) {
+        // Traverse to find TryStatements and collect sources
+        funcPath.traverse({
+            TryStatement: (tryPath) => {
+                const tryNode = tryPath.node;
+                const handler = tryNode.handler;
+                // Skip if no catch clause
+                if (!handler)
+                    return;
+                // Find the catch block for this try
+                // Match by line number since we don't have the tryBlockId here
+                const catchLine = getLine(handler);
+                const catchBlock = catchBlocks.find(cb => cb.file === module.file && cb.line === catchLine);
+                if (!catchBlock || !catchBlock.parameterName)
+                    return;
+                // Traverse only the try block body (not catch or finally)
+                const _tryBody = tryNode.block;
+                const sources = [];
+                // Collect sources from try block
+                tryPath.get('block').traverse({
+                    // Stop at nested TryStatement - don't collect from inner try blocks
+                    TryStatement: (innerPath) => {
+                        innerPath.skip(); // Don't traverse into nested try blocks
+                    },
+                    // Stop at function boundaries - don't collect from nested functions
+                    Function: (innerFuncPath) => {
+                        innerFuncPath.skip();
+                    },
+                    CallExpression: (callPath) => {
+                        const callNode = callPath.node;
+                        const callLine = getLine(callNode);
+                        const callColumn = getColumn(callNode);
+                        // Check if this is an awaited call
+                        const parent = callPath.parentPath;
+                        const isAwaited = parent?.isAwaitExpression() ?? false;
+                        // Find the CALL node that matches this CallExpression
+                        let sourceId = null;
+                        let sourceType = 'sync_call';
+                        // Check method calls first (includes Promise.reject which is a method call)
+                        const matchingMethodCall = methodCalls.find(mc => mc.file === module.file &&
+                            mc.line === callLine &&
+                            mc.column === callColumn);
+                        if (matchingMethodCall) {
+                            sourceId = matchingMethodCall.id;
+                            sourceType = isAwaited ? 'awaited_call' : 'sync_call';
+                        }
+                        else {
+                            // Check direct function calls
+                            const matchingCallSite = callSites.find(cs => cs.file === module.file &&
+                                cs.line === callLine &&
+                                cs.column === callColumn);
+                            if (matchingCallSite) {
+                                sourceId = matchingCallSite.id;
+                                sourceType = isAwaited ? 'awaited_call' : 'sync_call';
+                            }
+                        }
+                        if (sourceId) {
+                            sources.push({ id: sourceId, type: sourceType, line: callLine });
+                        }
+                    },
+                    ThrowStatement: (throwPath) => {
+                        const throwNode = throwPath.node;
+                        const throwLine = getLine(throwNode);
+                        const throwColumn = getColumn(throwNode);
+                        // Create a synthetic ID for the throw statement
+                        // We don't have THROW_STATEMENT nodes, so we use line/column as identifier
+                        const sourceId = `THROW#${module.file}#${throwLine}:${throwColumn}`;
+                        sources.push({ id: sourceId, type: 'throw_statement', line: throwLine });
+                    },
+                    NewExpression: (newPath) => {
+                        // Skip NewExpression that is direct argument of ThrowStatement
+                        // In `throw new Error()`, the throw statement is the primary source
+                        if (newPath.parentPath?.isThrowStatement()) {
+                            return;
+                        }
+                        const newNode = newPath.node;
+                        const newLine = getLine(newNode);
+                        const newColumn = getColumn(newNode);
+                        // Find matching constructor call
+                        const matchingConstructor = constructorCalls.find(cc => cc.file === module.file &&
+                            cc.line === newLine &&
+                            cc.column === newColumn);
+                        if (matchingConstructor) {
+                            sources.push({ id: matchingConstructor.id, type: 'constructor_call', line: newLine });
+                        }
+                    }
+                });
+                // Create CatchesFromInfo for each source
+                for (const source of sources) {
+                    catchesFromInfos.push({
+                        catchBlockId: catchBlock.id,
+                        parameterName: catchBlock.parameterName,
+                        sourceId: source.id,
+                        sourceType: source.type,
+                        file: module.file,
+                        sourceLine: source.line
+                    });
+                }
+            }
+        });
     }
     /**
      * Detect array mutation calls (push, unshift, splice) inside functions
@@ -3831,20 +4289,24 @@ export class JSASTAnalyzer extends Plugin {
     }
     /**
      * Detect indexed array assignment: arr[i] = value
-     * Creates ArrayMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+     * Creates ArrayMutationInfo for FLOWS_INTO edge generation in GraphBuilder.
+     * For non-variable values (LITERAL, OBJECT_LITERAL, ARRAY_LITERAL), creates
+     * value nodes and sets valueNodeId so GraphBuilder can create FLOWS_INTO edges.
      *
      * @param assignNode - The assignment expression node
      * @param module - Current module being analyzed
      * @param arrayMutations - Collection to push mutation info into
+     * @param scopeTracker - Scope tracker for semantic ID generation
+     * @param collections - Collections for creating value nodes (literals, objectLiterals, etc.)
      */
-    detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker) {
+    detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker, collections) {
         // Check for indexed array assignment: arr[i] = value
         if (assignNode.left.type === 'MemberExpression' && assignNode.left.computed) {
             const memberExpr = assignNode.left;
             // Only process NumericLiteral keys - those are clearly array indexed assignments
             // e.g., arr[0] = value, arr[1] = value
-            // All other computed keys (StringLiteral, Identifier, expressions) are handled as object mutations
-            // This avoids duplicate edge creation for ambiguous cases like obj[key] = value
+            // Other computed keys (Identifier, expressions) are ambiguous (could be array or object)
+            // and are handled by detectObjectPropertyAssignment as computed mutations
             if (memberExpr.property.type !== 'NumericLiteral') {
                 return;
             }
@@ -3852,16 +4314,38 @@ export class JSASTAnalyzer extends Plugin {
             if (memberExpr.object.type === 'Identifier') {
                 const arrayName = memberExpr.object.name;
                 const value = assignNode.right;
+                // Use defensive loc checks instead of ! assertions
+                const line = assignNode.loc?.start.line ?? 0;
+                const column = assignNode.loc?.start.column ?? 0;
                 const argInfo = {
                     argIndex: 0,
                     isSpread: false,
                     valueType: 'EXPRESSION'
                 };
-                // Determine value type
+                // Determine value type and create value nodes for non-variable types (REG-392)
                 const literalValue = ExpressionEvaluator.extractLiteralValue(value);
                 if (literalValue !== null) {
                     argInfo.valueType = 'LITERAL';
                     argInfo.literalValue = literalValue;
+                    const valueLine = value.loc?.start.line ?? line;
+                    const valueColumn = value.loc?.start.column ?? column;
+                    // Create LITERAL node if collections available
+                    if (collections?.literals && collections.literalCounterRef) {
+                        const literalCounterRef = collections.literalCounterRef;
+                        const literalId = `LITERAL#indexed#${module.file}#${valueLine}:${valueColumn}:${literalCounterRef.value++}`;
+                        collections.literals.push({
+                            id: literalId,
+                            type: 'LITERAL',
+                            value: literalValue,
+                            valueType: typeof literalValue,
+                            file: module.file,
+                            line: valueLine,
+                            column: valueColumn,
+                            parentCallId: undefined,
+                            argIndex: 0
+                        });
+                        argInfo.valueNodeId = literalId;
+                    }
                 }
                 else if (value.type === 'Identifier') {
                     argInfo.valueType = 'VARIABLE';
@@ -3869,18 +4353,37 @@ export class JSASTAnalyzer extends Plugin {
                 }
                 else if (value.type === 'ObjectExpression') {
                     argInfo.valueType = 'OBJECT_LITERAL';
+                    const valueLine = value.loc?.start.line ?? line;
+                    const valueColumn = value.loc?.start.column ?? column;
+                    // Create OBJECT_LITERAL node if collections available
+                    if (collections?.objectLiteralCounterRef) {
+                        if (!collections.objectLiterals)
+                            collections.objectLiterals = [];
+                        const objectLiteralCounterRef = collections.objectLiteralCounterRef;
+                        const objectNode = ObjectLiteralNode.create(module.file, valueLine, valueColumn, { counter: objectLiteralCounterRef.value++ });
+                        collections.objectLiterals.push(objectNode);
+                        argInfo.valueNodeId = objectNode.id;
+                    }
                 }
                 else if (value.type === 'ArrayExpression') {
                     argInfo.valueType = 'ARRAY_LITERAL';
+                    const valueLine = value.loc?.start.line ?? line;
+                    const valueColumn = value.loc?.start.column ?? column;
+                    // Create ARRAY_LITERAL node if collections available
+                    if (collections?.arrayLiteralCounterRef) {
+                        if (!collections.arrayLiterals)
+                            collections.arrayLiterals = [];
+                        const arrayLiteralCounterRef = collections.arrayLiteralCounterRef;
+                        const arrayNode = ArrayLiteralNode.create(module.file, valueLine, valueColumn, { counter: arrayLiteralCounterRef.value++ });
+                        collections.arrayLiterals.push(arrayNode);
+                        argInfo.valueNodeId = arrayNode.id;
+                    }
                 }
                 else if (value.type === 'CallExpression') {
                     argInfo.valueType = 'CALL';
                     argInfo.callLine = value.loc?.start.line;
                     argInfo.callColumn = value.loc?.start.column;
                 }
-                // Use defensive loc checks instead of ! assertions
-                const line = assignNode.loc?.start.line ?? 0;
-                const column = assignNode.loc?.start.column ?? 0;
                 // Capture scope path for scope-aware lookup (REG-309)
                 const scopePath = scopeTracker?.getContext().scopePath ?? [];
                 arrayMutations.push({
@@ -4303,3 +4806,4 @@ export class JSASTAnalyzer extends Plugin {
         }
     }
 }
+//# sourceMappingURL=JSASTAnalyzer.js.map