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

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

@@ -2,7 +2,14 @@
  * GraphBuilder - создание узлов и рёбер графа из собранных AST данных
  * OPTIMIZED: Uses batched writes to reduce FFI overhead
  */
-import { dirname, resolve } from 'path';
+import { basename } from 'path';
+import { ImportNode } from '../../../core/nodes/ImportNode.js';
+import { InterfaceNode } from '../../../core/nodes/InterfaceNode.js';
+import { EnumNode } from '../../../core/nodes/EnumNode.js';
+import { DecoratorNode } from '../../../core/nodes/DecoratorNode.js';
+import { NetworkRequestNode } from '../../../core/nodes/NetworkRequestNode.js';
+import { NodeFactory } from '../../../core/NodeFactory.js';
+import { computeSemanticId, parseSemanticId } from '../../../core/SemanticId.js';
 export class GraphBuilder {
     // Track singleton nodes to avoid duplicates (net:stdio, net:request, etc.)
     _createdSingletons = new Set();
@@ -51,9 +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 = [] } = data;
+        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 = [], objectProperties = [], arrayLiterals = [] } = data;
         // Reset buffers for this build
         this._nodeBuffer = [];
         this._edgeBuffer = [];
@@ -67,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) {
@@ -86,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
@@ -119,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)
@@ -133,14 +225,25 @@ export class GraphBuilder {
         this.bufferDecoratorNodes(decorators);
         // 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) =============
     bufferFunctionEdges(module, functions) {
@@ -206,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;
@@ -237,39 +705,61 @@ 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) {
         const consoleIOMethods = methodCalls.filter(mc => (mc.object === 'console' && (mc.method === 'log' || mc.method === 'error')));
         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);
+                this._createdSingletons.add(stdioNode.id);
             }
             // Buffer WRITES_TO edges for console.log/error
             for (const methodCall of consoleIOMethods) {
                 this._bufferEdge({
                     type: 'WRITES_TO',
                     src: methodCall.id,
-                    dst: stdioId
+                    dst: stdioNode.id
                 });
             }
         }
@@ -295,9 +785,13 @@ export class GraphBuilder {
                     dst: methodId
                 });
             }
-            // 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: [] };
+                const superClassId = computeSemanticId('CLASS', superClass, globalContext);
                 this._bufferEdge({
                     type: 'DERIVES_FROM',
                     src: id,
@@ -308,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);
             }
         }
@@ -318,16 +814,12 @@ export class GraphBuilder {
             const { variableId, className, line } = instantiation;
             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: [] };
+                classId = computeSemanticId('CLASS', className, globalContext);
+                // NO node creation - node will exist when class file analyzed
             }
             // Buffer INSTANCE_OF edge
             this._bufferEdge({
@@ -352,119 +844,136 @@ export class GraphBuilder {
     }
     bufferImportNodes(module, imports) {
         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}`;
-                this._bufferNode({
-                    id: importId,
-                    type: 'IMPORT',
-                    source: source,
-                    importType: importType,
-                    imported: spec.imported,
-                    local: spec.local,
-                    file: module.file,
-                    line: 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(importNode);
                 // 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}`;
-                    this._bufferNode({
-                        id: externalModuleId,
-                        type: 'EXTERNAL_MODULE',
-                        name: source,
-                        file: module.file,
-                        line: line
-                    });
+                    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: 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);
+                    // 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) {
         for (const exp of exports) {
             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);
                 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}`;
-                        this._bufferNode({
-                            id: exportId,
-                            type: 'EXPORT',
-                            exportType: 'named',
-                            name: spec.exported,
+                        const exportNode = NodeFactory.createExport(spec.exported, module.file, line, 0, {
                             local: spec.local,
-                            file: module.file,
-                            line: line,
-                            source: source
+                            source: source,
+                            exportType: 'named'
                         });
+                        this._bufferNode(exportNode);
                         this._bufferEdge({
                             type: 'CONTAINS',
                             src: module.id,
-                            dst: exportId
+                            dst: exportNode.id
                         });
                     }
                 }
                 else if (name) {
-                    const exportId = `${module.file}:EXPORT:${name}:${line}`;
-                    this._bufferNode({
-                        id: exportId,
-                        type: 'EXPORT',
-                        exportType: 'named',
-                        name: name,
-                        file: module.file,
-                        line: line
-                    });
+                    const exportNode = NodeFactory.createExport(name, module.file, line, 0, { exportType: 'named' });
+                    this._bufferNode(exportNode);
                     this._bufferEdge({
                         type: 'CONTAINS',
                         src: module.id,
-                        dst: exportId
+                        dst: exportNode.id
                     });
                 }
             }
             else if (type === 'all') {
-                const exportId = `${module.file}:EXPORT:*:${line}`;
-                this._bufferNode({
-                    id: exportId,
-                    type: 'EXPORT',
-                    exportType: 'all',
-                    name: '*',
-                    file: module.file,
-                    line: line,
-                    source: source
+                const exportNode = NodeFactory.createExport('*', module.file, line, 0, {
+                    source: source,
+                    exportType: 'all'
                 });
+                this._bufferNode(exportNode);
                 this._bufferEdge({
                     type: 'CONTAINS',
                     src: module.id,
-                    dst: exportId
+                    dst: exportNode.id
                 });
             }
         }
@@ -493,14 +1002,11 @@ export class GraphBuilder {
     }
     bufferHttpRequests(httpRequests, functions) {
         if (httpRequests.length > 0) {
-            const networkId = 'net:request#__network__';
-            if (!this._createdSingletons.has(networkId)) {
-                this._bufferNode({
-                    id: networkId,
-                    type: 'net:request',
-                    name: '__network__'
-                });
-                this._createdSingletons.add(networkId);
+            // Create net:request singleton using factory
+            const networkNode = NetworkRequestNode.create();
+            if (!this._createdSingletons.has(networkNode.id)) {
+                this._bufferNode(networkNode);
+                this._createdSingletons.add(networkNode.id);
             }
             for (const request of httpRequests) {
                 const { parentScopeId, ...requestData } = request;
@@ -508,7 +1014,7 @@ export class GraphBuilder {
                 this._bufferEdge({
                     type: 'CALLS',
                     src: request.id,
-                    dst: networkId
+                    dst: networkNode.id
                 });
                 if (parentScopeId) {
                     const scopeParts = parentScopeId.split(':');
@@ -536,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({
@@ -582,8 +1103,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);
                 if (sourceVariable) {
                     this._bufferEdge({
@@ -614,35 +1137,25 @@ export class GraphBuilder {
                     });
                 }
             }
-            // EXPRESSION node creation
+            // 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 } = assignment;
-                const expressionNode = {
-                    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;
-                    }
-                    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>';
-                }
+                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
+                    object,
+                    property,
+                    computed,
+                    computedPropertyVar: computedPropertyVar ?? undefined,
+                    operator,
+                    // Destructuring support (REG-201)
+                    path,
+                    baseName,
+                    propertyPath,
+                    arrayIndex
+                });
                 this._bufferNode(expressionNode);
                 this._bufferEdge({
                     type: 'ASSIGNED_FROM',
@@ -662,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));
@@ -770,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',
@@ -787,53 +1341,50 @@ export class GraphBuilder {
     // ============= TypeScript-specific buffer methods =============
     /**
      * 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
      */
     bufferInterfaceNodes(module, interfaces) {
+        // First pass: create all interface nodes and store them
+        const interfaceNodes = new Map();
         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);
             // 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);
                         this._bufferEdge({
                             type: 'EXTENDS',
-                            src: iface.id,
-                            dst: externalId
+                            src: srcNode.id,
+                            dst: externalInterface.id
                         });
                     }
                 }
@@ -845,45 +1396,35 @@ export class GraphBuilder {
      */
     bufferTypeAliasNodes(module, typeAliases) {
         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);
             // 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)
      */
     bufferEnumNodes(module, enums) {
         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);
             // MODULE -> CONTAINS -> ENUM
             this._bufferEdge({
                 type: 'CONTAINS',
                 src: module.id,
-                dst: enumDecl.id
+                dst: enumNode.id // Use factory-generated ID (colon format)
             });
         }
     }
@@ -892,22 +1433,15 @@ export class GraphBuilder {
      */
     bufferDecoratorNodes(decorators) {
         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);
             // TARGET -> DECORATED_BY -> DECORATOR
             this._bufferEdge({
                 type: 'DECORATED_BY',
                 src: decorator.targetId,
-                dst: decorator.id
+                dst: decoratorNode.id // Use factory-generated ID (colon format)
             });
         }
     }
@@ -921,27 +1455,23 @@ 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);
                         this._bufferEdge({
                             type: 'IMPLEMENTS',
                             src: classDecl.id,
-                            dst: externalId
+                            dst: externalInterface.id
                         });
                     }
                 }
@@ -949,127 +1479,808 @@ 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()
      */
-    async createClassAssignmentEdges(variableAssignments, graph) {
-        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 = null;
-                for await (const node of graph.queryNodes({ type: 'CLASS' })) {
-                    if (node.name === className && (!file || node.file === file)) {
-                        classNode = node;
-                        break;
+    bufferArrayMutationEdges(arrayMutations, variableDeclarations, parameters) {
+        // Note: No longer using Map-based cache - scope-aware lookup requires scope chain walk
+        for (const mutation of arrayMutations) {
+            const { arrayName, mutationScopePath, mutationMethod, insertedValues, file, isNested, baseObjectName, propertyName } = mutation;
+            const scopePath = mutationScopePath ?? [];
+            // REG-117: For nested mutations (obj.arr.push), resolve target node
+            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 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 = {
+                            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);
                     }
                 }
-                if (classNode) {
-                    await graph.addEdge({
-                        type: 'ASSIGNED_FROM',
-                        src: variableId,
-                        dst: classNode.id
-                    });
-                    edgesCreated++;
-                }
+                // For literals, object literals, etc. - we could create edges from LITERAL nodes
+                // but for now we just track variable -> array flows
             }
         }
-        return edgesCreated;
     }
     /**
-     * Create IMPORTS_FROM edges linking imports to their target exports
+     * 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'.
      */
-    async createImportExportEdges(module, imports, _exports, graph, _projectPath) {
-        let edgesCreated = 0;
-        for (const imp of imports) {
-            const { source, specifiers, line } = imp;
-            // Только для относительных импортов
-            const isRelative = source.startsWith('./') || source.startsWith('../');
-            if (!isRelative) {
-                continue;
+    bufferObjectMutationEdges(objectMutations, variableDeclarations, parameters, functions, classDeclarations) {
+        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 = null;
+            let effectiveMutationType = 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;
             }
-            // Резолвим целевой модуль
-            const currentDir = dirname(module.file);
-            let targetPath = resolve(currentDir, source);
-            // Пытаемся найти файл с расширениями .js, .ts, .jsx, .tsx
-            const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts'];
-            let targetModule = null;
-            // Ищем MODULE ноду по file атрибуту (не по ID, т.к. формат ID изменился)
-            for (const ext of extensions) {
-                const testPath = targetPath + ext;
-                // Ищем MODULE с этим file path
-                for await (const node of graph.queryNodes({ type: 'MODULE' })) {
-                    if (node.file === testPath) {
-                        targetModule = node;
-                        targetPath = testPath;
-                        break;
+            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 = {
+                        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);
                 }
-                if (targetModule)
-                    break;
             }
-            if (!targetModule) {
-                // Целевой модуль не найден в графе
+            // 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;
             }
-            // Создаём IMPORTS edge от MODULE к MODULE (для совместимости с тестами)
-            await graph.addEdge({
-                type: 'IMPORTS',
-                src: module.id,
-                dst: targetModule.id
-            });
-            edgesCreated++;
-            // Для каждого импортированного идентификатора создаём ребро к соответствующему 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';
-                if (importType === 'namespace') {
-                    // import * as foo - связываем со всем модулем
-                    await graph.addEdge({
-                        type: 'IMPORTS_FROM',
-                        src: importId,
-                        dst: targetModule.id
+            // 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)
                     });
-                    edgesCreated++;
                 }
-                else if (importType === 'default') {
-                    // Находим EXPORT default в целевом модуле
-                    const targetExports = [];
-                    for await (const node of graph.queryNodes({ type: 'EXPORT' })) {
-                        const exportNode = node;
-                        if (exportNode.file === targetPath && exportNode.exportType === 'default') {
-                            targetExports.push(exportNode);
+                // 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;
+                            }
                         }
                     }
-                    if (targetExports.length > 0) {
-                        await graph.addEdge({
-                            type: 'IMPORTS_FROM',
-                            src: importId,
-                            dst: targetExports[0].id
-                        });
-                        edgesCreated++;
+                    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;
                 }
-                else {
-                    // Named import - находим соответствующий named export
-                    const targetExports = [];
-                    for await (const node of graph.queryNodes({ type: 'EXPORT' })) {
-                        const exportNode = node;
-                        if (exportNode.file === targetPath && exportNode.exportType === 'named' && exportNode.name === spec.imported) {
-                            targetExports.push(exportNode);
+                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;
                         }
                     }
-                    if (targetExports.length > 0) {
-                        await graph.addEdge({
-                            type: 'IMPORTS_FROM',
-                            src: importId,
-                            dst: targetExports[0].id
-                        });
-                        edgesCreated++;
+                    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.
+     */
+    bufferObjectLiteralNodes(objectLiterals) {
+        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
+            });
+        }
+    }
+    /**
+     * Buffer ARRAY_LITERAL nodes to the graph.
+     * These are array literals passed as function arguments or nested in other literals.
+     */
+    bufferArrayLiteralNodes(arrayLiterals) {
+        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
+            });
+        }
+    }
+    /**
+     * 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)
+     */
+    async createClassAssignmentEdges(variableAssignments, graph) {
+        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 = null;
+                for await (const node of graph.queryNodes({ type: 'CLASS' })) {
+                    if (node.name === className && (!file || node.file === file)) {
+                        classNode = node;
+                        break;
                     }
                 }
+                if (classNode) {
+                    await graph.addEdge({
+                        type: 'ASSIGNED_FROM',
+                        src: variableId,
+                        dst: classNode.id
+                    });
+                    edgesCreated++;
+                }
             }
         }
         return edgesCreated;