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

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

@@ -3,18 +3,29 @@
  * OPTIMIZED: Uses batched writes to reduce FFI overhead
  */
 
-import { dirname, resolve } from 'path';
+import { dirname, resolve, basename } from 'path';
 import type { GraphBackend } 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 { DecoratorNode } from '../../../core/nodes/DecoratorNode.js';
+import { NetworkRequestNode } from '../../../core/nodes/NetworkRequestNode.js';
+import { NodeFactory } from '../../../core/NodeFactory.js';
+import { computeSemanticId, parseSemanticId } from '../../../core/SemanticId.js';
 import type {
   ModuleNode,
   FunctionInfo,
   ParameterInfo,
   ScopeInfo,
+  BranchInfo,
+  CaseInfo,
+  LoopInfo,
   VariableDeclarationInfo,
   CallSiteInfo,
   MethodCallInfo,
   EventListenerInfo,
   ClassInstantiationInfo,
+  ConstructorCallInfo,
   ClassDeclarationInfo,
   MethodCallbackInfo,
   CallArgumentInfo,
@@ -27,6 +38,18 @@ import type {
   TypeAliasInfo,
   EnumDeclarationInfo,
   DecoratorInfo,
+  ArrayMutationInfo,
+  ObjectMutationInfo,
+  VariableReassignmentInfo,
+  ReturnStatementInfo,
+  ObjectLiteralInfo,
+  ObjectPropertyInfo,
+  ArrayLiteralInfo,
+  TryBlockInfo,
+  CatchBlockInfo,
+  FinallyBlockInfo,
+  UpdateExpressionInfo,
+  PromiseResolutionInfo,
   ASTCollections,
   GraphNode,
   GraphEdge,
@@ -91,11 +114,21 @@ export class GraphBuilder {
       functions,
       parameters = [],
       scopes,
+      // Branching
+      branches = [],
+      cases = [],
+      // Control flow (loops)
+      loops = [],
+      // Control flow (try/catch/finally) - Phase 4
+      tryBlocks = [],
+      catchBlocks = [],
+      finallyBlocks = [],
       variableDeclarations,
       callSites,
       methodCalls = [],
       eventListeners = [],
       classInstantiations = [],
+      constructorCalls = [],
       classDeclarations = [],
       methodCallbacks = [],
       callArguments = [],
@@ -108,7 +141,23 @@ export class GraphBuilder {
       interfaces = [],
       typeAliases = [],
       enums = [],
-      decorators = []
+      decorators = [],
+      // Array mutation tracking for FLOWS_INTO edges
+      arrayMutations = [],
+      // Object mutation tracking for FLOWS_INTO edges
+      objectMutations = [],
+      // Variable reassignment tracking for FLOWS_INTO edges (REG-290)
+      variableReassignments = [],
+      // Return statement tracking for RETURNS edges
+      returnStatements = [],
+      // Update expression tracking for MODIFIES edges (REG-288, REG-312)
+      updateExpressions = [],
+      // Promise resolution tracking for RESOLVES_TO edges (REG-334)
+      promiseResolutions = [],
+      // Object/Array literal tracking
+      objectLiterals = [],
+      objectProperties = [],
+      arrayLiterals = []
     } = data;
 
     // Reset buffers for this build
@@ -127,10 +176,50 @@ export class GraphBuilder {
       this._bufferNode(scopeData as GraphNode);
     }
 
-    // 3. Buffer variables
+    // 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;
+      this._bufferNode(branchData as GraphNode);
+    }
+
+    // 2.6. Buffer CASE nodes
+    for (const caseInfo of cases) {
+      const { parentBranchId, ...caseData } = caseInfo;
+      this._bufferNode(caseData as GraphNode);
+    }
+
+    // 2.7. Buffer LOOP nodes
+    for (const loop of loops) {
+      // Exclude metadata used for edge creation (not stored on node)
+      const {
+        iteratesOverName, iteratesOverLine, iteratesOverColumn,
+        conditionExpressionId, conditionExpressionType, conditionLine, conditionColumn,
+        ...loopData
+      } = loop;
+      this._bufferNode(loopData as GraphNode);
+    }
+
+    // 2.8. Buffer TRY_BLOCK nodes (Phase 4)
+    for (const tryBlock of tryBlocks) {
+      this._bufferNode(tryBlock as GraphNode);
+    }
+
+    // 2.9. Buffer CATCH_BLOCK nodes (Phase 4)
+    for (const catchBlock of catchBlocks) {
+      const { 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;
+      this._bufferNode(finallyData as GraphNode);
+    }
+
+    // 3. Buffer variables (keep parentScopeId on node for queries)
     for (const varDecl of variableDeclarations) {
-      const { parentScopeId, ...varData } = varDecl;
-      this._bufferNode(varData as GraphNode);
+      this._bufferNode(varDecl as unknown as GraphNode);
     }
 
     // 3.5. Buffer PARAMETER nodes and HAS_PARAMETER edges
@@ -149,26 +238,62 @@ export class GraphBuilder {
       }
     }
 
-    // 4. Buffer CALL_SITE
+    // 4. Buffer CALL_SITE (keep parentScopeId on node for queries)
     for (const callSite of callSites) {
-      const { parentScopeId, targetFunctionName, ...callData } = callSite;
+      const { targetFunctionName, ...callData } = callSite;
       this._bufferNode(callData as GraphNode);
     }
 
+    // 4.5 Buffer CONSTRUCTOR_CALL nodes
+    for (const constructorCall of constructorCalls) {
+      this._bufferNode({
+        id: constructorCall.id,
+        type: constructorCall.type,
+        name: `new ${constructorCall.className}()`,
+        className: constructorCall.className,
+        isBuiltin: constructorCall.isBuiltin,
+        file: constructorCall.file,
+        line: constructorCall.line,
+        column: constructorCall.column
+      } as GraphNode);
+    }
+
     // 5. Buffer edges for functions
     this.bufferFunctionEdges(module, functions);
 
     // 6. Buffer edges for SCOPE
     this.bufferScopeEdges(scopes, variableDeclarations);
 
+    // 6.3. Buffer edges for LOOP (HAS_BODY, ITERATES_OVER, CONTAINS)
+    this.bufferLoopEdges(loops, scopes, variableDeclarations, parameters);
+
+    // 6.35. Buffer HAS_CONDITION edges for LOOP (REG-280)
+    this.bufferLoopConditionEdges(loops, callSites);
+
+    // 6.37. Buffer EXPRESSION nodes for loop conditions (REG-280)
+    this.bufferLoopConditionExpressions(loops);
+
+    // 6.5. Buffer edges for BRANCH (needs callSites for CallExpression discriminant lookup)
+    // Phase 3 (REG-267): Now includes scopes for if-branches HAS_CONSEQUENT/HAS_ALTERNATE
+    this.bufferBranchEdges(branches, callSites, scopes);
+
+    // 6.6. Buffer edges for CASE
+    this.bufferCaseEdges(cases);
+
+    // 6.65. Buffer edges for TRY_BLOCK, CATCH_BLOCK, FINALLY_BLOCK (Phase 4)
+    this.bufferTryCatchFinallyEdges(tryBlocks, catchBlocks, finallyBlocks);
+
+    // 6.7. Buffer EXPRESSION nodes for switch discriminants (needs callSites for CallExpression)
+    this.bufferDiscriminantExpressions(branches, callSites);
+
     // 7. Buffer edges for variables
     this.bufferVariableEdges(variableDeclarations);
 
     // 8. Buffer edges for CALL_SITE
     this.bufferCallSiteEdges(callSites, functions);
 
-    // 9. Buffer METHOD_CALL nodes and CONTAINS edges
-    this.bufferMethodCalls(methodCalls);
+    // 9. Buffer METHOD_CALL nodes, CONTAINS edges, and USES edges (REG-262)
+    this.bufferMethodCalls(methodCalls, variableDeclarations, parameters);
 
     // 10. Buffer net:stdio and WRITES_TO edges for console.log/error
     this.bufferStdioNodes(methodCalls);
@@ -197,6 +322,16 @@ export class GraphBuilder {
     // 18. Buffer LITERAL nodes
     this.bufferLiterals(literals);
 
+    // 18.5. Buffer OBJECT_LITERAL nodes (moved before bufferArgumentEdges)
+    this.bufferObjectLiteralNodes(objectLiterals);
+
+    // 18.6. Buffer ARRAY_LITERAL nodes (moved before bufferArgumentEdges)
+    this.bufferArrayLiteralNodes(arrayLiterals);
+
+    // 18.7. Buffer HAS_PROPERTY edges (OBJECT_LITERAL -> property values)
+    // REG-329: Pass variableDeclarations and parameters for scope-aware variable resolution
+    this.bufferObjectPropertyEdges(objectProperties, variableDeclarations, parameters);
+
     // 19. Buffer ASSIGNED_FROM edges for data flow (some need to create EXPRESSION nodes)
     this.bufferAssignmentEdges(variableAssignments, variableDeclarations, callSites, methodCalls, functions, classInstantiations, parameters);
 
@@ -218,17 +353,33 @@ export class GraphBuilder {
     // 25. Buffer IMPLEMENTS edges (CLASS -> INTERFACE)
     this.bufferImplementsEdges(classDeclarations, interfaces);
 
+    // 26. Buffer FLOWS_INTO edges for array mutations (push, unshift, splice, indexed assignment)
+    this.bufferArrayMutationEdges(arrayMutations, variableDeclarations, parameters);
+
+    // 27. Buffer FLOWS_INTO edges for object mutations (property assignment, Object.assign)
+    // REG-152: Now includes classDeclarations for this.prop = value patterns
+    this.bufferObjectMutationEdges(objectMutations, variableDeclarations, parameters, functions, classDeclarations);
+
+    // 28. Buffer FLOWS_INTO edges for variable reassignments (REG-290)
+    this.bufferVariableReassignmentEdges(variableReassignments, variableDeclarations, callSites, methodCalls, parameters);
+
+    // 29. Buffer RETURNS edges for return statements
+    this.bufferReturnEdges(returnStatements, callSites, methodCalls, variableDeclarations, parameters);
+
+    // 30. Buffer UPDATE_EXPRESSION nodes and MODIFIES edges (REG-288, REG-312)
+    this.bufferUpdateExpressionEdges(updateExpressions, variableDeclarations, parameters, classDeclarations);
+
+    // 31. Buffer RESOLVES_TO edges for Promise data flow (REG-334)
+    this.bufferPromiseResolutionEdges(promiseResolutions);
+
     // FLUSH: Write all nodes first, then edges in single batch calls
     const nodesCreated = await this._flushNodes(graph);
     const edgesCreated = await this._flushEdges(graph);
 
-    // Handle async operations that need graph queries (IMPORTS_FROM edges)
-    const importExportEdges = await this.createImportExportEdges(module, imports, exports, graph, projectPath);
-
     // Handle async operations for ASSIGNED_FROM with CLASS lookups
     const classAssignmentEdges = await this.createClassAssignmentEdges(variableAssignments, graph);
 
-    return { nodes: nodesCreated, edges: edgesCreated + importExportEdges + classAssignmentEdges };
+    return { nodes: nodesCreated, edges: edgesCreated + classAssignmentEdges };
   }
 
   // ============= BUFFERED METHODS (synchronous, no awaits) =============
@@ -302,6 +453,428 @@ export class GraphBuilder {
     }
   }
 
+  /**
+   * Buffer LOOP edges (CONTAINS, HAS_BODY, ITERATES_OVER)
+   *
+   * Creates edges for:
+   * - Parent -> CONTAINS -> LOOP
+   * - LOOP -> HAS_BODY -> body SCOPE
+   * - LOOP -> ITERATES_OVER -> collection VARIABLE/PARAMETER (for for-in/for-of)
+   *
+   * Scope-aware variable lookup for ITERATES_OVER:
+   * For for-of/for-in, finds the iterated variable preferring:
+   * 1. Variables declared before the loop on same or earlier line (closest first)
+   * 2. Parameters (function arguments)
+   */
+  private bufferLoopEdges(
+    loops: LoopInfo[],
+    scopes: ScopeInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[]
+  ): void {
+    for (const loop of loops) {
+      // Parent -> CONTAINS -> LOOP
+      if (loop.parentScopeId) {
+        this._bufferEdge({
+          type: 'CONTAINS',
+          src: loop.parentScopeId,
+          dst: loop.id
+        });
+      }
+
+      // LOOP -> HAS_BODY -> body SCOPE
+      // Find the body scope by matching parentScopeId to loop.id
+      const bodyScope = scopes.find(s => s.parentScopeId === loop.id);
+      if (bodyScope) {
+        this._bufferEdge({
+          type: 'HAS_BODY',
+          src: loop.id,
+          dst: bodyScope.id
+        });
+      }
+
+      // LOOP -> ITERATES_OVER -> collection VARIABLE/PARAMETER (for for-in/for-of)
+      if (loop.iteratesOverName && (loop.loopType === 'for-in' || loop.loopType === 'for-of')) {
+        // For MemberExpression iterables (obj.items), extract base object
+        const iterableName = loop.iteratesOverName.includes('.')
+          ? loop.iteratesOverName.split('.')[0]
+          : loop.iteratesOverName;
+
+        // Scope-aware lookup: prefer parameters over variables
+        // Parameters are function-local and shadow outer variables
+        const param = parameters.find(p =>
+          p.name === iterableName && p.file === loop.file
+        );
+
+        // Determine iteration type: for-in iterates keys, for-of iterates values
+        const iterates = loop.loopType === 'for-in' ? 'keys' : 'values';
+
+        if (param) {
+          // Parameter found - most local binding
+          this._bufferEdge({
+            type: 'ITERATES_OVER',
+            src: loop.id,
+            dst: param.id,
+            metadata: { iterates }
+          });
+        } else {
+          // Find variable by name and line proximity (scope-aware heuristic)
+          // Prefer variables declared before the loop in the same file
+          const candidateVars = variableDeclarations.filter(v =>
+            v.name === iterableName &&
+            v.file === loop.file &&
+            (v.line ?? 0) <= loop.line  // Declared before or on loop line
+          );
+
+          // Sort by line descending to find closest declaration
+          candidateVars.sort((a, b) => (b.line ?? 0) - (a.line ?? 0));
+
+          if (candidateVars.length > 0) {
+            this._bufferEdge({
+              type: 'ITERATES_OVER',
+              src: loop.id,
+              dst: candidateVars[0].id,
+              metadata: { iterates }
+            });
+          }
+        }
+      }
+
+      // REG-282: LOOP (for) -> HAS_INIT -> VARIABLE (let i = 0)
+      if (loop.loopType === 'for' && loop.initVariableName && loop.initLine) {
+        // Find the variable declared in the init on this line
+        const initVar = variableDeclarations.find(v =>
+          v.name === loop.initVariableName &&
+          v.file === loop.file &&
+          v.line === loop.initLine
+        );
+        if (initVar) {
+          this._bufferEdge({
+            type: 'HAS_INIT',
+            src: loop.id,
+            dst: initVar.id
+          });
+        }
+      }
+
+      // REG-282: LOOP -> HAS_CONDITION -> EXPRESSION (i < 10 or condition for while/do-while)
+      if (loop.testExpressionId && loop.testExpressionType) {
+        // Create EXPRESSION node for the test
+        this._bufferNode({
+          id: loop.testExpressionId,
+          type: 'EXPRESSION',
+          name: loop.testExpressionType,
+          file: loop.file,
+          line: loop.testLine,
+          column: loop.testColumn,
+          expressionType: loop.testExpressionType
+        });
+
+        this._bufferEdge({
+          type: 'HAS_CONDITION',
+          src: loop.id,
+          dst: loop.testExpressionId
+        });
+      }
+
+      // REG-282: LOOP (for) -> HAS_UPDATE -> EXPRESSION (i++)
+      if (loop.loopType === 'for' && loop.updateExpressionId && loop.updateExpressionType) {
+        // Create EXPRESSION node for the update
+        this._bufferNode({
+          id: loop.updateExpressionId,
+          type: 'EXPRESSION',
+          name: loop.updateExpressionType,
+          file: loop.file,
+          line: loop.updateLine,
+          column: loop.updateColumn,
+          expressionType: loop.updateExpressionType
+        });
+
+        this._bufferEdge({
+          type: 'HAS_UPDATE',
+          src: loop.id,
+          dst: loop.updateExpressionId
+        });
+      }
+    }
+  }
+
+  /**
+   * Buffer HAS_CONDITION edges from LOOP to condition EXPRESSION/CALL nodes.
+   * Also creates EXPRESSION nodes for non-CallExpression conditions.
+   *
+   * REG-280: For while/do-while/for loops, creates HAS_CONDITION edge to the
+   * condition expression. For-in/for-of loops don't have conditions (use ITERATES_OVER).
+   *
+   * For CallExpression conditions, links to existing CALL_SITE node by coordinates.
+   */
+  private bufferLoopConditionEdges(loops: LoopInfo[], callSites: CallSiteInfo[]): void {
+    for (const loop of loops) {
+      // Skip for-in/for-of loops - they don't have test expressions
+      if (loop.loopType === 'for-in' || loop.loopType === 'for-of') {
+        continue;
+      }
+
+      // Skip if no condition (e.g., infinite for loop: for(;;))
+      if (!loop.conditionExpressionId) {
+        continue;
+      }
+
+      // LOOP -> HAS_CONDITION -> EXPRESSION/CALL
+      let targetId = loop.conditionExpressionId;
+
+      // For CallExpression conditions, look up the actual CALL_SITE by coordinates
+      // because CALL_SITE uses semantic IDs that don't match the generated ID
+      if (loop.conditionExpressionType === 'CallExpression' && loop.conditionLine && loop.conditionColumn !== undefined) {
+        const callSite = callSites.find(cs =>
+          cs.file === loop.file &&
+          cs.line === loop.conditionLine &&
+          cs.column === loop.conditionColumn
+        );
+        if (callSite) {
+          targetId = callSite.id;
+        }
+      }
+
+      this._bufferEdge({
+        type: 'HAS_CONDITION',
+        src: loop.id,
+        dst: targetId
+      });
+    }
+  }
+
+  /**
+   * Buffer EXPRESSION nodes for loop condition expressions (non-CallExpression).
+   * Similar to bufferDiscriminantExpressions but for loops.
+   *
+   * REG-280: Creates EXPRESSION nodes for while/do-while/for loop conditions.
+   * CallExpression conditions use existing CALL_SITE nodes (no EXPRESSION created).
+   */
+  private bufferLoopConditionExpressions(loops: LoopInfo[]): void {
+    for (const loop of loops) {
+      // Skip for-in/for-of loops - they don't have test expressions
+      if (loop.loopType === 'for-in' || loop.loopType === 'for-of') {
+        continue;
+      }
+
+      if (loop.conditionExpressionId && loop.conditionExpressionType) {
+        // Skip CallExpression - we link to existing CALL_SITE in bufferLoopConditionEdges
+        if (loop.conditionExpressionType === 'CallExpression') {
+          continue;
+        }
+
+        // Only create if it looks like an EXPRESSION ID
+        if (loop.conditionExpressionId.includes(':EXPRESSION:')) {
+          this._bufferNode({
+            id: loop.conditionExpressionId,
+            type: 'EXPRESSION',
+            name: loop.conditionExpressionType,
+            file: loop.file,
+            line: loop.conditionLine,
+            column: loop.conditionColumn,
+            expressionType: loop.conditionExpressionType
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Buffer BRANCH edges (CONTAINS, HAS_CONDITION, HAS_CONSEQUENT, HAS_ALTERNATE)
+   *
+   * REG-275: For CallExpression discriminants (switch(getType())), looks up the
+   * actual CALL_SITE node by coordinates since the CALL_SITE uses semantic IDs.
+   *
+   * Phase 3 (REG-267): For if-branches, creates HAS_CONSEQUENT and HAS_ALTERNATE edges
+   * pointing to the if-body and else-body SCOPEs.
+   */
+  private bufferBranchEdges(branches: BranchInfo[], callSites: CallSiteInfo[], scopes: ScopeInfo[]): void {
+    for (const branch of branches) {
+      // Parent SCOPE -> CONTAINS -> BRANCH
+      if (branch.parentScopeId) {
+        this._bufferEdge({
+          type: 'CONTAINS',
+          src: branch.parentScopeId,
+          dst: branch.id
+        });
+      }
+
+      // BRANCH -> HAS_CONDITION -> EXPRESSION/CALL (discriminant)
+      if (branch.discriminantExpressionId) {
+        let targetId = branch.discriminantExpressionId;
+
+        // For CallExpression discriminants, look up the actual CALL_SITE by coordinates
+        // because CALL_SITE uses semantic IDs that don't match the generated ID
+        if (branch.discriminantExpressionType === 'CallExpression' && branch.discriminantLine && branch.discriminantColumn !== undefined) {
+          const callSite = callSites.find(cs =>
+            cs.file === branch.file &&
+            cs.line === branch.discriminantLine &&
+            cs.column === branch.discriminantColumn
+          );
+          if (callSite) {
+            targetId = callSite.id;
+          }
+        }
+
+        this._bufferEdge({
+          type: 'HAS_CONDITION',
+          src: branch.id,
+          dst: targetId
+        });
+      }
+
+      // Phase 3: For if-branches, create HAS_CONSEQUENT and HAS_ALTERNATE edges
+      if (branch.branchType === 'if') {
+        // Find consequent (if-body) scope - parentScopeId matches branch.id, scopeType is 'if_statement'
+        const consequentScope = scopes.find(s =>
+          s.parentScopeId === branch.id && s.scopeType === 'if_statement'
+        );
+        if (consequentScope) {
+          this._bufferEdge({
+            type: 'HAS_CONSEQUENT',
+            src: branch.id,
+            dst: consequentScope.id
+          });
+        }
+
+        // Find alternate (else-body) scope - parentScopeId matches branch.id, scopeType is 'else_statement'
+        const alternateScope = scopes.find(s =>
+          s.parentScopeId === branch.id && s.scopeType === 'else_statement'
+        );
+        if (alternateScope) {
+          this._bufferEdge({
+            type: 'HAS_ALTERNATE',
+            src: branch.id,
+            dst: alternateScope.id
+          });
+        }
+
+        // For else-if chains: if this branch is the alternate of another branch
+        // This is handled differently - see below
+      }
+
+      // REG-287: For ternary branches, create HAS_CONSEQUENT and HAS_ALTERNATE edges to expressions
+      if (branch.branchType === 'ternary') {
+        if (branch.consequentExpressionId) {
+          this._bufferEdge({
+            type: 'HAS_CONSEQUENT',
+            src: branch.id,
+            dst: branch.consequentExpressionId
+          });
+        }
+        if (branch.alternateExpressionId) {
+          this._bufferEdge({
+            type: 'HAS_ALTERNATE',
+            src: branch.id,
+            dst: branch.alternateExpressionId
+          });
+        }
+      }
+
+      // Phase 3: For else-if chains, create HAS_ALTERNATE from parent branch to this branch
+      if (branch.isAlternateOfBranchId) {
+        this._bufferEdge({
+          type: 'HAS_ALTERNATE',
+          src: branch.isAlternateOfBranchId,
+          dst: branch.id
+        });
+      }
+    }
+  }
+
+  /**
+   * Buffer CASE edges (HAS_CASE, HAS_DEFAULT)
+   */
+  private bufferCaseEdges(cases: CaseInfo[]): void {
+    for (const caseInfo of cases) {
+      // BRANCH -> HAS_CASE or HAS_DEFAULT -> CASE
+      const edgeType = caseInfo.isDefault ? 'HAS_DEFAULT' : 'HAS_CASE';
+      this._bufferEdge({
+        type: edgeType,
+        src: caseInfo.parentBranchId,
+        dst: caseInfo.id
+      });
+    }
+  }
+
+  /**
+   * Buffer edges for TRY_BLOCK, CATCH_BLOCK, FINALLY_BLOCK nodes (Phase 4)
+   *
+   * Creates edges for:
+   * - Parent -> CONTAINS -> TRY_BLOCK
+   * - TRY_BLOCK -> HAS_CATCH -> CATCH_BLOCK
+   * - TRY_BLOCK -> HAS_FINALLY -> FINALLY_BLOCK
+   */
+  private bufferTryCatchFinallyEdges(
+    tryBlocks: TryBlockInfo[],
+    catchBlocks: CatchBlockInfo[],
+    finallyBlocks: FinallyBlockInfo[]
+  ): void {
+    // Buffer TRY_BLOCK edges
+    for (const tryBlock of tryBlocks) {
+      // Parent -> CONTAINS -> TRY_BLOCK
+      if (tryBlock.parentScopeId) {
+        this._bufferEdge({
+          type: 'CONTAINS',
+          src: tryBlock.parentScopeId,
+          dst: tryBlock.id
+        });
+      }
+    }
+
+    // Buffer CATCH_BLOCK edges (HAS_CATCH from TRY_BLOCK)
+    for (const catchBlock of catchBlocks) {
+      // TRY_BLOCK -> HAS_CATCH -> CATCH_BLOCK
+      this._bufferEdge({
+        type: 'HAS_CATCH',
+        src: catchBlock.parentTryBlockId,
+        dst: catchBlock.id
+      });
+    }
+
+    // Buffer FINALLY_BLOCK edges (HAS_FINALLY from TRY_BLOCK)
+    for (const finallyBlock of finallyBlocks) {
+      // TRY_BLOCK -> HAS_FINALLY -> FINALLY_BLOCK
+      this._bufferEdge({
+        type: 'HAS_FINALLY',
+        src: finallyBlock.parentTryBlockId,
+        dst: finallyBlock.id
+      });
+    }
+  }
+
+  /**
+   * Buffer EXPRESSION nodes for switch discriminants
+   * Uses stored metadata directly instead of parsing from ID (Linus improvement)
+   *
+   * 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 {
+    for (const branch of branches) {
+      if (branch.discriminantExpressionId && branch.discriminantExpressionType) {
+        // Skip CallExpression - we link to existing CALL_SITE in bufferBranchEdges
+        if (branch.discriminantExpressionType === 'CallExpression') {
+          continue;
+        }
+
+        // Only create if it looks like an EXPRESSION ID
+        if (branch.discriminantExpressionId.includes(':EXPRESSION:')) {
+          this._bufferNode({
+            id: branch.discriminantExpressionId,
+            type: 'EXPRESSION',
+            name: branch.discriminantExpressionType,
+            file: branch.file,
+            line: branch.discriminantLine,
+            column: branch.discriminantColumn,
+            expressionType: branch.discriminantExpressionType
+          });
+        }
+      }
+    }
+  }
+
   private bufferVariableEdges(variableDeclarations: VariableDeclarationInfo[]): void {
     for (const varDecl of variableDeclarations) {
       const { parentScopeId, ...varData } = varDecl;
@@ -338,19 +911,56 @@ export class GraphBuilder {
     }
   }
 
-  private bufferMethodCalls(methodCalls: MethodCallInfo[]): void {
+  private bufferMethodCalls(
+    methodCalls: MethodCallInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[]
+  ): void {
     for (const methodCall of methodCalls) {
-      const { parentScopeId, ...methodData } = methodCall;
-
-      // Buffer METHOD_CALL node
-      this._bufferNode(methodData as GraphNode);
+      // Keep parentScopeId on node for queries
+      this._bufferNode(methodCall as unknown as GraphNode);
 
       // SCOPE -> CONTAINS -> METHOD_CALL
       this._bufferEdge({
         type: 'CONTAINS',
-        src: parentScopeId as string,
-        dst: methodData.id
+        src: methodCall.parentScopeId as string,
+        dst: methodCall.id
       });
+
+      // REG-262: Create USES edge from METHOD_CALL to receiver variable
+      // Skip 'this' - it's not a variable node
+      if (methodCall.object && methodCall.object !== 'this') {
+        // Handle nested member expressions: obj.nested.method() -> use base 'obj'
+        const receiverName = methodCall.object.includes('.')
+          ? methodCall.object.split('.')[0]
+          : methodCall.object;
+
+        // Find receiver variable in current file
+        const receiverVar = variableDeclarations.find(v =>
+          v.name === receiverName && v.file === methodCall.file
+        );
+
+        if (receiverVar) {
+          this._bufferEdge({
+            type: 'USES',
+            src: methodCall.id,
+            dst: receiverVar.id
+          });
+        } else {
+          // Check parameters (function arguments)
+          const receiverParam = parameters.find(p =>
+            p.name === receiverName && p.file === methodCall.file
+          );
+
+          if (receiverParam) {
+            this._bufferEdge({
+              type: 'USES',
+              src: methodCall.id,
+              dst: receiverParam.id
+            });
+          }
+        }
+      }
     }
   }
 
@@ -360,16 +970,12 @@ export class GraphBuilder {
     );
 
     if (consoleIOMethods.length > 0) {
-      const stdioId = 'net:stdio#__stdio__';
+      const stdioNode = NodeFactory.createExternalStdio();
+
       // Buffer net:stdio node only once (singleton)
-      if (!this._createdSingletons.has(stdioId)) {
-        this._bufferNode({
-          id: stdioId,
-          type: 'net:stdio',
-          name: '__stdio__',
-          description: 'Standard input/output stream'
-        });
-        this._createdSingletons.add(stdioId);
+      if (!this._createdSingletons.has(stdioNode.id)) {
+        this._bufferNode(stdioNode as unknown as GraphNode);
+        this._createdSingletons.add(stdioNode.id);
       }
 
       // Buffer WRITES_TO edges for console.log/error
@@ -377,7 +983,7 @@ export class GraphBuilder {
         this._bufferEdge({
           type: 'WRITES_TO',
           src: methodCall.id,
-          dst: stdioId
+          dst: stdioNode.id
         });
       }
     }
@@ -407,9 +1013,14 @@ export class GraphBuilder {
         });
       }
 
-      // If superClass, buffer DERIVES_FROM edge
+      // If superClass, buffer DERIVES_FROM edge with computed ID
       if (superClass) {
-        const superClassId = `CLASS#${superClass}#${file}`;
+        // Compute superclass ID using semantic ID format
+        // Assume superclass is in same file at global scope (most common case)
+        // When superclass is in different file, edge will be dangling until that file analyzed
+        const globalContext = { file, scopePath: [] as string[] };
+        const superClassId = computeSemanticId('CLASS', superClass, globalContext);
+
         this._bufferEdge({
           type: 'DERIVES_FROM',
           src: id,
@@ -421,9 +1032,11 @@ export class GraphBuilder {
 
   private bufferClassNodes(module: ModuleNode, classInstantiations: ClassInstantiationInfo[], classDeclarations: ClassDeclarationInfo[]): void {
     // Create lookup map: className → declaration ID
+    // Use basename for comparison because CLASS nodes use scopeTracker.file (basename)
+    const moduleBasename = basename(module.file);
     const declarationMap = new Map<string, string>();
     for (const decl of classDeclarations) {
-      if (decl.file === module.file) {
+      if (decl.file === moduleBasename) {
         declarationMap.set(decl.name, decl.id);
       }
     }
@@ -434,16 +1047,13 @@ export class GraphBuilder {
       let classId = declarationMap.get(className);
 
       if (!classId) {
-        // External class - buffer CLASS node
-        classId = `${module.file}:CLASS:${className}:${line}`;
-        this._bufferNode({
-          id: classId,
-          type: 'CLASS',
-          name: className,
-          file: module.file,
-          line,
-          isInstantiationRef: true
-        });
+        // External class - compute semantic ID
+        // Use basename to match CLASS node format (scopeTracker uses basename)
+        // When class is in different file, edge will be dangling until that file analyzed
+        const globalContext = { file: moduleBasename, scopePath: [] as string[] };
+        classId = computeSemanticId('CLASS', className, globalContext);
+
+        // NO node creation - node will exist when class file analyzed
       }
 
       // Buffer INSTANCE_OF edge
@@ -475,50 +1085,98 @@ export class GraphBuilder {
 
   private bufferImportNodes(module: ModuleNode, imports: ImportInfo[]): void {
     for (const imp of imports) {
-      const { source, specifiers, line } = imp;
-
-      for (const spec of specifiers) {
-        const importType = spec.imported === 'default' ? 'default' :
-                          spec.imported === '*' ? 'namespace' : 'named';
-
-        const importId = `${module.file}:IMPORT:${source}:${spec.local}:${line}`;
+      const { source, specifiers, line, column, isDynamic, isResolvable, dynamicPath } = imp;
+
+      // REG-273: Handle side-effect-only imports (no specifiers)
+      if (specifiers.length === 0) {
+        // Side-effect import: import './polyfill.js'
+        const importNode = ImportNode.create(
+          source,               // name = source (no local binding)
+          module.file,          // file
+          line,                 // line (stored as field, not in ID)
+          column || 0,          // column
+          source,               // source module
+          {
+            imported: '*',      // no specific export
+            local: source,      // source becomes local
+            sideEffect: true    // mark as side-effect import
+          }
+        );
 
-        this._bufferNode({
-          id: importId,
-          type: 'IMPORT',
-          source: source,
-          importType: importType,
-          imported: spec.imported,
-          local: spec.local,
-          file: module.file,
-          line: line
-        });
+        this._bufferNode(importNode as unknown as GraphNode);
 
         // MODULE -> CONTAINS -> IMPORT
         this._bufferEdge({
           type: 'CONTAINS',
           src: module.id,
-          dst: importId
+          dst: importNode.id
         });
 
         // Create EXTERNAL_MODULE node for external modules
         const isRelative = source.startsWith('./') || source.startsWith('../');
         if (!isRelative) {
-          const externalModuleId = `EXTERNAL_MODULE:${source}`;
+          const externalModule = NodeFactory.createExternalModule(source);
 
-          this._bufferNode({
-            id: externalModuleId,
-            type: 'EXTERNAL_MODULE',
-            name: source,
-            file: module.file,
-            line: line
-          });
+          // Avoid duplicate EXTERNAL_MODULE nodes
+          if (!this._createdSingletons.has(externalModule.id)) {
+            this._bufferNode(externalModule as unknown as GraphNode);
+            this._createdSingletons.add(externalModule.id);
+          }
 
           this._bufferEdge({
             type: 'IMPORTS',
             src: module.id,
-            dst: externalModuleId
+            dst: externalModule.id
+          });
+        }
+      } else {
+        // Regular imports with specifiers
+        for (const spec of specifiers) {
+          // Use ImportNode factory for proper semantic IDs and field population
+          const importNode = ImportNode.create(
+            spec.local,           // name = local binding
+            module.file,          // file
+            line,                 // line (stored as field, not in ID)
+            column || 0,          // column
+            source,               // source module
+            {
+              imported: spec.imported,
+              local: spec.local,
+              sideEffect: false,  // regular imports are not side-effects
+              // importType is auto-detected from imported field
+              // Dynamic import fields
+              isDynamic,
+              isResolvable,
+              dynamicPath
+            }
+          );
+
+          this._bufferNode(importNode as unknown as GraphNode);
+
+          // MODULE -> CONTAINS -> IMPORT
+          this._bufferEdge({
+            type: 'CONTAINS',
+            src: module.id,
+            dst: importNode.id
           });
+
+          // Create EXTERNAL_MODULE node for external modules
+          const isRelative = source.startsWith('./') || source.startsWith('../');
+          if (!isRelative) {
+            const externalModule = NodeFactory.createExternalModule(source);
+
+            // Avoid duplicate EXTERNAL_MODULE nodes
+            if (!this._createdSingletons.has(externalModule.id)) {
+              this._bufferNode(externalModule as unknown as GraphNode);
+              this._createdSingletons.add(externalModule.id);
+            }
+
+            this._bufferEdge({
+              type: 'IMPORTS',
+              src: module.id,
+              dst: externalModule.id
+            });
+          }
         }
       }
     }
@@ -529,79 +1187,79 @@ export class GraphBuilder {
       const { type, line, name, specifiers, source } = exp;
 
       if (type === 'default') {
-        const exportId = `${module.file}:EXPORT:default:${line}`;
-
-        this._bufferNode({
-          id: exportId,
-          type: 'EXPORT',
-          exportType: 'default',
-          name: 'default',
-          file: module.file,
-          line: line
-        });
+        const exportNode = NodeFactory.createExport(
+          'default',
+          module.file,
+          line,
+          0,
+          { default: true, exportType: 'default' }
+        );
+
+        this._bufferNode(exportNode as unknown as GraphNode);
 
         this._bufferEdge({
           type: 'CONTAINS',
           src: module.id,
-          dst: exportId
+          dst: exportNode.id
         });
       } else if (type === 'named') {
         if (specifiers) {
           for (const spec of specifiers) {
-            const exportId = `${module.file}:EXPORT:${spec.exported}:${line}`;
+            const exportNode = NodeFactory.createExport(
+              spec.exported,
+              module.file,
+              line,
+              0,
+              {
+                local: spec.local,
+                source: source,
+                exportType: 'named'
+              }
+            );
 
-            this._bufferNode({
-              id: exportId,
-              type: 'EXPORT',
-              exportType: 'named',
-              name: spec.exported,
-              local: spec.local,
-              file: module.file,
-              line: line,
-              source: source
-            });
+            this._bufferNode(exportNode as unknown as GraphNode);
 
             this._bufferEdge({
               type: 'CONTAINS',
               src: module.id,
-              dst: exportId
+              dst: exportNode.id
             });
           }
         } else if (name) {
-          const exportId = `${module.file}:EXPORT:${name}:${line}`;
+          const exportNode = NodeFactory.createExport(
+            name,
+            module.file,
+            line,
+            0,
+            { exportType: 'named' }
+          );
 
-          this._bufferNode({
-            id: exportId,
-            type: 'EXPORT',
-            exportType: 'named',
-            name: name,
-            file: module.file,
-            line: line
-          });
+          this._bufferNode(exportNode as unknown as GraphNode);
 
           this._bufferEdge({
             type: 'CONTAINS',
             src: module.id,
-            dst: exportId
+            dst: exportNode.id
           });
         }
       } else if (type === 'all') {
-        const exportId = `${module.file}:EXPORT:*:${line}`;
+        const exportNode = NodeFactory.createExport(
+          '*',
+          module.file,
+          line,
+          0,
+          {
+            source: source,
+            exportType: 'all'
+          }
+        );
 
-        this._bufferNode({
-          id: exportId,
-          type: 'EXPORT',
-          exportType: 'all',
-          name: '*',
-          file: module.file,
-          line: line,
-          source: source
-        });
+        this._bufferNode(exportNode as unknown as GraphNode);
 
         this._bufferEdge({
           type: 'CONTAINS',
           src: module.id,
-          dst: exportId
+          dst: exportNode.id
         });
       }
     }
@@ -638,15 +1296,12 @@ export class GraphBuilder {
 
   private bufferHttpRequests(httpRequests: HttpRequestInfo[], functions: FunctionInfo[]): void {
     if (httpRequests.length > 0) {
-      const networkId = 'net:request#__network__';
+      // Create net:request singleton using factory
+      const networkNode = NetworkRequestNode.create();
 
-      if (!this._createdSingletons.has(networkId)) {
-        this._bufferNode({
-          id: networkId,
-          type: 'net:request',
-          name: '__network__'
-        });
-        this._createdSingletons.add(networkId);
+      if (!this._createdSingletons.has(networkNode.id)) {
+        this._bufferNode(networkNode as unknown as GraphNode);
+        this._createdSingletons.add(networkNode.id);
       }
 
       for (const request of httpRequests) {
@@ -657,7 +1312,7 @@ export class GraphBuilder {
         this._bufferEdge({
           type: 'CALLS',
           src: request.id,
-          dst: networkId
+          dst: networkNode.id
         });
 
         if (parentScopeId) {
@@ -710,6 +1365,7 @@ export class GraphBuilder {
         sourceFile,
         functionName,
         line,
+        column,
         className
       } = assignment;
 
@@ -718,6 +1374,29 @@ export class GraphBuilder {
         continue;
       }
 
+      // CONSTRUCTOR_CALL: create ASSIGNED_FROM edge to existing node
+      // Note: CONSTRUCTOR_CALL nodes are already created from constructorCalls collection in step 4.5
+      if (sourceType === 'CONSTRUCTOR_CALL' && className) {
+        const constructorLine = line ?? 0;
+        const constructorColumn = column ?? 0;
+        const constructorFile = assignment.file ?? '';
+
+        // Generate ID matching the one created in NewExpression visitor
+        const constructorCallId = NodeFactory.generateConstructorCallId(
+          className,
+          constructorFile,
+          constructorLine,
+          constructorColumn
+        );
+
+        this._bufferEdge({
+          type: 'ASSIGNED_FROM',
+          src: variableId,
+          dst: constructorCallId
+        });
+        continue;
+      }
+
       // Direct LITERAL assignment
       if (sourceId && sourceType !== 'EXPRESSION') {
         this._bufferEdge({
@@ -766,8 +1445,10 @@ export class GraphBuilder {
       }
       // VARIABLE by name
       else if (sourceType === 'VARIABLE' && sourceName) {
-        const varIdParts = variableId.split('#');
-        const varFile = varIdParts.length >= 3 ? varIdParts[2] : null;
+        // Find the current variable's file by looking it up in variableDeclarations
+        // (semantic IDs don't have predictable file positions like old hash-based IDs)
+        const currentVar = variableDeclarations.find(v => v.id === variableId);
+        const varFile = currentVar?.file ?? null;
         const sourceVariable = variableDeclarations.find(v =>
           v.name === sourceName && v.file === varFile
         );
@@ -806,7 +1487,7 @@ export class GraphBuilder {
           });
         }
       }
-      // EXPRESSION node creation
+      // EXPRESSION node creation using NodeFactory
       else if (sourceType === 'EXPRESSION' && sourceId) {
         const {
           expressionType,
@@ -821,33 +1502,35 @@ export class GraphBuilder {
           consequentSourceName,
           alternateSourceName,
           file: exprFile,
-          line: exprLine
+          line: exprLine,
+          column: exprColumn,
+          // Destructuring support (REG-201)
+          path,
+          baseName,
+          propertyPath,
+          arrayIndex
         } = assignment;
 
-        const expressionNode: GraphNode = {
-          id: sourceId,
-          type: 'EXPRESSION',
-          expressionType,
-          file: exprFile,
-          line: exprLine
-        };
-
-        if (expressionType === 'MemberExpression') {
-          expressionNode.object = object;
-          expressionNode.property = property;
-          expressionNode.computed = computed;
-          if (computedPropertyVar) {
-            expressionNode.computedPropertyVar = computedPropertyVar;
+        // Create node from upstream metadata using factory
+        const expressionNode = NodeFactory.createExpressionFromMetadata(
+          expressionType || 'Unknown',
+          exprFile || '',
+          exprLine || 0,
+          exprColumn || 0,
+          {
+            id: sourceId,  // ID from JSASTAnalyzer
+            object,
+            property,
+            computed,
+            computedPropertyVar: computedPropertyVar ?? undefined,
+            operator,
+            // Destructuring support (REG-201)
+            path,
+            baseName,
+            propertyPath,
+            arrayIndex
           }
-          expressionNode.name = `${object}.${property}`;
-        } else if (expressionType === 'BinaryExpression' || expressionType === 'LogicalExpression') {
-          expressionNode.operator = operator;
-          expressionNode.name = `<${expressionType}>`;
-        } else if (expressionType === 'ConditionalExpression') {
-          expressionNode.name = '<ternary>';
-        } else if (expressionType === 'TemplateLiteral') {
-          expressionNode.name = '<template>';
-        }
+        );
 
         this._bufferNode(expressionNode);
 
@@ -873,6 +1556,50 @@ export class GraphBuilder {
             });
           }
         }
+        // Call-based source lookup (REG-223)
+        else if (expressionType === 'MemberExpression' && assignment.callSourceLine !== undefined) {
+          const { callSourceLine, callSourceColumn, callSourceName, callSourceFile } = assignment;
+
+          // Try CALL_SITE first (direct function calls)
+          const callSite = callSites.find(cs =>
+            cs.line === callSourceLine &&
+            cs.column === callSourceColumn &&
+            (callSourceName ? cs.name === callSourceName : true)
+          );
+
+          if (callSite) {
+            this._bufferEdge({
+              type: 'DERIVES_FROM',
+              src: sourceId,
+              dst: callSite.id
+            });
+          }
+          // Fall back to methodCalls (arr.map(), obj.getConfig())
+          else {
+            const methodCall = methodCalls.find(mc =>
+              mc.line === callSourceLine &&
+              mc.column === callSourceColumn &&
+              (callSourceName ? mc.name === callSourceName : true)
+            );
+
+            if (methodCall) {
+              this._bufferEdge({
+                type: 'DERIVES_FROM',
+                src: sourceId,
+                dst: methodCall.id
+              });
+            }
+            // Log warning when lookup fails (per Linus review - no silent failures)
+            else {
+              console.warn(
+                `[REG-223] DERIVES_FROM lookup failed for EXPRESSION(${assignment.object}.${assignment.property}) ` +
+                `at ${callSourceFile}:${callSourceLine}:${callSourceColumn}. ` +
+                `Expected CALL_SITE or methodCall for "${callSourceName}". ` +
+                `This indicates a coordinate mismatch or missing call node.`
+              );
+            }
+          }
+        }
 
         if ((expressionType === 'BinaryExpression' || expressionType === 'LogicalExpression')) {
           if (leftSourceName) {
@@ -1029,6 +1756,12 @@ export class GraphBuilder {
           targetNodeId = nestedCall.id;
         }
       }
+      else if (targetType === 'LITERAL' ||
+               targetType === 'OBJECT_LITERAL' ||
+               targetType === 'ARRAY_LITERAL') {
+        // targetId is already set by CallExpressionVisitor
+        targetNodeId = targetId;
+      }
 
       if (targetNodeId) {
         const edgeData: GraphEdge = {
@@ -1051,54 +1784,66 @@ export class GraphBuilder {
 
   /**
    * Buffer INTERFACE nodes and EXTENDS edges
+   *
+   * Uses two-pass approach:
+   * 1. First pass: create all interface nodes, store in Map
+   * 2. Second pass: create EXTENDS edges using stored node IDs
    */
   private bufferInterfaceNodes(module: ModuleNode, interfaces: InterfaceDeclarationInfo[]): void {
+    // First pass: create all interface nodes and store them
+    const interfaceNodes = new Map<string, InterfaceNodeRecord>();
+
     for (const iface of interfaces) {
-      // Buffer INTERFACE node
-      this._bufferNode({
-        id: iface.id,
-        type: 'INTERFACE',
-        name: iface.name,
-        file: iface.file,
-        line: iface.line,
-        column: iface.column,
-        properties: iface.properties,
-        extends: iface.extends
-      });
+      const interfaceNode = InterfaceNode.create(
+        iface.name,
+        iface.file,
+        iface.line,
+        iface.column || 0,
+        {
+          extends: iface.extends,
+          properties: iface.properties
+        }
+      );
+      interfaceNodes.set(iface.name, interfaceNode);
+      this._bufferNode(interfaceNode as unknown as GraphNode);
 
       // MODULE -> CONTAINS -> INTERFACE
       this._bufferEdge({
         type: 'CONTAINS',
         src: module.id,
-        dst: iface.id
+        dst: interfaceNode.id
       });
+    }
 
-      // INTERFACE -> EXTENDS -> INTERFACE (for each parent interface)
+    // Second pass: create EXTENDS edges
+    for (const iface of interfaces) {
       if (iface.extends && iface.extends.length > 0) {
+        const srcNode = interfaceNodes.get(iface.name)!;
+
         for (const parentName of iface.extends) {
-          // Try to find the parent interface in the same file
-          const parentInterface = interfaces.find(i => i.name === parentName);
-          if (parentInterface) {
+          const parentNode = interfaceNodes.get(parentName);
+
+          if (parentNode) {
+            // Same-file interface
             this._bufferEdge({
               type: 'EXTENDS',
-              src: iface.id,
-              dst: parentInterface.id
+              src: srcNode.id,
+              dst: parentNode.id
             });
           } else {
             // External interface - create a reference node
-            const externalId = `INTERFACE#${parentName}#${iface.file}#external`;
-            this._bufferNode({
-              id: externalId,
-              type: 'INTERFACE',
-              name: parentName,
-              file: iface.file,
-              line: iface.line,
-              isExternal: true
-            });
+            const externalInterface = NodeFactory.createInterface(
+              parentName,
+              iface.file,
+              iface.line,
+              0,
+              { isExternal: true }
+            );
+            this._bufferNode(externalInterface as unknown as GraphNode);
             this._bufferEdge({
               type: 'EXTENDS',
-              src: iface.id,
-              dst: externalId
+              src: srcNode.id,
+              dst: externalInterface.id
             });
           }
         }
@@ -1111,48 +1856,51 @@ export class GraphBuilder {
    */
   private bufferTypeAliasNodes(module: ModuleNode, typeAliases: TypeAliasInfo[]): void {
     for (const typeAlias of typeAliases) {
-      // Buffer TYPE node
-      this._bufferNode({
-        id: typeAlias.id,
-        type: 'TYPE',
-        name: typeAlias.name,
-        file: typeAlias.file,
-        line: typeAlias.line,
-        column: typeAlias.column,
-        aliasOf: typeAlias.aliasOf
-      });
+      // Create TYPE node using factory
+      const typeNode = NodeFactory.createType(
+        typeAlias.name,
+        typeAlias.file,
+        typeAlias.line,
+        typeAlias.column || 0,
+        { aliasOf: typeAlias.aliasOf }
+      );
+      this._bufferNode(typeNode as unknown as GraphNode);
 
       // MODULE -> CONTAINS -> TYPE
       this._bufferEdge({
         type: 'CONTAINS',
         src: module.id,
-        dst: typeAlias.id
+        dst: typeNode.id
       });
     }
   }
 
   /**
    * Buffer ENUM nodes
+   * Uses EnumNode.create() to ensure consistent ID format (colon separator)
    */
   private bufferEnumNodes(module: ModuleNode, enums: EnumDeclarationInfo[]): void {
     for (const enumDecl of enums) {
-      // Buffer ENUM node
-      this._bufferNode({
-        id: enumDecl.id,
-        type: 'ENUM',
-        name: enumDecl.name,
-        file: enumDecl.file,
-        line: enumDecl.line,
-        column: enumDecl.column,
-        isConst: enumDecl.isConst,
-        members: enumDecl.members
-      });
+      // Use EnumNode.create() to generate proper ID (colon format)
+      // Do NOT use enumDecl.id which has legacy # format from TypeScriptVisitor
+      const enumNode = EnumNode.create(
+        enumDecl.name,
+        enumDecl.file,
+        enumDecl.line,
+        enumDecl.column || 0,
+        {
+          isConst: enumDecl.isConst || false,
+          members: enumDecl.members || []
+        }
+      );
+
+      this._bufferNode(enumNode as unknown as GraphNode);
 
       // MODULE -> CONTAINS -> ENUM
       this._bufferEdge({
         type: 'CONTAINS',
         src: module.id,
-        dst: enumDecl.id
+        dst: enumNode.id  // Use factory-generated ID (colon format)
       });
     }
   }
@@ -1162,23 +1910,24 @@ export class GraphBuilder {
    */
   private bufferDecoratorNodes(decorators: DecoratorInfo[]): void {
     for (const decorator of decorators) {
-      // Buffer DECORATOR node
-      this._bufferNode({
-        id: decorator.id,
-        type: 'DECORATOR',
-        name: decorator.name,
-        file: decorator.file,
-        line: decorator.line,
-        column: decorator.column,
-        arguments: decorator.arguments,
-        targetType: decorator.targetType
-      });
+      // Create DECORATOR node using factory (generates colon-format ID)
+      const decoratorNode = DecoratorNode.create(
+        decorator.name,
+        decorator.file,
+        decorator.line,
+        decorator.column || 0,
+        decorator.targetId,  // Now included in the node!
+        decorator.targetType,
+        { arguments: decorator.arguments }
+      );
+
+      this._bufferNode(decoratorNode as unknown as GraphNode);
 
       // TARGET -> DECORATED_BY -> DECORATOR
       this._bufferEdge({
         type: 'DECORATED_BY',
         src: decorator.targetId,
-        dst: decorator.id
+        dst: decoratorNode.id  // Use factory-generated ID (colon format)
       });
     }
   }
@@ -1193,26 +1942,28 @@ export class GraphBuilder {
           // Try to find the interface in the same file
           const iface = interfaces.find(i => i.name === ifaceName);
           if (iface) {
+            // Compute interface ID using same formula as InterfaceNode.create()
+            // Format: {file}:INTERFACE:{name}:{line}
+            const interfaceId = `${iface.file}:INTERFACE:${iface.name}:${iface.line}`;
             this._bufferEdge({
               type: 'IMPLEMENTS',
               src: classDecl.id,
-              dst: iface.id
+              dst: interfaceId
             });
           } else {
             // External interface - create a reference node
-            const externalId = `INTERFACE#${ifaceName}#${classDecl.file}#external`;
-            this._bufferNode({
-              id: externalId,
-              type: 'INTERFACE',
-              name: ifaceName,
-              file: classDecl.file,
-              line: classDecl.line,
-              isExternal: true
-            });
+            const externalInterface = NodeFactory.createInterface(
+              ifaceName,
+              classDecl.file,
+              classDecl.line,
+              0,
+              { isExternal: true }
+            );
+            this._bufferNode(externalInterface as unknown as GraphNode);
             this._bufferEdge({
               type: 'IMPLEMENTS',
               src: classDecl.id,
-              dst: externalId
+              dst: externalInterface.id
             });
           }
         }
@@ -1221,148 +1972,1017 @@ export class GraphBuilder {
   }
 
   /**
-   * Handle CLASS ASSIGNED_FROM edges asynchronously (needs graph queries)
+   * 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
+   *
+   * OPTIMIZED: Uses Map-based lookup cache for O(1) variable lookups instead of O(n) find()
    */
-  private async createClassAssignmentEdges(variableAssignments: VariableAssignmentInfo[], graph: GraphBackend): Promise<number> {
-    let edgesCreated = 0;
+  private bufferArrayMutationEdges(
+    arrayMutations: ArrayMutationInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[]
+  ): void {
+    // Note: No longer using Map-based cache - scope-aware lookup requires scope chain walk
 
-    for (const assignment of variableAssignments) {
-      const { variableId, sourceType, className } = assignment;
+    for (const mutation of arrayMutations) {
+      const { arrayName, mutationScopePath, mutationMethod, insertedValues, file, isNested, baseObjectName, propertyName } = mutation;
 
-      if (sourceType === 'CLASS' && className) {
-        const parts = variableId.split('#');
-        const file = parts.length >= 3 ? parts[2] : null;
+      const scopePath = mutationScopePath ?? [];
 
-        let classNode: { id: string; name: string; file?: string } | null = null;
-        for await (const node of graph.queryNodes({ type: 'CLASS' })) {
-          if (node.name === className && (!file || node.file === file)) {
-            classNode = node as { id: string; name: string; file?: string };
-            break;
+      // REG-117: For nested mutations (obj.arr.push), resolve target node
+      let targetNodeId: string | null = null;
+      let nestedProperty: string | undefined;
+
+      if (isNested && baseObjectName) {
+        // Skip 'this.items.push' - 'this' is not a variable node
+        if (baseObjectName === 'this') continue;
+
+        // Nested mutation: try base object lookup with scope chain (REG-309)
+        const baseVar = this.resolveVariableInScope(baseObjectName, scopePath, file, variableDeclarations);
+        const baseParam = !baseVar ? this.resolveParameterInScope(baseObjectName, scopePath, file, parameters) : null;
+        targetNodeId = baseVar?.id ?? baseParam?.id ?? null;
+        nestedProperty = propertyName;
+      } else {
+        // Direct mutation: arr.push() (REG-309)
+        const arrayVar = this.resolveVariableInScope(arrayName, scopePath, file, variableDeclarations);
+        const arrayParam = !arrayVar ? this.resolveParameterInScope(arrayName, scopePath, file, parameters) : null;
+        targetNodeId = arrayVar?.id ?? arrayParam?.id ?? null;
+      }
+
+      if (!targetNodeId) continue;
+
+      // Create FLOWS_INTO edges for each inserted value
+      for (const arg of insertedValues) {
+        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);
           }
         }
+        // For literals, object literals, etc. - we could create edges from LITERAL nodes
+        // but for now we just track variable -> array flows
+      }
+    }
+  }
 
-        if (classNode) {
-          await graph.addEdge({
-            type: 'ASSIGNED_FROM',
-            src: variableId,
-            dst: classNode.id
-          });
-          edgesCreated++;
+  /**
+   * Buffer FLOWS_INTO edges for object mutations (property assignment, Object.assign)
+   * Creates edges from source values to the object variable being mutated.
+   *
+   * REG-152: For 'this.prop = value' patterns inside classes, creates edges
+   * to the CLASS node with mutationType: 'this_property'.
+   */
+  private bufferObjectMutationEdges(
+    objectMutations: ObjectMutationInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[],
+    functions: FunctionInfo[],
+    classDeclarations: ClassDeclarationInfo[]
+  ): void {
+    for (const mutation of objectMutations) {
+      const { objectName, mutationScopePath, propertyName, mutationType, computedPropertyVar, value, file, enclosingClassName } = mutation;
+
+      const scopePath = mutationScopePath ?? [];
+
+      // Find the target node (object variable, parameter, or class for 'this')
+      let objectNodeId: string | null = null;
+      let effectiveMutationType: 'property' | 'computed' | 'assign' | 'spread' | 'this_property' = mutationType;
+
+      if (objectName !== 'this') {
+        // Regular object - find variable, parameter, or function using scope chain (REG-309)
+        const objectVar = this.resolveVariableInScope(objectName, scopePath, file, variableDeclarations);
+        const objectParam = !objectVar ? this.resolveParameterInScope(objectName, scopePath, file, parameters) : null;
+        const objectFunc = !objectVar && !objectParam ? functions.find(f => f.name === objectName && f.file === file) : null;
+        objectNodeId = objectVar?.id ?? objectParam?.id ?? objectFunc?.id ?? null;
+        if (!objectNodeId) continue;
+      } else {
+        // REG-152: 'this' mutations - find the CLASS node
+        if (!enclosingClassName) continue;  // Skip if no class context (e.g., standalone function)
+
+        // Compare using basename since classes use scopeTracker.file (basename)
+        // but mutations use module.file (full path)
+        const fileBasename = basename(file);
+        const classDecl = classDeclarations.find(c => c.name === enclosingClassName && c.file === fileBasename);
+        objectNodeId = classDecl?.id ?? null;
+
+        if (!objectNodeId) continue;  // Skip if class not found
+
+        // Use special mutation type to distinguish from regular property mutations
+        effectiveMutationType = 'this_property';
+      }
+
+      // Create FLOWS_INTO edge for VARIABLE value type
+      if (value.valueType === 'VARIABLE' && value.valueName) {
+        // Find the source: can be variable, parameter, or function using scope chain (REG-309)
+        const sourceVar = this.resolveVariableInScope(value.valueName, scopePath, file, variableDeclarations);
+        const sourceParam = !sourceVar ? this.resolveParameterInScope(value.valueName, scopePath, file, parameters) : null;
+        const sourceFunc = !sourceVar && !sourceParam ? functions.find(f => f.name === value.valueName && f.file === file) : null;
+        const sourceNodeId = sourceVar?.id ?? sourceParam?.id ?? sourceFunc?.id;
+
+        if (sourceNodeId && objectNodeId) {
+          const edgeData: GraphEdge = {
+            type: 'FLOWS_INTO',
+            src: sourceNodeId,
+            dst: objectNodeId,
+            mutationType: effectiveMutationType,
+            propertyName,
+            computedPropertyVar  // For enrichment phase resolution
+          };
+          if (value.argIndex !== undefined) {
+            edgeData.argIndex = value.argIndex;
+          }
+          if (value.isSpread) {
+            edgeData.isSpread = true;
+          }
+          this._bufferEdge(edgeData);
         }
       }
+      // For literals, object literals, etc. - we just track variable -> object flows for now
     }
+  }
 
-    return edgesCreated;
+  /**
+   * Resolve variable by name using scope chain lookup (REG-309).
+   * Mirrors JavaScript lexical scoping: search current scope, then parent, then grandparent, etc.
+   *
+   * @param name - Variable name
+   * @param scopePath - Scope path where reference occurs (from ScopeTracker)
+   * @param file - File path
+   * @param variables - All variable declarations
+   * @returns Variable declaration or null if not found
+   */
+  private resolveVariableInScope(
+    name: string,
+    scopePath: string[],
+    file: string,
+    variables: VariableDeclarationInfo[]
+  ): VariableDeclarationInfo | null {
+    // Try current scope, then parent, then grandparent, etc.
+    for (let i = scopePath.length; i >= 0; i--) {
+      const searchScopePath = scopePath.slice(0, i);
+
+      const matchingVar = variables.find(v => {
+        if (v.name !== name || v.file !== file) return false;
+
+        // Variable ID IS the semantic ID (when scopeTracker was available during analysis)
+        // Format: file->scope1->scope2->TYPE->name
+        // Legacy format: VARIABLE#name#file#line:column:counter
+
+        // Try parsing as semantic ID
+        const parsed = parseSemanticId(v.id);
+        // REG-329: Check for both VARIABLE and CONSTANT (const declarations)
+        if (parsed && (parsed.type === 'VARIABLE' || parsed.type === 'CONSTANT')) {
+          // FIXED (REG-309): Handle module-level scope matching
+          // Empty search scope [] should match semantic ID scope ['global']
+          if (searchScopePath.length === 0) {
+            return parsed.scopePath.length === 1 && parsed.scopePath[0] === 'global';
+          }
+          // Non-empty scope: exact match
+          return this.scopePathsMatch(parsed.scopePath, searchScopePath);
+        }
+
+        // Legacy ID - assume module-level if no semantic ID
+        return searchScopePath.length === 0;
+      });
+
+      if (matchingVar) return matchingVar;
+    }
+
+    return null;
   }
 
   /**
-   * Create IMPORTS_FROM edges linking imports to their target exports
+   * Resolve parameter by name using scope chain lookup (REG-309).
+   * Same semantics as resolveVariableInScope but for parameters.
+   *
+   * @param name - Parameter name
+   * @param scopePath - Scope path where reference occurs (from ScopeTracker)
+   * @param file - File path
+   * @param parameters - All parameter declarations
+   * @returns Parameter declaration or null if not found
    */
-  private async createImportExportEdges(
-    module: ModuleNode,
-    imports: ImportInfo[],
-    _exports: ExportInfo[],
-    graph: GraphBackend,
-    _projectPath: string
-  ): Promise<number> {
-    let edgesCreated = 0;
+  private resolveParameterInScope(
+    name: string,
+    scopePath: string[],
+    file: string,
+    parameters: ParameterInfo[]
+  ): ParameterInfo | null {
+    // Parameters have semanticId field populated (unlike variables which use id field)
+    return parameters.find(p => {
+      if (p.name !== name || p.file !== file) return false;
+
+      if (p.semanticId) {
+        const parsed = parseSemanticId(p.semanticId);
+        if (parsed && parsed.type === 'PARAMETER') {
+          // Check if parameter's scope matches any scope in the chain
+          for (let i = scopePath.length; i >= 0; i--) {
+            const searchScopePath = scopePath.slice(0, i);
+
+            // FIXED (REG-309): Handle module-level scope matching for parameters
+            if (searchScopePath.length === 0) {
+              if (parsed.scopePath.length === 1 && parsed.scopePath[0] === 'global') {
+                return true;
+              }
+            } else {
+              if (this.scopePathsMatch(parsed.scopePath, searchScopePath)) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+      return false;
+    }) ?? null;
+  }
 
-    for (const imp of imports) {
-      const { source, specifiers, line } = imp;
+  /**
+   * Check if two scope paths match (REG-309).
+   * Handles: ['foo', 'if#0'] vs ['foo', 'if#0']
+   */
+  private scopePathsMatch(a: string[], b: string[]): boolean {
+    if (a.length !== b.length) return false;
+    return a.every((item, idx) => item === b[idx]);
+  }
 
-      // Только для относительных импортов
-      const isRelative = source.startsWith('./') || source.startsWith('../');
-      if (!isRelative) {
+  /**
+   * Buffer FLOWS_INTO edges for variable reassignments.
+   * Handles: x = y, x += y (when x is already declared, not initialization)
+   *
+   * Edge patterns:
+   * - Simple assignment (=): source --FLOWS_INTO--> variable
+   * - Compound operators (+=, -=, etc.):
+   *   - source --FLOWS_INTO--> variable (write new value)
+   *   - variable --READS_FROM--> variable (self-loop: reads current value before write)
+   *
+   * REG-309: Uses scope-aware variable lookup via resolveVariableInScope().
+   *
+   * REG-290: Complete implementation with inline node creation (no continue statements).
+   */
+  private bufferVariableReassignmentEdges(
+    variableReassignments: VariableReassignmentInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    callSites: CallSiteInfo[],
+    methodCalls: MethodCallInfo[],
+    parameters: ParameterInfo[]
+  ): void {
+    // Note: No longer using Map-based cache - scope-aware lookup requires scope chain walk
+    // Performance: O(n*m*s) where s = scope depth (typically 2-3), acceptable for correctness
+
+    for (const reassignment of variableReassignments) {
+      const {
+        variableName,
+        mutationScopePath,
+        valueType,
+        valueName,
+        valueId,
+        callLine,
+        callColumn,
+        operator,
+        literalValue,
+        expressionType,
+        expressionMetadata,
+        file,
+        line,
+        column
+      } = reassignment;
+
+      // Find target variable node using scope chain resolution (REG-309)
+      const scopePath = mutationScopePath ?? [];
+      const targetVar = this.resolveVariableInScope(variableName, scopePath, file, variableDeclarations);
+      const targetParam = !targetVar ? this.resolveParameterInScope(variableName, scopePath, file, parameters) : null;
+      const targetNodeId = targetVar?.id ?? targetParam?.id;
+
+      if (!targetNodeId) {
+        // Variable not found - could be external reference
         continue;
       }
 
-      // Резолвим целевой модуль
-      const currentDir = dirname(module.file);
-      let targetPath = resolve(currentDir, source);
+      // Resolve source node based on value type
+      let sourceNodeId: string | null = null;
 
-      // Пытаемся найти файл с расширениями .js, .ts, .jsx, .tsx
-      const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts'];
-      let targetModule: { id: string; file: string } | null = null;
+      // LITERAL: Create node inline (NO CONTINUE STATEMENT)
+      if (valueType === 'LITERAL' && valueId) {
+        // Create LITERAL node
+        this._bufferNode({
+          type: 'LITERAL',
+          id: valueId,
+          value: literalValue,
+          file,
+          line,
+          column
+        });
+        sourceNodeId = valueId;
+      }
+      // VARIABLE: Look up existing variable/parameter node using scope chain (REG-309)
+      else if (valueType === 'VARIABLE' && valueName) {
+        const sourceVar = this.resolveVariableInScope(valueName, scopePath, file, variableDeclarations);
+        const sourceParam = !sourceVar ? this.resolveParameterInScope(valueName, scopePath, file, parameters) : null;
+        sourceNodeId = sourceVar?.id ?? sourceParam?.id ?? null;
+      }
+      // CALL_SITE: Look up existing call node
+      else if (valueType === 'CALL_SITE' && callLine && callColumn) {
+        const callSite = callSites.find(cs =>
+          cs.line === callLine && cs.column === callColumn && cs.file === file
+        );
+        sourceNodeId = callSite?.id ?? null;
+      }
+      // METHOD_CALL: Look up existing method call node
+      else if (valueType === 'METHOD_CALL' && callLine && callColumn) {
+        const methodCall = methodCalls.find(mc =>
+          mc.line === callLine && mc.column === callColumn && mc.file === file
+        );
+        sourceNodeId = methodCall?.id ?? null;
+      }
+      // EXPRESSION: Create node inline (NO CONTINUE STATEMENT)
+      else if (valueType === 'EXPRESSION' && valueId && expressionType) {
+        // Create EXPRESSION node using NodeFactory
+        const expressionNode = NodeFactory.createExpressionFromMetadata(
+          expressionType,
+          file,
+          line,
+          column,
+          {
+            id: valueId,  // ID from JSASTAnalyzer
+            object: expressionMetadata?.object,
+            property: expressionMetadata?.property,
+            computed: expressionMetadata?.computed,
+            computedPropertyVar: expressionMetadata?.computedPropertyVar ?? undefined,
+            operator: expressionMetadata?.operator
+          }
+        );
 
-      // Ищем MODULE ноду по file атрибуту (не по ID, т.к. формат ID изменился)
-      for (const ext of extensions) {
-        const testPath = targetPath + ext;
+        this._bufferNode(expressionNode);
+        sourceNodeId = valueId;
+      }
 
-        // Ищем MODULE с этим file path
-        for await (const node of graph.queryNodes({ type: 'MODULE' })) {
-          if (node.file === testPath) {
-            targetModule = node as { id: string; file: string };
-            targetPath = testPath;
-            break;
-          }
+      // Create edges if source found
+      if (sourceNodeId && targetNodeId) {
+        // For compound operators (operator !== '='), LHS reads its own current value
+        // Create READS_FROM self-loop (Linus requirement)
+        if (operator !== '=') {
+          this._bufferEdge({
+            type: 'READS_FROM',
+            src: targetNodeId,  // Variable reads from...
+            dst: targetNodeId   // ...itself (self-loop)
+          });
         }
-        if (targetModule) break;
+
+        // RHS flows into LHS (write side)
+        this._bufferEdge({
+          type: 'FLOWS_INTO',
+          src: sourceNodeId,
+          dst: targetNodeId
+        });
       }
+    }
+  }
+
+  /**
+   * Buffer RETURNS edges connecting return expressions to their containing functions.
+   *
+   * Edge direction: returnExpression --RETURNS--> function
+   *
+   * This enables tracing data flow through function calls:
+   * - Query: "What does formatDate return?"
+   * - Answer: Follow RETURNS edges from function to see all possible return values
+   */
+  private bufferReturnEdges(
+    returnStatements: ReturnStatementInfo[],
+    callSites: CallSiteInfo[],
+    methodCalls: MethodCallInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[]
+  ): void {
+    for (const ret of returnStatements) {
+      const { parentFunctionId, returnValueType, file } = ret;
 
-      if (!targetModule) {
-        // Целевой модуль не найден в графе
+      // Skip if no value returned (bare return;)
+      if (returnValueType === 'NONE') {
         continue;
       }
 
-      // Создаём IMPORTS edge от MODULE к MODULE (для совместимости с тестами)
-      await graph.addEdge({
-        type: 'IMPORTS',
-        src: module.id,
-        dst: targetModule.id
-      });
-      edgesCreated++;
+      let sourceNodeId: string | null = null;
 
-      // Для каждого импортированного идентификатора создаём ребро к соответствующему EXPORT
-      for (const spec of specifiers) {
-        const importId = `${module.file}:IMPORT:${source}:${spec.local}:${line}`;
-        const importType = spec.imported === 'default' ? 'default' :
-                          spec.imported === '*' ? 'namespace' : 'named';
+      switch (returnValueType) {
+        case 'LITERAL':
+          // Direct reference to literal node
+          sourceNodeId = ret.returnValueId ?? null;
+          break;
 
-        if (importType === 'namespace') {
-          // import * as foo - связываем со всем модулем
-          await graph.addEdge({
-            type: 'IMPORTS_FROM',
-            src: importId,
-            dst: targetModule.id
-          });
-          edgesCreated++;
-        } else if (importType === 'default') {
-          // Находим EXPORT default в целевом модуле
-          const targetExports: { id: string }[] = [];
-          for await (const node of graph.queryNodes({ type: 'EXPORT' })) {
-            const exportNode = node as { id: string; file?: string; exportType?: string };
-            if (exportNode.file === targetPath && exportNode.exportType === 'default') {
-              targetExports.push(exportNode);
+        case 'VARIABLE': {
+          // Find variable declaration by name in same file
+          const varName = ret.returnValueName;
+          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;
+        }
 
-          if (targetExports.length > 0) {
-            await graph.addEdge({
-              type: 'IMPORTS_FROM',
-              src: importId,
-              dst: targetExports[0].id
-            });
-            edgesCreated++;
+        case 'CALL_SITE': {
+          // Find call site by coordinates
+          const { returnValueLine, returnValueColumn, returnValueCallName } = ret;
+          if (returnValueLine && returnValueColumn) {
+            const callSite = callSites.find(cs =>
+              cs.line === returnValueLine &&
+              cs.column === returnValueColumn &&
+              (returnValueCallName ? cs.name === returnValueCallName : true)
+            );
+            if (callSite) {
+              sourceNodeId = callSite.id;
+            }
           }
-        } else {
-          // Named import - находим соответствующий named export
-          const targetExports: { id: string }[] = [];
-          for await (const node of graph.queryNodes({ type: 'EXPORT' })) {
-            const exportNode = node as { id: string; file?: string; exportType?: string; name?: string };
-            if (exportNode.file === targetPath && exportNode.exportType === 'named' && exportNode.name === spec.imported) {
-              targetExports.push(exportNode);
+          break;
+        }
+
+        case 'METHOD_CALL': {
+          // Find method call by coordinates and method name
+          const { returnValueLine, returnValueColumn, returnValueCallName } = ret;
+          if (returnValueLine && returnValueColumn) {
+            const methodCall = methodCalls.find(mc =>
+              mc.line === returnValueLine &&
+              mc.column === returnValueColumn &&
+              mc.file === file &&
+              (returnValueCallName ? mc.method === returnValueCallName : true)
+            );
+            if (methodCall) {
+              sourceNodeId = methodCall.id;
             }
           }
+          break;
+        }
 
-          if (targetExports.length > 0) {
-            await graph.addEdge({
-              type: 'IMPORTS_FROM',
-              src: importId,
-              dst: targetExports[0].id
-            });
-            edgesCreated++;
+        case 'EXPRESSION': {
+          // REG-276: Create EXPRESSION node and DERIVES_FROM edges for return expressions
+          const {
+            expressionType,
+            returnValueId,
+            returnValueLine,
+            returnValueColumn,
+            operator,
+            object,
+            property,
+            computed,
+            objectSourceName,
+            leftSourceName,
+            rightSourceName,
+            consequentSourceName,
+            alternateSourceName,
+            expressionSourceNames,
+            unaryArgSourceName
+          } = ret;
+
+          // Skip if no expression ID was generated
+          if (!returnValueId) {
+            break;
+          }
+
+          // Create EXPRESSION node using NodeFactory
+          const expressionNode = NodeFactory.createExpressionFromMetadata(
+            expressionType || 'Unknown',
+            file,
+            returnValueLine || ret.line,
+            returnValueColumn || ret.column,
+            {
+              id: returnValueId,
+              object,
+              property,
+              computed,
+              operator
+            }
+          );
+
+          this._bufferNode(expressionNode);
+          sourceNodeId = returnValueId;
+
+          // 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 sourceId = findSource(objectSourceName);
+            if (sourceId) {
+              this._bufferEdge({
+                type: 'DERIVES_FROM',
+                src: returnValueId,
+                dst: sourceId
+              });
+            }
+          }
+
+          // BinaryExpression / LogicalExpression: derives from left and right operands
+          if (expressionType === 'BinaryExpression' || expressionType === 'LogicalExpression') {
+            if (leftSourceName) {
+              const sourceId = findSource(leftSourceName);
+              if (sourceId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: returnValueId,
+                  dst: sourceId
+                });
+              }
+            }
+            if (rightSourceName) {
+              const sourceId = findSource(rightSourceName);
+              if (sourceId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: returnValueId,
+                  dst: sourceId
+                });
+              }
+            }
+          }
+
+          // ConditionalExpression: derives from consequent and alternate
+          if (expressionType === 'ConditionalExpression') {
+            if (consequentSourceName) {
+              const sourceId = findSource(consequentSourceName);
+              if (sourceId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: returnValueId,
+                  dst: sourceId
+                });
+              }
+            }
+            if (alternateSourceName) {
+              const sourceId = findSource(alternateSourceName);
+              if (sourceId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: returnValueId,
+                  dst: sourceId
+                });
+              }
+            }
+          }
+
+          // UnaryExpression: derives from the argument
+          if (expressionType === 'UnaryExpression' && unaryArgSourceName) {
+            const sourceId = findSource(unaryArgSourceName);
+            if (sourceId) {
+              this._bufferEdge({
+                type: 'DERIVES_FROM',
+                src: returnValueId,
+                dst: sourceId
+              });
+            }
+          }
+
+          // TemplateLiteral: derives from all embedded expressions
+          if (expressionType === 'TemplateLiteral' && expressionSourceNames && expressionSourceNames.length > 0) {
+            for (const sourceName of expressionSourceNames) {
+              const sourceId = findSource(sourceName);
+              if (sourceId) {
+                this._bufferEdge({
+                  type: 'DERIVES_FROM',
+                  src: returnValueId,
+                  dst: sourceId
+                });
+              }
+            }
+          }
+
+          break;
+        }
+      }
+
+      // Create RETURNS edge if we found a source node
+      if (sourceNodeId && parentFunctionId) {
+        this._bufferEdge({
+          type: 'RETURNS',
+          src: sourceNodeId,
+          dst: parentFunctionId
+        });
+      }
+    }
+  }
+
+  /**
+   * Buffer UPDATE_EXPRESSION nodes and edges for increment/decrement operations.
+   *
+   * Handles two target types:
+   * - IDENTIFIER: Simple variable (i++, --count)
+   * - MEMBER_EXPRESSION: Object property (obj.prop++, arr[i]++, this.count++)
+   *
+   * Creates:
+   * - UPDATE_EXPRESSION node with operator and target metadata
+   * - MODIFIES edge: UPDATE_EXPRESSION -> target (VARIABLE, PARAMETER, or CLASS)
+   * - READS_FROM self-loop: target -> target (reads current value before update)
+   * - CONTAINS edge: SCOPE -> UPDATE_EXPRESSION
+   *
+   * REG-288: Initial implementation for IDENTIFIER targets
+   * REG-312: Extended for MEMBER_EXPRESSION targets
+   */
+  private bufferUpdateExpressionEdges(
+    updateExpressions: UpdateExpressionInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[],
+    classDeclarations: ClassDeclarationInfo[]
+  ): void {
+    // Build lookup caches: O(n) instead of O(n*m)
+    const varLookup = new Map<string, VariableDeclarationInfo>();
+    for (const v of variableDeclarations) {
+      varLookup.set(`${v.file}:${v.name}`, v);
+    }
+
+    const paramLookup = new Map<string, ParameterInfo>();
+    for (const p of parameters) {
+      paramLookup.set(`${p.file}:${p.name}`, p);
+    }
+
+    for (const update of updateExpressions) {
+      if (update.targetType === 'IDENTIFIER') {
+        // REG-288: Simple identifier (i++, --count)
+        this.bufferIdentifierUpdate(update, varLookup, paramLookup);
+      } else if (update.targetType === 'MEMBER_EXPRESSION') {
+        // REG-312: Member expression (obj.prop++, arr[i]++)
+        this.bufferMemberExpressionUpdate(update, varLookup, paramLookup, classDeclarations);
+      }
+    }
+  }
+
+  /**
+   * Buffer UPDATE_EXPRESSION node and edges for simple identifier updates (i++, --count)
+   * REG-288: Original implementation extracted for clarity
+   */
+  private bufferIdentifierUpdate(
+    update: UpdateExpressionInfo,
+    varLookup: Map<string, VariableDeclarationInfo>,
+    paramLookup: Map<string, ParameterInfo>
+  ): void {
+    const {
+      variableName,
+      operator,
+      prefix,
+      file,
+      line,
+      column,
+      parentScopeId
+    } = update;
+
+    if (!variableName) return;
+
+    // Find target variable node
+    const targetVar = varLookup.get(`${file}:${variableName}`);
+    const targetParam = !targetVar ? paramLookup.get(`${file}:${variableName}`) : null;
+    const targetNodeId = targetVar?.id ?? targetParam?.id;
+
+    if (!targetNodeId) {
+      // Variable not found - could be module-level or external reference
+      return;
+    }
+
+    // Create UPDATE_EXPRESSION node
+    const updateId = `${file}:UPDATE_EXPRESSION:${operator}:${line}:${column}`;
+
+    this._bufferNode({
+      type: 'UPDATE_EXPRESSION',
+      id: updateId,
+      name: `${prefix ? operator : ''}${variableName}${prefix ? '' : operator}`,
+      targetType: 'IDENTIFIER',
+      operator,
+      prefix,
+      variableName,
+      file,
+      line,
+      column
+    } as GraphNode);
+
+    // Create READS_FROM self-loop
+    this._bufferEdge({
+      type: 'READS_FROM',
+      src: targetNodeId,
+      dst: targetNodeId
+    });
+
+    // Create MODIFIES edge
+    this._bufferEdge({
+      type: 'MODIFIES',
+      src: updateId,
+      dst: targetNodeId
+    });
+
+    // Create CONTAINS edge
+    if (parentScopeId) {
+      this._bufferEdge({
+        type: 'CONTAINS',
+        src: parentScopeId,
+        dst: updateId
+      });
+    }
+  }
+
+  /**
+   * Buffer UPDATE_EXPRESSION node and edges for member expression updates (obj.prop++, arr[i]++)
+   * REG-312: New implementation for member expression targets
+   *
+   * Creates:
+   * - UPDATE_EXPRESSION node with member expression metadata
+   * - MODIFIES edge: UPDATE_EXPRESSION -> VARIABLE(object) or CLASS (for this.prop++)
+   * - READS_FROM self-loop: VARIABLE(object) -> VARIABLE(object)
+   * - CONTAINS edge: SCOPE -> UPDATE_EXPRESSION
+   */
+  private bufferMemberExpressionUpdate(
+    update: UpdateExpressionInfo,
+    varLookup: Map<string, VariableDeclarationInfo>,
+    paramLookup: Map<string, ParameterInfo>,
+    classDeclarations: ClassDeclarationInfo[]
+  ): void {
+    const {
+      objectName,
+      propertyName,
+      mutationType,
+      computedPropertyVar,
+      enclosingClassName,
+      operator,
+      prefix,
+      file,
+      line,
+      column,
+      parentScopeId
+    } = update;
+
+    if (!objectName || !propertyName) return;
+
+    // Find target object node
+    let objectNodeId: string | null = null;
+
+    if (objectName !== 'this') {
+      // Regular object: obj.prop++, arr[i]++
+      const targetVar = varLookup.get(`${file}:${objectName}`);
+      const targetParam = !targetVar ? paramLookup.get(`${file}:${objectName}`) : null;
+      objectNodeId = targetVar?.id ?? targetParam?.id ?? null;
+    } else {
+      // this.prop++ - follow REG-152 pattern from bufferObjectMutationEdges
+      if (!enclosingClassName) return;
+
+      const fileBasename = basename(file);
+      const classDecl = classDeclarations.find(c =>
+        c.name === enclosingClassName && c.file === fileBasename
+      );
+      objectNodeId = classDecl?.id ?? null;
+    }
+
+    if (!objectNodeId) {
+      // Object not found - external reference or scope issue
+      return;
+    }
+
+    // Create UPDATE_EXPRESSION node
+    const updateId = `${file}:UPDATE_EXPRESSION:${operator}:${line}:${column}`;
+
+    // Display name: "obj.prop++" or "this.count++" or "arr[i]++"
+    const displayName = (() => {
+      const opStr = prefix ? operator : '';
+      const postOpStr = prefix ? '' : operator;
+
+      if (objectName === 'this') {
+        return `${opStr}this.${propertyName}${postOpStr}`;
+      }
+      if (mutationType === 'computed') {
+        const computedPart = computedPropertyVar || '?';
+        return `${opStr}${objectName}[${computedPart}]${postOpStr}`;
+      }
+      return `${opStr}${objectName}.${propertyName}${postOpStr}`;
+    })();
+
+    this._bufferNode({
+      type: 'UPDATE_EXPRESSION',
+      id: updateId,
+      name: displayName,
+      targetType: 'MEMBER_EXPRESSION',
+      operator,
+      prefix,
+      objectName,
+      propertyName,
+      mutationType,
+      computedPropertyVar,
+      enclosingClassName,
+      file,
+      line,
+      column
+    } as GraphNode);
+
+    // Create READS_FROM self-loop (object reads from itself)
+    this._bufferEdge({
+      type: 'READS_FROM',
+      src: objectNodeId,
+      dst: objectNodeId
+    });
+
+    // Create MODIFIES edge (UPDATE_EXPRESSION modifies object)
+    this._bufferEdge({
+      type: 'MODIFIES',
+      src: updateId,
+      dst: objectNodeId
+    });
+
+    // Create CONTAINS edge
+    if (parentScopeId) {
+      this._bufferEdge({
+        type: 'CONTAINS',
+        src: parentScopeId,
+        dst: updateId
+      });
+    }
+  }
+
+  /**
+   * Buffer RESOLVES_TO edges for Promise resolution data flow (REG-334).
+   *
+   * Links resolve/reject CALL nodes to their parent Promise CONSTRUCTOR_CALL.
+   * This enables traceValues to follow Promise data flow:
+   *
+   * Example:
+   * ```
+   * const result = new Promise((resolve) => {
+   *   resolve(42);  // CALL[resolve] --RESOLVES_TO--> CONSTRUCTOR_CALL[Promise]
+   * });
+   * ```
+   *
+   * The edge direction (CALL -> CONSTRUCTOR_CALL) matches data flow semantics:
+   * data flows FROM resolve(value) TO the Promise result.
+   */
+  private bufferPromiseResolutionEdges(promiseResolutions: PromiseResolutionInfo[]): void {
+    for (const resolution of promiseResolutions) {
+      this._bufferEdge({
+        type: 'RESOLVES_TO',
+        src: resolution.callId,
+        dst: resolution.constructorCallId,
+        metadata: {
+          isReject: resolution.isReject
+        }
+      });
+    }
+  }
+
+  /**
+   * Buffer OBJECT_LITERAL nodes to the graph.
+   * These are object literals passed as function arguments or nested in other literals.
+   */
+  private bufferObjectLiteralNodes(objectLiterals: ObjectLiteralInfo[]): void {
+    for (const obj of objectLiterals) {
+      this._bufferNode({
+        id: obj.id,
+        type: obj.type,
+        name: '<object>',
+        file: obj.file,
+        line: obj.line,
+        column: obj.column,
+        parentCallId: obj.parentCallId,
+        argIndex: obj.argIndex
+      } as GraphNode);
+    }
+  }
+
+  /**
+   * Buffer ARRAY_LITERAL nodes to the graph.
+   * These are array literals passed as function arguments or nested in other literals.
+   */
+  private bufferArrayLiteralNodes(arrayLiterals: ArrayLiteralInfo[]): void {
+    for (const arr of arrayLiterals) {
+      this._bufferNode({
+        id: arr.id,
+        type: arr.type,
+        name: '<array>',
+        file: arr.file,
+        line: arr.line,
+        column: arr.column,
+        parentCallId: arr.parentCallId,
+        argIndex: arr.argIndex
+      } as GraphNode);
+    }
+  }
+
+  /**
+   * Buffer HAS_PROPERTY edges connecting OBJECT_LITERAL nodes to their property values.
+   * Creates edges from object literal to its property value nodes (LITERAL, nested OBJECT_LITERAL, ARRAY_LITERAL, etc.)
+   *
+   * REG-329: Adds scope-aware variable resolution for VARIABLE property values.
+   * Uses the same resolveVariableInScope infrastructure as mutation handlers.
+   */
+  private bufferObjectPropertyEdges(
+    objectProperties: ObjectPropertyInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[]
+  ): void {
+    for (const prop of objectProperties) {
+      // REG-329: Handle VARIABLE value types with scope resolution
+      if (prop.valueType === 'VARIABLE' && prop.valueName) {
+        const scopePath = prop.valueScopePath ?? [];
+        const file = prop.file;
+
+        // Resolve variable using scope chain
+        const resolvedVar = this.resolveVariableInScope(
+          prop.valueName, scopePath, file, variableDeclarations
+        );
+        const resolvedParam = !resolvedVar
+          ? this.resolveParameterInScope(prop.valueName, scopePath, file, parameters)
+          : null;
+
+        const resolvedNodeId = resolvedVar?.id ?? resolvedParam?.semanticId ?? resolvedParam?.id;
+
+        if (resolvedNodeId) {
+          this._bufferEdge({
+            type: 'HAS_PROPERTY',
+            src: prop.objectId,
+            dst: resolvedNodeId,
+            propertyName: prop.propertyName
+          });
+        }
+        continue;
+      }
+
+      // Existing logic for non-VARIABLE types
+      if (prop.valueNodeId) {
+        this._bufferEdge({
+          type: 'HAS_PROPERTY',
+          src: prop.objectId,
+          dst: prop.valueNodeId,
+          propertyName: prop.propertyName
+        });
+      }
+    }
+  }
+
+  /**
+   * Handle CLASS ASSIGNED_FROM edges asynchronously (needs graph queries)
+   */
+  private async createClassAssignmentEdges(variableAssignments: VariableAssignmentInfo[], graph: GraphBackend): Promise<number> {
+    let edgesCreated = 0;
+
+    for (const assignment of variableAssignments) {
+      const { variableId, sourceType, className } = assignment;
+
+      if (sourceType === 'CLASS' && className) {
+        const parts = variableId.split('#');
+        const file = parts.length >= 3 ? parts[2] : null;
+
+        let classNode: { id: string; name: string; file?: string } | null = null;
+        for await (const node of graph.queryNodes({ type: 'CLASS' })) {
+          if (node.name === className && (!file || node.file === file)) {
+            classNode = node as { id: string; name: string; file?: string };
+            break;
           }
         }
+
+        if (classNode) {
+          await graph.addEdge({
+            type: 'ASSIGNED_FROM',
+            src: variableId,
+            dst: classNode.id
+          });
+          edgesCreated++;
+        }
       }
     }