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

package/dist/plugins/analysis/ServiceLayerAnalyzer.js

@@ -12,6 +12,7 @@ import { readFileSync } from 'fs';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { getLine } from './ast/utils/location.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = traverseModule.default || traverseModule;
 export class ServiceLayerAnalyzer extends Plugin {
@@ -28,11 +29,12 @@ export class ServiceLayerAnalyzer extends Plugin {
         };
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { graph } = context;
             // Получаем все модули
             const modules = await this.getModules(graph);
-            console.log(`[ServiceLayerAnalyzer] Processing ${modules.length} modules...`);
+            logger.info('Processing modules', { count: modules.length });
             let classesCount = 0;
             let instancesCount = 0;
             let registrationsCount = 0;
@@ -49,10 +51,20 @@ export class ServiceLayerAnalyzer extends Plugin {
                 if ((i + 1) % 20 === 0 || i === modules.length - 1) {
                     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
                     const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
-                    console.log(`[ServiceLayerAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`);
+                    logger.debug('Progress', {
+                        current: i + 1,
+                        total: modules.length,
+                        elapsed: `${elapsed}s`,
+                        avgTime: `${avgTime}ms/module`
+                    });
                 }
             }
-            console.log(`[ServiceLayerAnalyzer] Found ${classesCount} service classes, ${instancesCount} instances, ${registrationsCount} registrations, ${usagesCount} usages`);
+            logger.info('Analysis complete', {
+                classesCount,
+                instancesCount,
+                registrationsCount,
+                usagesCount
+            });
             return createSuccessResult({
                 nodes: classesCount + instancesCount + registrationsCount + usagesCount,
                 edges: 0
@@ -64,7 +76,7 @@ export class ServiceLayerAnalyzer extends Plugin {
             });
         }
         catch (error) {
-            console.error('[ServiceLayerAnalyzer] Error:', error);
+            logger.error('Analysis failed', { error });
             return createErrorResult(error);
         }
     }
@@ -95,7 +107,7 @@ export class ServiceLayerAnalyzer extends Plugin {
                     const node = path.node;
                     const className = node.id?.name;
                     if (className && this.isServiceClass(className)) {
-                        const line = node.loc.start.line;
+                        const line = getLine(node);
                         // Извлекаем методы сервиса
                         const methods = node.body.body
                             .filter(m => m.type === 'ClassMethod' && m.kind === 'method')
@@ -117,7 +129,7 @@ export class ServiceLayerAnalyzer extends Plugin {
                     if (callee.type === 'Identifier') {
                         const className = callee.name;
                         if (this.isServiceClass(className)) {
-                            const line = node.loc.start.line;
+                            const line = getLine(node);
                             serviceInstances.push({
                                 id: `${module.file}:SERVICE_INSTANCE:${className}:${line}`,
                                 type: 'SERVICE_INSTANCE',
@@ -139,7 +151,7 @@ export class ServiceLayerAnalyzer extends Plugin {
                         const objectName = this.getObjectName(callee.object);
                         if (objectName === 'app' && node.arguments.length >= 2) {
                             const serviceName = this.extractStringArg(node.arguments[0]);
-                            const line = node.loc.start.line;
+                            const line = getLine(node);
                             // Проверяем что это похоже на service (имя содержит 'service' или '*Service')
                             if (serviceName.toLowerCase().includes('service') ||
                                 this.isServiceClass(serviceName)) {
@@ -164,7 +176,7 @@ export class ServiceLayerAnalyzer extends Plugin {
                             objectChain.includes('app')) {
                             if (node.arguments.length >= 1) {
                                 const serviceName = this.extractStringArg(node.arguments[0]);
-                                const line = node.loc.start.line;
+                                const line = getLine(node);
                                 // Проверяем что это похоже на service
                                 if (serviceName.toLowerCase().includes('service') ||
                                     this.isServiceClass(serviceName)) {
@@ -237,7 +249,7 @@ export class ServiceLayerAnalyzer extends Plugin {
             };
         }
         catch (error) {
-            console.error(`[ServiceLayerAnalyzer] Error analyzing ${module.file}:`, error.message);
+            // Silent - per-module errors shouldn't spam logs
             return { classes: 0, instances: 0, registrations: 0, usages: 0 };
         }
     }

package/dist/plugins/analysis/SocketIOAnalyzer.d.ts

@@ -19,6 +19,15 @@ import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 export declare class SocketIOAnalyzer extends Plugin {
     get metadata(): PluginMetadata;
     execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Create event channel nodes and connect them to emits/listeners
+     *
+     * This runs AFTER all modules are analyzed, so all emit/listener nodes exist.
+     * Creates one socketio:event node per unique event name, then connects:
+     * - socketio:emit → EMITS_EVENT → socketio:event
+     * - socketio:event → LISTENED_BY → socketio:on
+     */
+    private createEventChannels;
     private analyzeModule;
     /**
      * Извлекает имя объекта из MemberExpression

package/dist/plugins/analysis/SocketIOAnalyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SocketIOAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/SocketIOAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAyDhF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA+C9C,aAAa;IA+M3B;;;OAGG;IACH,OAAO,CAAC,aAAa;IAWrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CA4BzB"}
+{"version":3,"file":"SocketIOAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/SocketIOAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAwEhF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA2D5D;;;;;;;OAOG;YACW,mBAAmB;YAiFnB,aAAa;IAsN3B;;;OAGG;IACH,OAAO,CAAC,aAAa;IAWrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CA4BzB"}

package/dist/plugins/analysis/SocketIOAnalyzer.js

@@ -18,6 +18,7 @@ import { readFileSync } from 'fs';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = traverseModule.default || traverseModule;
 export class SocketIOAnalyzer extends Plugin {
@@ -27,22 +28,24 @@ export class SocketIOAnalyzer extends Plugin {
             phase: 'ANALYSIS',
             priority: 75, // После JSASTAnalyzer (80)
             creates: {
-                nodes: ['socketio:emit', 'socketio:on', 'socketio:room'],
-                edges: ['CONTAINS', 'EMITS_EVENT', 'LISTENS_TO', 'JOINS_ROOM']
+                nodes: ['socketio:emit', 'socketio:on', 'socketio:room', 'socketio:event'],
+                edges: ['CONTAINS', 'EMITS_EVENT', 'LISTENS_TO', 'JOINS_ROOM', 'LISTENED_BY']
             },
             dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
         };
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { graph } = context;
             // Получаем все модули
             const modules = await this.getModules(graph);
-            console.log(`[SocketIOAnalyzer] Processing ${modules.length} modules...`);
+            logger.info('Processing modules', { count: modules.length });
             let emitsCount = 0;
             let listenersCount = 0;
             let roomsCount = 0;
             const startTime = Date.now();
+            // PHASE 1: Analyze modules and create emit/listener/room nodes
             for (let i = 0; i < modules.length; i++) {
                 const module = modules[i];
                 const result = await this.analyzeModule(module, graph);
@@ -53,20 +56,106 @@ export class SocketIOAnalyzer extends Plugin {
                 if ((i + 1) % 20 === 0 || i === modules.length - 1) {
                     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
                     const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
-                    console.log(`[SocketIOAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`);
+                    logger.debug('Progress', {
+                        current: i + 1,
+                        total: modules.length,
+                        elapsed: `${elapsed}s`,
+                        avgTime: `${avgTime}ms/module`
+                    });
                 }
             }
-            console.log(`[SocketIOAnalyzer] Found ${emitsCount} emits, ${listenersCount} listeners, ${roomsCount} rooms`);
+            // PHASE 2: Create event channel nodes and edges
+            const eventCount = await this.createEventChannels(graph, logger);
+            logger.info('Analysis complete', {
+                emitsCount,
+                listenersCount,
+                roomsCount,
+                eventCount
+            });
             return createSuccessResult({
-                nodes: emitsCount + listenersCount + roomsCount,
+                nodes: emitsCount + listenersCount + roomsCount + eventCount,
                 edges: 0
-            }, { emitsCount, listenersCount, roomsCount });
+            }, { emitsCount, listenersCount, roomsCount, eventCount });
         }
         catch (error) {
-            console.error('[SocketIOAnalyzer] Error:', error);
+            logger.error('Analysis failed', { error });
             return createErrorResult(error);
         }
     }
+    /**
+     * Create event channel nodes and connect them to emits/listeners
+     *
+     * This runs AFTER all modules are analyzed, so all emit/listener nodes exist.
+     * Creates one socketio:event node per unique event name, then connects:
+     * - socketio:emit → EMITS_EVENT → socketio:event
+     * - socketio:event → LISTENED_BY → socketio:on
+     */
+    async createEventChannels(graph, logger) {
+        try {
+            // Step 1: Get all emit and listener nodes
+            const allEmits = await graph.getAllNodes({ type: 'socketio:emit' });
+            const allListeners = await graph.getAllNodes({ type: 'socketio:on' });
+            logger.debug('Creating event channels', {
+                emits: allEmits.length,
+                listeners: allListeners.length
+            });
+            // Step 2: Extract unique event names
+            const eventNames = new Set();
+            for (const emit of allEmits) {
+                if (emit.event && typeof emit.event === 'string') {
+                    eventNames.add(emit.event);
+                }
+            }
+            for (const listener of allListeners) {
+                if (listener.event && typeof listener.event === 'string') {
+                    eventNames.add(listener.event);
+                }
+            }
+            logger.debug('Unique events found', { count: eventNames.size });
+            // Step 3: Create event channel node for each unique event
+            let createdCount = 0;
+            for (const eventName of eventNames) {
+                const eventNodeId = `socketio:event#${eventName}`;
+                // Create event channel node
+                const eventNode = {
+                    id: eventNodeId,
+                    type: 'socketio:event',
+                    name: eventName,
+                    event: eventName
+                };
+                await graph.addNode(eventNode);
+                createdCount++;
+                // Step 4: Connect all emits of this event to the channel
+                const matchingEmits = allEmits.filter(e => e.event === eventName);
+                for (const emit of matchingEmits) {
+                    await graph.addEdge({
+                        type: 'EMITS_EVENT',
+                        src: emit.id,
+                        dst: eventNodeId
+                    });
+                }
+                // Step 5: Connect event channel to all listeners of this event
+                const matchingListeners = allListeners.filter(l => l.event === eventName);
+                for (const listener of matchingListeners) {
+                    await graph.addEdge({
+                        type: 'LISTENED_BY',
+                        src: eventNodeId,
+                        dst: listener.id
+                    });
+                }
+                logger.debug('Created event channel', {
+                    event: eventName,
+                    emits: matchingEmits.length,
+                    listeners: matchingListeners.length
+                });
+            }
+            return createdCount;
+        }
+        catch (error) {
+            logger.error('Failed to create event channels', { error });
+            return 0;
+        }
+    }
     async analyzeModule(module, graph) {
         try {
             const code = readFileSync(module.file, 'utf-8');
@@ -97,8 +186,8 @@ export class SocketIOAnalyzer extends Plugin {
                         callee.property.name === 'emit') {
                         const objectName = this.getObjectName(callee.object);
                         const event = this.extractStringArg(node.arguments[0]);
-                        const line = node.loc.start.line;
-                        const column = node.loc.start.column;
+                        const line = getLine(node);
+                        const column = getColumn(node);
                         // io.to('room').emit() - room-based emit
                         let room = null;
                         if (callee.object.type === 'CallExpression' &&
@@ -138,7 +227,7 @@ export class SocketIOAnalyzer extends Plugin {
                         callee.property.name === 'on') {
                         const objectName = this.getObjectName(callee.object);
                         const event = this.extractStringArg(node.arguments[0]);
-                        const line = node.loc.start.line;
+                        const line = getLine(node);
                         const handler = node.arguments[1];
                         // Извлекаем имя handler функции
                         let handlerName = 'anonymous';
@@ -146,8 +235,8 @@ export class SocketIOAnalyzer extends Plugin {
                         if (handler) {
                             if (handler.type === 'FunctionExpression' ||
                                 handler.type === 'ArrowFunctionExpression') {
-                                handlerName = `anonymous:${handler.loc.start.line}`;
-                                handlerLine = handler.loc.start.line;
+                                handlerName = `anonymous:${getLine(handler)}`;
+                                handlerLine = getLine(handler);
                             }
                             else if (handler.type === 'Identifier') {
                                 handlerName = handler.name;
@@ -161,7 +250,8 @@ export class SocketIOAnalyzer extends Plugin {
                             handlerName: handlerName,
                             handlerLine: handlerLine,
                             file: module.file,
-                            line: line
+                            line: line,
+                            column: getColumn(node)
                         });
                     }
                     // Pattern: socket.join(room)
@@ -170,7 +260,7 @@ export class SocketIOAnalyzer extends Plugin {
                         callee.property.name === 'join') {
                         const objectName = this.getObjectName(callee.object);
                         const roomName = this.extractStringArg(node.arguments[0]);
-                        const line = node.loc.start.line;
+                        const line = getLine(node);
                         if (objectName === 'socket') {
                             rooms.push({
                                 id: `socketio:room#${roomName}#${module.file}#${line}`,
@@ -178,7 +268,8 @@ export class SocketIOAnalyzer extends Plugin {
                                 room: roomName,
                                 objectName: objectName,
                                 file: module.file,
-                                line: line
+                                line: line,
+                                column: getColumn(node)
                             });
                         }
                     }
@@ -202,14 +293,19 @@ export class SocketIOAnalyzer extends Plugin {
                     src: module.id,
                     dst: listener.id
                 });
-                // Ищем FUNCTION node для handler и создаём ребро LISTENS_TO
-                const handlerFunctionId = `FUNCTION#${listener.handlerName}#${listener.file}#${listener.handlerLine}`;
-                const handlerFunction = await graph.getNode(handlerFunctionId);
+                // Find FUNCTION node for handler by name and file (supports both legacy and semantic IDs)
+                const handlerFunctions = await graph.getAllNodes({
+                    type: 'FUNCTION',
+                    name: listener.handlerName,
+                    file: listener.file
+                });
+                // Find the handler at the matching line
+                const handlerFunction = handlerFunctions.find(fn => fn.line === listener.handlerLine);
                 if (handlerFunction) {
                     await graph.addEdge({
                         type: 'LISTENS_TO',
                         src: listener.id,
-                        dst: handlerFunctionId
+                        dst: handlerFunction.id
                     });
                 }
             }
@@ -229,7 +325,7 @@ export class SocketIOAnalyzer extends Plugin {
             };
         }
         catch (error) {
-            console.error(`[SocketIOAnalyzer] Error analyzing ${module.file}:`, error.message);
+            // Silent - per-module errors shouldn't spam logs
             return { emits: 0, listeners: 0, rooms: 0 };
         }
     }

package/dist/plugins/analysis/SystemDbAnalyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SystemDbAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/SystemDbAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2BhF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuL5D;;OAEG;IACH,OAAO,CAAC,cAAc;IAiBtB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAkB1B"}
+{"version":3,"file":"SystemDbAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/SystemDbAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2BhF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA4L5D;;OAEG;IACH,OAAO,CAAC,cAAc;IAiBtB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAkB1B"}

package/dist/plugins/analysis/SystemDbAnalyzer.js

@@ -29,13 +29,14 @@ export class SystemDbAnalyzer extends Plugin {
         };
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { graph } = context;
             let nodesCreated = 0;
             let edgesCreated = 0;
             // Get all MODULE nodes
             const modules = await this.getModules(graph);
-            console.log(`[SystemDbAnalyzer] Analyzing ${modules.length} modules for system_db patterns...\n`);
+            logger.info('Analyzing modules for system_db patterns', { count: modules.length });
             for (const module of modules) {
                 if (!module.file)
                     continue;
@@ -114,7 +115,13 @@ export class SystemDbAnalyzer extends Plugin {
                     // Create SYSTEM_DB_VIEW_REGISTRATION nodes
                     for (const reg of registrations) {
                         const nodeId = `${module.file}:SYSTEM_DB_VIEW_REGISTRATION:${reg.viewName}:${reg.line}`;
-                        console.log(`   📌 Found: ${reg.type}('${reg.viewName}', '${reg.serverName}') at ${module.file.split('/').pop()}:${reg.line}`);
+                        logger.debug('Found registration', {
+                            type: reg.type,
+                            viewName: reg.viewName,
+                            serverName: reg.serverName,
+                            file: module.file.split('/').pop(),
+                            line: reg.line
+                        });
                         await graph.addNode({
                             id: nodeId,
                             type: 'SYSTEM_DB_VIEW_REGISTRATION',
@@ -160,15 +167,18 @@ export class SystemDbAnalyzer extends Plugin {
                 catch (err) {
                     // Skip files that can't be parsed
                     if (err.code !== 'ENOENT') {
-                        console.error(`   ⚠️  Failed to analyze ${module.file}: ${err.message}`);
+                        logger.warn('Failed to analyze module', {
+                            file: module.file,
+                            error: err.message
+                        });
                     }
                 }
             }
-            console.log(`[SystemDbAnalyzer] Created ${nodesCreated} system_db nodes, ${edgesCreated} edges\n`);
+            logger.info('Analysis complete', { nodesCreated, edgesCreated });
             return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { modulesAnalyzed: modules.length });
         }
         catch (error) {
-            console.error(`[SystemDbAnalyzer] Error:`, error);
+            logger.error('Analysis failed', { error });
             return createErrorResult(error);
         }
     }

package/dist/plugins/analysis/ast/GraphBuilder.d.ts

@@ -31,6 +31,69 @@ export declare class GraphBuilder {
     build(module: ModuleNode, graph: GraphBackend, projectPath: string, data: ASTCollections): Promise<BuildResult>;
     private bufferFunctionEdges;
     private bufferScopeEdges;
+    /**
+     * Buffer LOOP edges (CONTAINS, HAS_BODY, ITERATES_OVER)
+     *
+     * Creates edges for:
+     * - Parent -> CONTAINS -> LOOP
+     * - LOOP -> HAS_BODY -> body SCOPE
+     * - LOOP -> ITERATES_OVER -> collection VARIABLE/PARAMETER (for for-in/for-of)
+     *
+     * Scope-aware variable lookup for ITERATES_OVER:
+     * For for-of/for-in, finds the iterated variable preferring:
+     * 1. Variables declared before the loop on same or earlier line (closest first)
+     * 2. Parameters (function arguments)
+     */
+    private bufferLoopEdges;
+    /**
+     * Buffer HAS_CONDITION edges from LOOP to condition EXPRESSION/CALL nodes.
+     * Also creates EXPRESSION nodes for non-CallExpression conditions.
+     *
+     * REG-280: For while/do-while/for loops, creates HAS_CONDITION edge to the
+     * condition expression. For-in/for-of loops don't have conditions (use ITERATES_OVER).
+     *
+     * For CallExpression conditions, links to existing CALL_SITE node by coordinates.
+     */
+    private bufferLoopConditionEdges;
+    /**
+     * Buffer EXPRESSION nodes for loop condition expressions (non-CallExpression).
+     * Similar to bufferDiscriminantExpressions but for loops.
+     *
+     * REG-280: Creates EXPRESSION nodes for while/do-while/for loop conditions.
+     * CallExpression conditions use existing CALL_SITE nodes (no EXPRESSION created).
+     */
+    private bufferLoopConditionExpressions;
+    /**
+     * Buffer BRANCH edges (CONTAINS, HAS_CONDITION, HAS_CONSEQUENT, HAS_ALTERNATE)
+     *
+     * REG-275: For CallExpression discriminants (switch(getType())), looks up the
+     * actual CALL_SITE node by coordinates since the CALL_SITE uses semantic IDs.
+     *
+     * Phase 3 (REG-267): For if-branches, creates HAS_CONSEQUENT and HAS_ALTERNATE edges
+     * pointing to the if-body and else-body SCOPEs.
+     */
+    private bufferBranchEdges;
+    /**
+     * Buffer CASE edges (HAS_CASE, HAS_DEFAULT)
+     */
+    private bufferCaseEdges;
+    /**
+     * Buffer edges for TRY_BLOCK, CATCH_BLOCK, FINALLY_BLOCK nodes (Phase 4)
+     *
+     * Creates edges for:
+     * - Parent -> CONTAINS -> TRY_BLOCK
+     * - TRY_BLOCK -> HAS_CATCH -> CATCH_BLOCK
+     * - TRY_BLOCK -> HAS_FINALLY -> FINALLY_BLOCK
+     */
+    private bufferTryCatchFinallyEdges;
+    /**
+     * Buffer EXPRESSION nodes for switch discriminants
+     * Uses stored metadata directly instead of parsing from ID (Linus improvement)
+     *
+     * REG-275: For CallExpression discriminants, we don't create nodes here since
+     * bufferBranchEdges links to the existing CALL_SITE node by coordinates.
+     */
+    private bufferDiscriminantExpressions;
     private bufferVariableEdges;
     private bufferCallSiteEdges;
     private bufferMethodCalls;
@@ -47,6 +110,10 @@ export declare class GraphBuilder {
     private bufferArgumentEdges;
     /**
      * Buffer INTERFACE nodes and EXTENDS edges
+     *
+     * Uses two-pass approach:
+     * 1. First pass: create all interface nodes, store in Map
+     * 2. Second pass: create EXTENDS edges using stored node IDs
      */
     private bufferInterfaceNodes;
     /**
@@ -55,6 +122,7 @@ export declare class GraphBuilder {
     private bufferTypeAliasNodes;
     /**
      * Buffer ENUM nodes
+     * Uses EnumNode.create() to ensure consistent ID format (colon separator)
      */
     private bufferEnumNodes;
     /**
@@ -66,12 +134,147 @@ export declare class GraphBuilder {
      */
     private bufferImplementsEdges;
     /**
-     * Handle CLASS ASSIGNED_FROM edges asynchronously (needs graph queries)
+     * Buffer FLOWS_INTO edges for array mutations (push, unshift, splice, indexed assignment)
+     * Creates edges from inserted values to the array variable
+     *
+     * REG-117: Now handles nested mutations like obj.arr.push(item):
+     * - For nested mutations, falls back to base object if array property not found
+     * - Adds nestedProperty metadata for tracking
+     *
+     * OPTIMIZED: Uses Map-based lookup cache for O(1) variable lookups instead of O(n) find()
      */
-    private createClassAssignmentEdges;
+    private bufferArrayMutationEdges;
+    /**
+     * Buffer FLOWS_INTO edges for object mutations (property assignment, Object.assign)
+     * Creates edges from source values to the object variable being mutated.
+     *
+     * REG-152: For 'this.prop = value' patterns inside classes, creates edges
+     * to the CLASS node with mutationType: 'this_property'.
+     */
+    private bufferObjectMutationEdges;
+    /**
+     * Resolve variable by name using scope chain lookup (REG-309).
+     * Mirrors JavaScript lexical scoping: search current scope, then parent, then grandparent, etc.
+     *
+     * @param name - Variable name
+     * @param scopePath - Scope path where reference occurs (from ScopeTracker)
+     * @param file - File path
+     * @param variables - All variable declarations
+     * @returns Variable declaration or null if not found
+     */
+    private resolveVariableInScope;
+    /**
+     * Resolve parameter by name using scope chain lookup (REG-309).
+     * Same semantics as resolveVariableInScope but for parameters.
+     *
+     * @param name - Parameter name
+     * @param scopePath - Scope path where reference occurs (from ScopeTracker)
+     * @param file - File path
+     * @param parameters - All parameter declarations
+     * @returns Parameter declaration or null if not found
+     */
+    private resolveParameterInScope;
     /**
-     * Create IMPORTS_FROM edges linking imports to their target exports
+     * Check if two scope paths match (REG-309).
+     * Handles: ['foo', 'if#0'] vs ['foo', 'if#0']
      */
-    private createImportExportEdges;
+    private scopePathsMatch;
+    /**
+     * Buffer FLOWS_INTO edges for variable reassignments.
+     * Handles: x = y, x += y (when x is already declared, not initialization)
+     *
+     * Edge patterns:
+     * - Simple assignment (=): source --FLOWS_INTO--> variable
+     * - Compound operators (+=, -=, etc.):
+     *   - source --FLOWS_INTO--> variable (write new value)
+     *   - variable --READS_FROM--> variable (self-loop: reads current value before write)
+     *
+     * REG-309: Uses scope-aware variable lookup via resolveVariableInScope().
+     *
+     * REG-290: Complete implementation with inline node creation (no continue statements).
+     */
+    private bufferVariableReassignmentEdges;
+    /**
+     * Buffer RETURNS edges connecting return expressions to their containing functions.
+     *
+     * Edge direction: returnExpression --RETURNS--> function
+     *
+     * This enables tracing data flow through function calls:
+     * - Query: "What does formatDate return?"
+     * - Answer: Follow RETURNS edges from function to see all possible return values
+     */
+    private bufferReturnEdges;
+    /**
+     * Buffer UPDATE_EXPRESSION nodes and edges for increment/decrement operations.
+     *
+     * Handles two target types:
+     * - IDENTIFIER: Simple variable (i++, --count)
+     * - MEMBER_EXPRESSION: Object property (obj.prop++, arr[i]++, this.count++)
+     *
+     * Creates:
+     * - UPDATE_EXPRESSION node with operator and target metadata
+     * - MODIFIES edge: UPDATE_EXPRESSION -> target (VARIABLE, PARAMETER, or CLASS)
+     * - READS_FROM self-loop: target -> target (reads current value before update)
+     * - CONTAINS edge: SCOPE -> UPDATE_EXPRESSION
+     *
+     * REG-288: Initial implementation for IDENTIFIER targets
+     * REG-312: Extended for MEMBER_EXPRESSION targets
+     */
+    private bufferUpdateExpressionEdges;
+    /**
+     * Buffer UPDATE_EXPRESSION node and edges for simple identifier updates (i++, --count)
+     * REG-288: Original implementation extracted for clarity
+     */
+    private bufferIdentifierUpdate;
+    /**
+     * Buffer UPDATE_EXPRESSION node and edges for member expression updates (obj.prop++, arr[i]++)
+     * REG-312: New implementation for member expression targets
+     *
+     * Creates:
+     * - UPDATE_EXPRESSION node with member expression metadata
+     * - MODIFIES edge: UPDATE_EXPRESSION -> VARIABLE(object) or CLASS (for this.prop++)
+     * - READS_FROM self-loop: VARIABLE(object) -> VARIABLE(object)
+     * - CONTAINS edge: SCOPE -> UPDATE_EXPRESSION
+     */
+    private bufferMemberExpressionUpdate;
+    /**
+     * Buffer RESOLVES_TO edges for Promise resolution data flow (REG-334).
+     *
+     * Links resolve/reject CALL nodes to their parent Promise CONSTRUCTOR_CALL.
+     * This enables traceValues to follow Promise data flow:
+     *
+     * Example:
+     * ```
+     * const result = new Promise((resolve) => {
+     *   resolve(42);  // CALL[resolve] --RESOLVES_TO--> CONSTRUCTOR_CALL[Promise]
+     * });
+     * ```
+     *
+     * The edge direction (CALL -> CONSTRUCTOR_CALL) matches data flow semantics:
+     * data flows FROM resolve(value) TO the Promise result.
+     */
+    private bufferPromiseResolutionEdges;
+    /**
+     * Buffer OBJECT_LITERAL nodes to the graph.
+     * These are object literals passed as function arguments or nested in other literals.
+     */
+    private bufferObjectLiteralNodes;
+    /**
+     * Buffer ARRAY_LITERAL nodes to the graph.
+     * These are array literals passed as function arguments or nested in other literals.
+     */
+    private bufferArrayLiteralNodes;
+    /**
+     * Buffer HAS_PROPERTY edges connecting OBJECT_LITERAL nodes to their property values.
+     * Creates edges from object literal to its property value nodes (LITERAL, nested OBJECT_LITERAL, ARRAY_LITERAL, etc.)
+     *
+     * REG-329: Adds scope-aware variable resolution for VARIABLE property values.
+     * Uses the same resolveVariableInScope infrastructure as mutation handlers.
+     */
+    private bufferObjectPropertyEdges;
+    /**
+     * Handle CLASS ASSIGNED_FROM edges asynchronously (needs graph queries)
+     */
+    private createClassAssignmentEdges;
 }
 //# sourceMappingURL=GraphBuilder.d.ts.map