@grafema/core 0.2.4-beta → 0.2.5-beta

package/src/plugins/analysis/ast/GraphBuilder.ts

@@ -3,11 +3,11 @@
  * OPTIMIZED: Uses batched writes to reduce FFI overhead
  */
 
-import { dirname, resolve, basename } from 'path';
-import type { GraphBackend } from '@grafema/types';
+import { basename } from 'path';
+import type { GraphBackend, NodeRecord } from '@grafema/types';
 import { ImportNode } from '../../../core/nodes/ImportNode.js';
 import { InterfaceNode, type InterfaceNodeRecord } from '../../../core/nodes/InterfaceNode.js';
-import { EnumNode, type EnumNodeRecord } from '../../../core/nodes/EnumNode.js';
+import { EnumNode } from '../../../core/nodes/EnumNode.js';
 import { DecoratorNode } from '../../../core/nodes/DecoratorNode.js';
 import { NetworkRequestNode } from '../../../core/nodes/NetworkRequestNode.js';
 import { NodeFactory } from '../../../core/NodeFactory.js';
@@ -23,11 +23,10 @@ import type {
   VariableDeclarationInfo,
   CallSiteInfo,
   MethodCallInfo,
+  MethodCallbackInfo,
   EventListenerInfo,
   ClassInstantiationInfo,
-  ConstructorCallInfo,
   ClassDeclarationInfo,
-  MethodCallbackInfo,
   CallArgumentInfo,
   ImportInfo,
   ExportInfo,
@@ -41,15 +40,19 @@ import type {
   ArrayMutationInfo,
   ObjectMutationInfo,
   VariableReassignmentInfo,
+  UpdateExpressionInfo,
   ReturnStatementInfo,
+  YieldExpressionInfo,
   ObjectLiteralInfo,
   ObjectPropertyInfo,
   ArrayLiteralInfo,
   TryBlockInfo,
   CatchBlockInfo,
   FinallyBlockInfo,
-  UpdateExpressionInfo,
   PromiseResolutionInfo,
+  RejectionPatternInfo,
+  CatchesFromInfo,
+  PropertyAccessInfo,
   ASTCollections,
   GraphNode,
   GraphEdge,
@@ -84,7 +87,7 @@ export class GraphBuilder {
   private async _flushNodes(graph: GraphBackend): Promise<number> {
     if (this._nodeBuffer.length > 0) {
       // Cast to unknown first since GraphNode is more permissive than NodeRecord
-      await graph.addNodes(this._nodeBuffer as unknown as import('@grafema/types').NodeRecord[]);
+      await graph.addNodes(this._nodeBuffer as unknown as NodeRecord[]);
       const count = this._nodeBuffer.length;
       this._nodeBuffer = [];
       return count;
@@ -148,16 +151,24 @@ export class GraphBuilder {
       objectMutations = [],
       // Variable reassignment tracking for FLOWS_INTO edges (REG-290)
       variableReassignments = [],
+      // Update expression tracking for UPDATE_EXPRESSION nodes and MODIFIES edges (REG-288, REG-312)
+      updateExpressions = [],
       // Return statement tracking for RETURNS edges
       returnStatements = [],
-      // Update expression tracking for MODIFIES edges (REG-288, REG-312)
-      updateExpressions = [],
+      // Yield expression tracking for YIELDS/DELEGATES_TO edges (REG-270)
+      yieldExpressions = [],
       // Promise resolution tracking for RESOLVES_TO edges (REG-334)
       promiseResolutions = [],
       // Object/Array literal tracking
       objectLiterals = [],
       objectProperties = [],
-      arrayLiterals = []
+      arrayLiterals = [],
+      // REG-311: Rejection pattern tracking for async error analysis
+      rejectionPatterns = [],
+      // REG-311: CATCHES_FROM tracking for catch parameter error sources
+      catchesFromInfos = [],
+      // Property access tracking for PROPERTY_ACCESS nodes (REG-395)
+      propertyAccesses = []
     } = data;
 
     // Reset buffers for this build
@@ -166,26 +177,26 @@ export class GraphBuilder {
 
     // 1. Buffer all functions (without edges)
     for (const func of functions) {
-      const { parentScopeId, ...funcData } = func;
+      const { parentScopeId: _parentScopeId, ...funcData } = func;
       this._bufferNode(funcData as GraphNode);
     }
 
     // 2. Buffer all SCOPE (without edges)
     for (const scope of scopes) {
-      const { parentFunctionId, parentScopeId, capturesFrom, modifies, ...scopeData } = scope;
+      const { parentFunctionId: _parentFunctionId, parentScopeId: _parentScopeId, capturesFrom: _capturesFrom, ...scopeData } = scope;
       this._bufferNode(scopeData as GraphNode);
     }
 
     // 2.5. Buffer BRANCH nodes
     // Note: parentScopeId is kept on node for query support (REG-275 test requirement)
     for (const branch of branches) {
-      const { discriminantExpressionId, discriminantExpressionType, discriminantLine, discriminantColumn, ...branchData } = branch;
+      const { discriminantExpressionId: _discriminantExpressionId, discriminantExpressionType: _discriminantExpressionType, discriminantLine: _discriminantLine, discriminantColumn: _discriminantColumn, ...branchData } = branch;
       this._bufferNode(branchData as GraphNode);
     }
 
     // 2.6. Buffer CASE nodes
     for (const caseInfo of cases) {
-      const { parentBranchId, ...caseData } = caseInfo;
+      const { parentBranchId: _parentBranchId, ...caseData } = caseInfo;
       this._bufferNode(caseData as GraphNode);
     }
 
@@ -193,8 +204,8 @@ export class GraphBuilder {
     for (const loop of loops) {
       // Exclude metadata used for edge creation (not stored on node)
       const {
-        iteratesOverName, iteratesOverLine, iteratesOverColumn,
-        conditionExpressionId, conditionExpressionType, conditionLine, conditionColumn,
+        iteratesOverName: _iteratesOverName, iteratesOverLine: _iteratesOverLine, iteratesOverColumn: _iteratesOverColumn,
+        conditionExpressionId: _conditionExpressionId, conditionExpressionType: _conditionExpressionType, conditionLine: _conditionLine, conditionColumn: _conditionColumn,
         ...loopData
       } = loop;
       this._bufferNode(loopData as GraphNode);
@@ -207,13 +218,13 @@ export class GraphBuilder {
 
     // 2.9. Buffer CATCH_BLOCK nodes (Phase 4)
     for (const catchBlock of catchBlocks) {
-      const { parentTryBlockId, ...catchData } = catchBlock;
+      const { parentTryBlockId: _parentTryBlockId, ...catchData } = catchBlock;
       this._bufferNode(catchData as GraphNode);
     }
 
     // 2.10. Buffer FINALLY_BLOCK nodes (Phase 4)
     for (const finallyBlock of finallyBlocks) {
-      const { parentTryBlockId, ...finallyData } = finallyBlock;
+      const { parentTryBlockId: _parentTryBlockId2, ...finallyData } = finallyBlock;
       this._bufferNode(finallyData as GraphNode);
     }
 
@@ -224,7 +235,7 @@ export class GraphBuilder {
 
     // 3.5. Buffer PARAMETER nodes and HAS_PARAMETER edges
     for (const param of parameters) {
-      const { functionId, ...paramData } = param;
+      const { functionId: _functionId, ...paramData } = param;
       // Keep parentFunctionId on the node for queries
       this._bufferNode(paramData as GraphNode);
 
@@ -240,7 +251,7 @@ export class GraphBuilder {
 
     // 4. Buffer CALL_SITE (keep parentScopeId on node for queries)
     for (const callSite of callSites) {
-      const { targetFunctionName, ...callData } = callSite;
+      const { targetFunctionName: _targetFunctionName, ...callData } = callSite;
       this._bufferNode(callData as GraphNode);
     }
 
@@ -295,6 +306,9 @@ export class GraphBuilder {
     // 9. Buffer METHOD_CALL nodes, CONTAINS edges, and USES edges (REG-262)
     this.bufferMethodCalls(methodCalls, variableDeclarations, parameters);
 
+    // 9.5. Buffer PROPERTY_ACCESS nodes and CONTAINS edges (REG-395)
+    this.bufferPropertyAccessNodes(module, propertyAccesses);
+
     // 10. Buffer net:stdio and WRITES_TO edges for console.log/error
     this.bufferStdioNodes(methodCalls);
 
@@ -354,7 +368,8 @@ export class GraphBuilder {
     this.bufferImplementsEdges(classDeclarations, interfaces);
 
     // 26. Buffer FLOWS_INTO edges for array mutations (push, unshift, splice, indexed assignment)
-    this.bufferArrayMutationEdges(arrayMutations, variableDeclarations, parameters);
+    // REG-392: Pass literals, objectLiterals, arrayLiterals, callSites for non-variable value lookups
+    this.bufferArrayMutationEdges(arrayMutations, variableDeclarations, parameters, literals, objectLiterals, arrayLiterals, callSites);
 
     // 27. Buffer FLOWS_INTO edges for object mutations (property assignment, Object.assign)
     // REG-152: Now includes classDeclarations for this.prop = value patterns
@@ -372,6 +387,15 @@ export class GraphBuilder {
     // 31. Buffer RESOLVES_TO edges for Promise data flow (REG-334)
     this.bufferPromiseResolutionEdges(promiseResolutions);
 
+    // 32. Buffer YIELDS/DELEGATES_TO edges for generator yields (REG-270)
+    this.bufferYieldEdges(yieldExpressions, callSites, methodCalls, variableDeclarations, parameters);
+
+    // 33. Buffer REJECTS edges for async error tracking (REG-311)
+    this.bufferRejectionEdges(functions, rejectionPatterns);
+
+    // 34. Buffer CATCHES_FROM edges linking catch blocks to error sources (REG-311)
+    this.bufferCatchesFromEdges(catchesFromInfos);
+
     // FLUSH: Write all nodes first, then edges in single batch calls
     const nodesCreated = await this._flushNodes(graph);
     const edgesCreated = await this._flushEdges(graph);
@@ -408,7 +432,7 @@ export class GraphBuilder {
 
   private bufferScopeEdges(scopes: ScopeInfo[], variableDeclarations: VariableDeclarationInfo[]): void {
     for (const scope of scopes) {
-      const { parentFunctionId, parentScopeId, capturesFrom, modifies, ...scopeData } = scope;
+      const { parentFunctionId, parentScopeId, capturesFrom, ...scopeData } = scope;
 
       // FUNCTION -> HAS_SCOPE -> SCOPE (для function_body)
       if (parentFunctionId) {
@@ -440,16 +464,7 @@ export class GraphBuilder {
         }
       }
 
-      // MODIFIES - scope модифицирует переменные (count++)
-      if (modifies && modifies.length > 0) {
-        for (const mod of modifies) {
-          this._bufferEdge({
-            type: 'MODIFIES',
-            src: scopeData.id,
-            dst: mod.variableId
-          });
-        }
-      }
+      // REG-288: MODIFIES edges removed - now come from UPDATE_EXPRESSION nodes
     }
   }
 
@@ -851,7 +866,7 @@ export class GraphBuilder {
    * REG-275: For CallExpression discriminants, we don't create nodes here since
    * bufferBranchEdges links to the existing CALL_SITE node by coordinates.
    */
-  private bufferDiscriminantExpressions(branches: BranchInfo[], callSites: CallSiteInfo[]): void {
+  private bufferDiscriminantExpressions(branches: BranchInfo[], _callSites: CallSiteInfo[]): void {
     for (const branch of branches) {
       if (branch.discriminantExpressionId && branch.discriminantExpressionType) {
         // Skip CallExpression - we link to existing CALL_SITE in bufferBranchEdges
@@ -877,7 +892,12 @@ export class GraphBuilder {
 
   private bufferVariableEdges(variableDeclarations: VariableDeclarationInfo[]): void {
     for (const varDecl of variableDeclarations) {
-      const { parentScopeId, ...varData } = varDecl;
+      const { parentScopeId, isClassProperty, ...varData } = varDecl;
+
+      // REG-271: Skip class properties - they get HAS_PROPERTY edges from CLASS, not DECLARES from SCOPE
+      if (isClassProperty) {
+        continue;
+      }
 
       // SCOPE -> DECLARES -> VARIABLE
       this._bufferEdge({
@@ -964,6 +984,38 @@ export class GraphBuilder {
     }
   }
 
+  /**
+   * Buffer PROPERTY_ACCESS nodes and CONTAINS edges (REG-395).
+   *
+   * Creates nodes for property reads (obj.prop, a.b.c) and
+   * CONTAINS edges from the enclosing scope (function or module).
+   */
+  private bufferPropertyAccessNodes(module: ModuleNode, propertyAccesses: PropertyAccessInfo[]): void {
+    for (const propAccess of propertyAccesses) {
+      // Buffer node with all relevant fields
+      this._bufferNode({
+        id: propAccess.id,
+        type: 'PROPERTY_ACCESS',
+        name: propAccess.propertyName,
+        objectName: propAccess.objectName,
+        file: propAccess.file,
+        line: propAccess.line,
+        column: propAccess.column,
+        semanticId: propAccess.semanticId,
+        optional: propAccess.optional,
+        computed: propAccess.computed
+      } as GraphNode);
+
+      // SCOPE/FUNCTION/MODULE -> CONTAINS -> PROPERTY_ACCESS
+      const containsSrc = propAccess.parentScopeId ?? module.id;
+      this._bufferEdge({
+        type: 'CONTAINS',
+        src: containsSrc,
+        dst: propAccess.id
+      });
+    }
+  }
+
   private bufferStdioNodes(methodCalls: MethodCallInfo[]): void {
     const consoleIOMethods = methodCalls.filter(mc =>
       (mc.object === 'console' && (mc.method === 'log' || mc.method === 'error'))
@@ -991,7 +1043,7 @@ export class GraphBuilder {
 
   private bufferClassDeclarationNodes(classDeclarations: ClassDeclarationInfo[]): void {
     for (const classDecl of classDeclarations) {
-      const { id, type, name, file, line, column, superClass, methods } = classDecl;
+      const { id, type, name, file, line, column, superClass, methods, properties, staticBlocks } = classDecl;
 
       // Buffer CLASS node
       this._bufferNode({
@@ -1013,6 +1065,28 @@ export class GraphBuilder {
         });
       }
 
+      // REG-271: Buffer HAS_PROPERTY edges: CLASS -> VARIABLE (private fields)
+      if (properties) {
+        for (const propertyId of properties) {
+          this._bufferEdge({
+            type: 'HAS_PROPERTY',
+            src: id,
+            dst: propertyId
+          });
+        }
+      }
+
+      // REG-271: Buffer CONTAINS edges: CLASS -> SCOPE (static blocks)
+      if (staticBlocks) {
+        for (const staticBlockId of staticBlocks) {
+          this._bufferEdge({
+            type: 'CONTAINS',
+            src: id,
+            dst: staticBlockId
+          });
+        }
+      }
+
       // If superClass, buffer DERIVES_FROM edge with computed ID
       if (superClass) {
         // Compute superclass ID using semantic ID format
@@ -1042,7 +1116,7 @@ export class GraphBuilder {
     }
 
     for (const instantiation of classInstantiations) {
-      const { variableId, className, line } = instantiation;
+      const { variableId, className, line: _line } = instantiation;
 
       let classId = declarationMap.get(className);
 
@@ -1340,7 +1414,7 @@ export class GraphBuilder {
 
   private bufferLiterals(literals: LiteralInfo[]): void {
     for (const literal of literals) {
-      const { parentCallId, argIndex, ...literalData } = literal;
+      const { parentCallId: _parentCallId, argIndex: _argIndex, ...literalData } = literal;
       this._bufferNode(literalData as GraphNode);
     }
   }
@@ -1973,21 +2047,20 @@ export class GraphBuilder {
 
   /**
    * Buffer FLOWS_INTO edges for array mutations (push, unshift, splice, indexed assignment)
-   * Creates edges from inserted values to the array variable
-   *
-   * REG-117: Now handles nested mutations like obj.arr.push(item):
-   * - For nested mutations, falls back to base object if array property not found
-   * - Adds nestedProperty metadata for tracking
+   * Creates edges from inserted values to the array variable.
    *
-   * OPTIMIZED: Uses Map-based lookup cache for O(1) variable lookups instead of O(n) find()
+   * REG-117: Handles nested mutations like obj.arr.push(item)
+   * REG-392: Handles non-variable values (LITERAL, OBJECT_LITERAL, ARRAY_LITERAL, CALL)
    */
   private bufferArrayMutationEdges(
     arrayMutations: ArrayMutationInfo[],
     variableDeclarations: VariableDeclarationInfo[],
-    parameters: ParameterInfo[]
+    parameters: ParameterInfo[],
+    literals: LiteralInfo[],
+    objectLiterals: ObjectLiteralInfo[],
+    arrayLiterals: ArrayLiteralInfo[],
+    callSites: CallSiteInfo[]
   ): void {
-    // Note: No longer using Map-based cache - scope-aware lookup requires scope chain walk
-
     for (const mutation of arrayMutations) {
       const { arrayName, mutationScopePath, mutationMethod, insertedValues, file, isNested, baseObjectName, propertyName } = mutation;
 
@@ -2017,32 +2090,58 @@ export class GraphBuilder {
 
       // Create FLOWS_INTO edges for each inserted value
       for (const arg of insertedValues) {
+        let sourceNodeId: string | undefined;
+
         if (arg.valueType === 'VARIABLE' && arg.valueName) {
           // Scope-aware lookup for source variable (REG-309)
           const sourceVar = this.resolveVariableInScope(arg.valueName, scopePath, file, variableDeclarations);
           const sourceParam = !sourceVar ? this.resolveParameterInScope(arg.valueName, scopePath, file, parameters) : null;
-          const sourceNodeId = sourceVar?.id ?? sourceParam?.id;
-
-          if (sourceNodeId) {
-            const edgeData: GraphEdge = {
-              type: 'FLOWS_INTO',
-              src: sourceNodeId,
-              dst: targetNodeId,
-              mutationMethod,
-              argIndex: arg.argIndex
-            };
-            if (arg.isSpread) {
-              edgeData.isSpread = true;
-            }
-            // REG-117: Add nested property metadata
-            if (nestedProperty) {
-              edgeData.nestedProperty = nestedProperty;
-            }
-            this._bufferEdge(edgeData);
+          sourceNodeId = sourceVar?.id ?? sourceParam?.id;
+        } else if (arg.valueNodeId) {
+          // REG-392: Direct node ID for indexed assignments (LITERAL, OBJECT_LITERAL, ARRAY_LITERAL)
+          sourceNodeId = arg.valueNodeId;
+        } else if (arg.valueType === 'LITERAL' && arg.valueLine !== undefined && arg.valueColumn !== undefined) {
+          // REG-392: Find LITERAL node by coordinates (push/unshift — nodes created by extractArguments)
+          const literalNode = literals.find(l =>
+            l.line === arg.valueLine && l.column === arg.valueColumn && l.file === file
+          );
+          sourceNodeId = literalNode?.id;
+        } else if (arg.valueType === 'OBJECT_LITERAL' && arg.valueLine !== undefined && arg.valueColumn !== undefined) {
+          // REG-392: Find OBJECT_LITERAL node by coordinates
+          const objNode = objectLiterals.find(o =>
+            o.line === arg.valueLine && o.column === arg.valueColumn && o.file === file
+          );
+          sourceNodeId = objNode?.id;
+        } else if (arg.valueType === 'ARRAY_LITERAL' && arg.valueLine !== undefined && arg.valueColumn !== undefined) {
+          // REG-392: Find ARRAY_LITERAL node by coordinates
+          const arrNode = arrayLiterals.find(a =>
+            a.line === arg.valueLine && a.column === arg.valueColumn && a.file === file
+          );
+          sourceNodeId = arrNode?.id;
+        } else if (arg.valueType === 'CALL' && arg.callLine !== undefined && arg.callColumn !== undefined) {
+          // REG-392: Find CALL_SITE node by coordinates
+          const callSite = callSites.find(cs =>
+            cs.line === arg.callLine && cs.column === arg.callColumn && cs.file === file
+          );
+          sourceNodeId = callSite?.id;
+        }
+
+        if (sourceNodeId) {
+          const edgeData: GraphEdge = {
+            type: 'FLOWS_INTO',
+            src: sourceNodeId,
+            dst: targetNodeId,
+            mutationMethod,
+            argIndex: arg.argIndex
+          };
+          if (arg.isSpread) {
+            edgeData.isSpread = true;
+          }
+          if (nestedProperty) {
+            edgeData.nestedProperty = nestedProperty;
           }
+          this._bufferEdge(edgeData);
         }
-        // For literals, object literals, etc. - we could create edges from LITERAL nodes
-        // but for now we just track variable -> array flows
       }
     }
   }
@@ -2606,6 +2705,260 @@ export class GraphBuilder {
     }
   }
 
+  /**
+   * Buffer YIELDS and DELEGATES_TO edges connecting yield expressions to their generator functions.
+   *
+   * Edge direction:
+   * - For yield:  yieldedExpression --YIELDS--> generatorFunction
+   * - For yield*: delegatedCall --DELEGATES_TO--> generatorFunction
+   *
+   * This enables tracing data flow through generator functions:
+   * - Query: "What does this generator yield?"
+   * - Answer: Follow YIELDS edges from function to see all possible yielded values
+   * - Query: "What generators does this delegate to?"
+   * - Answer: Follow DELEGATES_TO edges from function
+   *
+   * REG-270: Generator yield tracking
+   */
+  private bufferYieldEdges(
+    yieldExpressions: YieldExpressionInfo[],
+    callSites: CallSiteInfo[],
+    methodCalls: MethodCallInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[]
+  ): void {
+    for (const yld of yieldExpressions) {
+      const { parentFunctionId, yieldValueType, file, isDelegate } = yld;
+
+      // Skip if no value yielded (bare yield;)
+      if (yieldValueType === 'NONE') {
+        continue;
+      }
+
+      let sourceNodeId: string | null = null;
+
+      switch (yieldValueType) {
+        case 'LITERAL':
+          // Direct reference to literal node
+          sourceNodeId = yld.yieldValueId ?? null;
+          break;
+
+        case 'VARIABLE': {
+          // Find variable declaration by name in same file
+          const varName = yld.yieldValueName;
+          if (varName) {
+            const sourceVar = variableDeclarations.find(v =>
+              v.name === varName && v.file === file
+            );
+            if (sourceVar) {
+              sourceNodeId = sourceVar.id;
+            } else {
+              // Check parameters
+              const sourceParam = parameters.find(p =>
+                p.name === varName && p.file === file
+              );
+              if (sourceParam) {
+                sourceNodeId = sourceParam.id;
+              }
+            }
+          }
+          break;
+        }
+
+        case 'CALL_SITE': {
+          // Find call site by coordinates
+          const { yieldValueLine, yieldValueColumn, yieldValueCallName } = yld;
+          if (yieldValueLine && yieldValueColumn) {
+            const callSite = callSites.find(cs =>
+              cs.line === yieldValueLine &&
+              cs.column === yieldValueColumn &&
+              (yieldValueCallName ? cs.name === yieldValueCallName : true)
+            );
+            if (callSite) {
+              sourceNodeId = callSite.id;
+            }
+          }
+          break;
+        }
+
+        case 'METHOD_CALL': {
+          // Find method call by coordinates and method name
+          const { yieldValueLine, yieldValueColumn, yieldValueCallName } = yld;
+          if (yieldValueLine && yieldValueColumn) {
+            const methodCall = methodCalls.find(mc =>
+              mc.line === yieldValueLine &&
+              mc.column === yieldValueColumn &&
+              mc.file === file &&
+              (yieldValueCallName ? mc.method === yieldValueCallName : true)
+            );
+            if (methodCall) {
+              sourceNodeId = methodCall.id;
+            }
+          }
+          break;
+        }
+
+        case 'EXPRESSION': {
+          // Create EXPRESSION node and DERIVES_FROM edges for yield expressions
+          const {
+            expressionType,
+            yieldValueId,
+            yieldValueLine,
+            yieldValueColumn,
+            operator,
+            object,
+            property,
+            computed,
+            objectSourceName,
+            leftSourceName,
+            rightSourceName,
+            consequentSourceName,
+            alternateSourceName,
+            expressionSourceNames,
+            unaryArgSourceName
+          } = yld;
+
+          // Skip if no expression ID was generated
+          if (!yieldValueId) {
+            break;
+          }
+
+          // Create EXPRESSION node using NodeFactory
+          const expressionNode = NodeFactory.createExpressionFromMetadata(
+            expressionType || 'Unknown',
+            file,
+            yieldValueLine || yld.line,
+            yieldValueColumn || yld.column,
+            {
+              id: yieldValueId,
+              object,
+              property,
+              computed,
+              operator
+            }
+          );
+
+          this._bufferNode(expressionNode);
+          sourceNodeId = yieldValueId;
+
+          // Buffer DERIVES_FROM edges based on expression type
+          // Helper function to find source variable or parameter
+          const findSource = (name: string): string | null => {
+            const variable = variableDeclarations.find(v =>
+              v.name === name && v.file === file
+            );
+            if (variable) return variable.id;
+
+            const param = parameters.find(p =>
+              p.name === name && p.file === file
+            );
+            if (param) return param.id;
+
+            return null;
+          };
+
+          // MemberExpression: derives from the object
+          if (expressionType === 'MemberExpression' && objectSourceName) {
+            const srcId = findSource(objectSourceName);
+            if (srcId) {
+              this._bufferEdge({
+                type: 'DERIVES_FROM',
+                src: yieldValueId,
+                dst: srcId
+              });
+            }
+          }
+
+          // BinaryExpression / LogicalExpression: derives from left and right operands
+          if (expressionType === 'BinaryExpression' || expressionType === 'LogicalExpression') {
+            if (leftSourceName) {
+              const srcId = findSource(leftSourceName);
+              if (srcId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: yieldValueId,
+                  dst: srcId
+                });
+              }
+            }
+            if (rightSourceName) {
+              const srcId = findSource(rightSourceName);
+              if (srcId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: yieldValueId,
+                  dst: srcId
+                });
+              }
+            }
+          }
+
+          // ConditionalExpression: derives from consequent and alternate
+          if (expressionType === 'ConditionalExpression') {
+            if (consequentSourceName) {
+              const srcId = findSource(consequentSourceName);
+              if (srcId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: yieldValueId,
+                  dst: srcId
+                });
+              }
+            }
+            if (alternateSourceName) {
+              const srcId = findSource(alternateSourceName);
+              if (srcId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: yieldValueId,
+                  dst: srcId
+                });
+              }
+            }
+          }
+
+          // UnaryExpression: derives from the argument
+          if (expressionType === 'UnaryExpression' && unaryArgSourceName) {
+            const srcId = findSource(unaryArgSourceName);
+            if (srcId) {
+              this._bufferEdge({
+                type: 'DERIVES_FROM',
+                src: yieldValueId,
+                dst: srcId
+              });
+            }
+          }
+
+          // TemplateLiteral: derives from all embedded expressions
+          if (expressionType === 'TemplateLiteral' && expressionSourceNames && expressionSourceNames.length > 0) {
+            for (const sourceName of expressionSourceNames) {
+              const srcId = findSource(sourceName);
+              if (srcId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: yieldValueId,
+                  dst: srcId
+                });
+              }
+            }
+          }
+
+          break;
+        }
+      }
+
+      // Create YIELDS or DELEGATES_TO edge if we found a source node
+      if (sourceNodeId && parentFunctionId) {
+        const edgeType = isDelegate ? 'DELEGATES_TO' : 'YIELDS';
+        this._bufferEdge({
+          type: edgeType,
+          src: sourceNodeId,
+          dst: parentFunctionId
+        });
+      }
+    }
+  }
+
   /**
    * Buffer UPDATE_EXPRESSION nodes and edges for increment/decrement operations.
    *
@@ -2988,4 +3341,117 @@ export class GraphBuilder {
 
     return edgesCreated;
   }
+
+  /**
+   * Buffer REJECTS edges for async error tracking (REG-311).
+   *
+   * Creates edges from FUNCTION nodes to error CLASS nodes they can reject.
+   * This enables tracking which async functions can throw which error types:
+   *
+   * - Promise.reject(new Error()) -> FUNCTION --REJECTS--> CLASS[Error]
+   * - reject(new ValidationError()) in executor -> FUNCTION --REJECTS--> CLASS[ValidationError]
+   * - throw new AuthError() in async function -> FUNCTION --REJECTS--> CLASS[AuthError]
+   *
+   * Also stores rejectionPatterns in function metadata for downstream enrichers.
+   *
+   * @param functions - All function infos from analysis
+   * @param rejectionPatterns - Collected rejection patterns from analysis
+   */
+  private bufferRejectionEdges(functions: FunctionInfo[], rejectionPatterns: RejectionPatternInfo[]): void {
+    // Group rejection patterns by functionId for efficient lookup
+    const patternsByFunction = new Map<string, RejectionPatternInfo[]>();
+    for (const pattern of rejectionPatterns) {
+      const existing = patternsByFunction.get(pattern.functionId);
+      if (existing) {
+        existing.push(pattern);
+      } else {
+        patternsByFunction.set(pattern.functionId, [pattern]);
+      }
+    }
+
+    // Process each function that has rejection patterns
+    for (const [functionId, patterns] of patternsByFunction) {
+      // Collect unique error class names from this function's rejection patterns
+      const errorClassNames = new Set<string>();
+      for (const pattern of patterns) {
+        if (pattern.errorClassName) {
+          errorClassNames.add(pattern.errorClassName);
+        }
+      }
+
+      // Create REJECTS edges to error class nodes
+      // Note: These edges target computed CLASS IDs - they will be dangling
+      // if the class isn't declared, but that's expected behavior for
+      // built-in classes like Error, TypeError, etc.
+      for (const errorClassName of errorClassNames) {
+        // Find the function's file to compute the class ID
+        const func = functions.find(f => f.id === functionId);
+        const file = func?.file ?? '';
+
+        // Compute potential class ID at global scope
+        // For built-in errors, this will be a dangling reference (expected)
+        const globalContext = { file, scopePath: [] as string[] };
+        const classId = computeSemanticId('CLASS', errorClassName, globalContext);
+
+        this._bufferEdge({
+          type: 'REJECTS',
+          src: functionId,
+          dst: classId,
+          metadata: {
+            errorClassName
+          }
+        });
+      }
+
+      // Store rejection patterns in function metadata for downstream enrichers
+      // Find and update the function node in the buffer
+      for (const node of this._nodeBuffer) {
+        if (node.id === functionId) {
+          // Store in metadata field for proper persistence and test compatibility
+          if (!node.metadata) {
+            node.metadata = {};
+          }
+          (node.metadata as Record<string, unknown>).rejectionPatterns = patterns.map(p => ({
+            rejectionType: p.rejectionType,
+            errorClassName: p.errorClassName,
+            line: p.line,
+            column: p.column,
+            sourceVariableName: p.sourceVariableName,
+            tracePath: p.tracePath
+          }));
+          break;
+        }
+      }
+    }
+  }
+
+  /**
+   * Buffer CATCHES_FROM edges linking catch blocks to error sources (REG-311).
+   *
+   * Creates edges from CATCH_BLOCK nodes to potential error sources within
+   * their corresponding try blocks. This enables tracking which catch blocks
+   * can handle which exceptions:
+   *
+   * - try { await fetch() } catch(e) -> CATCH_BLOCK --CATCHES_FROM--> CALL[fetch]
+   * - try { throw new Error() } catch(e) -> CATCH_BLOCK --CATCHES_FROM--> THROW_STATEMENT
+   *
+   * The sourceType metadata helps distinguish different error source kinds
+   * for more precise error flow analysis.
+   *
+   * @param catchesFromInfos - Collected CATCHES_FROM info from analysis
+   */
+  private bufferCatchesFromEdges(catchesFromInfos: CatchesFromInfo[]): void {
+    for (const info of catchesFromInfos) {
+      this._bufferEdge({
+        type: 'CATCHES_FROM',
+        src: info.catchBlockId,
+        dst: info.sourceId,
+        metadata: {
+          parameterName: info.parameterName,
+          sourceType: info.sourceType,
+          sourceLine: info.sourceLine
+        }
+      });
+    }
+  }
 }