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

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

@@ -19,7 +19,6 @@ export interface ModuleNode {
 // === FUNCTION INFO ===
 export interface FunctionInfo {
   id: string;
-  stableId: string;
   type: 'FUNCTION';
   name: string;
   file: string;
@@ -31,17 +30,21 @@ export interface FunctionInfo {
   isAssignment?: boolean;
   isCallback?: boolean;
   parentScopeId?: string;
+  controlFlow?: ControlFlowMetadata;
 }
 
 // === PARAMETER INFO ===
 export interface ParameterInfo {
   id: string;
+  semanticId?: string;  // Stable ID: file->scope->PARAMETER->name
   type: 'PARAMETER';
   name: string;
   file: string;
   line: number;
   index?: number;
-  functionId: string;
+  hasDefault?: boolean;  // Has default value (e.g., function(a = 1))
+  isRest?: boolean;      // Rest parameter (e.g., function(...args))
+  functionId?: string;   // Legacy field - prefer parentFunctionId
   parentFunctionId?: string;
 }
 
@@ -51,7 +54,7 @@ export interface ScopeInfo {
   type: 'SCOPE';
   scopeType: string;
   name?: string;
-  semanticId?: string;  // Stable ID for diff comparison (e.g., "MyClass.myMethod:if_statement[0]")
+  semanticId?: string;  // Stable ID for diff comparison (e.g., "MyClass->myMethod:if_statement[0]")
   conditional?: boolean;
   condition?: string;
   constraints?: unknown[];
@@ -63,9 +66,135 @@ export interface ScopeInfo {
   modifies?: Array<{ variableId: string; variableName: string; line: number }>;
 }
 
+// === BRANCH INFO ===
+export interface BranchInfo {
+  id: string;
+  semanticId?: string;
+  type: 'BRANCH';
+  branchType: 'switch' | 'if' | 'ternary';
+  file: string;
+  line: number;
+  parentScopeId?: string;
+  discriminantExpressionId?: string;  // ID of EXPRESSION node for discriminant
+  // Linus improvement: store discriminant metadata directly instead of parsing from ID
+  discriminantExpressionType?: string;
+  discriminantLine?: number;
+  discriminantColumn?: number;
+  // For else-if chains: the parent BRANCH id whose alternate this branch is
+  isAlternateOfBranchId?: string;
+  // For ternary: IDs of consequent and alternate expressions
+  consequentExpressionId?: string;
+  alternateExpressionId?: string;
+}
+
+// === CASE INFO ===
+export interface CaseInfo {
+  id: string;
+  semanticId?: string;
+  type: 'CASE';
+  value: unknown;
+  isDefault: boolean;
+  fallsThrough: boolean;
+  isEmpty: boolean;
+  file: string;
+  line: number;
+  parentBranchId: string;
+}
+
+// === LOOP INFO ===
+export interface LoopInfo {
+  id: string;
+  semanticId?: string;
+  type: 'LOOP';
+  loopType: 'for' | 'for-in' | 'for-of' | 'while' | 'do-while';
+  file: string;
+  line: number;
+  column?: number;
+  parentScopeId?: string;
+  // For for-in/for-of: the collection being iterated
+  iteratesOverName?: string;      // Variable name (e.g., 'items')
+  iteratesOverLine?: number;      // Line of collection reference
+  iteratesOverColumn?: number;    // Column of collection reference
+  // For while/do-while: condition expression (REG-280)
+  conditionExpressionId?: string;     // ID of EXPRESSION/CALL node for condition
+  conditionExpressionType?: string;   // 'Identifier', 'BinaryExpression', 'CallExpression', etc.
+  conditionLine?: number;             // Line of condition expression
+  conditionColumn?: number;           // Column of condition expression
+
+  // For classic for loop (REG-282): init, test, update expressions
+  // All three can be null (e.g., for (;;) {})
+
+  // Init: let i = 0 - points to VARIABLE node
+  initVariableName?: string;      // Variable name declared in init (e.g., 'i')
+  initLine?: number;              // Line of init declaration
+
+  // Test (condition): i < 10 - points to EXPRESSION node
+  testExpressionId?: string;      // ID of EXPRESSION node
+  testExpressionType?: string;    // 'BinaryExpression', 'Identifier', etc.
+  testLine?: number;
+  testColumn?: number;
+
+  // Update: i++ - points to EXPRESSION node
+  updateExpressionId?: string;    // ID of EXPRESSION node
+  updateExpressionType?: string;  // 'UpdateExpression', 'AssignmentExpression', etc.
+  updateLine?: number;
+  updateColumn?: number;
+
+  // For for-await-of (REG-284)
+  async?: boolean;                // true for for-await-of loops
+}
+
+// === TRY BLOCK INFO ===
+export interface TryBlockInfo {
+  id: string;
+  semanticId?: string;
+  type: 'TRY_BLOCK';
+  file: string;
+  line: number;
+  column?: number;
+  parentScopeId?: string;
+}
+
+// === CATCH BLOCK INFO ===
+export interface CatchBlockInfo {
+  id: string;
+  semanticId?: string;
+  type: 'CATCH_BLOCK';
+  file: string;
+  line: number;
+  column?: number;
+  parentScopeId?: string;
+  parentTryBlockId: string;  // ID of parent TRY_BLOCK
+  parameterName?: string;     // Error parameter name
+}
+
+// === FINALLY BLOCK INFO ===
+export interface FinallyBlockInfo {
+  id: string;
+  semanticId?: string;
+  type: 'FINALLY_BLOCK';
+  file: string;
+  line: number;
+  column?: number;
+  parentScopeId?: string;
+  parentTryBlockId: string;  // ID of parent TRY_BLOCK
+}
+
+// === CONTROL FLOW METADATA ===
+// Attached to FUNCTION nodes
+export interface ControlFlowMetadata {
+  hasBranches: boolean;      // Has if/switch statements
+  hasLoops: boolean;         // Has any loop type
+  hasTryCatch: boolean;      // Has try/catch blocks
+  hasEarlyReturn: boolean;   // Has return before function end
+  hasThrow: boolean;         // Has throw statements
+  cyclomaticComplexity: number;  // McCabe cyclomatic complexity
+}
+
 // === VARIABLE DECLARATION INFO ===
 export interface VariableDeclarationInfo {
   id: string;
+  semanticId?: string;  // Stable ID: file->scope->VARIABLE->name
   type: 'VARIABLE' | 'CONSTANT';
   name: string;
   file: string;
@@ -78,6 +207,7 @@ export interface VariableDeclarationInfo {
 // === CALL SITE INFO ===
 export interface CallSiteInfo {
   id: string;
+  semanticId?: string;  // Stable ID: file->scope->CALL->name#N
   type: 'CALL';
   name: string;
   file: string;
@@ -91,10 +221,13 @@ export interface CallSiteInfo {
 // === METHOD CALL INFO ===
 export interface MethodCallInfo {
   id: string;
+  semanticId?: string;  // Stable ID: file->scope->CALL->object.method#N
   type: 'CALL';
   name: string;
   object: string;
   method: string;
+  computed?: boolean;             // Whether method was accessed via computed property [x]
+  computedPropertyVar?: string | null;  // Variable name used in obj[x]() calls
   file: string;
   line: number;
   column?: number;
@@ -106,6 +239,7 @@ export interface MethodCallInfo {
 // === EVENT LISTENER INFO ===
 export interface EventListenerInfo {
   id: string;
+  semanticId?: string;  // Stable ID: file->scope->EVENT_LISTENER->name#N
   type: 'event:listener';
   name: string;
   object: string;
@@ -124,9 +258,21 @@ export interface ClassInstantiationInfo {
   parentScopeId?: string;
 }
 
+// === CONSTRUCTOR CALL INFO ===
+export interface ConstructorCallInfo {
+  id: string;
+  type: 'CONSTRUCTOR_CALL';
+  className: string;
+  isBuiltin: boolean;
+  file: string;
+  line: number;
+  column: number;
+}
+
 // === CLASS DECLARATION INFO ===
 export interface ClassDeclarationInfo {
   id: string;
+  semanticId?: string;  // Stable ID: file->scope->CLASS->name
   type: 'CLASS';
   name: string;
   file: string;
@@ -139,7 +285,12 @@ export interface ClassDeclarationInfo {
 
 // === INTERFACE DECLARATION INFO ===
 export interface InterfaceDeclarationInfo {
-  id: string;
+  /**
+   * @deprecated ID is now generated by InterfaceNode.create() in GraphBuilder.
+   * This field will be removed in a future version.
+   */
+  id?: string;
+  semanticId?: string;  // Stable ID: file->scope->INTERFACE->name
   type: 'INTERFACE';
   name: string;
   file: string;
@@ -158,7 +309,12 @@ export interface InterfacePropertyInfo {
 
 // === TYPE ALIAS INFO ===
 export interface TypeAliasInfo {
-  id: string;
+  /**
+   * @deprecated ID is now generated by NodeFactory.createType() in GraphBuilder.
+   * This field will be removed in a future version.
+   */
+  id?: string;
+  semanticId?: string;  // Stable ID: file->scope->TYPE->name
   type: 'TYPE';
   name: string;
   file: string;
@@ -169,7 +325,12 @@ export interface TypeAliasInfo {
 
 // === ENUM DECLARATION INFO ===
 export interface EnumDeclarationInfo {
-  id: string;
+  /**
+   * @deprecated ID is now generated by EnumNode.create() in GraphBuilder.
+   * This field will be removed in a future version.
+   */
+  id?: string;
+  semanticId?: string;  // Stable ID: file->scope->ENUM->name
   type: 'ENUM';
   name: string;
   file: string;
@@ -187,6 +348,7 @@ export interface EnumMemberInfo {
 // === DECORATOR INFO ===
 export interface DecoratorInfo {
   id: string;
+  semanticId?: string;  // Stable ID: file->target->DECORATOR->name#N
   type: 'DECORATOR';
   name: string;
   file: string;
@@ -214,6 +376,11 @@ export interface CallArgumentInfo {
   targetId?: string;
   targetName?: string;
   file?: string;
+  // REG-334: Additional fields for resolve/reject argument tracking
+  line?: number;
+  column?: number;
+  literalValue?: unknown;
+  expressionType?: string;
   isSpread?: boolean;
   functionLine?: number;
   functionColumn?: number;
@@ -229,7 +396,11 @@ export interface ImportInfo {
   source: string;
   file: string;
   line: number;
+  column?: number;  // Column position for ImportNode
   specifiers: ImportSpecifier[];
+  isDynamic?: boolean;         // true for dynamic import() expressions
+  isResolvable?: boolean;      // true if path is a string literal (statically analyzable)
+  dynamicPath?: string;        // original expression for template/variable paths
 }
 
 export interface ImportSpecifier {
@@ -267,6 +438,7 @@ export interface HttpRequestInfo {
 // === LITERAL INFO ===
 export interface LiteralInfo {
   id: string;
+  semanticId?: string;  // Stable ID: file->scope->LITERAL->type#N
   type: 'LITERAL' | 'CALL';
   value?: unknown;
   valueType?: string;
@@ -281,6 +453,207 @@ export interface LiteralInfo {
   argIndex?: number;
 }
 
+// === OBJECT LITERAL INFO ===
+export interface ObjectLiteralInfo {
+  id: string;
+  semanticId?: string;  // Stable ID: file->scope->OBJECT_LITERAL->literal#N
+  type: 'OBJECT_LITERAL';
+  file: string;
+  line: number;
+  column: number;
+  parentCallId?: string;
+  argIndex?: number;
+  isSpread?: boolean;
+}
+
+// === OBJECT PROPERTY INFO ===
+export interface ObjectPropertyInfo {
+  objectId: string;
+  propertyName: string;
+  valueNodeId?: string;
+  valueType: 'LITERAL' | 'VARIABLE' | 'CALL' | 'EXPRESSION' | 'OBJECT_LITERAL' | 'ARRAY_LITERAL' | 'SPREAD';
+  valueName?: string;       // For VARIABLE
+  literalValue?: unknown;   // For LITERAL
+  file: string;
+  line: number;
+  column: number;
+  // For CALL values
+  callLine?: number;
+  callColumn?: number;
+  // For nested object/array
+  nestedObjectId?: string;
+  nestedArrayId?: string;
+  // For VARIABLE values - scope path for scope-aware lookup (REG-329)
+  valueScopePath?: string[];
+}
+
+// === ARRAY LITERAL INFO ===
+export interface ArrayLiteralInfo {
+  id: string;
+  semanticId?: string;  // Stable ID: file->scope->ARRAY_LITERAL->literal#N
+  type: 'ARRAY_LITERAL';
+  file: string;
+  line: number;
+  column: number;
+  parentCallId?: string;
+  argIndex?: number;
+}
+
+// === ARRAY ELEMENT INFO ===
+export interface ArrayElementInfo {
+  arrayId: string;
+  index: number;
+  valueNodeId?: string;
+  valueType: 'LITERAL' | 'VARIABLE' | 'CALL' | 'EXPRESSION' | 'OBJECT_LITERAL' | 'ARRAY_LITERAL' | 'SPREAD';
+  valueName?: string;       // For VARIABLE
+  literalValue?: unknown;   // For LITERAL
+  file: string;
+  line: number;
+  column: number;
+  // For CALL values
+  callLine?: number;
+  callColumn?: number;
+  // For nested object/array
+  nestedObjectId?: string;
+  nestedArrayId?: string;
+}
+
+// === ARRAY MUTATION INFO ===
+/**
+ * Tracks array mutation calls (push, unshift, splice) and indexed assignments
+ * Used to create FLOWS_INTO edges in GraphBuilder
+ *
+ * IMPORTANT: This type is defined ONLY here. Import from this file everywhere.
+ */
+export interface ArrayMutationInfo {
+  id?: string;                 // Semantic ID for the mutation (optional for backward compatibility)
+  arrayName: string;           // Name of the array variable being mutated
+  arrayLine?: number;          // Line where array is referenced (for scope resolution)
+  mutationScopePath?: string[];  // Scope path where mutation happens (from ScopeTracker)
+  mutationMethod: 'push' | 'unshift' | 'splice' | 'indexed';
+  file: string;
+  line: number;
+  column: number;
+  insertedValues: ArrayMutationArgument[];  // What's being added to the array
+  isNested?: boolean;          // REG-117: true if receiver is MemberExpression
+  baseObjectName?: string;     // REG-117: "obj" from obj.arr.push()
+  propertyName?: string;       // REG-117: "arr" - the array property name
+}
+
+export interface ArrayMutationArgument {
+  argIndex: number;
+  isSpread?: boolean;
+  valueType: 'LITERAL' | 'VARIABLE' | 'CALL' | 'EXPRESSION' | 'OBJECT_LITERAL' | 'ARRAY_LITERAL';
+  valueName?: string;          // For VARIABLE type - name of the variable
+  valueNodeId?: string;        // For LITERAL, OBJECT_LITERAL, ARRAY_LITERAL - node ID
+  literalValue?: unknown;      // For LITERAL type
+  callLine?: number;           // For CALL type
+  callColumn?: number;
+}
+
+// === OBJECT MUTATION INFO ===
+/**
+ * Tracks object property mutations for FLOWS_INTO edge creation in GraphBuilder.
+ * Handles: obj.prop = value, obj['prop'] = value, Object.assign(), spread in object literals.
+ *
+ * IMPORTANT: This type is defined ONLY here. Import from this file everywhere.
+ */
+export interface ObjectMutationInfo {
+  id?: string;                   // Semantic ID for the mutation (optional for backward compatibility)
+  objectName: string;            // Name of the object being mutated ('config', 'this', etc.)
+  objectLine?: number;           // Line where object is referenced (for scope resolution)
+  mutationScopePath?: string[];  // Scope path where mutation happens (from ScopeTracker)
+  enclosingClassName?: string;   // Class name when objectName === 'this' (REG-152)
+  propertyName: string;          // Property name or '<computed>' for obj[x] or '<assign>' for Object.assign
+  mutationType: 'property' | 'computed' | 'assign' | 'spread';
+  computedPropertyVar?: string;  // Variable name in obj[key] = value (for computed mutation type)
+  file: string;
+  line: number;
+  column: number;
+  value: ObjectMutationValue;
+}
+
+export interface ObjectMutationValue {
+  valueType: 'LITERAL' | 'VARIABLE' | 'CALL' | 'EXPRESSION' | 'OBJECT_LITERAL' | 'ARRAY_LITERAL';
+  valueName?: string;            // For VARIABLE type - name of the variable
+  valueNodeId?: string;          // For LITERAL, OBJECT_LITERAL, ARRAY_LITERAL - node ID
+  literalValue?: unknown;        // For LITERAL type
+  callLine?: number;             // For CALL type
+  callColumn?: number;
+  isSpread?: boolean;            // For Object.assign with spread: Object.assign(target, ...sources)
+  argIndex?: number;             // For Object.assign - which source argument (0, 1, 2, ...)
+}
+
+// === RETURN STATEMENT INFO ===
+/**
+ * Tracks return statements for RETURNS edge creation in GraphBuilder.
+ * Used to connect returned expressions to their containing functions.
+ *
+ * Edge direction: returnExpression --RETURNS--> function
+ */
+export interface ReturnStatementInfo {
+  parentFunctionId: string;          // ID of the containing function
+  file: string;
+  line: number;
+  column: number;
+  // Return value type determines how to resolve the source node
+  returnValueType: 'VARIABLE' | 'CALL_SITE' | 'METHOD_CALL' | 'LITERAL' | 'EXPRESSION' | 'NONE';
+  // For VARIABLE type
+  returnValueName?: string;
+  // For LITERAL type - the literal node ID
+  returnValueId?: string;
+  // For CALL_SITE/METHOD_CALL type - coordinates for lookup
+  returnValueLine?: number;
+  returnValueColumn?: number;
+  returnValueCallName?: string;
+  // For EXPRESSION type (BinaryExpression, ConditionalExpression, etc.)
+  expressionType?: string;
+
+  // For EXPRESSION type - source variable extraction (REG-276)
+  // Mirrors VariableAssignmentInfo pattern for code reuse
+
+  // For BinaryExpression/LogicalExpression
+  operator?: string;
+  leftSourceName?: string;
+  rightSourceName?: string;
+
+  // For ConditionalExpression
+  consequentSourceName?: string;
+  alternateSourceName?: string;
+
+  // For MemberExpression
+  object?: string;
+  property?: string;
+  computed?: boolean;
+  objectSourceName?: string;
+
+  // For TemplateLiteral
+  expressionSourceNames?: string[];
+
+  // For UnaryExpression
+  unaryArgSourceName?: string;
+
+  // For arrow function implicit returns
+  isImplicitReturn?: boolean;
+}
+
+/**
+ * Resolution status for computed property names.
+ * Used in FLOWS_INTO edge metadata to indicate how property name was determined.
+ *
+ * - RESOLVED: Single deterministic value traced from literals
+ * - RESOLVED_CONDITIONAL: Multiple possible values (ternary, logical OR, etc.)
+ * - UNKNOWN_PARAMETER: Variable traces to function parameter
+ * - UNKNOWN_RUNTIME: Variable traces to function call result
+ * - DEFERRED_CROSS_FILE: Variable traces to import (requires cross-file analysis)
+ */
+export type ResolutionStatus =
+  | 'RESOLVED'
+  | 'RESOLVED_CONDITIONAL'
+  | 'UNKNOWN_PARAMETER'
+  | 'UNKNOWN_RUNTIME'
+  | 'DEFERRED_CROSS_FILE';
+
 // === VARIABLE ASSIGNMENT INFO ===
 export interface VariableAssignmentInfo {
   variableId: string;
@@ -296,6 +669,7 @@ export interface VariableAssignmentInfo {
   className?: string;
   functionName?: string;
   line?: number;
+  column?: number;  // Column position for EXPRESSION nodes
   expressionType?: string;
   object?: string;
   property?: string;
@@ -309,6 +683,165 @@ export interface VariableAssignmentInfo {
   alternateSourceName?: string | null;
   expressionSourceNames?: string[];
   file?: string;
+  // Destructuring support (REG-201)
+  path?: string;               // Full property path string, e.g., "req.headers.contentType"
+  baseName?: string;           // Base object name, e.g., "req"
+  propertyPath?: string[];     // Property path array, e.g., ["headers", "contentType"]
+  arrayIndex?: number;         // Array index for array destructuring, e.g., 0 for first element
+
+  // Call-based destructuring support (REG-223)
+  callSourceLine?: number;     // Line of the CallExpression
+  callSourceColumn?: number;   // Column of the CallExpression
+  callSourceFile?: string;     // File containing the call
+  callSourceName?: string;     // Function name (for lookup disambiguation)
+  sourceMetadata?: {
+    sourceType: 'call' | 'variable' | 'method-call';
+  };
+}
+
+// === VARIABLE REASSIGNMENT INFO ===
+/**
+ * Tracks variable reassignments for FLOWS_INTO edge creation.
+ * Used when a variable is assigned AFTER its declaration: x = y (not const x = y).
+ *
+ * Edge direction: value --FLOWS_INTO--> variable
+ *
+ * Supports:
+ * - Simple assignment: x = y
+ * - Compound operators: x += y, x -= y, x *= y, x /= y, x %= y, x **= y
+ * - Bitwise operators: x &= y, x |= y, x ^= y, x <<= y, x >>= y, x >>>= y
+ * - Logical operators: x &&= y, x ||= y, x ??= y
+ *
+ * For compound operators (operator !== '='), creates TWO edges:
+ * - READS_FROM: variable --READS_FROM--> variable (self-loop, reads current value)
+ * - FLOWS_INTO: source --FLOWS_INTO--> variable (writes new value)
+ *
+ * Distinction from VariableAssignmentInfo:
+ * - VariableAssignmentInfo: initialization (const x = y) -> ASSIGNED_FROM edge
+ * - VariableReassignmentInfo: mutation (x = y, x += y) -> FLOWS_INTO edge
+ */
+export interface VariableReassignmentInfo {
+  variableName: string;           // Name of variable being reassigned
+  variableLine: number;           // Line where variable is referenced on LHS
+  mutationScopePath?: string[];   // Scope path where mutation happens (from ScopeTracker)
+  valueType: 'VARIABLE' | 'CALL_SITE' | 'METHOD_CALL' | 'LITERAL' | 'EXPRESSION';
+  valueName?: string;             // For VARIABLE, CALL_SITE types
+  valueId?: string | null;        // For LITERAL, EXPRESSION types
+  callLine?: number;              // For CALL_SITE, METHOD_CALL types
+  callColumn?: number;
+  operator: string;               // '=', '+=', '-=', '*=', etc.
+
+  // For LITERAL type - complete metadata for node creation
+  literalValue?: unknown;         // Actual literal value (number, string, boolean, null)
+
+  // For EXPRESSION type - complete metadata for node creation
+  expressionType?: string;        // 'MemberExpression', 'BinaryExpression', 'ConditionalExpression', etc.
+  expressionMetadata?: {          // Type-specific metadata (matches VariableAssignmentInfo pattern)
+    // MemberExpression
+    object?: string;
+    property?: string;
+    computed?: boolean;
+    computedPropertyVar?: string | null;
+
+    // BinaryExpression, LogicalExpression
+    operator?: string;
+    leftSourceName?: string;
+    rightSourceName?: string;
+
+    // ConditionalExpression
+    consequentSourceName?: string;
+    alternateSourceName?: string;
+  };
+
+  file: string;
+  line: number;                   // Line of assignment statement
+  column: number;
+}
+
+// === UPDATE EXPRESSION INFO (i++, obj.prop++, arr[i]++) ===
+/**
+ * Information about update expressions (increment/decrement).
+ *
+ * Supports two target types:
+ * - IDENTIFIER: Simple variable (i++, --count)
+ * - MEMBER_EXPRESSION: Object property (obj.prop++, arr[i]++, this.count++)
+ *
+ * Creates:
+ * - UPDATE_EXPRESSION node with operator and target metadata
+ * - MODIFIES edge: UPDATE_EXPRESSION -> target (VARIABLE, PARAMETER, or CLASS)
+ * - READS_FROM self-loop: target -> target (reads current value before update)
+ * - CONTAINS edge: SCOPE -> UPDATE_EXPRESSION
+ *
+ * REG-288: Initial implementation for IDENTIFIER targets
+ * REG-312: Extended for MEMBER_EXPRESSION targets (obj.prop++, arr[i]++)
+ */
+export interface UpdateExpressionInfo {
+  // Common fields for all update expressions
+  operator: '++' | '--';          // Increment or decrement
+  prefix: boolean;                // ++i (true) vs i++ (false)
+  file: string;
+  line: number;                   // Line of update expression
+  column: number;
+  parentScopeId?: string;         // Containing scope for CONTAINS edge
+
+  // Discriminator: IDENTIFIER (i++) vs MEMBER_EXPRESSION (obj.prop++)
+  targetType: 'IDENTIFIER' | 'MEMBER_EXPRESSION';
+
+  // ===== IDENTIFIER fields (REG-288 behavior) =====
+  variableName?: string;          // Name of variable being modified (for i++)
+  variableLine?: number;          // Line where variable is referenced
+
+  // ===== MEMBER_EXPRESSION fields (REG-312 new) =====
+  objectName?: string;            // Object name ("obj" from obj.prop++, "this" from this.count++)
+  objectLine?: number;            // Line where object is referenced (for scope resolution)
+  enclosingClassName?: string;    // Class name when objectName === 'this' (follows REG-152 pattern)
+  propertyName?: string;          // Property name ("prop" from obj.prop++, "<computed>" for obj[key]++)
+  mutationType?: 'property' | 'computed';  // 'property' for obj.prop++, 'computed' for obj[key]++
+  computedPropertyVar?: string;   // Variable name for computed access: obj[i]++ -> "i"
+}
+
+// === PROMISE EXECUTOR CONTEXT ===
+/**
+ * Tracks Promise executor context during analysis.
+ * Used to detect when resolve/reject calls should create RESOLVES_TO edges.
+ *
+ * Stored in collections.promiseExecutorContexts Map, keyed by executor function's start:end position.
+ */
+export interface PromiseExecutorContext {
+  /** ID of the CONSTRUCTOR_CALL node for `new Promise()` */
+  constructorCallId: string;
+  /** Name of the first parameter (typically 'resolve') */
+  resolveName: string;
+  /** Name of the second parameter (typically 'reject'), if any */
+  rejectName?: string;
+  /** File path for edge creation */
+  file: string;
+  /** Line of the Promise constructor for debugging */
+  line: number;
+}
+
+// === PROMISE RESOLUTION INFO ===
+/**
+ * Info for Promise resolution RESOLVES_TO edges.
+ * Created when resolve(value) or reject(error) is called inside Promise executor.
+ *
+ * Graph structure:
+ * CALL[resolve(42)] --RESOLVES_TO--> CONSTRUCTOR_CALL[new Promise]
+ *
+ * Edge direction: resolve CALL -> Promise CONSTRUCTOR_CALL
+ * This allows traceValues to follow RESOLVES_TO from Promise to find data sources.
+ */
+export interface PromiseResolutionInfo {
+  /** ID of the resolve/reject CALL node */
+  callId: string;
+  /** ID of the Promise CONSTRUCTOR_CALL node */
+  constructorCallId: string;
+  /** True if this is reject(), false for resolve() */
+  isReject: boolean;
+  /** File path */
+  file: string;
+  /** Line number of resolve/reject call */
+  line: number;
 }
 
 // === COUNTER REF ===
@@ -335,11 +868,20 @@ export interface ASTCollections {
   functions: FunctionInfo[];
   parameters?: ParameterInfo[];
   scopes: ScopeInfo[];
+  // Branching
+  branches?: BranchInfo[];
+  cases?: CaseInfo[];
+  // Control flow (new)
+  loops?: LoopInfo[];
+  tryBlocks?: TryBlockInfo[];
+  catchBlocks?: CatchBlockInfo[];
+  finallyBlocks?: FinallyBlockInfo[];
   variableDeclarations: VariableDeclarationInfo[];
   callSites: CallSiteInfo[];
   methodCalls?: MethodCallInfo[];
   eventListeners?: EventListenerInfo[];
   classInstantiations?: ClassInstantiationInfo[];
+  constructorCalls?: ConstructorCallInfo[];
   classDeclarations?: ClassDeclarationInfo[];
   methodCallbacks?: MethodCallbackInfo[];
   callArguments?: CallArgumentInfo[];
@@ -348,6 +890,25 @@ export interface ASTCollections {
   httpRequests?: HttpRequestInfo[];
   literals?: LiteralInfo[];
   variableAssignments?: VariableAssignmentInfo[];
+  // Object/Array literal tracking for data flow
+  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[];
+  // Variable reassignment tracking for FLOWS_INTO edges (REG-290)
+  variableReassignments?: VariableReassignmentInfo[];
+  // Return statement tracking for RETURNS edges
+  returnStatements?: ReturnStatementInfo[];
+  // Update expression tracking (i++, obj.prop++, arr[i]++) for MODIFIES edges (REG-288, REG-312)
+  updateExpressions?: UpdateExpressionInfo[];
+  // Promise resolution tracking for RESOLVES_TO edges (REG-334)
+  promiseResolutions?: PromiseResolutionInfo[];
+  // Promise executor contexts (REG-334) - keyed by executor function's start:end position
+  promiseExecutorContexts?: Map<string, PromiseExecutorContext>;
   // TypeScript-specific collections
   interfaces?: InterfaceDeclarationInfo[];
   typeAliases?: TypeAliasInfo[];
@@ -361,7 +922,18 @@ export interface ASTCollections {
   functionCounterRef?: CounterRef;
   httpRequestCounterRef?: CounterRef;
   literalCounterRef?: CounterRef;
+  objectLiteralCounterRef?: CounterRef;
+  arrayLiteralCounterRef?: CounterRef;
+  branchCounterRef?: CounterRef;
+  caseCounterRef?: CounterRef;
+  // Counter refs for control flow (add)
+  loopCounterRef?: CounterRef;
+  tryBlockCounterRef?: CounterRef;
+  catchBlockCounterRef?: CounterRef;
+  finallyBlockCounterRef?: CounterRef;
   processedNodes?: ProcessedNodes;
+  // ScopeTracker for semantic ID generation
+  scopeTracker?: import('../../../core/ScopeTracker.js').ScopeTracker;
 }
 
 // === EXTRACTED VARIABLE ===
@@ -381,6 +953,12 @@ export interface GraphNode {
   file?: string;
   line?: number;
   column?: number;
+  // IMPORT node fields
+  source?: string;
+  importType?: 'default' | 'named' | 'namespace';
+  importBinding?: 'value' | 'type' | 'typeof';
+  imported?: string;
+  local?: string;
   [key: string]: unknown;
 }
 
@@ -390,6 +968,18 @@ export interface GraphEdge {
   src: string;
   dst: string;
   index?: number;
+  // For FLOWS_INTO edges (array mutations)
+  mutationMethod?: string;
+  argIndex?: number;
+  isSpread?: boolean;
+  nestedProperty?: string;  // REG-117: Property name for nested mutations (obj.arr.push -> "arr")
+  // For FLOWS_INTO edges (object mutations)
+  mutationType?: 'property' | 'computed' | 'assign' | 'spread' | 'this_property';
+  propertyName?: string;
+  // For computed property resolution (enrichment phase)
+  computedPropertyVar?: string;           // Variable name for obj[key] patterns
+  resolvedPropertyNames?: string[];       // Resolved names after enrichment
+  resolutionStatus?: ResolutionStatus;    // How resolution was determined
   metadata?: Record<string, unknown>;
 }