@grafema/core 0.1.1-alpha → 0.2.0-beta

package/dist/plugins/analysis/ast/GraphBuilder.js

@@ -9,6 +9,7 @@ import { EnumNode } from '../../../core/nodes/EnumNode.js';
 import { DecoratorNode } from '../../../core/nodes/DecoratorNode.js';
 import { NetworkRequestNode } from '../../../core/nodes/NetworkRequestNode.js';
 import { NodeFactory } from '../../../core/NodeFactory.js';
+import { computeSemanticId, parseSemanticId } from '../../../core/SemanticId.js';
 export class GraphBuilder {
     // Track singleton nodes to avoid duplicates (net:stdio, net:request, etc.)
     _createdSingletons = new Set();
@@ -57,15 +58,29 @@ export class GraphBuilder {
      * Создаёт ноды и рёбра в графе (BATCHED VERSION)
      */
     async build(module, graph, projectPath, data) {
-        const { functions, parameters = [], scopes, variableDeclarations, callSites, methodCalls = [], eventListeners = [], classInstantiations = [], classDeclarations = [], methodCallbacks = [], callArguments = [], imports = [], exports = [], httpRequests = [], literals = [], variableAssignments = [], 
+        const { 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 = [], imports = [], exports = [], httpRequests = [], literals = [], variableAssignments = [], 
         // TypeScript-specific collections
         interfaces = [], typeAliases = [], enums = [], 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 = [], arrayLiterals = [] } = data;
+        objectLiterals = [], objectProperties = [], arrayLiterals = [] } = data;
         // Reset buffers for this build
         this._nodeBuffer = [];
         this._edgeBuffer = [];
@@ -79,10 +94,40 @@ export class GraphBuilder {
             const { parentFunctionId, parentScopeId, capturesFrom, modifies, ...scopeData } = scope;
             this._bufferNode(scopeData);
         }
-        // 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);
+        }
+        // 2.6. Buffer CASE nodes
+        for (const caseInfo of cases) {
+            const { parentBranchId, ...caseData } = caseInfo;
+            this._bufferNode(caseData);
+        }
+        // 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);
+        }
+        // 2.8. Buffer TRY_BLOCK nodes (Phase 4)
+        for (const tryBlock of tryBlocks) {
+            this._bufferNode(tryBlock);
+        }
+        // 2.9. Buffer CATCH_BLOCK nodes (Phase 4)
+        for (const catchBlock of catchBlocks) {
+            const { parentTryBlockId, ...catchData } = catchBlock;
+            this._bufferNode(catchData);
+        }
+        // 2.10. Buffer FINALLY_BLOCK nodes (Phase 4)
+        for (const finallyBlock of finallyBlocks) {
+            const { parentTryBlockId, ...finallyData } = finallyBlock;
+            this._bufferNode(finallyData);
+        }
+        // 3. Buffer variables (keep parentScopeId on node for queries)
         for (const varDecl of variableDeclarations) {
-            const { parentScopeId, ...varData } = varDecl;
-            this._bufferNode(varData);
+            this._bufferNode(varDecl);
         }
         // 3.5. Buffer PARAMETER nodes and HAS_PARAMETER edges
         for (const param of parameters) {
@@ -98,21 +143,49 @@ 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);
         }
+        // 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
+            });
+        }
         // 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);
         // 11. Buffer CLASS nodes for class declarations and CONTAINS edges
@@ -131,6 +204,13 @@ export class GraphBuilder {
         this.bufferHttpRequests(httpRequests, functions);
         // 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);
         // 20. Buffer PASSES_ARGUMENT edges (CALL -> argument)
@@ -150,10 +230,14 @@ export class GraphBuilder {
         // 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 OBJECT_LITERAL nodes
-        this.bufferObjectLiteralNodes(objectLiterals);
-        // 29. Buffer ARRAY_LITERAL nodes
-        this.bufferArrayLiteralNodes(arrayLiterals);
+        // 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);
@@ -225,6 +309,371 @@ 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)
+     */
+    bufferLoopEdges(loops, scopes, variableDeclarations, parameters) {
+        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.
+     */
+    bufferLoopConditionEdges(loops, callSites) {
+        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).
+     */
+    bufferLoopConditionExpressions(loops) {
+        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.
+     */
+    bufferBranchEdges(branches, callSites, scopes) {
+        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)
+     */
+    bufferCaseEdges(cases) {
+        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
+     */
+    bufferTryCatchFinallyEdges(tryBlocks, catchBlocks, finallyBlocks) {
+        // 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.
+     */
+    bufferDiscriminantExpressions(branches, callSites) {
+        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
+                    });
+                }
+            }
+        }
+    }
     bufferVariableEdges(variableDeclarations) {
         for (const varDecl of variableDeclarations) {
             const { parentScopeId, ...varData } = varDecl;
@@ -256,17 +705,44 @@ export class GraphBuilder {
             }
         }
     }
-    bufferMethodCalls(methodCalls) {
+    bufferMethodCalls(methodCalls, variableDeclarations, parameters) {
         for (const methodCall of methodCalls) {
-            const { parentScopeId, ...methodData } = methodCall;
-            // Buffer METHOD_CALL node
-            this._bufferNode(methodData);
+            // Keep parentScopeId on node for queries
+            this._bufferNode(methodCall);
             // SCOPE -> CONTAINS -> METHOD_CALL
             this._bufferEdge({
                 type: 'CONTAINS',
-                src: parentScopeId,
-                dst: methodData.id
+                src: methodCall.parentScopeId,
+                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
+                        });
+                    }
+                }
+            }
         }
     }
     bufferStdioNodes(methodCalls) {
@@ -311,10 +787,11 @@ export class GraphBuilder {
             }
             // If superClass, buffer DERIVES_FROM edge with computed ID
             if (superClass) {
-                // Compute superclass ID using same format as ClassNode (line 0 = unknown location)
-                // Assume superclass is in same file (most common case)
+                // 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 superClassId = `${file}:CLASS:${superClass}:0`;
+                const globalContext = { file, scopePath: [] };
+                const superClassId = computeSemanticId('CLASS', superClass, globalContext);
                 this._bufferEdge({
                     type: 'DERIVES_FROM',
                     src: id,
@@ -325,9 +802,11 @@ export class GraphBuilder {
     }
     bufferClassNodes(module, classInstantiations, classDeclarations) {
         // 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();
         for (const decl of classDeclarations) {
-            if (decl.file === module.file) {
+            if (decl.file === moduleBasename) {
                 declarationMap.set(decl.name, decl.id);
             }
         }
@@ -335,10 +814,11 @@ export class GraphBuilder {
             const { variableId, className, line } = instantiation;
             let classId = declarationMap.get(className);
             if (!classId) {
-                // External class - compute ID using ClassNode format (line 0 = unknown location)
-                // Assume class is in same file (most common case)
+                // 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
-                classId = `${module.file}:CLASS:${className}:0`;
+                const globalContext = { file: moduleBasename, scopePath: [] };
+                classId = computeSemanticId('CLASS', className, globalContext);
                 // NO node creation - node will exist when class file analyzed
             }
             // Buffer INSTANCE_OF edge
@@ -364,18 +844,19 @@ export class GraphBuilder {
     }
     bufferImportNodes(module, imports) {
         for (const imp of imports) {
-            const { source, specifiers, line, column } = imp;
-            for (const spec of specifiers) {
-                // Use ImportNode factory for proper semantic IDs and field population
-                const importNode = ImportNode.create(spec.local, // name = local binding
+            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: spec.imported,
-                    local: spec.local
-                    // importType is auto-detected from imported field
+                    imported: '*', // no specific export
+                    local: source, // source becomes local
+                    sideEffect: true // mark as side-effect import
                 });
                 this._bufferNode(importNode);
                 // MODULE -> CONTAINS -> IMPORT
@@ -400,6 +881,49 @@ export class GraphBuilder {
                     });
                 }
             }
+            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);
+                    // 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);
+                            this._createdSingletons.add(externalModule.id);
+                        }
+                        this._bufferEdge({
+                            type: 'IMPORTS',
+                            src: module.id,
+                            dst: externalModule.id
+                        });
+                    }
+                }
+            }
         }
     }
     bufferExportNodes(module, exports) {
@@ -518,11 +1042,26 @@ export class GraphBuilder {
     }
     bufferAssignmentEdges(variableAssignments, variableDeclarations, callSites, methodCalls, functions, classInstantiations, parameters) {
         for (const assignment of variableAssignments) {
-            const { variableId, sourceId, sourceType, sourceName, sourceLine, sourceColumn, sourceFile, functionName, line, className } = assignment;
+            const { variableId, sourceId, sourceType, sourceName, sourceLine, sourceColumn, sourceFile, functionName, line, column, className } = assignment;
             // Skip CLASS sourceType - handled async in createClassAssignmentEdges
             if (sourceType === 'CLASS') {
                 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({
@@ -600,7 +1139,9 @@ export class GraphBuilder {
             }
             // EXPRESSION node creation using NodeFactory
             else if (sourceType === 'EXPRESSION' && sourceId) {
-                const { expressionType, object, property, computed, computedPropertyVar, operator, objectSourceName, leftSourceName, rightSourceName, consequentSourceName, alternateSourceName, file: exprFile, line: exprLine, column: exprColumn } = assignment;
+                const { expressionType, object, property, computed, computedPropertyVar, operator, objectSourceName, leftSourceName, rightSourceName, consequentSourceName, alternateSourceName, file: exprFile, line: exprLine, column: exprColumn, 
+                // Destructuring support (REG-201)
+                path, baseName, propertyPath, arrayIndex } = assignment;
                 // Create node from upstream metadata using factory
                 const expressionNode = NodeFactory.createExpressionFromMetadata(expressionType || 'Unknown', exprFile || '', exprLine || 0, exprColumn || 0, {
                     id: sourceId, // ID from JSASTAnalyzer
@@ -608,7 +1149,12 @@ export class GraphBuilder {
                     property,
                     computed,
                     computedPropertyVar: computedPropertyVar ?? undefined,
-                    operator
+                    operator,
+                    // Destructuring support (REG-201)
+                    path,
+                    baseName,
+                    propertyPath,
+                    arrayIndex
                 });
                 this._bufferNode(expressionNode);
                 this._bufferEdge({
@@ -629,6 +1175,41 @@ 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) {
                         const leftVar = variableDeclarations.find(v => v.name === leftSourceName && (!varFile || v.file === varFile));
@@ -737,6 +1318,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 = {
                     type: 'PASSES_ARGUMENT',
@@ -902,36 +1489,27 @@ export class GraphBuilder {
      * OPTIMIZED: Uses Map-based lookup cache for O(1) variable lookups instead of O(n) find()
      */
     bufferArrayMutationEdges(arrayMutations, variableDeclarations, parameters) {
-        // Build lookup cache once: O(n) instead of O(n*m) with find() per mutation
-        const varLookup = new Map();
-        for (const v of variableDeclarations) {
-            varLookup.set(`${v.file}:${v.name}`, v);
-        }
-        // Build parameter lookup cache for function-level mutations
-        const paramLookup = new Map();
-        for (const p of parameters) {
-            paramLookup.set(`${p.file}:${p.name}`, p);
-        }
+        // Note: No longer using Map-based cache - scope-aware lookup requires scope chain walk
         for (const mutation of arrayMutations) {
-            const { arrayName, mutationMethod, insertedValues, file, isNested, baseObjectName, propertyName } = mutation;
+            const { arrayName, mutationScopePath, mutationMethod, insertedValues, file, isNested, baseObjectName, propertyName } = mutation;
+            const scopePath = mutationScopePath ?? [];
             // REG-117: For nested mutations (obj.arr.push), resolve target node
-            // First try direct lookup, then fallback to base object
             let targetNodeId = null;
             let nestedProperty;
             if (isNested && baseObjectName) {
                 // Skip 'this.items.push' - 'this' is not a variable node
                 if (baseObjectName === 'this')
                     continue;
-                // Nested mutation: try base object lookup
-                const baseVar = varLookup.get(`${file}:${baseObjectName}`);
-                const baseParam = !baseVar ? paramLookup.get(`${file}:${baseObjectName}`) : null;
+                // 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()
-                const arrayVar = varLookup.get(`${file}:${arrayName}`);
-                const arrayParam = !arrayVar ? paramLookup.get(`${file}:${arrayName}`) : null;
+                // 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)
@@ -939,9 +1517,9 @@ export class GraphBuilder {
             // Create FLOWS_INTO edges for each inserted value
             for (const arg of insertedValues) {
                 if (arg.valueType === 'VARIABLE' && arg.valueName) {
-                    // O(1) lookup instead of O(n) find
-                    const sourceVar = varLookup.get(`${file}:${arg.valueName}`);
-                    const sourceParam = !sourceVar ? paramLookup.get(`${file}:${arg.valueName}`) : null;
+                    // 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 = {
@@ -975,15 +1553,17 @@ export class GraphBuilder {
      */
     bufferObjectMutationEdges(objectMutations, variableDeclarations, parameters, functions, classDeclarations) {
         for (const mutation of objectMutations) {
-            const { objectName, propertyName, mutationType, computedPropertyVar, value, file, enclosingClassName } = mutation;
+            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 = null;
             let effectiveMutationType = mutationType;
             if (objectName !== 'this') {
-                // Regular object - find variable or parameter
-                const objectVar = variableDeclarations.find(v => v.name === objectName && v.file === file);
-                const objectParam = !objectVar ? parameters.find(p => p.name === objectName && p.file === file) : null;
-                objectNodeId = objectVar?.id ?? objectParam?.id ?? null;
+                // 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;
             }
@@ -1003,9 +1583,9 @@ export class GraphBuilder {
             }
             // Create FLOWS_INTO edge for VARIABLE value type
             if (value.valueType === 'VARIABLE' && value.valueName) {
-                // Find the source: can be variable, parameter, or function (arrow functions assigned to const)
-                const sourceVar = variableDeclarations.find(v => v.name === value.valueName && v.file === file);
-                const sourceParam = !sourceVar ? parameters.find(p => p.name === value.valueName && p.file === file) : null;
+                // 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) {
@@ -1029,6 +1609,577 @@ export class GraphBuilder {
             // For literals, object literals, etc. - we just track variable -> object flows for now
         }
     }
+    /**
+     * 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
+     */
+    resolveVariableInScope(name, scopePath, file, variables) {
+        // 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;
+    }
+    /**
+     * 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
+     */
+    resolveParameterInScope(name, scopePath, file, parameters) {
+        // 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;
+    }
+    /**
+     * Check if two scope paths match (REG-309).
+     * Handles: ['foo', 'if#0'] vs ['foo', 'if#0']
+     */
+    scopePathsMatch(a, b) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((item, idx) => item === b[idx]);
+    }
+    /**
+     * 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).
+     */
+    bufferVariableReassignmentEdges(variableReassignments, variableDeclarations, callSites, methodCalls, parameters) {
+        // 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;
+            }
+            // Resolve source node based on value type
+            let sourceNodeId = 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
+                });
+                this._bufferNode(expressionNode);
+                sourceNodeId = valueId;
+            }
+            // 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)
+                    });
+                }
+                // 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
+     */
+    bufferReturnEdges(returnStatements, callSites, methodCalls, variableDeclarations, parameters) {
+        for (const ret of returnStatements) {
+            const { parentFunctionId, returnValueType, file } = ret;
+            // Skip if no value returned (bare return;)
+            if (returnValueType === 'NONE') {
+                continue;
+            }
+            let sourceNodeId = null;
+            switch (returnValueType) {
+                case 'LITERAL':
+                    // Direct reference to literal node
+                    sourceNodeId = ret.returnValueId ?? null;
+                    break;
+                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;
+                }
+                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;
+                        }
+                    }
+                    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;
+                }
+                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) => {
+                        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
+     */
+    bufferUpdateExpressionEdges(updateExpressions, variableDeclarations, parameters, classDeclarations) {
+        // Build lookup caches: O(n) instead of O(n*m)
+        const varLookup = new Map();
+        for (const v of variableDeclarations) {
+            varLookup.set(`${v.file}:${v.name}`, v);
+        }
+        const paramLookup = new Map();
+        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
+     */
+    bufferIdentifierUpdate(update, varLookup, paramLookup) {
+        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
+        });
+        // 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
+     */
+    bufferMemberExpressionUpdate(update, varLookup, paramLookup, classDeclarations) {
+        const { objectName, propertyName, mutationType, computedPropertyVar, enclosingClassName, operator, prefix, file, line, column, parentScopeId } = update;
+        if (!objectName || !propertyName)
+            return;
+        // Find target object node
+        let objectNodeId = 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
+        });
+        // 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.
+     */
+    bufferPromiseResolutionEdges(promiseResolutions) {
+        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.
@@ -1065,6 +2216,46 @@ export class GraphBuilder {
             });
         }
     }
+    /**
+     * 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.
+     */
+    bufferObjectPropertyEdges(objectProperties, variableDeclarations, parameters) {
+        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)
      */