@grafema/core 0.1.0-alpha.5 → 0.1.1-alpha

package/src/plugins/analysis/JSASTAnalyzer.ts

@@ -5,6 +5,7 @@
 
 import { readFileSync } from 'fs';
 import { createHash } from 'crypto';
+import { basename } from 'path';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import type { NodePath, TraverseOptions } from '@babel/traverse';
@@ -46,8 +47,13 @@ import {
 import { Task } from '../../core/Task.js';
 import { PriorityQueue } from '../../core/PriorityQueue.js';
 import { WorkerPool } from '../../core/WorkerPool.js';
+import { ASTWorkerPool, type ModuleInfo as ASTModuleInfo, type ParseResult } from '../../core/ASTWorkerPool.js';
 import { ConditionParser } from './ast/ConditionParser.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 import { Profiler } from '../../core/Profiler.js';
+import { ScopeTracker } from '../../core/ScopeTracker.js';
+import { computeSemanticId } from '../../core/SemanticId.js';
+import { ExpressionNode } from '../../core/nodes/ExpressionNode.js';
 import type { PluginContext, PluginResult, PluginMetadata, GraphBackend } from '@grafema/types';
 import type {
   ModuleNode,
@@ -71,6 +77,14 @@ import type {
   TypeAliasInfo,
   EnumDeclarationInfo,
   DecoratorInfo,
+  ObjectLiteralInfo,
+  ObjectPropertyInfo,
+  ArrayLiteralInfo,
+  ArrayElementInfo,
+  ArrayMutationInfo,
+  ArrayMutationArgument,
+  ObjectMutationInfo,
+  ObjectMutationValue,
   CounterRef,
   ProcessedNodes,
   ASTCollections,
@@ -79,14 +93,8 @@ import type {
 
 // === LOCAL TYPES ===
 
-/**
- * Context for tracking semantic IDs within a scope hierarchy.
- * Used to generate stable, line-number-independent IDs for SCOPE nodes.
- */
-interface ScopeContext {
-  semanticPath: string;                    // "ClassName.method" or "funcName"
-  siblingCounters: Map<string, number>;    // scopeType → count for this level
-}
+// Note: Legacy ScopeContext interface removed in REG-141
+// Semantic ID generation now uses ScopeTracker exclusively
 
 // Internal Collections with required fields (ASTCollections has optional for GraphBuilder)
 interface Collections {
@@ -111,6 +119,17 @@ interface Collections {
   typeAliases: TypeAliasInfo[];
   enums: EnumDeclarationInfo[];
   decorators: DecoratorInfo[];
+  // Object/Array literal tracking
+  objectLiterals: ObjectLiteralInfo[];
+  objectProperties: ObjectPropertyInfo[];
+  arrayLiterals: ArrayLiteralInfo[];
+  arrayElements: ArrayElementInfo[];
+  // Array mutation tracking for FLOWS_INTO edges
+  arrayMutations: ArrayMutationInfo[];
+  // Object mutation tracking for FLOWS_INTO edges
+  objectMutations: ObjectMutationInfo[];
+  objectLiteralCounterRef: CounterRef;
+  arrayLiteralCounterRef: CounterRef;
   ifScopeCounterRef: CounterRef;
   scopeCounterRef: CounterRef;
   varDeclCounterRef: CounterRef;
@@ -120,7 +139,6 @@ interface Collections {
   literalCounterRef: CounterRef;
   anonymousFunctionCounterRef: CounterRef;
   processedNodes: ProcessedNodes;
-  moduleScopeCtx?: ScopeContext;
   code?: string;
   // VisitorCollections compatibility
   classes: ClassDeclarationInfo[];
@@ -128,6 +146,8 @@ interface Collections {
   variables: VariableDeclarationInfo[];
   sideEffects: unknown[];  // TODO: define SideEffectInfo
   variableCounterRef: CounterRef;
+  // ScopeTracker for semantic ID generation
+  scopeTracker?: ScopeTracker;
   [key: string]: unknown;
 }
 
@@ -140,6 +160,8 @@ interface AnalyzeContext extends PluginContext {
   manifest?: AnalysisManifest;
   forceAnalysis?: boolean;
   workerCount?: number;
+  /** Enable parallel parsing using ASTWorkerPool (worker_threads) */
+  parallelParsing?: boolean;
   // Use base onProgress type for compatibility
   onProgress?: (info: Record<string, unknown>) => void;
 }
@@ -148,14 +170,12 @@ export class JSASTAnalyzer extends Plugin {
   private graphBuilder: GraphBuilder;
   private analyzedModules: Set<string>;
   private profiler: Profiler;
-  private _cacheCleared: boolean;
 
   constructor() {
     super();
     this.graphBuilder = new GraphBuilder();
     this.analyzedModules = new Set();
     this.profiler = new Profiler('JSASTAnalyzer');
-    this._cacheCleared = false;
   }
 
   get metadata(): PluginMetadata {
@@ -235,13 +255,14 @@ export class JSASTAnalyzer extends Plugin {
   }
 
   async execute(context: AnalyzeContext): Promise<PluginResult> {
+    const logger = this.log(context);
+
     try {
       const { manifest, graph, forceAnalysis = false } = context;
       const projectPath = manifest?.projectPath ?? '';
 
-      if (forceAnalysis && !this._cacheCleared) {
+      if (forceAnalysis) {
         this.analyzedModules.clear();
-        this._cacheCleared = true;
       }
 
       const allModules = await this.getModuleNodes(graph);
@@ -262,13 +283,18 @@ export class JSASTAnalyzer extends Plugin {
         }
       }
 
-      console.log(`[JSASTAnalyzer] Starting parallel analysis of ${modulesToAnalyze.length} modules (${skippedCount} cached)...`);
+      logger.info('Starting module analysis', { toAnalyze: modulesToAnalyze.length, cached: skippedCount });
 
       if (modulesToAnalyze.length === 0) {
-        console.log(`[JSASTAnalyzer] All modules are up-to-date, skipping analysis`);
+        logger.info('All modules up-to-date, skipping analysis');
         return createSuccessResult({ nodes: 0, edges: 0 });
       }
 
+      // Use ASTWorkerPool for true parallel parsing with worker_threads if enabled
+      if (context.parallelParsing) {
+        return await this.executeParallel(modulesToAnalyze, graph, projectPath, context);
+      }
+
       const queue = new PriorityQueue();
       const pool = new WorkerPool(context.workerCount || 10);
 
@@ -311,7 +337,7 @@ export class JSASTAnalyzer extends Plugin {
         completed++;
 
         if (completed % 10 === 0 || completed === modulesToAnalyze.length) {
-          console.log(`[JSASTAnalyzer] Progress: ${completed}/${modulesToAnalyze.length}`);
+          logger.debug('Analysis progress', { completed, total: modulesToAnalyze.length });
         }
       });
 
@@ -339,8 +365,8 @@ export class JSASTAnalyzer extends Plugin {
         }
       }
 
-      console.log(`[JSASTAnalyzer] Analyzed ${modulesToAnalyze.length} modules, created ${nodesCreated} nodes`);
-      console.log(`[JSASTAnalyzer] Stats:`, stats);
+      logger.info('Analysis complete', { modulesAnalyzed: modulesToAnalyze.length, nodesCreated });
+      logger.debug('Worker stats', { ...stats });
 
       this.profiler.printSummary();
 
@@ -350,12 +376,105 @@ export class JSASTAnalyzer extends Plugin {
       );
 
     } catch (error) {
-      console.error(`[JSASTAnalyzer] Error:`, error);
+      logger.error('Analysis failed', { error: error instanceof Error ? error.message : String(error) });
       const err = error instanceof Error ? error : new Error(String(error));
       return createErrorResult(err);
     }
   }
 
+  /**
+   * Execute parallel analysis using ASTWorkerPool (worker_threads).
+   *
+   * This method uses actual OS threads for true parallel CPU-intensive parsing.
+   * Workers generate semantic IDs using ScopeTracker, matching sequential behavior.
+   *
+   * @param modules - Modules to analyze
+   * @param graph - Graph backend for writing results
+   * @param projectPath - Project root path
+   * @param context - Analysis context with options
+   * @returns Plugin result with node/edge counts
+   */
+  private async executeParallel(
+    modules: ModuleNode[],
+    graph: GraphBackend,
+    projectPath: string,
+    context: AnalyzeContext
+  ): Promise<PluginResult> {
+    const logger = this.log(context);
+    const workerCount = context.workerCount || 4;
+    const pool = new ASTWorkerPool(workerCount);
+
+    logger.debug('Starting parallel parsing', { workerCount });
+
+    try {
+      await pool.init();
+
+      // Convert ModuleNode to ASTModuleInfo format
+      const moduleInfos: ASTModuleInfo[] = modules.map(m => ({
+        id: m.id,
+        file: m.file,
+        name: m.name
+      }));
+
+      // Parse all modules in parallel using worker threads
+      const results: ParseResult[] = await pool.parseModules(moduleInfos);
+
+      let nodesCreated = 0;
+      let edgesCreated = 0;
+      let errors = 0;
+
+      // Process results - collections already have semantic IDs from workers
+      for (const result of results) {
+        if (result.error) {
+          logger.warn('Parse error', { file: result.module.file, error: result.error.message });
+          errors++;
+          continue;
+        }
+
+        if (result.collections) {
+          // Find original module for metadata
+          const module = modules.find(m => m.id === result.module.id);
+          if (!module) continue;
+
+          // Pass collections directly to GraphBuilder - IDs already semantic
+          // Cast is safe because ASTWorker.ASTCollections is structurally compatible
+          // with ast/types.ASTCollections (METHOD extends FUNCTION semantically)
+          const buildResult = await this.graphBuilder.build(
+            module,
+            graph,
+            projectPath,
+            result.collections as unknown as ASTCollections
+          );
+
+          if (typeof buildResult === 'object' && buildResult !== null) {
+            nodesCreated += (buildResult as { nodes: number }).nodes || 0;
+            edgesCreated += (buildResult as { edges: number }).edges || 0;
+          }
+        }
+
+        // Report progress
+        if (context.onProgress) {
+          context.onProgress({
+            phase: 'analysis',
+            currentPlugin: 'JSASTAnalyzer',
+            message: `Processed ${result.module.file.replace(projectPath, '')}`,
+            totalFiles: modules.length,
+            processedFiles: results.indexOf(result) + 1
+          });
+        }
+      }
+
+      logger.info('Parallel parsing complete', { nodesCreated, edgesCreated, errors });
+
+      return createSuccessResult(
+        { nodes: nodesCreated, edges: edgesCreated },
+        { modulesAnalyzed: modules.length - errors, parallelParsing: true }
+      );
+    } finally {
+      await pool.terminate();
+    }
+  }
+
   /**
    * Extract variable names from destructuring patterns
    * Uses t.isX() type guards to avoid casts
@@ -473,8 +592,8 @@ export class JSASTAnalyzer extends Plugin {
         sourceId: null,
         sourceType: 'CALL_SITE',
         callName: initExpression.callee.name,
-        callLine: initExpression.loc!.start.line,
-        callColumn: initExpression.loc!.start.column
+        callLine: getLine(initExpression),
+        callColumn: getColumn(initExpression)
       });
       return;
     }
@@ -486,7 +605,7 @@ export class JSASTAnalyzer extends Plugin {
       const methodName = callee.property.type === 'Identifier' ? callee.property.name : 'unknown';
 
       const fullName = `${objectName}.${methodName}`;
-      const methodCallId = `CALL#${fullName}#${module.file}#${initExpression.loc!.start.line}:${initExpression.loc!.start.column}:inline`;
+      const methodCallId = `CALL#${fullName}#${module.file}#${getLine(initExpression)}:${getColumn(initExpression)}:inline`;
 
       const existing = variableAssignments.find(a => a.sourceId === methodCallId);
       if (!existing) {
@@ -495,15 +614,15 @@ export class JSASTAnalyzer extends Plugin {
           if (arg.type !== 'SpreadElement') {
             const argLiteralValue = ExpressionEvaluator.extractLiteralValue(arg);
             if (argLiteralValue !== null) {
-              const literalId = `LITERAL#arg${index}#${module.file}#${initExpression.loc!.start.line}:${initExpression.loc!.start.column}:${literalCounterRef.value++}`;
+              const literalId = `LITERAL#arg${index}#${module.file}#${getLine(initExpression)}:${getColumn(initExpression)}:${literalCounterRef.value++}`;
               literals.push({
                 id: literalId,
                 type: 'LITERAL',
                 value: argLiteralValue,
                 valueType: typeof argLiteralValue,
                 file: module.file,
-                line: arg.loc?.start.line || initExpression.loc!.start.line,
-                column: arg.loc?.start.column || initExpression.loc!.start.column,
+                line: arg.loc?.start.line || getLine(initExpression),
+                column: arg.loc?.start.column || getColumn(initExpression),
                 parentCallId: methodCallId,
                 argIndex: index
               });
@@ -522,8 +641,8 @@ export class JSASTAnalyzer extends Plugin {
           method: methodName,
           file: module.file,
           arguments: extractedArgs,
-          line: initExpression.loc!.start.line,
-          column: initExpression.loc!.start.column
+          line: getLine(initExpression),
+          column: getColumn(initExpression)
         });
       }
 
@@ -584,7 +703,8 @@ export class JSASTAnalyzer extends Plugin {
         ? initExpression.property.name
         : null;
 
-      const expressionId = `EXPRESSION#${objectName}.${propertyName}#${module.file}#${line}:${initExpression.start}`;
+      const column = initExpression.start ?? 0;
+      const expressionId = ExpressionNode.generateId('MemberExpression', module.file, line, column);
 
       variableAssignments.push({
         variableId,
@@ -597,14 +717,16 @@ export class JSASTAnalyzer extends Plugin {
         computedPropertyVar,
         objectSourceName: initExpression.object.type === 'Identifier' ? initExpression.object.name : null,
         file: module.file,
-        line: line
+        line: line,
+        column: column
       });
       return;
     }
 
     // 8. BinaryExpression
     if (initExpression.type === 'BinaryExpression') {
-      const expressionId = `EXPRESSION#binary#${module.file}#${line}:${initExpression.start}`;
+      const column = initExpression.start ?? 0;
+      const expressionId = ExpressionNode.generateId('BinaryExpression', module.file, line, column);
 
       variableAssignments.push({
         variableId,
@@ -615,14 +737,16 @@ export class JSASTAnalyzer extends Plugin {
         leftSourceName: initExpression.left.type === 'Identifier' ? initExpression.left.name : null,
         rightSourceName: initExpression.right.type === 'Identifier' ? initExpression.right.name : null,
         file: module.file,
-        line: line
+        line: line,
+        column: column
       });
       return;
     }
 
     // 9. ConditionalExpression
     if (initExpression.type === 'ConditionalExpression') {
-      const expressionId = `EXPRESSION#conditional#${module.file}#${line}:${initExpression.start}`;
+      const column = initExpression.start ?? 0;
+      const expressionId = ExpressionNode.generateId('ConditionalExpression', module.file, line, column);
 
       variableAssignments.push({
         variableId,
@@ -632,7 +756,8 @@ export class JSASTAnalyzer extends Plugin {
         consequentSourceName: initExpression.consequent.type === 'Identifier' ? initExpression.consequent.name : null,
         alternateSourceName: initExpression.alternate.type === 'Identifier' ? initExpression.alternate.name : null,
         file: module.file,
-        line: line
+        line: line,
+        column: column
       });
 
       this.trackVariableAssignment(initExpression.consequent, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
@@ -642,7 +767,8 @@ export class JSASTAnalyzer extends Plugin {
 
     // 10. LogicalExpression
     if (initExpression.type === 'LogicalExpression') {
-      const expressionId = `EXPRESSION#logical#${module.file}#${line}:${initExpression.start}`;
+      const column = initExpression.start ?? 0;
+      const expressionId = ExpressionNode.generateId('LogicalExpression', module.file, line, column);
 
       variableAssignments.push({
         variableId,
@@ -653,7 +779,8 @@ export class JSASTAnalyzer extends Plugin {
         leftSourceName: initExpression.left.type === 'Identifier' ? initExpression.left.name : null,
         rightSourceName: initExpression.right.type === 'Identifier' ? initExpression.right.name : null,
         file: module.file,
-        line: line
+        line: line,
+        column: column
       });
 
       this.trackVariableAssignment(initExpression.left, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
@@ -663,7 +790,8 @@ export class JSASTAnalyzer extends Plugin {
 
     // 11. TemplateLiteral
     if (initExpression.type === 'TemplateLiteral' && initExpression.expressions.length > 0) {
-      const expressionId = `EXPRESSION#template#${module.file}#${line}:${initExpression.start}`;
+      const column = initExpression.start ?? 0;
+      const expressionId = ExpressionNode.generateId('TemplateLiteral', module.file, line, column);
 
       const expressionSourceNames = initExpression.expressions
         .filter((expr): expr is t.Identifier => expr.type === 'Identifier')
@@ -676,7 +804,8 @@ export class JSASTAnalyzer extends Plugin {
         expressionType: 'TemplateLiteral',
         expressionSourceNames,
         file: module.file,
-        line: line
+        line: line,
+        column: column
       });
 
       for (const expr of initExpression.expressions) {
@@ -719,6 +848,10 @@ export class JSASTAnalyzer extends Plugin {
       });
       this.profiler.end('babel_parse');
 
+      // Create ScopeTracker for semantic ID generation
+      // Use basename for shorter, more readable semantic IDs
+      const scopeTracker = new ScopeTracker(basename(module.file));
+
       const functions: FunctionInfo[] = [];
       const parameters: ParameterInfo[] = [];
       const scopes: ScopeInfo[] = [];
@@ -740,6 +873,15 @@ export class JSASTAnalyzer extends Plugin {
       const typeAliases: TypeAliasInfo[] = [];
       const enums: EnumDeclarationInfo[] = [];
       const decorators: DecoratorInfo[] = [];
+      // Object/Array literal tracking for data flow
+      const objectLiterals: ObjectLiteralInfo[] = [];
+      const objectProperties: ObjectPropertyInfo[] = [];
+      const arrayLiterals: ArrayLiteralInfo[] = [];
+      const arrayElements: ArrayElementInfo[] = [];
+      // Array mutation tracking for FLOWS_INTO edges
+      const arrayMutations: ArrayMutationInfo[] = [];
+      // Object mutation tracking for FLOWS_INTO edges
+      const objectMutations: ObjectMutationInfo[] = [];
 
       const ifScopeCounterRef: CounterRef = { value: 0 };
       const scopeCounterRef: CounterRef = { value: 0 };
@@ -749,6 +891,8 @@ export class JSASTAnalyzer extends Plugin {
       const httpRequestCounterRef: CounterRef = { value: 0 };
       const literalCounterRef: CounterRef = { value: 0 };
       const anonymousFunctionCounterRef: CounterRef = { value: 0 };
+      const objectLiteralCounterRef: CounterRef = { value: 0 };
+      const arrayLiteralCounterRef: CounterRef = { value: 0 };
 
       const processedNodes: ProcessedNodes = {
         functions: new Set(),
@@ -779,33 +923,37 @@ export class JSASTAnalyzer extends Plugin {
         module,
         { variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef },
         this.extractVariableNamesFromPattern.bind(this),
-        this.trackVariableAssignment.bind(this) as TrackVariableAssignmentCallback
+        this.trackVariableAssignment.bind(this) as TrackVariableAssignmentCallback,
+        scopeTracker  // Pass ScopeTracker for semantic ID generation
       );
       traverse(ast, variableVisitor.getHandlers());
       this.profiler.end('traverse_variables');
 
-      // Module-level scope context for consistent anonymous naming
-      const moduleScopeCtx: ScopeContext = {
-        semanticPath: module.name!,
-        siblingCounters: new Map()
-      };
-
       const allCollections: Collections = {
         functions, parameters, scopes, variableDeclarations, callSites, methodCalls,
         eventListeners, methodCallbacks, callArguments, classInstantiations, classDeclarations,
         httpRequests, literals, variableAssignments,
         // TypeScript-specific collections
         interfaces, typeAliases, enums, decorators,
+        // Object/Array literal tracking
+        objectLiterals, objectProperties, arrayLiterals, arrayElements,
+        // Array mutation tracking
+        arrayMutations,
+        // Object mutation tracking
+        objectMutations,
+        objectLiteralCounterRef, arrayLiteralCounterRef,
         ifScopeCounterRef, scopeCounterRef, varDeclCounterRef,
         callSiteCounterRef, functionCounterRef, httpRequestCounterRef,
         literalCounterRef, anonymousFunctionCounterRef, processedNodes,
-        imports, exports, moduleScopeCtx, code,
+        imports, exports, code,
         // VisitorCollections compatibility
         classes: classDeclarations,
         methods: [],
         variables: variableDeclarations,
         sideEffects: [],
-        variableCounterRef: varDeclCounterRef
+        variableCounterRef: varDeclCounterRef,
+        // ScopeTracker for semantic ID generation
+        scopeTracker
       };
 
       // Functions
@@ -813,7 +961,8 @@ export class JSASTAnalyzer extends Plugin {
       const functionVisitor = new FunctionVisitor(
         module,
         allCollections,
-        this.analyzeFunctionBody.bind(this)
+        this.analyzeFunctionBody.bind(this),
+        scopeTracker  // Pass ScopeTracker for semantic ID generation
       );
       traverse(ast, functionVisitor.getHandlers());
       this.profiler.end('traverse_functions');
@@ -841,22 +990,22 @@ export class JSASTAnalyzer extends Plugin {
             }
 
             const funcNode = assignNode.right;
-            const functionId = `FUNCTION#${functionName}#${module.file}#${assignNode.loc!.start.line}:${assignNode.loc!.start.column}`;
+            // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+            const functionId = computeSemanticId('FUNCTION', functionName, scopeTracker.getContext());
 
             functions.push({
               id: functionId,
-              stableId: functionId,
               type: 'FUNCTION',
               name: functionName,
               file: module.file,
-              line: assignNode.loc!.start.line,
-              column: assignNode.loc!.start.column,
+              line: getLine(assignNode),
+              column: getColumn(assignNode),
               async: funcNode.async || false,
               generator: funcNode.type === 'FunctionExpression' ? funcNode.generator : false,
               isAssignment: true
             });
 
-            const funcBodyScopeId = `SCOPE#${functionName}:body#${module.file}#${assignNode.loc!.start.line}`;
+            const funcBodyScopeId = `SCOPE#${functionName}:body#${module.file}#${getLine(assignNode)}`;
             scopes.push({
               id: funcBodyScopeId,
               type: 'SCOPE',
@@ -865,18 +1014,22 @@ export class JSASTAnalyzer extends Plugin {
               semanticId: `${functionName}:function_body[0]`,
               conditional: false,
               file: module.file,
-              line: assignNode.loc!.start.line,
+              line: getLine(assignNode),
               parentFunctionId: functionId
             });
 
             const funcPath = assignPath.get('right') as NodePath<t.FunctionExpression | t.ArrowFunctionExpression>;
-            // Create scope context for analyzing the function body
-            const funcScopeCtx: ScopeContext = {
-              semanticPath: functionName,
-              siblingCounters: new Map()
-            };
-            this.analyzeFunctionBody(funcPath, funcBodyScopeId, module, allCollections, funcScopeCtx);
+            // Enter function scope for semantic ID generation and analyze
+            scopeTracker.enterScope(functionName, 'function');
+            this.analyzeFunctionBody(funcPath, funcBodyScopeId, module, allCollections);
+            scopeTracker.exitScope();
           }
+
+          // Check for indexed array assignment at module level: arr[i] = value
+          this.detectIndexedArrayAssignment(assignNode, module, arrayMutations);
+
+          // Check for object property assignment at module level: obj.prop = value
+          this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
         }
       });
       this.profiler.end('traverse_assignments');
@@ -886,14 +1039,15 @@ export class JSASTAnalyzer extends Plugin {
       const classVisitor = new ClassVisitor(
         module,
         allCollections,
-        this.analyzeFunctionBody.bind(this)
+        this.analyzeFunctionBody.bind(this),
+        scopeTracker  // Pass ScopeTracker for semantic ID generation
       );
       traverse(ast, classVisitor.getHandlers());
       this.profiler.end('traverse_classes');
 
       // TypeScript-specific constructs (interfaces, type aliases, enums)
       this.profiler.start('traverse_typescript');
-      const typescriptVisitor = new TypeScriptVisitor(module, allCollections);
+      const typescriptVisitor = new TypeScriptVisitor(module, allCollections, scopeTracker);
       traverse(ast, typescriptVisitor.getHandlers());
       this.profiler.end('traverse_typescript');
 
@@ -906,24 +1060,24 @@ export class JSASTAnalyzer extends Plugin {
           if (functionParent) return;
 
           if (funcPath.parent && funcPath.parent.type === 'CallExpression') {
-            const funcName = funcNode.id ? funcNode.id.name : this.generateAnonymousName(moduleScopeCtx);
-            const functionId = `FUNCTION#${funcName}#${module.file}#${funcNode.loc!.start.line}:${funcNode.loc!.start.column}`;
+            const funcName = funcNode.id ? funcNode.id.name : this.generateAnonymousName(scopeTracker);
+            // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+            const functionId = computeSemanticId('FUNCTION', funcName, scopeTracker.getContext());
 
             functions.push({
               id: functionId,
-              stableId: functionId,
               type: 'FUNCTION',
               name: funcName,
               file: module.file,
-              line: funcNode.loc!.start.line,
-              column: funcNode.loc!.start.column,
+              line: getLine(funcNode),
+              column: getColumn(funcNode),
               async: funcNode.async || false,
               generator: funcNode.generator || false,
               isCallback: true,
               parentScopeId: module.id
             });
 
-            const callbackScopeId = `SCOPE#${funcName}:body#${module.file}#${funcNode.loc!.start.line}`;
+            const callbackScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(funcNode)}`;
             scopes.push({
               id: callbackScopeId,
               type: 'SCOPE',
@@ -932,16 +1086,14 @@ export class JSASTAnalyzer extends Plugin {
               semanticId: `${funcName}:callback_body[0]`,
               conditional: false,
               file: module.file,
-              line: funcNode.loc!.start.line,
+              line: getLine(funcNode),
               parentFunctionId: functionId
             });
 
-            // Create scope context for analyzing the callback body
-            const callbackScopeCtx: ScopeContext = {
-              semanticPath: funcName,
-              siblingCounters: new Map()
-            };
-            this.analyzeFunctionBody(funcPath, callbackScopeId, module, allCollections, callbackScopeCtx);
+            // Enter callback scope for semantic ID generation and analyze
+            scopeTracker.enterScope(funcName, 'callback');
+            this.analyzeFunctionBody(funcPath, callbackScopeId, module, allCollections);
+            scopeTracker.exitScope();
             funcPath.skip();
           }
         }
@@ -950,7 +1102,7 @@ export class JSASTAnalyzer extends Plugin {
 
       // Call expressions
       this.profiler.start('traverse_calls');
-      const callExpressionVisitor = new CallExpressionVisitor(module, allCollections);
+      const callExpressionVisitor = new CallExpressionVisitor(module, allCollections, scopeTracker);
       traverse(ast, callExpressionVisitor.getHandlers());
       this.profiler.end('traverse_calls');
 
@@ -964,42 +1116,42 @@ export class JSASTAnalyzer extends Plugin {
           const ifNode = ifPath.node;
           const condition = code.substring(ifNode.test.start!, ifNode.test.end!) || 'condition';
           const counterId = ifScopeCounterRef.value++;
-          const ifScopeId = `SCOPE#if#${module.file}#${ifNode.loc!.start.line}:${ifNode.loc!.start.column}:${counterId}`;
+          const ifScopeId = `SCOPE#if#${module.file}#${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`;
 
           const constraints = ConditionParser.parse(ifNode.test);
-          const ifSemanticId = this.generateSemanticId('if_statement', moduleScopeCtx);
+          const ifSemanticId = this.generateSemanticId('if_statement', scopeTracker);
 
           scopes.push({
             id: ifScopeId,
             type: 'SCOPE',
             scopeType: 'if_statement',
-            name: `if:${ifNode.loc!.start.line}:${ifNode.loc!.start.column}:${counterId}`,
+            name: `if:${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`,
             semanticId: ifSemanticId,
             conditional: true,
             condition,
             constraints: constraints.length > 0 ? constraints : undefined,
             file: module.file,
-            line: ifNode.loc!.start.line,
+            line: getLine(ifNode),
             parentScopeId: module.id
           });
 
           if (ifNode.alternate && ifNode.alternate.type !== 'IfStatement') {
             const elseCounterId = ifScopeCounterRef.value++;
-            const elseScopeId = `SCOPE#else#${module.file}#${ifNode.alternate.loc!.start.line}:${ifNode.alternate.loc!.start.column}:${elseCounterId}`;
+            const elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
 
             const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
-            const elseSemanticId = this.generateSemanticId('else_statement', moduleScopeCtx);
+            const elseSemanticId = this.generateSemanticId('else_statement', scopeTracker);
 
             scopes.push({
               id: elseScopeId,
               type: 'SCOPE',
               scopeType: 'else_statement',
-              name: `else:${ifNode.alternate.loc!.start.line}:${ifNode.alternate.loc!.start.column}:${elseCounterId}`,
+              name: `else:${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`,
               semanticId: elseSemanticId,
               conditional: true,
               constraints: negatedConstraints,
               file: module.file,
-              line: ifNode.alternate.loc!.start.line,
+              line: getLine(ifNode.alternate),
               parentScopeId: module.id
             });
           }
@@ -1030,67 +1182,569 @@ export class JSASTAnalyzer extends Plugin {
         interfaces,
         typeAliases,
         enums,
-        decorators
+        decorators,
+        // Array mutation tracking
+        arrayMutations,
+        // Object mutation tracking
+        objectMutations,
+        // Object/Array literal tracking - use allCollections refs as visitors may have created new arrays
+        objectLiterals: allCollections.objectLiterals || objectLiterals,
+        arrayLiterals: allCollections.arrayLiterals || arrayLiterals
       });
       this.profiler.end('graph_build');
 
       nodesCreated = result.nodes;
       edgesCreated = result.edges;
 
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error(`[JSASTAnalyzer] Error analyzing ${module.file}:`, err.message);
-      console.error(err.stack);
+    } catch {
+      // Error analyzing module - silently skip, caller handles the result
     }
 
     return { nodes: nodesCreated, edges: edgesCreated };
   }
 
   /**
-   * Helper to generate semantic ID for a scope and update counters
+   * Helper to generate semantic ID for a scope using ScopeTracker.
+   * Format: "scopePath:scopeType[index]" e.g. "MyClass->myMethod:if_statement[0]"
    */
   private generateSemanticId(
     scopeType: string,
-    scopeCtx: ScopeContext | undefined
+    scopeTracker: ScopeTracker | undefined
   ): string | undefined {
-    if (!scopeCtx) return undefined;
+    if (!scopeTracker) return undefined;
+
+    const scopePath = scopeTracker.getScopePath();
+    const siblingIndex = scopeTracker.getItemCounter(`semanticId:${scopeType}`);
+    return `${scopePath}:${scopeType}[${siblingIndex}]`;
+  }
 
-    const siblingIndex = scopeCtx.siblingCounters.get(scopeType) || 0;
-    scopeCtx.siblingCounters.set(scopeType, siblingIndex + 1);
-    return `${scopeCtx.semanticPath}:${scopeType}[${siblingIndex}]`;
+  /**
+   * Generate a unique anonymous function name within the current scope.
+   * Uses ScopeTracker.getSiblingIndex() for stable naming.
+   */
+  private generateAnonymousName(scopeTracker: ScopeTracker | undefined): string {
+    if (!scopeTracker) return 'anonymous';
+    const index = scopeTracker.getSiblingIndex('anonymous');
+    return `anonymous[${index}]`;
   }
 
   /**
-   * Helper to create child scope context from a semantic ID
+   * Factory method to create loop scope handlers.
+   * All loop statements (for, for-in, for-of, while, do-while) follow the same pattern:
+   * 1. Create scope with SCOPE#<scopeType>#file#line:counter
+   * 2. Generate semantic ID
+   * 3. Push to scopes array
+   * 4. Enter/exit scope tracker
+   *
+   * @param trackerScopeType - Scope type for ScopeTracker (e.g., 'for', 'for-in', 'while')
+   * @param scopeType - Scope type for the graph node (e.g., 'for-loop', 'for-in-loop')
+   * @param parentScopeId - Parent scope ID for the scope node
+   * @param module - Module context
+   * @param scopes - Collection to push scope nodes to
+   * @param scopeCounterRef - Counter for unique scope IDs
+   * @param scopeTracker - Tracker for semantic ID generation
+   */
+
+  /**
+   * Handles VariableDeclaration nodes within function bodies.
+   *
+   * Extracts variable names from patterns (including destructuring), determines
+   * if the variable should be CONSTANT or VARIABLE, generates semantic or legacy IDs,
+   * and tracks class instantiations and variable assignments.
+   *
+   * @param varPath - The NodePath for the VariableDeclaration
+   * @param parentScopeId - Parent scope ID for the variable
+   * @param module - Module context with file info
+   * @param variableDeclarations - Collection to push variable declarations to
+   * @param classInstantiations - Collection to push class instantiations to
+   * @param literals - Collection for literal tracking
+   * @param variableAssignments - Collection for variable assignment tracking
+   * @param varDeclCounterRef - Counter for unique variable declaration IDs
+   * @param literalCounterRef - Counter for unique literal IDs
+   * @param scopeTracker - Tracker for semantic ID generation
+   * @param parentScopeVariables - Set to track variables for closure analysis
    */
-  private createChildScopeContext(semanticId: string | undefined): ScopeContext | undefined {
-    if (!semanticId) return undefined;
+  private handleVariableDeclaration(
+    varPath: NodePath<t.VariableDeclaration>,
+    parentScopeId: string,
+    module: VisitorModule,
+    variableDeclarations: VariableDeclarationInfo[],
+    classInstantiations: ClassInstantiationInfo[],
+    literals: LiteralInfo[],
+    variableAssignments: VariableAssignmentInfo[],
+    varDeclCounterRef: CounterRef,
+    literalCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined,
+    parentScopeVariables: Set<{ name: string; id: string; scopeId: string }>
+  ): void {
+    const varNode = varPath.node;
+    const isConst = varNode.kind === 'const';
+
+    varNode.declarations.forEach(declarator => {
+      const variables = this.extractVariableNamesFromPattern(declarator.id);
+
+      variables.forEach(varInfo => {
+        const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
+        const isLiteral = literalValue !== null;
+        const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
+
+        const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+        const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+
+        // Generate semantic ID (primary) or legacy ID (fallback)
+        const legacyId = `${nodeType}#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+
+        const varId = scopeTracker
+          ? computeSemanticId(nodeType, varInfo.name, scopeTracker.getContext())
+          : legacyId;
+
+        parentScopeVariables.add({
+          name: varInfo.name,
+          id: varId,
+          scopeId: parentScopeId
+        });
+
+        if (shouldBeConstant) {
+          const constantData: VariableDeclarationInfo = {
+            id: varId,
+            type: 'CONSTANT',
+            name: varInfo.name,
+            file: module.file,
+            line: varInfo.loc.start.line,
+            parentScopeId
+          };
+
+          if (isLiteral) {
+            constantData.value = literalValue;
+          }
+
+          variableDeclarations.push(constantData);
+
+          const init = declarator.init;
+          if (isNewExpression && t.isNewExpression(init) && t.isIdentifier(init.callee)) {
+            const className = init.callee.name;
+            classInstantiations.push({
+              variableId: varId,
+              variableName: varInfo.name,
+              className: className,
+              line: varInfo.loc.start.line,
+              parentScopeId
+            });
+          }
+        } else {
+          variableDeclarations.push({
+            id: varId,
+            type: 'VARIABLE',
+            name: varInfo.name,
+            file: module.file,
+            line: varInfo.loc.start.line,
+            parentScopeId
+          });
+        }
+
+        if (declarator.init) {
+          this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
+        }
+      });
+    });
+  }
+
+  private createLoopScopeHandler(
+    trackerScopeType: string,
+    scopeType: string,
+    parentScopeId: string,
+    module: VisitorModule,
+    scopes: ScopeInfo[],
+    scopeCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined
+  ): { enter: (path: NodePath<t.Loop>) => void; exit: () => void } {
     return {
-      semanticPath: semanticId,
-      siblingCounters: new Map()
+      enter: (path: NodePath<t.Loop>) => {
+        const node = path.node;
+        const scopeId = `SCOPE#${scopeType}#${module.file}#${getLine(node)}:${scopeCounterRef.value++}`;
+        const semanticId = this.generateSemanticId(scopeType, scopeTracker);
+        scopes.push({
+          id: scopeId,
+          type: 'SCOPE',
+          scopeType,
+          semanticId,
+          file: module.file,
+          line: getLine(node),
+          parentScopeId
+        });
+
+        // Enter scope for semantic ID generation
+        if (scopeTracker) {
+          scopeTracker.enterCountedScope(trackerScopeType);
+        }
+      },
+      exit: () => {
+        // Exit scope
+        if (scopeTracker) {
+          scopeTracker.exitScope();
+        }
+      }
     };
   }
 
   /**
-   * Generate a unique anonymous function name within the current scope
-   * Uses scopeCtx.siblingCounters to ensure stability across JS/TS versions
+   * Process VariableDeclarations within a try/catch/finally block.
+   * This is a simplified version that doesn't track parentScopeVariables or class instantiations.
+   *
+   * @param blockPath - The NodePath for the block to process
+   * @param blockScopeId - The scope ID for variables in this block
+   * @param module - Module context
+   * @param variableDeclarations - Collection to push variable declarations to
+   * @param literals - Collection for literal tracking
+   * @param variableAssignments - Collection for variable assignment tracking
+   * @param varDeclCounterRef - Counter for unique variable declaration IDs
+   * @param literalCounterRef - Counter for unique literal IDs
+   * @param scopeTracker - Tracker for semantic ID generation
    */
-  private generateAnonymousName(scopeCtx: ScopeContext | undefined): string {
-    if (!scopeCtx) return 'anonymous';
-    const index = scopeCtx.siblingCounters.get('anonymous') || 0;
-    scopeCtx.siblingCounters.set('anonymous', index + 1);
-    return `anonymous[${index}]`;
+  private processBlockVariables(
+    blockPath: NodePath,
+    blockScopeId: string,
+    module: VisitorModule,
+    variableDeclarations: VariableDeclarationInfo[],
+    literals: LiteralInfo[],
+    variableAssignments: VariableAssignmentInfo[],
+    varDeclCounterRef: CounterRef,
+    literalCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined
+  ): void {
+    blockPath.traverse({
+      VariableDeclaration: (varPath: NodePath<t.VariableDeclaration>) => {
+        const varNode = varPath.node;
+        const isConst = varNode.kind === 'const';
+
+        varNode.declarations.forEach(declarator => {
+          const variables = this.extractVariableNamesFromPattern(declarator.id);
+
+          variables.forEach(varInfo => {
+            const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
+            const isLiteral = literalValue !== null;
+            const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
+            const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+            const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+
+            const legacyId = `${nodeType}#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+            const varId = scopeTracker
+              ? computeSemanticId(nodeType, varInfo.name, scopeTracker.getContext())
+              : legacyId;
+
+            variableDeclarations.push({
+              id: varId,
+              type: nodeType,
+              name: varInfo.name,
+              file: module.file,
+              line: varInfo.loc.start.line,
+              parentScopeId: blockScopeId
+            });
+
+            if (declarator.init) {
+              this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
+            }
+          });
+        });
+      }
+    });
+  }
+
+  /**
+   * Handles TryStatement nodes within function bodies.
+   * Creates try, catch (with optional error parameter), and finally scopes,
+   * and processes variable declarations within each block.
+   *
+   * @param tryPath - The NodePath for the TryStatement
+   * @param parentScopeId - Parent scope ID for the scope nodes
+   * @param module - Module context
+   * @param scopes - Collection to push scope nodes to
+   * @param variableDeclarations - Collection to push variable declarations to
+   * @param literals - Collection for literal tracking
+   * @param variableAssignments - Collection for variable assignment tracking
+   * @param scopeCounterRef - Counter for unique scope IDs
+   * @param varDeclCounterRef - Counter for unique variable declaration IDs
+   * @param literalCounterRef - Counter for unique literal IDs
+   * @param scopeTracker - Tracker for semantic ID generation
+   */
+  private handleTryStatement(
+    tryPath: NodePath<t.TryStatement>,
+    parentScopeId: string,
+    module: VisitorModule,
+    scopes: ScopeInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    literals: LiteralInfo[],
+    variableAssignments: VariableAssignmentInfo[],
+    scopeCounterRef: CounterRef,
+    varDeclCounterRef: CounterRef,
+    literalCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined
+  ): void {
+    const tryNode = tryPath.node;
+
+    // Create and process try block
+    const tryScopeId = `SCOPE#try-block#${module.file}#${getLine(tryNode)}:${scopeCounterRef.value++}`;
+    const trySemanticId = this.generateSemanticId('try-block', scopeTracker);
+    scopes.push({
+      id: tryScopeId,
+      type: 'SCOPE',
+      scopeType: 'try-block',
+      semanticId: trySemanticId,
+      file: module.file,
+      line: getLine(tryNode),
+      parentScopeId
+    });
+
+    if (scopeTracker) {
+      scopeTracker.enterCountedScope('try');
+    }
+    this.processBlockVariables(
+      tryPath.get('block'),
+      tryScopeId,
+      module,
+      variableDeclarations,
+      literals,
+      variableAssignments,
+      varDeclCounterRef,
+      literalCounterRef,
+      scopeTracker
+    );
+    if (scopeTracker) {
+      scopeTracker.exitScope();
+    }
+
+    // Create and process catch block if present
+    if (tryNode.handler) {
+      const catchBlock = tryNode.handler;
+      const catchScopeId = `SCOPE#catch-block#${module.file}#${getLine(catchBlock)}:${scopeCounterRef.value++}`;
+      const catchSemanticId = this.generateSemanticId('catch-block', scopeTracker);
+
+      scopes.push({
+        id: catchScopeId,
+        type: 'SCOPE',
+        scopeType: 'catch-block',
+        semanticId: catchSemanticId,
+        file: module.file,
+        line: getLine(catchBlock),
+        parentScopeId
+      });
+
+      if (scopeTracker) {
+        scopeTracker.enterCountedScope('catch');
+      }
+
+      // Handle catch parameter (e.g., catch (e))
+      if (catchBlock.param) {
+        const errorVarInfo = this.extractVariableNamesFromPattern(catchBlock.param);
+
+        errorVarInfo.forEach(varInfo => {
+          const legacyId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+          const varId = scopeTracker
+            ? computeSemanticId('VARIABLE', varInfo.name, scopeTracker.getContext())
+            : legacyId;
+
+          variableDeclarations.push({
+            id: varId,
+            type: 'VARIABLE',
+            name: varInfo.name,
+            file: module.file,
+            line: varInfo.loc.start.line,
+            parentScopeId: catchScopeId
+          });
+        });
+      }
+
+      this.processBlockVariables(
+        tryPath.get('handler.body'),
+        catchScopeId,
+        module,
+        variableDeclarations,
+        literals,
+        variableAssignments,
+        varDeclCounterRef,
+        literalCounterRef,
+        scopeTracker
+      );
+
+      if (scopeTracker) {
+        scopeTracker.exitScope();
+      }
+    }
+
+    // Create and process finally block if present
+    if (tryNode.finalizer) {
+      const finallyScopeId = `SCOPE#finally-block#${module.file}#${getLine(tryNode.finalizer)}:${scopeCounterRef.value++}`;
+      const finallySemanticId = this.generateSemanticId('finally-block', scopeTracker);
+
+      scopes.push({
+        id: finallyScopeId,
+        type: 'SCOPE',
+        scopeType: 'finally-block',
+        semanticId: finallySemanticId,
+        file: module.file,
+        line: getLine(tryNode.finalizer),
+        parentScopeId
+      });
+
+      if (scopeTracker) {
+        scopeTracker.enterCountedScope('finally');
+      }
+
+      const finalizerPath = tryPath.get('finalizer');
+      if (finalizerPath.node) {
+        this.processBlockVariables(
+          finalizerPath as NodePath,
+          finallyScopeId,
+          module,
+          variableDeclarations,
+          literals,
+          variableAssignments,
+          varDeclCounterRef,
+          literalCounterRef,
+          scopeTracker
+        );
+      }
+
+      if (scopeTracker) {
+        scopeTracker.exitScope();
+      }
+    }
+
+    tryPath.skip();
+  }
+
+  /**
+   * Factory method to create IfStatement handler.
+   * Creates if scope with condition parsing and optional else scope.
+   * Tracks if/else scope transitions via ifElseScopeMap.
+   *
+   * @param parentScopeId - Parent scope ID for the scope nodes
+   * @param module - Module context
+   * @param scopes - Collection to push scope nodes to
+   * @param ifScopeCounterRef - Counter for unique if scope IDs
+   * @param scopeTracker - Tracker for semantic ID generation
+   * @param sourceCode - Source code for extracting condition text
+   * @param ifElseScopeMap - Map to track if/else scope transitions
+   */
+  private createIfStatementHandler(
+    parentScopeId: string,
+    module: VisitorModule,
+    scopes: ScopeInfo[],
+    ifScopeCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined,
+    sourceCode: string,
+    ifElseScopeMap: Map<t.IfStatement, { inElse: boolean; hasElse: boolean }>
+  ): { enter: (ifPath: NodePath<t.IfStatement>) => void; exit: (ifPath: NodePath<t.IfStatement>) => void } {
+    return {
+      enter: (ifPath: NodePath<t.IfStatement>) => {
+        const ifNode = ifPath.node;
+        const condition = sourceCode.substring(ifNode.test.start!, ifNode.test.end!) || 'condition';
+        const counterId = ifScopeCounterRef.value++;
+        const ifScopeId = `SCOPE#if#${module.file}#${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`;
+
+        // Parse condition to extract constraints
+        const constraints = ConditionParser.parse(ifNode.test);
+        const ifSemanticId = this.generateSemanticId('if_statement', scopeTracker);
+
+        scopes.push({
+          id: ifScopeId,
+          type: 'SCOPE',
+          scopeType: 'if_statement',
+          name: `if:${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`,
+          semanticId: ifSemanticId,
+          conditional: true,
+          condition,
+          constraints: constraints.length > 0 ? constraints : undefined,
+          file: module.file,
+          line: getLine(ifNode),
+          parentScopeId
+        });
+
+        // Enter scope for semantic ID generation
+        if (scopeTracker) {
+          scopeTracker.enterCountedScope('if');
+        }
+
+        // Handle else branch if present
+        if (ifNode.alternate && !t.isIfStatement(ifNode.alternate)) {
+          // Only create else scope for actual else block, not else-if
+          const elseCounterId = ifScopeCounterRef.value++;
+          const elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
+
+          const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
+          const elseSemanticId = this.generateSemanticId('else_statement', scopeTracker);
+
+          scopes.push({
+            id: elseScopeId,
+            type: 'SCOPE',
+            scopeType: 'else_statement',
+            name: `else:${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`,
+            semanticId: elseSemanticId,
+            conditional: true,
+            constraints: negatedConstraints,
+            file: module.file,
+            line: getLine(ifNode.alternate),
+            parentScopeId
+          });
+
+          // Store info to switch to else scope when we enter alternate
+          ifElseScopeMap.set(ifNode, { inElse: false, hasElse: true });
+        } else {
+          ifElseScopeMap.set(ifNode, { inElse: false, hasElse: false });
+        }
+      },
+      exit: (ifPath: NodePath<t.IfStatement>) => {
+        const ifNode = ifPath.node;
+
+        // Exit the current scope (either if or else)
+        if (scopeTracker) {
+          scopeTracker.exitScope();
+        }
+
+        // If we were in else, we already exited else scope
+        // If we only had if, we exit if scope (done above)
+        ifElseScopeMap.delete(ifNode);
+      }
+    };
+  }
+
+  /**
+   * Factory method to create BlockStatement handler for tracking if/else transitions.
+   * When entering an else block, switches scope from if to else.
+   *
+   * @param scopeTracker - Tracker for semantic ID generation
+   * @param ifElseScopeMap - Map to track if/else scope transitions
+   */
+  private createIfElseBlockStatementHandler(
+    scopeTracker: ScopeTracker | undefined,
+    ifElseScopeMap: Map<t.IfStatement, { inElse: boolean; hasElse: boolean }>
+  ): { enter: (blockPath: NodePath<t.BlockStatement>) => void } {
+    return {
+      enter: (blockPath: NodePath<t.BlockStatement>) => {
+        // Check if this block is the alternate of an IfStatement
+        const parent = blockPath.parent;
+        if (t.isIfStatement(parent) && parent.alternate === blockPath.node) {
+          const scopeInfo = ifElseScopeMap.get(parent);
+          if (scopeInfo && scopeInfo.hasElse && !scopeInfo.inElse && scopeTracker) {
+            // Exit if scope, enter else scope
+            scopeTracker.exitScope();
+            scopeTracker.enterCountedScope('else');
+            scopeInfo.inElse = true;
+          }
+        }
+      }
+    };
   }
 
   /**
-   * Анализирует тело функции и извлекает переменные, вызовы, условные блоки
+   * Анализирует тело функции и извлекает переменные, вызовы, условные блоки.
+   * Uses ScopeTracker from collections for semantic ID generation.
    */
   analyzeFunctionBody(
     funcPath: NodePath<t.Function>,
     parentScopeId: string,
     module: VisitorModule,
-    collections: VisitorCollections,
-    scopeCtx?: ScopeContext
+    collections: VisitorCollections
   ): void {
     // Extract with defaults for optional properties
     const functions = (collections.functions ?? []) as FunctionInfo[];
@@ -1112,6 +1766,7 @@ export class JSASTAnalyzer extends Plugin {
     const httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 }) as CounterRef;
     const literalCounterRef = (collections.literalCounterRef ?? { value: 0 }) as CounterRef;
     const anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 }) as CounterRef;
+    const scopeTracker = collections.scopeTracker as ScopeTracker | undefined;
     const processedNodes = collections.processedNodes ?? {
       functions: new Set<string>(),
       classes: new Set<string>(),
@@ -1131,219 +1786,75 @@ export class JSASTAnalyzer extends Plugin {
     const processedMethodCalls = processedNodes.methodCalls;
     const processedEventListeners = processedNodes.eventListeners;
 
+    // Track if/else scope transitions
+    const ifElseScopeMap = new Map<t.IfStatement, { inElse: boolean; hasElse: boolean }>();
+
     funcPath.traverse({
       VariableDeclaration: (varPath: NodePath<t.VariableDeclaration>) => {
-        const varNode = varPath.node;
-        const isConst = varNode.kind === 'const';
+        this.handleVariableDeclaration(
+          varPath,
+          parentScopeId,
+          module,
+          variableDeclarations,
+          classInstantiations,
+          literals,
+          variableAssignments,
+          varDeclCounterRef,
+          literalCounterRef,
+          scopeTracker,
+          parentScopeVariables
+        );
+      },
 
-        varNode.declarations.forEach(declarator => {
-          const variables = this.extractVariableNamesFromPattern(declarator.id);
+      // Detect indexed array assignments: arr[i] = value
+      AssignmentExpression: (assignPath: NodePath<t.AssignmentExpression>) => {
+        const assignNode = assignPath.node;
 
-          variables.forEach(varInfo => {
-            const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
-            const isLiteral = literalValue !== null;
-            const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
+        // Initialize collection if not exists
+        if (!collections.arrayMutations) {
+          collections.arrayMutations = [];
+        }
+        const arrayMutations = collections.arrayMutations as ArrayMutationInfo[];
 
-            const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+        // Check for indexed array assignment: arr[i] = value
+        this.detectIndexedArrayAssignment(assignNode, module, arrayMutations);
 
-            const varId = shouldBeConstant
-              ? `CONSTANT#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`
-              : `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+        // Initialize object mutations collection if not exists
+        if (!collections.objectMutations) {
+          collections.objectMutations = [];
+        }
+        const objectMutations = collections.objectMutations as ObjectMutationInfo[];
 
-            parentScopeVariables.add({
-              name: varInfo.name,
-              id: varId,
-              scopeId: parentScopeId
-            });
-
-            if (shouldBeConstant) {
-              const constantData: VariableDeclarationInfo = {
-                id: varId,
-                type: 'CONSTANT',
-                name: varInfo.name,
-                file: module.file,
-                line: varInfo.loc.start.line,
-                parentScopeId
-              };
-
-              if (isLiteral) {
-                constantData.value = literalValue;
-              }
-
-              variableDeclarations.push(constantData);
-
-              const init = declarator.init;
-              if (isNewExpression && t.isNewExpression(init) && t.isIdentifier(init.callee)) {
-                const className = init.callee.name;
-                classInstantiations.push({
-                  variableId: varId,
-                  variableName: varInfo.name,
-                  className: className,
-                  line: varInfo.loc.start.line,
-                  parentScopeId
-                });
-              }
-            } else {
-              variableDeclarations.push({
-                id: varId,
-                type: 'VARIABLE',
-                name: varInfo.name,
-                file: module.file,
-                line: varInfo.loc.start.line,
-                parentScopeId
-              });
-            }
-
-            if (declarator.init) {
-              this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
-            }
-          });
-        });
-      },
-
-      ForStatement: (forPath: NodePath<t.ForStatement>) => {
-        const forNode = forPath.node;
-        const scopeId = `SCOPE#for-loop#${module.file}#${forNode.loc!.start.line}:${scopeCounterRef.value++}`;
-        const semanticId = this.generateSemanticId('for-loop', scopeCtx);
-        scopes.push({
-          id: scopeId,
-          type: 'SCOPE',
-          scopeType: 'for-loop',
-          semanticId,
-          file: module.file,
-          line: forNode.loc!.start.line,
-          parentScopeId
-        });
-      },
-
-      ForInStatement: (forPath: NodePath<t.ForInStatement>) => {
-        const forNode = forPath.node;
-        const scopeId = `SCOPE#for-in-loop#${module.file}#${forNode.loc!.start.line}:${scopeCounterRef.value++}`;
-        const semanticId = this.generateSemanticId('for-in-loop', scopeCtx);
-        scopes.push({
-          id: scopeId,
-          type: 'SCOPE',
-          scopeType: 'for-in-loop',
-          semanticId,
-          file: module.file,
-          line: forNode.loc!.start.line,
-          parentScopeId
-        });
+        // Check for object property assignment: obj.prop = value
+        this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
       },
 
-      ForOfStatement: (forPath: NodePath<t.ForOfStatement>) => {
-        const forNode = forPath.node;
-        const scopeId = `SCOPE#for-of-loop#${module.file}#${forNode.loc!.start.line}:${scopeCounterRef.value++}`;
-        const semanticId = this.generateSemanticId('for-of-loop', scopeCtx);
-        scopes.push({
-          id: scopeId,
-          type: 'SCOPE',
-          scopeType: 'for-of-loop',
-          semanticId,
-          file: module.file,
-          line: forNode.loc!.start.line,
-          parentScopeId
-        });
-      },
-
-      WhileStatement: (whilePath: NodePath<t.WhileStatement>) => {
-        const whileNode = whilePath.node;
-        const scopeId = `SCOPE#while-loop#${module.file}#${whileNode.loc!.start.line}:${scopeCounterRef.value++}`;
-        const semanticId = this.generateSemanticId('while-loop', scopeCtx);
-        scopes.push({
-          id: scopeId,
-          type: 'SCOPE',
-          scopeType: 'while-loop',
-          semanticId,
-          file: module.file,
-          line: whileNode.loc!.start.line,
-          parentScopeId
-        });
-      },
-
-      DoWhileStatement: (doPath: NodePath<t.DoWhileStatement>) => {
-        const doNode = doPath.node;
-        const scopeId = `SCOPE#do-while-loop#${module.file}#${doNode.loc!.start.line}:${scopeCounterRef.value++}`;
-        const semanticId = this.generateSemanticId('do-while-loop', scopeCtx);
-        scopes.push({
-          id: scopeId,
-          type: 'SCOPE',
-          scopeType: 'do-while-loop',
-          semanticId,
-          file: module.file,
-          line: doNode.loc!.start.line,
-          parentScopeId
-        });
-      },
+      ForStatement: this.createLoopScopeHandler('for', 'for-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+      ForInStatement: this.createLoopScopeHandler('for-in', 'for-in-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+      ForOfStatement: this.createLoopScopeHandler('for-of', 'for-of-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+      WhileStatement: this.createLoopScopeHandler('while', 'while-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+      DoWhileStatement: this.createLoopScopeHandler('do-while', 'do-while-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
 
       TryStatement: (tryPath: NodePath<t.TryStatement>) => {
-        const tryNode = tryPath.node;
-
-        const tryScopeId = `SCOPE#try-block#${module.file}#${tryNode.loc!.start.line}:${scopeCounterRef.value++}`;
-        const trySemanticId = this.generateSemanticId('try-block', scopeCtx);
-        scopes.push({
-          id: tryScopeId,
-          type: 'SCOPE',
-          scopeType: 'try-block',
-          semanticId: trySemanticId,
-          file: module.file,
-          line: tryNode.loc!.start.line,
-          parentScopeId
-        });
-
-        if (tryNode.handler) {
-          const catchBlock = tryNode.handler;
-          const catchScopeId = `SCOPE#catch-block#${module.file}#${catchBlock.loc!.start.line}:${scopeCounterRef.value++}`;
-          const catchSemanticId = this.generateSemanticId('catch-block', scopeCtx);
-
-          scopes.push({
-            id: catchScopeId,
-            type: 'SCOPE',
-            scopeType: 'catch-block',
-            semanticId: catchSemanticId,
-            file: module.file,
-            line: catchBlock.loc!.start.line,
-            parentScopeId
-          });
-
-          if (catchBlock.param) {
-            const errorVarInfo = this.extractVariableNamesFromPattern(catchBlock.param);
-
-            errorVarInfo.forEach(varInfo => {
-              const varId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
-
-              variableDeclarations.push({
-                id: varId,
-                type: 'VARIABLE',
-                name: varInfo.name,
-                file: module.file,
-                line: varInfo.loc.start.line,
-                parentScopeId: catchScopeId
-              });
-            });
-          }
-        }
-
-        if (tryNode.finalizer) {
-          const finallyScopeId = `SCOPE#finally-block#${module.file}#${tryNode.finalizer.loc!.start.line}:${scopeCounterRef.value++}`;
-          const finallySemanticId = this.generateSemanticId('finally-block', scopeCtx);
-
-          scopes.push({
-            id: finallyScopeId,
-            type: 'SCOPE',
-            scopeType: 'finally-block',
-            semanticId: finallySemanticId,
-            file: module.file,
-            line: tryNode.finalizer.loc!.start.line,
-            parentScopeId
-          });
-        }
+        this.handleTryStatement(
+          tryPath,
+          parentScopeId,
+          module,
+          scopes,
+          variableDeclarations,
+          literals,
+          variableAssignments,
+          scopeCounterRef,
+          varDeclCounterRef,
+          literalCounterRef,
+          scopeTracker
+        );
       },
 
       SwitchStatement: (switchPath: NodePath<t.SwitchStatement>) => {
         const switchNode = switchPath.node;
-        const scopeId = `SCOPE#switch-case#${module.file}#${switchNode.loc!.start.line}:${scopeCounterRef.value++}`;
-        const semanticId = this.generateSemanticId('switch-case', scopeCtx);
+        const scopeId = `SCOPE#switch-case#${module.file}#${getLine(switchNode)}:${scopeCounterRef.value++}`;
+        const semanticId = this.generateSemanticId('switch-case', scopeTracker);
 
         scopes.push({
           id: scopeId,
@@ -1351,31 +1862,34 @@ export class JSASTAnalyzer extends Plugin {
           scopeType: 'switch-case',
           semanticId,
           file: module.file,
-          line: switchNode.loc!.start.line,
+          line: getLine(switchNode),
           parentScopeId
         });
       },
 
       FunctionExpression: (funcPath: NodePath<t.FunctionExpression>) => {
         const node = funcPath.node;
-        const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeCtx);
-        const functionId = `FUNCTION#${funcName}#${module.file}#${node.loc!.start.line}:${node.loc!.start.column}:${functionCounterRef.value++}`;
+        const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeTracker);
+        // Use semantic ID as primary ID when scopeTracker available
+        const legacyId = `FUNCTION#${funcName}#${module.file}#${getLine(node)}:${getColumn(node)}:${functionCounterRef.value++}`;
+        const functionId = scopeTracker
+          ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
+          : legacyId;
 
         functions.push({
           id: functionId,
-          stableId: functionId,
           type: 'FUNCTION',
           name: funcName,
           file: module.file,
-          line: node.loc!.start.line,
-          column: node.loc!.start.column,
+          line: getLine(node),
+          column: getColumn(node),
           async: node.async || false,
           generator: node.generator || false,
           parentScopeId
         });
 
-        const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${node.loc!.start.line}`;
-        const closureSemanticId = this.generateSemanticId('closure', scopeCtx);
+        const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(node)}`;
+        const closureSemanticId = this.generateSemanticId('closure', scopeTracker);
         scopes.push({
           id: nestedScopeId,
           type: 'SCOPE',
@@ -1384,24 +1898,26 @@ export class JSASTAnalyzer extends Plugin {
           semanticId: closureSemanticId,
           conditional: false,
           file: module.file,
-          line: node.loc!.start.line,
+          line: getLine(node),
           parentFunctionId: functionId,
           capturesFrom: parentScopeId
         });
 
-        // For nested function, create new context with function name as semantic path
-        const nestedFuncCtx: ScopeContext = {
-          semanticPath: scopeCtx ? `${scopeCtx.semanticPath}.${funcName}` : funcName,
-          siblingCounters: new Map()
-        };
-        this.analyzeFunctionBody(funcPath, nestedScopeId, module, collections, nestedFuncCtx);
+        // Enter nested function scope for semantic ID generation
+        if (scopeTracker) {
+          scopeTracker.enterScope(funcName, 'function');
+        }
+        this.analyzeFunctionBody(funcPath, nestedScopeId, module, collections);
+        if (scopeTracker) {
+          scopeTracker.exitScope();
+        }
         funcPath.skip();
       },
 
       ArrowFunctionExpression: (arrowPath: NodePath<t.ArrowFunctionExpression>) => {
         const node = arrowPath.node;
-        const line = node.loc!.start.line;
-        const column = node.loc!.start.column;
+        const line = getLine(node);
+        const column = getColumn(node);
 
         // Определяем имя (anonymous если не присвоено переменной)
         const parent = arrowPath.parent;
@@ -1410,14 +1926,17 @@ export class JSASTAnalyzer extends Plugin {
           funcName = parent.id.name;
         } else {
           // Используем scope-level счётчик для стабильного semanticId
-          funcName = this.generateAnonymousName(scopeCtx);
+          funcName = this.generateAnonymousName(scopeTracker);
         }
 
-        const functionId = `FUNCTION#${funcName}:${line}:${column}:${functionCounterRef.value++}`;
+        // Use semantic ID as primary ID when scopeTracker available
+        const legacyId = `FUNCTION#${funcName}:${line}:${column}:${functionCounterRef.value++}`;
+        const functionId = scopeTracker
+          ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
+          : legacyId;
 
         functions.push({
           id: functionId,
-          stableId: functionId,
           type: 'FUNCTION',
           name: funcName,
           file: module.file,
@@ -1430,7 +1949,7 @@ export class JSASTAnalyzer extends Plugin {
 
         if (node.body.type === 'BlockStatement') {
           const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${line}`;
-          const arrowSemanticId = this.generateSemanticId('arrow_body', scopeCtx);
+          const arrowSemanticId = this.generateSemanticId('arrow_body', scopeTracker);
           scopes.push({
             id: nestedScopeId,
             type: 'SCOPE',
@@ -1444,12 +1963,14 @@ export class JSASTAnalyzer extends Plugin {
             capturesFrom: parentScopeId
           });
 
-          // For arrow function, create new context with function name as semantic path
-          const arrowFuncCtx: ScopeContext = {
-            semanticPath: scopeCtx ? `${scopeCtx.semanticPath}.${funcName}` : funcName,
-            siblingCounters: new Map()
-          };
-          this.analyzeFunctionBody(arrowPath, nestedScopeId, module, collections, arrowFuncCtx);
+          // Enter arrow function scope for semantic ID generation
+          if (scopeTracker) {
+            scopeTracker.enterScope(funcName, 'arrow');
+          }
+          this.analyzeFunctionBody(arrowPath, nestedScopeId, module, collections);
+          if (scopeTracker) {
+            scopeTracker.exitScope();
+          }
         }
 
         arrowPath.skip();
@@ -1472,7 +1993,7 @@ export class JSASTAnalyzer extends Plugin {
               scope.modifies.push({
                 variableId: variable.id,
                 variableName: varName,
-                line: updateNode.loc!.start.line
+                line: getLine(updateNode)
               });
             }
           }
@@ -1480,201 +2001,660 @@ export class JSASTAnalyzer extends Plugin {
       },
 
       // IF statements - создаём условные scope и обходим содержимое для CALL узлов
-      IfStatement: (ifPath: NodePath<t.IfStatement>) => {
-        const ifNode = ifPath.node;
-        const sourceCode = collections.code ?? '';
-        const condition = sourceCode.substring(ifNode.test.start!, ifNode.test.end!) || 'condition';
-        const counterId = ifScopeCounterRef.value++;
-        const ifScopeId = `SCOPE#if#${module.file}#${ifNode.loc!.start.line}:${ifNode.loc!.start.column}:${counterId}`;
+      IfStatement: this.createIfStatementHandler(
+        parentScopeId,
+        module,
+        scopes,
+        ifScopeCounterRef,
+        scopeTracker,
+        collections.code ?? '',
+        ifElseScopeMap
+      ),
 
-        // Parse condition to extract constraints
-        const constraints = ConditionParser.parse(ifNode.test);
-        const ifSemanticId = this.generateSemanticId('if_statement', scopeCtx);
+      // Track when we enter the alternate (else) block of an IfStatement
+      BlockStatement: this.createIfElseBlockStatementHandler(scopeTracker, ifElseScopeMap),
 
-        scopes.push({
-          id: ifScopeId,
-          type: 'SCOPE',
-          scopeType: 'if_statement',
-          name: `if:${ifNode.loc!.start.line}:${ifNode.loc!.start.column}:${counterId}`,
-          semanticId: ifSemanticId,
-          conditional: true,
-          condition,
-          constraints: constraints.length > 0 ? constraints : undefined,
-          file: module.file,
-          line: ifNode.loc!.start.line,
-          parentScopeId
-        });
-
-        // Обходим содержимое if-блока (consequent)
-        ifPath.get('consequent').traverse({
-          CallExpression: (callPath: NodePath<t.CallExpression>) => {
-            const callNode = callPath.node;
-            if (callNode.callee.type === 'Identifier') {
-              const nodeKey = `${callNode.start}:${callNode.end}`;
-              if (processedCallSites.has(nodeKey)) {
-                return;
-              }
-              processedCallSites.add(nodeKey);
+      // Function call expressions
+      CallExpression: (callPath: NodePath<t.CallExpression>) => {
+        this.handleCallExpression(
+          callPath.node,
+          processedCallSites,
+          processedMethodCalls,
+          callSites,
+          methodCalls,
+          module,
+          callSiteCounterRef,
+          scopeTracker,
+          parentScopeId,
+          collections
+        );
+      },
 
-              callSites.push({
-                id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc!.start.line}:${callNode.loc!.start.column}:${callSiteCounterRef.value++}`,
-                type: 'CALL',
-                name: callNode.callee.name,
-                file: module.file,
-                line: callNode.loc!.start.line,
-                parentScopeId: ifScopeId,
-                targetFunctionName: callNode.callee.name
-              });
-            }
-          },
-          NewExpression: (newPath: NodePath<t.NewExpression>) => {
-            const newNode = newPath.node;
-            if (newNode.callee.type === 'Identifier') {
-              const nodeKey = `new:${newNode.start}:${newNode.end}`;
-              if (processedCallSites.has(nodeKey)) {
-                return;
-              }
-              processedCallSites.add(nodeKey);
+      // NewExpression (constructor calls)
+      NewExpression: (newPath: NodePath<t.NewExpression>) => {
+        const newNode = newPath.node;
 
-              callSites.push({
-                id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc!.start.line}:${newNode.loc!.start.column}:${callSiteCounterRef.value++}`,
-                type: 'CALL',
-                name: newNode.callee.name,
-                file: module.file,
-                line: newNode.loc!.start.line,
-                parentScopeId: ifScopeId,
-                targetFunctionName: newNode.callee.name,
-                isNew: true
-              });
-            }
+        // Handle simple constructor: new Foo()
+        if (newNode.callee.type === 'Identifier') {
+          const nodeKey = `new:${newNode.start}:${newNode.end}`;
+          if (processedCallSites.has(nodeKey)) {
+            return;
           }
-        });
+          processedCallSites.add(nodeKey);
 
-        // Handle else branch if present
-        if (ifNode.alternate) {
-          const elseCounterId = ifScopeCounterRef.value++;
-          const elseScopeId = `SCOPE#else#${module.file}#${ifNode.alternate.loc!.start.line}:${ifNode.alternate.loc!.start.column}:${elseCounterId}`;
+          // Generate semantic ID (primary) or legacy ID (fallback)
+          const constructorName = newNode.callee.name;
+          const legacyId = `CALL#new:${constructorName}#${module.file}#${getLine(newNode)}:${getColumn(newNode)}:${callSiteCounterRef.value++}`;
 
-          // Negate constraints for else branch
-          const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
-          const elseSemanticId = this.generateSemanticId('else_statement', scopeCtx);
+          let newCallId = legacyId;
+          if (scopeTracker) {
+            const discriminator = scopeTracker.getItemCounter(`CALL:new:${constructorName}`);
+            newCallId = computeSemanticId('CALL', `new:${constructorName}`, scopeTracker.getContext(), { discriminator });
+          }
 
-          scopes.push({
-            id: elseScopeId,
-            type: 'SCOPE',
-            scopeType: 'else_statement',
-            name: `else:${ifNode.alternate.loc!.start.line}:${ifNode.alternate.loc!.start.column}:${elseCounterId}`,
-            semanticId: elseSemanticId,
-            conditional: true,
-            constraints: negatedConstraints,
+          callSites.push({
+            id: newCallId,
+            type: 'CALL',
+            name: constructorName,
             file: module.file,
-            line: ifNode.alternate.loc!.start.line,
-            parentScopeId
+            line: getLine(newNode),
+            parentScopeId,
+            targetFunctionName: constructorName,
+            isNew: true
           });
+        }
+        // Handle namespaced constructor: new ns.Constructor()
+        else if (newNode.callee.type === 'MemberExpression') {
+          const memberCallee = newNode.callee;
+          const object = memberCallee.object;
+          const property = memberCallee.property;
 
-          // Traverse else block
-          ifPath.get('alternate').traverse({
-            CallExpression: (callPath: NodePath<t.CallExpression>) => {
-              const callNode = callPath.node;
-              if (callNode.callee.type === 'Identifier') {
-                const nodeKey = `${callNode.start}:${callNode.end}`;
-                if (processedCallSites.has(nodeKey)) {
-                  return;
-                }
-                processedCallSites.add(nodeKey);
-
-                callSites.push({
-                  id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc!.start.line}:${callNode.loc!.start.column}:${callSiteCounterRef.value++}`,
-                  type: 'CALL',
-                  name: callNode.callee.name,
-                  file: module.file,
-                  line: callNode.loc!.start.line,
-                  parentScopeId: elseScopeId,
-                  targetFunctionName: callNode.callee.name
-                });
-              }
-            },
-            NewExpression: (newPath: NodePath<t.NewExpression>) => {
-              const newNode = newPath.node;
-              if (newNode.callee.type === 'Identifier') {
-                const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                if (processedCallSites.has(nodeKey)) {
-                  return;
-                }
-                processedCallSites.add(nodeKey);
-
-                callSites.push({
-                  id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc!.start.line}:${newNode.loc!.start.column}:${callSiteCounterRef.value++}`,
-                  type: 'CALL',
-                  name: newNode.callee.name,
-                  file: module.file,
-                  line: newNode.loc!.start.line,
-                  parentScopeId: elseScopeId,
-                  targetFunctionName: newNode.callee.name,
-                  isNew: true
-                });
-              }
+          if (object.type === 'Identifier' && property.type === 'Identifier') {
+            const nodeKey = `new:${newNode.start}:${newNode.end}`;
+            if (processedMethodCalls.has(nodeKey)) {
+              return;
             }
-          });
-        }
+            processedMethodCalls.add(nodeKey);
 
-        // Останавливаем дальнейший обход, чтобы не обрабатывать вызовы дважды
-        ifPath.skip();
-      },
+            const objectName = object.name;
+            const constructorName = property.name;
+            const fullName = `${objectName}.${constructorName}`;
 
-      // Вызовы функций на безусловном уровне (вне if/for/while)
-      CallExpression: (callPath: NodePath<t.CallExpression>) => {
-        // Проверяем что вызов не внутри if/for/while (их мы обрабатываем отдельно)
-        const parent = callPath.parent;
-        if (parent.type !== 'IfStatement' && parent.type !== 'ForStatement' && parent.type !== 'WhileStatement') {
-          const callNode = callPath.node;
-
-          // Обычные вызовы функций (greet(), main())
-          if (callNode.callee.type === 'Identifier') {
-            const nodeKey = `${callNode.start}:${callNode.end}`;
-            if (processedCallSites.has(nodeKey)) {
-              return;
+            // Generate semantic ID for method-style constructor call
+            const legacyId = `CALL#new:${fullName}#${module.file}#${getLine(newNode)}:${getColumn(newNode)}:${callSiteCounterRef.value++}`;
+
+            let newMethodCallId = legacyId;
+            if (scopeTracker) {
+              const discriminator = scopeTracker.getItemCounter(`CALL:new:${fullName}`);
+              newMethodCallId = computeSemanticId('CALL', `new:${fullName}`, scopeTracker.getContext(), { discriminator });
             }
-            processedCallSites.add(nodeKey);
 
-            callSites.push({
-              id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc!.start.line}:${callNode.loc!.start.column}:${callSiteCounterRef.value++}`,
+            methodCalls.push({
+              id: newMethodCallId,
               type: 'CALL',
-              name: callNode.callee.name,
+              name: fullName,
+              object: objectName,
+              method: constructorName,
               file: module.file,
-              line: callNode.loc!.start.line,
+              line: getLine(newNode),
+              column: getColumn(newNode),
               parentScopeId,
-              targetFunctionName: callNode.callee.name
+              isNew: true
             });
           }
         }
-      },
+      }
+    });
+  }
 
-      // NewExpression на безусловном уровне
-      NewExpression: (newPath: NodePath<t.NewExpression>) => {
-        const parent = newPath.parent;
-        if (parent.type !== 'IfStatement' && parent.type !== 'ForStatement' && parent.type !== 'WhileStatement') {
-          const newNode = newPath.node;
-          if (newNode.callee.type === 'Identifier') {
-            const nodeKey = `new:${newNode.start}:${newNode.end}`;
-            if (processedCallSites.has(nodeKey)) {
-              return;
-            }
-            processedCallSites.add(nodeKey);
+  /**
+   * Handle CallExpression nodes: direct function calls (greet(), main())
+   * and method calls (obj.method(), data.process()).
+   *
+   * Handles:
+   * - Direct function calls (Identifier callee) → callSites collection
+   * - Method calls (MemberExpression callee) → methodCalls collection
+   * - Array mutation detection (push, unshift, splice)
+   * - Object.assign() detection
+   *
+   * @param callNode - The call expression AST node
+   * @param processedCallSites - Set of already processed call site keys to avoid duplicates
+   * @param processedMethodCalls - Set of already processed method call keys to avoid duplicates
+   * @param callSites - Collection for direct function calls
+   * @param methodCalls - Collection for method calls
+   * @param module - Current module being analyzed
+   * @param callSiteCounterRef - Counter for legacy ID generation
+   * @param scopeTracker - Optional scope tracker for semantic ID generation
+   * @param parentScopeId - ID of the parent scope containing this call
+   * @param collections - Full collections object for array/object mutations
+   */
+  private handleCallExpression(
+    callNode: t.CallExpression,
+    processedCallSites: Set<string>,
+    processedMethodCalls: Set<string>,
+    callSites: CallSiteInfo[],
+    methodCalls: MethodCallInfo[],
+    module: VisitorModule,
+    callSiteCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined,
+    parentScopeId: string,
+    collections: VisitorCollections
+  ): void {
+    // Handle direct function calls (greet(), main())
+    if (callNode.callee.type === 'Identifier') {
+      const nodeKey = `${callNode.start}:${callNode.end}`;
+      if (processedCallSites.has(nodeKey)) {
+        return;
+      }
+      processedCallSites.add(nodeKey);
 
-            callSites.push({
-              id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc!.start.line}:${newNode.loc!.start.column}:${callSiteCounterRef.value++}`,
-              type: 'CALL',
-              name: newNode.callee.name,
-              file: module.file,
-              line: newNode.loc!.start.line,
-              parentScopeId,
-              targetFunctionName: newNode.callee.name,
-              isNew: true
-            });
+      // Generate semantic ID (primary) or legacy ID (fallback)
+      const calleeName = callNode.callee.name;
+      const legacyId = `CALL#${calleeName}#${module.file}#${getLine(callNode)}:${getColumn(callNode)}:${callSiteCounterRef.value++}`;
+
+      let callId = legacyId;
+      if (scopeTracker) {
+        const discriminator = scopeTracker.getItemCounter(`CALL:${calleeName}`);
+        callId = computeSemanticId('CALL', calleeName, scopeTracker.getContext(), { discriminator });
+      }
+
+      callSites.push({
+        id: callId,
+        type: 'CALL',
+        name: calleeName,
+        file: module.file,
+        line: getLine(callNode),
+        parentScopeId,
+        targetFunctionName: calleeName
+      });
+    }
+    // Handle method calls (obj.method(), data.process())
+    else if (callNode.callee.type === 'MemberExpression') {
+      const memberCallee = callNode.callee;
+      const object = memberCallee.object;
+      const property = memberCallee.property;
+      const isComputed = memberCallee.computed;
+
+      if ((object.type === 'Identifier' || object.type === 'ThisExpression') && property.type === 'Identifier') {
+        const nodeKey = `${callNode.start}:${callNode.end}`;
+        if (processedMethodCalls.has(nodeKey)) {
+          return;
+        }
+        processedMethodCalls.add(nodeKey);
+
+        const objectName = object.type === 'Identifier' ? object.name : 'this';
+        const methodName = isComputed ? '<computed>' : property.name;
+        const fullName = `${objectName}.${methodName}`;
+
+        // Generate semantic ID (primary) or legacy ID (fallback)
+        const legacyId = `CALL#${fullName}#${module.file}#${getLine(callNode)}:${getColumn(callNode)}:${callSiteCounterRef.value++}`;
+
+        let methodCallId = legacyId;
+        if (scopeTracker) {
+          const discriminator = scopeTracker.getItemCounter(`CALL:${fullName}`);
+          methodCallId = computeSemanticId('CALL', fullName, scopeTracker.getContext(), { discriminator });
+        }
+
+        methodCalls.push({
+          id: methodCallId,
+          type: 'CALL',
+          name: fullName,
+          object: objectName,
+          method: methodName,
+          computed: isComputed,
+          computedPropertyVar: isComputed ? property.name : null,
+          file: module.file,
+          line: getLine(callNode),
+          column: getColumn(callNode),
+          parentScopeId
+        });
+
+        // Check for array mutation methods (push, unshift, splice)
+        const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+        if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+          // Initialize collection if not exists
+          if (!collections.arrayMutations) {
+            collections.arrayMutations = [];
           }
+          const arrayMutations = collections.arrayMutations as ArrayMutationInfo[];
+          this.detectArrayMutationInFunction(
+            callNode,
+            objectName,
+            methodName as 'push' | 'unshift' | 'splice',
+            module,
+            arrayMutations,
+            scopeTracker
+          );
+        }
+
+        // Check for Object.assign() calls
+        if (objectName === 'Object' && methodName === 'assign') {
+          // Initialize collection if not exists
+          if (!collections.objectMutations) {
+            collections.objectMutations = [];
+          }
+          const objectMutations = collections.objectMutations as ObjectMutationInfo[];
+          this.detectObjectAssignInFunction(
+            callNode,
+            module,
+            objectMutations,
+            scopeTracker
+          );
+        }
+      }
+      // REG-117: Nested array mutations like obj.arr.push(item)
+      // object is MemberExpression, property is the method name
+      else if (object.type === 'MemberExpression' && property.type === 'Identifier') {
+        const nestedMember = object;
+        const methodName = property.name;
+        const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+
+        if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+          // Extract base object and property from nested MemberExpression
+          const base = nestedMember.object;
+          const prop = nestedMember.property;
+
+          // Only handle single-level nesting: obj.arr.push() or this.items.push()
+          if ((base.type === 'Identifier' || base.type === 'ThisExpression') &&
+              !nestedMember.computed &&
+              prop.type === 'Identifier') {
+            const baseObjectName = base.type === 'Identifier' ? base.name : 'this';
+            const propertyName = prop.name;
+
+            // Initialize collection if not exists
+            if (!collections.arrayMutations) {
+              collections.arrayMutations = [];
+            }
+            const arrayMutations = collections.arrayMutations as ArrayMutationInfo[];
+
+            this.detectArrayMutationInFunction(
+              callNode,
+              `${baseObjectName}.${propertyName}`,  // arrayName for ID purposes
+              methodName as 'push' | 'unshift' | 'splice',
+              module,
+              arrayMutations,
+              scopeTracker,
+              true,          // isNested
+              baseObjectName,
+              propertyName
+            );
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Detect array mutation calls (push, unshift, splice) inside functions
+   * and collect mutation info for FLOWS_INTO edge creation in GraphBuilder
+   *
+   * REG-117: Added isNested, baseObjectName, propertyName for nested mutations
+   *
+   * @param callNode - The call expression node
+   * @param arrayName - Name of the array being mutated
+   * @param method - The mutation method (push, unshift, splice)
+   * @param module - Current module being analyzed
+   * @param arrayMutations - Collection to push mutation info into
+   * @param scopeTracker - Optional scope tracker for semantic IDs
+   * @param isNested - REG-117: true if this is a nested mutation (obj.arr.push)
+   * @param baseObjectName - REG-117: base object name for nested mutations
+   * @param propertyName - REG-117: property name for nested mutations
+   */
+  private detectArrayMutationInFunction(
+    callNode: t.CallExpression,
+    arrayName: string,
+    method: 'push' | 'unshift' | 'splice',
+    module: VisitorModule,
+    arrayMutations: ArrayMutationInfo[],
+    scopeTracker?: ScopeTracker,
+    isNested?: boolean,
+    baseObjectName?: string,
+    propertyName?: string
+  ): void {
+    const mutationArgs: ArrayMutationArgument[] = [];
+
+    // For splice, only arguments from index 2 onwards are insertions
+    // splice(start, deleteCount, item1, item2, ...)
+    callNode.arguments.forEach((arg, index) => {
+      // Skip start and deleteCount for splice
+      if (method === 'splice' && index < 2) return;
+
+      const argInfo: ArrayMutationArgument = {
+        argIndex: method === 'splice' ? index - 2 : index,
+        isSpread: arg.type === 'SpreadElement',
+        valueType: 'EXPRESSION'  // Default
+      };
+
+      let actualArg: t.Node = arg;
+      if (arg.type === 'SpreadElement') {
+        actualArg = arg.argument;
+      }
+
+      // Determine value type
+      const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
+      if (literalValue !== null) {
+        argInfo.valueType = 'LITERAL';
+        argInfo.literalValue = literalValue;
+      } else if (actualArg.type === 'Identifier') {
+        argInfo.valueType = 'VARIABLE';
+        argInfo.valueName = actualArg.name;
+      } else if (actualArg.type === 'ObjectExpression') {
+        argInfo.valueType = 'OBJECT_LITERAL';
+      } else if (actualArg.type === 'ArrayExpression') {
+        argInfo.valueType = 'ARRAY_LITERAL';
+      } else if (actualArg.type === 'CallExpression') {
+        argInfo.valueType = 'CALL';
+        argInfo.callLine = actualArg.loc?.start.line;
+        argInfo.callColumn = actualArg.loc?.start.column;
+      }
+
+      mutationArgs.push(argInfo);
+    });
+
+    // Only record if there are actual insertions
+    if (mutationArgs.length > 0) {
+      const line = callNode.loc?.start.line ?? 0;
+      const column = callNode.loc?.start.column ?? 0;
+
+      // Generate semantic ID for array mutation if scopeTracker available
+      let mutationId: string | undefined;
+      if (scopeTracker) {
+        const discriminator = scopeTracker.getItemCounter(`ARRAY_MUTATION:${arrayName}.${method}`);
+        mutationId = computeSemanticId('ARRAY_MUTATION', `${arrayName}.${method}`, scopeTracker.getContext(), { discriminator });
+      }
+
+      arrayMutations.push({
+        id: mutationId,
+        arrayName,
+        mutationMethod: method,
+        file: module.file,
+        line,
+        column,
+        insertedValues: mutationArgs,
+        // REG-117: Nested mutation fields
+        isNested,
+        baseObjectName,
+        propertyName
+      });
+    }
+  }
+
+  /**
+   * Detect indexed array assignment: arr[i] = value
+   * Creates ArrayMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+   *
+   * @param assignNode - The assignment expression node
+   * @param module - Current module being analyzed
+   * @param arrayMutations - Collection to push mutation info into
+   */
+  private detectIndexedArrayAssignment(
+    assignNode: t.AssignmentExpression,
+    module: VisitorModule,
+    arrayMutations: ArrayMutationInfo[]
+  ): void {
+    // Check for indexed array assignment: arr[i] = value
+    if (assignNode.left.type === 'MemberExpression' && assignNode.left.computed) {
+      const memberExpr = assignNode.left;
+
+      // Only process NumericLiteral keys - those are clearly array indexed assignments
+      // e.g., arr[0] = value, arr[1] = value
+      // All other computed keys (StringLiteral, Identifier, expressions) are handled as object mutations
+      // This avoids duplicate edge creation for ambiguous cases like obj[key] = value
+      if (memberExpr.property.type !== 'NumericLiteral') {
+        return;
+      }
+
+      // Get array name (only simple identifiers for now)
+      if (memberExpr.object.type === 'Identifier') {
+        const arrayName = memberExpr.object.name;
+        const value = assignNode.right;
+
+        const argInfo: ArrayMutationArgument = {
+          argIndex: 0,
+          isSpread: false,
+          valueType: 'EXPRESSION'
+        };
+
+        // Determine value type
+        const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+        if (literalValue !== null) {
+          argInfo.valueType = 'LITERAL';
+          argInfo.literalValue = literalValue;
+        } else if (value.type === 'Identifier') {
+          argInfo.valueType = 'VARIABLE';
+          argInfo.valueName = value.name;
+        } else if (value.type === 'ObjectExpression') {
+          argInfo.valueType = 'OBJECT_LITERAL';
+        } else if (value.type === 'ArrayExpression') {
+          argInfo.valueType = 'ARRAY_LITERAL';
+        } else if (value.type === 'CallExpression') {
+          argInfo.valueType = 'CALL';
+          argInfo.callLine = value.loc?.start.line;
+          argInfo.callColumn = value.loc?.start.column;
         }
+
+        // Use defensive loc checks instead of ! assertions
+        const line = assignNode.loc?.start.line ?? 0;
+        const column = assignNode.loc?.start.column ?? 0;
+
+        arrayMutations.push({
+          arrayName,
+          mutationMethod: 'indexed',
+          file: module.file,
+          line: line,
+          column: column,
+          insertedValues: [argInfo]
+        });
       }
+    }
+  }
+
+  /**
+   * Detect object property assignment: obj.prop = value, obj['prop'] = value
+   * Creates ObjectMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+   *
+   * @param assignNode - The assignment expression node
+   * @param module - Current module being analyzed
+   * @param objectMutations - Collection to push mutation info into
+   * @param scopeTracker - Optional scope tracker for semantic IDs
+   */
+  private detectObjectPropertyAssignment(
+    assignNode: t.AssignmentExpression,
+    module: VisitorModule,
+    objectMutations: ObjectMutationInfo[],
+    scopeTracker?: ScopeTracker
+  ): void {
+    // Check for property assignment: obj.prop = value or obj['prop'] = value
+    if (assignNode.left.type !== 'MemberExpression') return;
+
+    const memberExpr = assignNode.left;
+
+    // Skip NumericLiteral indexed assignment (handled by array mutation handler)
+    // Array mutation handler processes: arr[0] (numeric literal index)
+    // Object mutation handler processes: obj.prop, obj['prop'], obj[key], obj[expr]
+    if (memberExpr.computed && memberExpr.property.type === 'NumericLiteral') {
+      return; // Let array mutation handler deal with this
+    }
+
+    // Get object name and enclosing class context for 'this'
+    let objectName: string;
+    let enclosingClassName: string | undefined;
+
+    if (memberExpr.object.type === 'Identifier') {
+      objectName = memberExpr.object.name;
+    } else if (memberExpr.object.type === 'ThisExpression') {
+      objectName = 'this';
+      // REG-152: Extract enclosing class name from scope context
+      if (scopeTracker) {
+        enclosingClassName = scopeTracker.getEnclosingScope('CLASS');
+      }
+    } else {
+      // Complex expressions like obj.nested.prop = value
+      // For now, skip these (documented limitation)
+      return;
+    }
+
+    // Get property name
+    let propertyName: string;
+    let mutationType: 'property' | 'computed';
+    let computedPropertyVar: string | undefined;
+
+    if (!memberExpr.computed) {
+      // obj.prop
+      if (memberExpr.property.type === 'Identifier') {
+        propertyName = memberExpr.property.name;
+        mutationType = 'property';
+      } else {
+        return; // Unexpected property type
+      }
+    } else {
+      // obj['prop'] or obj[key]
+      if (memberExpr.property.type === 'StringLiteral') {
+        propertyName = memberExpr.property.value;
+        mutationType = 'property'; // String literal is effectively a property name
+      } else {
+        propertyName = '<computed>';
+        mutationType = 'computed';
+        // Capture variable name for later resolution in enrichment phase
+        if (memberExpr.property.type === 'Identifier') {
+          computedPropertyVar = memberExpr.property.name;
+        }
+      }
+    }
+
+    // Extract value info
+    const value = assignNode.right;
+    const valueInfo = this.extractMutationValue(value);
+
+    // Use defensive loc checks
+    const line = assignNode.loc?.start.line ?? 0;
+    const column = assignNode.loc?.start.column ?? 0;
+
+    // Generate semantic ID if scopeTracker available
+    let mutationId: string | undefined;
+    if (scopeTracker) {
+      const discriminator = scopeTracker.getItemCounter(`OBJECT_MUTATION:${objectName}.${propertyName}`);
+      mutationId = computeSemanticId('OBJECT_MUTATION', `${objectName}.${propertyName}`, scopeTracker.getContext(), { discriminator });
+    }
+
+    objectMutations.push({
+      id: mutationId,
+      objectName,
+      enclosingClassName,  // REG-152: Class name for 'this' mutations
+      propertyName,
+      mutationType,
+      computedPropertyVar,
+      file: module.file,
+      line,
+      column,
+      value: valueInfo
     });
   }
+
+  /**
+   * Extract value information from an expression for mutation tracking
+   */
+  private extractMutationValue(value: t.Expression): ObjectMutationValue {
+    const valueInfo: ObjectMutationValue = {
+      valueType: 'EXPRESSION'  // Default
+    };
+
+    const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+    if (literalValue !== null) {
+      valueInfo.valueType = 'LITERAL';
+      valueInfo.literalValue = literalValue;
+    } else if (value.type === 'Identifier') {
+      valueInfo.valueType = 'VARIABLE';
+      valueInfo.valueName = value.name;
+    } else if (value.type === 'ObjectExpression') {
+      valueInfo.valueType = 'OBJECT_LITERAL';
+    } else if (value.type === 'ArrayExpression') {
+      valueInfo.valueType = 'ARRAY_LITERAL';
+    } else if (value.type === 'CallExpression') {
+      valueInfo.valueType = 'CALL';
+      valueInfo.callLine = value.loc?.start.line;
+      valueInfo.callColumn = value.loc?.start.column;
+    }
+
+    return valueInfo;
+  }
+
+  /**
+   * Detect Object.assign() calls inside functions
+   * Creates ObjectMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+   */
+  private detectObjectAssignInFunction(
+    callNode: t.CallExpression,
+    module: VisitorModule,
+    objectMutations: ObjectMutationInfo[],
+    scopeTracker?: ScopeTracker
+  ): void {
+    // Need at least 2 arguments: target and at least one source
+    if (callNode.arguments.length < 2) return;
+
+    // First argument is target
+    const targetArg = callNode.arguments[0];
+    let targetName: string;
+
+    if (targetArg.type === 'Identifier') {
+      targetName = targetArg.name;
+    } else if (targetArg.type === 'ObjectExpression') {
+      targetName = '<anonymous>';
+    } else {
+      return;
+    }
+
+    const line = callNode.loc?.start.line ?? 0;
+    const column = callNode.loc?.start.column ?? 0;
+
+    for (let i = 1; i < callNode.arguments.length; i++) {
+      let arg = callNode.arguments[i];
+      let isSpread = false;
+
+      if (arg.type === 'SpreadElement') {
+        isSpread = true;
+        arg = arg.argument;
+      }
+
+      const valueInfo: ObjectMutationValue = {
+        valueType: 'EXPRESSION',
+        argIndex: i - 1,
+        isSpread
+      };
+
+      const literalValue = ExpressionEvaluator.extractLiteralValue(arg);
+      if (literalValue !== null) {
+        valueInfo.valueType = 'LITERAL';
+        valueInfo.literalValue = literalValue;
+      } else if (arg.type === 'Identifier') {
+        valueInfo.valueType = 'VARIABLE';
+        valueInfo.valueName = arg.name;
+      } else if (arg.type === 'ObjectExpression') {
+        valueInfo.valueType = 'OBJECT_LITERAL';
+      } else if (arg.type === 'ArrayExpression') {
+        valueInfo.valueType = 'ARRAY_LITERAL';
+      } else if (arg.type === 'CallExpression') {
+        valueInfo.valueType = 'CALL';
+        valueInfo.callLine = arg.loc?.start.line;
+        valueInfo.callColumn = arg.loc?.start.column;
+      }
+
+      let mutationId: string | undefined;
+      if (scopeTracker) {
+        const discriminator = scopeTracker.getItemCounter(`OBJECT_MUTATION:Object.assign:${targetName}`);
+        mutationId = computeSemanticId('OBJECT_MUTATION', `Object.assign:${targetName}`, scopeTracker.getContext(), { discriminator });
+      }
+
+      objectMutations.push({
+        id: mutationId,
+        objectName: targetName,
+        propertyName: '<assign>',
+        mutationType: 'assign',
+        file: module.file,
+        line,
+        column,
+        value: valueInfo
+      });
+    }
+  }
 }