@grafema/core 0.2.4-beta → 0.2.5-beta

package/src/plugins/analysis/JSASTAnalyzer.ts

@@ -40,6 +40,7 @@ import {
   ClassVisitor,
   CallExpressionVisitor,
   TypeScriptVisitor,
+  PropertyAccessVisitor,
   type VisitorModule,
   type VisitorCollections,
   type TrackVariableAssignmentCallback
@@ -56,6 +57,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';
 import type { PluginContext, PluginResult, PluginMetadata, GraphBackend } from '@grafema/types';
 import type {
@@ -97,9 +99,13 @@ import type {
   ObjectMutationValue,
   VariableReassignmentInfo,
   ReturnStatementInfo,
+  YieldExpressionInfo,
   UpdateExpressionInfo,
   PromiseResolutionInfo,
   PromiseExecutorContext,
+  RejectionPatternInfo,
+  CatchesFromInfo,
+  PropertyAccessInfo,
   CounterRef,
   ProcessedNodes,
   ASTCollections,
@@ -165,6 +171,11 @@ interface Collections {
   promiseResolutions: PromiseResolutionInfo[];
   // Promise executor contexts (REG-334) - keyed by executor function's start:end position
   promiseExecutorContexts: Map<string, PromiseExecutorContext>;
+  // Yield expression tracking for YIELDS/DELEGATES_TO edges (REG-270)
+  yieldExpressions: YieldExpressionInfo[];
+  // Property access tracking for PROPERTY_ACCESS nodes (REG-395)
+  propertyAccesses: PropertyAccessInfo[];
+  propertyAccessCounterRef: CounterRef;
   objectLiteralCounterRef: CounterRef;
   arrayLiteralCounterRef: CounterRef;
   ifScopeCounterRef: CounterRef;
@@ -250,7 +261,6 @@ export class JSASTAnalyzer extends Plugin {
     return {
       name: 'JSASTAnalyzer',
       phase: 'ANALYSIS',
-      priority: 80,
       creates: {
         nodes: [
           'FUNCTION', 'CLASS', 'METHOD', 'VARIABLE', 'CONSTANT', 'SCOPE',
@@ -269,7 +279,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'] },
+      ]
     };
   }
 
@@ -1458,6 +1477,13 @@ export class JSASTAnalyzer extends Plugin {
       const promiseResolutions: PromiseResolutionInfo[] = [];
       // Promise executor contexts (REG-334) - keyed by executor function's start:end position
       const promiseExecutorContexts = new Map<string, PromiseExecutorContext>();
+      // Yield expression tracking for YIELDS/DELEGATES_TO edges (REG-270)
+      const yieldExpressions: YieldExpressionInfo[] = [];
+      // REG-311: Async error tracking
+      const rejectionPatterns: RejectionPatternInfo[] = [];
+      const catchesFromInfos: CatchesFromInfo[] = [];
+      // Property access tracking for PROPERTY_ACCESS nodes (REG-395)
+      const propertyAccesses: PropertyAccessInfo[] = [];
 
       const ifScopeCounterRef: CounterRef = { value: 0 };
       const scopeCounterRef: CounterRef = { value: 0 };
@@ -1471,6 +1497,7 @@ export class JSASTAnalyzer extends Plugin {
       const arrayLiteralCounterRef: CounterRef = { value: 0 };
       const branchCounterRef: CounterRef = { value: 0 };
       const caseCounterRef: CounterRef = { value: 0 };
+      const propertyAccessCounterRef: CounterRef = { value: 0 };
 
       const processedNodes: ProcessedNodes = {
         functions: new Set(),
@@ -1533,6 +1560,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,
@@ -1634,7 +1669,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);
@@ -1728,6 +1763,12 @@ export class JSASTAnalyzer extends Plugin {
       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');
@@ -1791,7 +1832,9 @@ export class JSASTAnalyzer extends Plugin {
                     resolveName,
                     rejectName,
                     file: module.file,
-                    line
+                    line,
+                    // REG-311: Module-level Promise has no creator function
+                    creatorFunctionId: undefined
                   });
                 }
               }
@@ -1897,6 +1940,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)
@@ -1904,7 +1949,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 as RejectionPatternInfo[]
+          : rejectionPatterns,
+        catchesFromInfos: Array.isArray(allCollections.catchesFromInfos)
+          ? allCollections.catchesFromInfos as CatchesFromInfo[]
+          : catchesFromInfos,
+        // Property access tracking (REG-395)
+        propertyAccesses: allCollections.propertyAccesses || propertyAccesses
       });
       this.profiler.end('graph_build');
 
@@ -2401,7 +2455,7 @@ export class JSASTAnalyzer extends Plugin {
     scopeTracker: ScopeTracker | undefined,
     tryScopeMap: Map<t.TryStatement, TryScopeInfo>,
     scopeIdStack?: string[],
-    controlFlowState?: { hasTryCatch: boolean }
+    controlFlowState?: { hasTryCatch: boolean; tryBlockDepth: number }
   ): { enter: (tryPath: NodePath<t.TryStatement>) => void; exit: (tryPath: NodePath<t.TryStatement>) => void } {
     return {
       enter: (tryPath: NodePath<t.TryStatement>) => {
@@ -2410,6 +2464,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
@@ -2549,7 +2605,13 @@ export class JSASTAnalyzer extends Plugin {
       },
       exit: (tryPath: NodePath<t.TryStatement>) => {
         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) {
@@ -2584,7 +2646,8 @@ export class JSASTAnalyzer extends Plugin {
     varDeclCounterRef: CounterRef,
     scopeTracker: ScopeTracker | undefined,
     tryScopeMap: Map<t.TryStatement, TryScopeInfo>,
-    scopeIdStack?: string[]
+    scopeIdStack?: string[],
+    controlFlowState?: { hasTryCatch: boolean; tryBlockDepth: number }
   ): { enter: (catchPath: NodePath<t.CatchClause>) => void } {
     return {
       enter: (catchPath: NodePath<t.CatchClause>) => {
@@ -2610,6 +2673,12 @@ export class JSASTAnalyzer extends Plugin {
             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';
         }
 
@@ -2947,6 +3016,209 @@ 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
+   */
+  private extractReturnExpressionInfo(
+    expr: t.Expression,
+    module: { file: string },
+    literals: LiteralInfo[],
+    literalCounterRef: CounterRef,
+    baseLine: number,
+    baseColumn: number,
+    literalIdSuffix: 'return' | 'implicit_return' | 'yield' = 'return'
+  ): Partial<ReturnStatementInfo> {
+    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: string[] = [];
+      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.
@@ -3284,7 +3556,7 @@ export class JSASTAnalyzer extends Plugin {
    * Uses ScopeTracker from collections for semantic ID generation.
    */
   analyzeFunctionBody(
-    funcPath: NodePath<t.Function>,
+    funcPath: NodePath<t.Function | t.StaticBlock>,
     parentScopeId: string,
     module: VisitorModule,
     collections: VisitorCollections
@@ -3295,11 +3567,11 @@ export class JSASTAnalyzer extends Plugin {
     const variableDeclarations = (collections.variableDeclarations ?? []) as VariableDeclarationInfo[];
     const callSites = (collections.callSites ?? []) as CallSiteInfo[];
     const methodCalls = (collections.methodCalls ?? []) as MethodCallInfo[];
-    const eventListeners = (collections.eventListeners ?? []) as EventListenerInfo[];
-    const methodCallbacks = (collections.methodCallbacks ?? []) as MethodCallbackInfo[];
+    const _eventListeners = (collections.eventListeners ?? []) as EventListenerInfo[];
+    const _methodCallbacks = (collections.methodCallbacks ?? []) as MethodCallbackInfo[];
     const classInstantiations = (collections.classInstantiations ?? []) as ClassInstantiationInfo[];
     const constructorCalls = (collections.constructorCalls ?? []) as ConstructorCallInfo[];
-    const httpRequests = (collections.httpRequests ?? []) as HttpRequestInfo[];
+    const _httpRequests = (collections.httpRequests ?? []) as HttpRequestInfo[];
     const literals = (collections.literals ?? []) as LiteralInfo[];
     const variableAssignments = (collections.variableAssignments ?? []) as VariableAssignmentInfo[];
     const ifScopeCounterRef = (collections.ifScopeCounterRef ?? { value: 0 }) as CounterRef;
@@ -3307,9 +3579,9 @@ export class JSASTAnalyzer extends Plugin {
     const varDeclCounterRef = (collections.varDeclCounterRef ?? { value: 0 }) as CounterRef;
     const callSiteCounterRef = (collections.callSiteCounterRef ?? { value: 0 }) as CounterRef;
     const functionCounterRef = (collections.functionCounterRef ?? { value: 0 }) as CounterRef;
-    const httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 }) as CounterRef;
+    const _httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 }) as CounterRef;
     const literalCounterRef = (collections.literalCounterRef ?? { value: 0 }) as CounterRef;
-    const anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 }) as CounterRef;
+    const _anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 }) as CounterRef;
     const scopeTracker = collections.scopeTracker as ScopeTracker | undefined;
     // Object literal tracking (REG-328)
     if (!collections.objectLiterals) {
@@ -3325,7 +3597,12 @@ export class JSASTAnalyzer extends Plugin {
     const objectProperties = collections.objectProperties as ObjectPropertyInfo[];
     const objectLiteralCounterRef = collections.objectLiteralCounterRef as CounterRef;
     const returnStatements = (collections.returnStatements ?? []) as ReturnStatementInfo[];
-    const parameters = (collections.parameters ?? []) as ParameterInfo[];
+    // Initialize yieldExpressions if not exist to ensure nested function calls share same array
+    if (!collections.yieldExpressions) {
+      collections.yieldExpressions = [];
+    }
+    const yieldExpressions = collections.yieldExpressions as YieldExpressionInfo[];
+    const _parameters = (collections.parameters ?? []) as ParameterInfo[];
     // Control flow collections (Phase 2: LOOP nodes)
     // Initialize if not exist to ensure nested function calls share same arrays
     if (!collections.loops) {
@@ -3352,9 +3629,9 @@ export class JSASTAnalyzer extends Plugin {
     const parentScopeVariables = new Set<{ name: string; id: string; scopeId: string }>();
 
     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<t.IfStatement, IfElseScopeInfo>();
@@ -3411,6 +3688,16 @@ export class JSASTAnalyzer extends Plugin {
     }
     const promiseResolutions = collections.promiseResolutions as PromiseResolutionInfo[];
 
+    // REG-311: Initialize rejectionPatterns and catchesFromInfos collections
+    if (!collections.rejectionPatterns) {
+      collections.rejectionPatterns = [];
+    }
+    if (!collections.catchesFromInfos) {
+      collections.catchesFromInfos = [];
+    }
+    const rejectionPatterns = collections.rejectionPatterns as RejectionPatternInfo[];
+    const catchesFromInfos = collections.catchesFromInfos as CatchesFromInfo[];
+
     // Dynamic scope ID stack for CONTAINS edges
     // Starts with the function body scope, gets updated as we enter/exit conditional scopes
     const scopeIdStack: string[] = [parentScopeId];
@@ -3418,16 +3705,24 @@ export class JSASTAnalyzer extends Plugin {
 
     // Determine the ID of the function we're analyzing for RETURNS edges
     // Find by matching file/line/column in functions collection (it was just added by the visitor)
+    // REG-271: Skip for StaticBlock (static blocks don't have RETURNS edges or control flow metadata)
     const funcNode = funcPath.node;
+    const functionNode = t.isFunction(funcNode) ? funcNode : null;
+    const functionPath = functionNode ? (funcPath as NodePath<t.Function>) : null;
     const funcLine = getLine(funcNode);
     const funcColumn = getColumn(funcNode);
     let currentFunctionId: string | null = null;
 
-    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;
     }
@@ -3442,7 +3737,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
@@ -3452,136 +3749,21 @@ export class JSASTAnalyzer extends Plugin {
       const bodyLine = getLine(bodyExpr);
       const bodyColumn = getColumn(bodyExpr);
 
+      // Extract expression-specific info using shared method
+      const exprInfo = this.extractReturnExpressionInfo(
+        bodyExpr, module, literals, literalCounterRef, funcLine, funcColumn, 'implicit_return'
+      );
+
       const returnInfo: ReturnStatementInfo = {
         parentFunctionId: currentFunctionId,
         file: module.file,
         line: bodyLine,
         column: bodyColumn,
         returnValueType: 'NONE',
-        isImplicitReturn: true
+        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: string[] = [];
-        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);
     }
 
@@ -3630,7 +3812,7 @@ export class JSASTAnalyzer extends Plugin {
         const arrayMutations = collections.arrayMutations as ArrayMutationInfo[];
 
         // 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) {
@@ -3695,238 +3877,174 @@ export class JSASTAnalyzer extends Plugin {
 
         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: ReturnStatementInfo = {
           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)
-          );
+        returnStatements.push(returnInfo);
+      },
 
-          // Extract all embedded expression identifiers
-          const sourceNames: string[] = [];
-          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;
+      // Phase 6 (REG-267): Track throw statements for control flow metadata
+      // REG-311: Also detect async_throw rejection patterns
+      ThrowStatement: (throwPath: NodePath<t.ThrowStatement>) => {
+        // Skip if this throw is inside a nested function (not the function we're analyzing)
+        let parent: NodePath | null = throwPath.parentPath;
+        while (parent) {
+          if (t.isFunction(parent.node) && parent.node !== funcNode) {
+            // This throw is inside a nested function - skip it
+            return;
           }
+          parent = parent.parentPath;
         }
-        // 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)
-          );
+        controlFlowState.hasThrow = true;
 
-          if (t.isIdentifier(arg.left)) {
-            returnInfo.leftSourceName = arg.left.name;
-          }
-          if (t.isIdentifier(arg.right)) {
-            returnInfo.rightSourceName = arg.right.name;
+        // 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
+            });
           }
-        }
-        // 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)
-          );
+          // Case 2: throw identifier - needs micro-trace
+          else if (arg && t.isIdentifier(arg)) {
+            const varName = arg.name;
 
-          // 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;
+            // 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
+              });
+            }
           }
         }
-        // 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;
-          }
+      // Handle yield expressions for YIELDS/DELEGATES_TO edges (REG-270)
+      YieldExpression: (yieldPath: NodePath<t.YieldExpression>) => {
+        // Skip if we couldn't determine the function ID
+        if (!currentFunctionId) {
+          return;
         }
-        // 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;
+        // Skip if this yield is inside a nested function (not the function we're analyzing)
+        // Check if there's a function ancestor BETWEEN us and funcNode
+        let parent: NodePath | null = yieldPath.parentPath;
+        while (parent) {
+          // If we've reached funcNode, we're done checking - this yield belongs to funcNode
+          if (parent.node === funcNode) {
+            break;
           }
-          if (t.isIdentifier(arg.property)) {
-            returnInfo.property = arg.property.name;
+          if (t.isFunction(parent.node)) {
+            // Found a function between yieldPath and funcNode - this yield is inside a nested function
+            return;
           }
-          returnInfo.computed = arg.computed;
+          parent = parent.parentPath;
         }
-        // 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)
-          );
+
+        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;
         }
-        // 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)
-          );
+        // For yield* without argument (syntax error in practice, but handle gracefully)
+        if (!yieldNode.argument) {
+          return;
         }
 
-        returnStatements.push(returnInfo);
-      },
+        const arg = yieldNode.argument;
 
-      // Phase 6 (REG-267): Track throw statements for control flow metadata
-      ThrowStatement: (throwPath: NodePath<t.ThrowStatement>) => {
-        // Skip if this throw is inside a nested function (not the function we're analyzing)
-        let parent: NodePath | null = throwPath.parentPath;
-        while (parent) {
-          if (t.isFunction(parent.node) && parent.node !== funcNode) {
-            // This throw is inside a nested function - skip it
-            return;
-          }
-          parent = parent.parentPath;
-        }
+        // 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'
+        );
 
-        controlFlowState.hasThrow = true;
+        // Map ReturnStatementInfo fields to YieldExpressionInfo fields
+        const yieldInfo: YieldExpressionInfo = {
+          parentFunctionId: currentFunctionId,
+          file: module.file,
+          line: yieldLine,
+          column: yieldColumn,
+          isDelegate,
+          yieldValueType: exprInfo.returnValueType ?? 'NONE',
+          yieldValueName: exprInfo.returnValueName,
+          yieldValueId: exprInfo.returnValueId,
+          yieldValueLine: exprInfo.returnValueLine,
+          yieldValueColumn: exprInfo.returnValueColumn,
+          yieldValueCallName: exprInfo.returnValueCallName,
+          expressionType: exprInfo.expressionType,
+          operator: exprInfo.operator,
+          leftSourceName: exprInfo.leftSourceName,
+          rightSourceName: exprInfo.rightSourceName,
+          consequentSourceName: exprInfo.consequentSourceName,
+          alternateSourceName: exprInfo.alternateSourceName,
+          object: exprInfo.object,
+          property: exprInfo.property,
+          computed: exprInfo.computed,
+          objectSourceName: exprInfo.objectSourceName,
+          expressionSourceNames: exprInfo.expressionSourceNames,
+          unaryArgSourceName: exprInfo.unaryArgSourceName,
+        };
+
+        yieldExpressions.push(yieldInfo);
       },
 
       ForStatement: this.createLoopScopeHandler('for', 'for-loop', 'for', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
@@ -3959,7 +4077,8 @@ export class JSASTAnalyzer extends Plugin {
         varDeclCounterRef,
         scopeTracker,
         tryScopeMap,
-        scopeIdStack
+        scopeIdStack,
+        controlFlowState
       ),
 
       SwitchStatement: (switchPath: NodePath<t.SwitchStatement>) => {
@@ -3973,6 +4092,53 @@ export class JSASTAnalyzer extends Plugin {
         );
       },
 
+      FunctionDeclaration: (funcDeclPath: NodePath<t.FunctionDeclaration>) => {
+        const node = funcDeclPath.node;
+        const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeTracker);
+        // Use semantic ID as primary ID when scopeTracker available
+        const legacyId = `FUNCTION#${funcName}#${module.file}#${getLine(node)}:${getColumn(node)}:${functionCounterRef.value++}`;
+        const functionId = scopeTracker
+          ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
+          : legacyId;
+
+        functions.push({
+          id: functionId,
+          type: 'FUNCTION',
+          name: funcName,
+          file: module.file,
+          line: getLine(node),
+          column: getColumn(node),
+          async: node.async || false,
+          generator: node.generator || false,
+          parentScopeId
+        });
+
+        const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(node)}`;
+        const closureSemanticId = this.generateSemanticId('closure', scopeTracker);
+        scopes.push({
+          id: nestedScopeId,
+          type: 'SCOPE',
+          scopeType: 'closure',
+          name: `${funcName}:body`,
+          semanticId: closureSemanticId,
+          conditional: false,
+          file: module.file,
+          line: getLine(node),
+          parentFunctionId: functionId,
+          capturesFrom: parentScopeId
+        });
+
+        // Enter nested function scope for semantic ID generation
+        if (scopeTracker) {
+          scopeTracker.enterScope(funcName, 'function');
+        }
+        this.analyzeFunctionBody(funcDeclPath, nestedScopeId, module, collections);
+        if (scopeTracker) {
+          scopeTracker.exitScope();
+        }
+        funcDeclPath.skip();
+      },
+
       FunctionExpression: (funcPath: NodePath<t.FunctionExpression>) => {
         const node = funcPath.node;
         const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeTracker);
@@ -4084,135 +4250,21 @@ export class JSASTAnalyzer extends Plugin {
           const bodyLine = getLine(bodyExpr);
           const bodyColumn = getColumn(bodyExpr);
 
+          // Extract expression-specific info using shared method
+          const exprInfo = this.extractReturnExpressionInfo(
+            bodyExpr, module, literals, literalCounterRef, line, column, 'implicit_return'
+          );
+
           const returnInfo: ReturnStatementInfo = {
             parentFunctionId: functionId,
             file: module.file,
             line: bodyLine,
             column: bodyColumn,
             returnValueType: 'NONE',
-            isImplicitReturn: true
+            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: string[] = [];
-            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);
         }
 
@@ -4282,6 +4334,13 @@ export class JSASTAnalyzer extends Plugin {
 
       // Function call expressions
       CallExpression: (callPath: NodePath<t.CallExpression>) => {
+        // REG-311: Detect isAwaited (parent is AwaitExpression)
+        const parent = callPath.parentPath;
+        const isAwaited = parent?.isAwaitExpression() ?? false;
+
+        // REG-311: Detect isInsideTry (O(1) via depth counter)
+        const isInsideTry = controlFlowState.tryBlockDepth > 0;
+
         this.handleCallExpression(
           callPath.node,
           processedCallSites,
@@ -4292,7 +4351,9 @@ export class JSASTAnalyzer extends Plugin {
           callSiteCounterRef,
           scopeTracker,
           getCurrentScopeId(),
-          collections
+          collections,
+          isAwaited,
+          isInsideTry
         );
 
         // REG-334: Check for resolve/reject calls inside Promise executors
@@ -4397,6 +4458,165 @@ 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: NodePath<t.Node> | null = funcParent;
+                while (checkParent) {
+                  if (t.isFunction(checkParent.node)) {
+                    if (checkParent.node.params.some(p =>
+                      t.isIdentifier(p) && p.name === varName
+                    )) {
+                      isParameter = true;
+                      break;
+                    }
+                  }
+                  checkParent = checkParent.getFunctionParent();
+                }
+
+                if (isParameter) {
+                  rejectionPatterns.push({
+                    functionId: targetFunctionId,
+                    errorClassName: null,
+                    rejectionType: 'variable_parameter',
+                    file: module.file,
+                    line: callLine,
+                    column: callColumn,
+                    sourceVariableName: varName
+                  });
+                } else {
+                  // Try micro-trace
+                  const { errorClassName, tracePath } = this.microTraceToErrorClass(
+                    varName,
+                    funcParent as NodePath<t.Function>,
+                    variableDeclarations
+                  );
+
+                  rejectionPatterns.push({
+                    functionId: targetFunctionId,
+                    errorClassName,
+                    rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
+                    file: module.file,
+                    line: callLine,
+                    column: callColumn,
+                    sourceVariableName: varName,
+                    tracePath
+                  });
+                }
+              }
+              break;
+            }
+            funcParent = funcParent.getFunctionParent();
+          }
+        }
+
+        // REG-311: Detect Promise.reject(new Error()) pattern
+        if (t.isMemberExpression(callNode.callee) && currentFunctionId) {
+          const memberCallee = callNode.callee;
+          if (t.isIdentifier(memberCallee.object) &&
+              memberCallee.object.name === 'Promise' &&
+              t.isIdentifier(memberCallee.property) &&
+              memberCallee.property.name === 'reject' &&
+              callNode.arguments.length > 0) {
+            const arg = callNode.arguments[0];
+            const callLine = getLine(callNode);
+            const callColumn = getColumn(callNode);
+
+            // Case 1: Promise.reject(new Error())
+            if (t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
+              rejectionPatterns.push({
+                functionId: currentFunctionId,
+                errorClassName: arg.callee.name,
+                rejectionType: 'promise_reject',
+                file: module.file,
+                line: callLine,
+                column: callColumn
+              });
+            }
+            // Case 2: Promise.reject(err) where err is variable
+            else if (t.isIdentifier(arg)) {
+              const varName = arg.name;
+              // Check if it's a parameter of containing function
+              const isParameter = functionNode
+                ? functionNode.params.some(param => t.isIdentifier(param) && param.name === varName)
+                : false;
+
+              if (isParameter) {
+                rejectionPatterns.push({
+                  functionId: currentFunctionId,
+                  errorClassName: null,
+                  rejectionType: 'variable_parameter',
+                  file: module.file,
+                  line: callLine,
+                  column: callColumn,
+                  sourceVariableName: varName
+                });
+              } else {
+                // Try micro-trace
+                if (!functionPath) {
+                  rejectionPatterns.push({
+                    functionId: currentFunctionId,
+                    errorClassName: null,
+                    rejectionType: 'variable_unknown',
+                    file: module.file,
+                    line: callLine,
+                    column: callColumn,
+                    sourceVariableName: varName,
+                    tracePath: [varName]
+                  });
+                  return;
+                }
+
+                const { errorClassName, tracePath } = this.microTraceToErrorClass(
+                  varName,
+                  functionPath,
+                  variableDeclarations
+                );
+
+                rejectionPatterns.push({
+                  functionId: currentFunctionId,
+                  errorClassName,
+                  rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
+                  file: module.file,
+                  line: callLine,
+                  column: callColumn,
+                  sourceVariableName: varName,
+                  tracePath
+                });
+              }
+            }
+          }
         }
       },
 
@@ -4460,7 +4680,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
                   });
                 }
               }
@@ -4535,9 +4757,65 @@ export class JSASTAnalyzer extends Plugin {
             });
           }
         }
+      },
+
+      // Property access expressions (REG-395)
+      // Shared handler for both MemberExpression and OptionalMemberExpression
+      MemberExpression: (memberPath: NodePath<t.MemberExpression>) => {
+        // Initialize collections if needed
+        if (!collections.propertyAccesses) {
+          collections.propertyAccesses = [];
+        }
+        if (!collections.propertyAccessCounterRef) {
+          collections.propertyAccessCounterRef = { value: 0 };
+        }
+
+        PropertyAccessVisitor.extractPropertyAccesses(
+          memberPath,
+          memberPath.node,
+          module,
+          collections.propertyAccesses as PropertyAccessInfo[],
+          collections.propertyAccessCounterRef as CounterRef,
+          scopeTracker,
+          currentFunctionId || getCurrentScopeId()
+        );
+      },
+      // OptionalMemberExpression: obj?.prop (same logic as MemberExpression)
+      OptionalMemberExpression: (memberPath: NodePath) => {
+        // Initialize collections if needed
+        if (!collections.propertyAccesses) {
+          collections.propertyAccesses = [];
+        }
+        if (!collections.propertyAccessCounterRef) {
+          collections.propertyAccessCounterRef = { value: 0 };
+        }
+
+        PropertyAccessVisitor.extractPropertyAccesses(
+          memberPath,
+          memberPath.node as t.MemberExpression,
+          module,
+          collections.propertyAccesses as PropertyAccessInfo[],
+          collections.propertyAccessCounterRef as CounterRef,
+          scopeTracker,
+          currentFunctionId || getCurrentScopeId()
+        );
       }
     });
 
+    // REG-311: Second pass - collect CATCHES_FROM info for try/catch blocks
+    // This links catch blocks to exception sources in their corresponding try blocks
+    if (functionPath) {
+      this.collectCatchesFromInfo(
+        functionPath,
+        catchBlocks,
+        callSites,
+        methodCalls,
+        constructorCalls,
+        catchesFromInfos,
+        module
+      );
+    }
+
     // Phase 6 (REG-267): Attach control flow metadata to the function node
     if (matchingFunction) {
       const cyclomaticComplexity = 1 +
@@ -4546,13 +4824,27 @@ export class JSASTAnalyzer extends Plugin {
         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
       };
     }
   }
@@ -4566,6 +4858,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
@@ -4577,6 +4870,8 @@ 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
    */
   private handleCallExpression(
     callNode: t.CallExpression,
@@ -4588,7 +4883,9 @@ export class JSASTAnalyzer extends Plugin {
     callSiteCounterRef: CounterRef,
     scopeTracker: ScopeTracker | undefined,
     parentScopeId: string,
-    collections: VisitorCollections
+    collections: VisitorCollections,
+    isAwaited: boolean = false,
+    isInsideTry: boolean = false
   ): void {
     // Handle direct function calls (greet(), main())
     if (callNode.callee.type === 'Identifier') {
@@ -4616,7 +4913,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())
@@ -4657,7 +4957,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)
@@ -4694,6 +4998,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;
@@ -4731,10 +5036,290 @@ export class JSASTAnalyzer extends Plugin {
             );
           }
         }
+
+        // REG-395: Create CALL node for nested method calls like a.b.c()
+        const objectName = CallExpressionVisitor.extractMemberExpressionName(nestedMember as t.MemberExpression);
+        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
+   */
+  private microTraceToErrorClass(
+    variableName: string,
+    funcPath: NodePath<t.Function>,
+    _variableDeclarations: VariableDeclarationInfo[]
+  ): { errorClassName: string | null; tracePath: string[] } {
+    const tracePath: string[] = [variableName];
+    const visited = new Set<string>(); // 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: string | null = null;
+      let nextName: string | null = null;
+
+      // Walk AST to find assignments: currentName = newValue
+      funcPath.traverse({
+        VariableDeclarator: (declPath: NodePath<t.VariableDeclarator>) => {
+          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: NodePath<t.AssignmentExpression>) => {
+          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
+   */
+  private collectCatchesFromInfo(
+    funcPath: NodePath<t.Function>,
+    catchBlocks: CatchBlockInfo[],
+    callSites: CallSiteInfo[],
+    methodCalls: MethodCallInfo[],
+    constructorCalls: ConstructorCallInfo[],
+    catchesFromInfos: CatchesFromInfo[],
+    module: VisitorModule
+  ): void {
+    // Traverse to find TryStatements and collect sources
+    funcPath.traverse({
+      TryStatement: (tryPath: NodePath<t.TryStatement>) => {
+        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: Array<{ id: string; type: CatchesFromInfo['sourceType']; line: number }> = [];
+
+        // 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: NodePath<t.CallExpression>) => {
+            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: string | null = null;
+            let sourceType: CatchesFromInfo['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: NodePath<t.ThrowStatement>) => {
+            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: NodePath<t.NewExpression>) => {
+            // 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
    * and collect mutation info for FLOWS_INTO edge creation in GraphBuilder
@@ -4832,17 +5417,22 @@ 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.)
    */
   private detectIndexedArrayAssignment(
     assignNode: t.AssignmentExpression,
     module: VisitorModule,
     arrayMutations: ArrayMutationInfo[],
-    scopeTracker?: ScopeTracker
+    scopeTracker?: ScopeTracker,
+    collections?: VisitorCollections
   ): void {
     // Check for indexed array assignment: arr[i] = value
     if (assignNode.left.type === 'MemberExpression' && assignNode.left.computed) {
@@ -4850,8 +5440,8 @@ export class JSASTAnalyzer extends Plugin {
 
       // 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;
       }
@@ -4861,34 +5451,79 @@ export class JSASTAnalyzer extends Plugin {
         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: ArrayMutationArgument = {
           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 as CounterRef;
+            const literalId = `LITERAL#indexed#${module.file}#${valueLine}:${valueColumn}:${literalCounterRef.value++}`;
+            (collections.literals as LiteralInfo[]).push({
+              id: literalId,
+              type: 'LITERAL',
+              value: literalValue,
+              valueType: typeof literalValue,
+              file: module.file,
+              line: valueLine,
+              column: valueColumn,
+              parentCallId: undefined,
+              argIndex: 0
+            } as LiteralInfo);
+            argInfo.valueNodeId = literalId;
+          }
         } else if (value.type === 'Identifier') {
           argInfo.valueType = 'VARIABLE';
           argInfo.valueName = value.name;
         } else if (value.type === 'ObjectExpression') {
           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 as CounterRef;
+            const objectNode = ObjectLiteralNode.create(
+              module.file, valueLine, valueColumn,
+              { counter: objectLiteralCounterRef.value++ }
+            );
+            (collections.objectLiterals as ObjectLiteralInfo[]).push(objectNode as unknown as ObjectLiteralInfo);
+            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 as CounterRef;
+            const arrayNode = ArrayLiteralNode.create(
+              module.file, valueLine, valueColumn,
+              { counter: arrayLiteralCounterRef.value++ }
+            );
+            (collections.arrayLiterals as ArrayLiteralInfo[]).push(arrayNode as unknown as ArrayLiteralInfo);
+            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 ?? [];