@grafema/core 0.2.5-beta → 0.2.7

package/src/plugins/analysis/SocketIOAnalyzer.ts

@@ -23,8 +23,10 @@ import type { CallExpression, Identifier, MemberExpression, Node } from '@babel/
 import type { NodePath } from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
-import type { NodeRecord } from '@grafema/types';
+import type { NodeRecord, AnyBrandedNode } from '@grafema/types';
+import { NodeFactory } from '../../core/NodeFactory.js';
 import { getLine, getColumn } from './ast/utils/location.js';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
 
  
 const traverse = (traverseModule as any).default || traverseModule;
@@ -73,18 +75,6 @@ interface SocketRoomNode {
   column: number;
 }
 
-/**
- * Socket event channel node - represents a single event across all emitters/listeners
- */
-interface SocketEventNode {
-  id: string;
-  type: 'socketio:event';
-  name: string;        // Event name (e.g., "slot:booked")
-  event: string;       // Same as name, for consistency
-  file?: string;       // Not applicable - event is global
-  line?: number;       // Not applicable
-}
-
 /**
  * Analysis result
  */
@@ -112,6 +102,7 @@ export class SocketIOAnalyzer extends Plugin {
 
     try {
       const { graph } = context;
+      const projectPath = (context.manifest as { projectPath?: string })?.projectPath ?? '';
 
       // Получаем все модули
       const modules = await this.getModules(graph);
@@ -125,7 +116,7 @@ export class SocketIOAnalyzer extends Plugin {
       // PHASE 1: Analyze modules and create emit/listener/room nodes
       for (let i = 0; i < modules.length; i++) {
         const module = modules[i];
-        const result = await this.analyzeModule(module, graph);
+        const result = await this.analyzeModule(module, graph, projectPath);
         emitsCount += result.emits;
         listenersCount += result.listeners;
         roomsCount += result.rooms;
@@ -207,22 +198,16 @@ export class SocketIOAnalyzer extends Plugin {
       logger.debug('Unique events found', { count: eventNames.size });
 
       // Step 3: Create event channel node for each unique event
-      const nodes: NodeRecord[] = [];
+      const nodes: AnyBrandedNode[] = [];
       const edges: Array<{ type: string; src: string; dst: string }> = [];
       let createdCount = 0;
 
       for (const eventName of eventNames) {
         const eventNodeId = `socketio:event#${eventName}`;
 
-        // Create event channel node
-        const eventNode: SocketEventNode = {
-          id: eventNodeId,
-          type: 'socketio:event',
-          name: eventName,
-          event: eventName
-        };
-
-        nodes.push(eventNode as unknown as NodeRecord);
+        // Create event channel node via factory
+        const brandedNode = NodeFactory.createSocketIOEvent(eventName);
+        nodes.push(brandedNode);
         createdCount++;
 
         // Step 4: Connect all emits of this event to the channel
@@ -265,10 +250,11 @@ export class SocketIOAnalyzer extends Plugin {
 
   private async analyzeModule(
     module: NodeRecord,
-    graph: PluginContext['graph']
+    graph: PluginContext['graph'],
+    projectPath: string
   ): Promise<AnalysisResult> {
     try {
-      const code = readFileSync(module.file!, 'utf-8');
+      const code = readFileSync(resolveNodeFile(module.file!, projectPath), 'utf-8');
 
       const ast = parse(code, {
         sourceType: 'module',
@@ -412,14 +398,16 @@ export class SocketIOAnalyzer extends Plugin {
         }
       });
 
-      // Создаём ноды в графе
-      const nodes: NodeRecord[] = [];
+      // Create branded nodes via factory
+      const nodes: AnyBrandedNode[] = [];
       const edges: Array<{ type: string; src: string; dst: string }> = [];
 
       for (const emit of emits) {
-        nodes.push(emit as unknown as NodeRecord);
+        nodes.push(NodeFactory.createSocketIOEmit(
+          emit.event, emit.objectName, emit.file, emit.line, emit.column,
+          { room: emit.room, namespace: emit.namespace, broadcast: emit.broadcast }
+        ));
 
-        // Создаём ребро от модуля к event
         edges.push({
           type: 'CONTAINS',
           src: module.id,
@@ -428,9 +416,11 @@ export class SocketIOAnalyzer extends Plugin {
       }
 
       for (const listener of listeners) {
-        nodes.push(listener as unknown as NodeRecord);
+        nodes.push(NodeFactory.createSocketIOListener(
+          listener.event, listener.objectName, listener.handlerName,
+          listener.handlerLine, listener.file, listener.line, listener.column
+        ));
 
-        // Создаём ребро от модуля к listener
         edges.push({
           type: 'CONTAINS',
           src: module.id,
@@ -459,9 +449,10 @@ export class SocketIOAnalyzer extends Plugin {
       }
 
       for (const room of rooms) {
-        nodes.push(room as unknown as NodeRecord);
+        nodes.push(NodeFactory.createSocketIORoom(
+          room.room, room.objectName, room.file, room.line, room.column
+        ));
 
-        // Создаём ребро от модуля к room
         edges.push({
           type: 'CONTAINS',
           src: module.id,

package/src/plugins/analysis/SystemDbAnalyzer.ts

@@ -12,6 +12,7 @@
  */
 
 import { readFileSync } from 'fs';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
 import type { ParserPlugin } from '@babel/parser';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
@@ -19,9 +20,10 @@ import type { CallExpression, Identifier, Node } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
-import type { NodeRecord } from '@grafema/types';
+import type { NodeRecord, AnyBrandedNode } from '@grafema/types';
+import { brandNodeInternal } from '../../core/brandNodeInternal.js';
+
 
- 
 const traverse = (traverseModule as any).default || traverseModule;
 
 /**
@@ -63,6 +65,7 @@ export class SystemDbAnalyzer extends Plugin {
 
     try {
       const { graph } = context;
+      const projectPath = (context.manifest as { projectPath?: string })?.projectPath ?? '';
 
       let nodesCreated = 0;
       let edgesCreated = 0;
@@ -73,14 +76,14 @@ export class SystemDbAnalyzer extends Plugin {
       logger.info('Analyzing modules for system_db patterns', { count: modules.length });
 
       // Collect all nodes and edges across ALL modules
-      const allNodes: NodeRecord[] = [];
+      const allNodes: AnyBrandedNode[] = [];
       const allEdges: Array<{ type: string; src: string; dst: string }> = [];
 
       for (const module of modules) {
         if (!module.file) continue;
 
         try {
-          const code = readFileSync(module.file, 'utf-8');
+          const code = readFileSync(resolveNodeFile(module.file, projectPath), 'utf-8');
           const ast = parse(code, {
             sourceType: 'module',
             plugins: ['jsx', 'typescript'] as ParserPlugin[],
@@ -182,17 +185,17 @@ export class SystemDbAnalyzer extends Plugin {
               line: reg.line
             });
 
-            allNodes.push({
+            allNodes.push(brandNodeInternal({
               id: nodeId,
-              type: 'SYSTEM_DB_VIEW_REGISTRATION',
+              type: 'SYSTEM_DB_VIEW_REGISTRATION' as NodeRecord['type'],
               name: `${reg.type}('${reg.viewName}', '${reg.serverName}')`,
-              file: module.file,
+              file: module.file!,
               line: reg.line,
               column: reg.column,
               viewName: reg.viewName,
               serverName: reg.serverName,
               callType: reg.type
-            } as unknown as NodeRecord);
+            }));
             nodesCreated++;
 
             // Link MODULE -> REGISTERS_VIEW -> REGISTRATION
@@ -208,15 +211,15 @@ export class SystemDbAnalyzer extends Plugin {
           for (const sub of subscriptions) {
             const nodeId = `${module.file}:SYSTEM_DB_SUBSCRIPTION:${sub.line}`;
 
-            allNodes.push({
+            allNodes.push(brandNodeInternal({
               id: nodeId,
-              type: 'SYSTEM_DB_SUBSCRIPTION',
+              type: 'SYSTEM_DB_SUBSCRIPTION' as NodeRecord['type'],
               name: `subscribe([${sub.servers.join(', ')}])`,
-              file: module.file,
+              file: module.file!,
               line: sub.line,
               column: sub.column,
               servers: sub.servers
-            } as unknown as NodeRecord);
+            }));
             nodesCreated++;
 
             // Link MODULE -> CHECKS_VIEWS -> SUBSCRIPTION

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

@@ -0,0 +1,137 @@
+/**
+ * CollisionResolver - Graduated disambiguation for v2 semantic IDs.
+ *
+ * Pipeline position: After all visitors complete for a file, before GraphBuilder.
+ *
+ * Algorithm:
+ * 1. Group PendingNodes by baseId
+ * 2. For groups with size=1: no change needed
+ * 3. For groups with size>1: compute content hashes
+ *    a. If all hashes unique within group: append [h:xxxx]
+ *    b. If hash collision: append [h:xxxx]#N (counter)
+ *
+ * Complexity: O(n) amortized where n = total nodes in file.
+ */
+
+import { computeContentHash } from '../../../core/SemanticId.js';
+import type { ContentHashHints } from '../../../core/SemanticId.js';
+
+/**
+ * A node awaiting final ID assignment.
+ *
+ * Created by visitors during AST traversal. Contains the
+ * base ID (without hash/counter) and content hints for
+ * hash computation if disambiguation is needed.
+ */
+export interface PendingNode {
+  /** Base ID: file->TYPE->name or file->TYPE->name[in:parent] */
+  baseId: string;
+
+  /** Content hints for hash computation (node-type-specific) */
+  contentHints: ContentHashHints;
+
+  /**
+   * Reference to the collection object whose .id will be updated.
+   * CollisionResolver mutates this in place.
+   */
+  collectionRef: { id: string };
+
+  /** Original insertion order (for deterministic counter assignment) */
+  insertionOrder: number;
+}
+
+export class CollisionResolver {
+  /**
+   * Resolve collisions and assign final IDs.
+   *
+   * Mutates each PendingNode's collectionRef.id in place.
+   * Returns a map of baseId -> finalId for nodes that were changed,
+   * used to rewrite cross-references (e.g., callArguments.parentCallId).
+   *
+   * Note: since multiple nodes can share the same baseId, the returned map
+   * only contains entries where the OLD id on the collectionRef differs
+   * from the NEW final id. Callers should use collectionRef objects for
+   * precise cross-reference resolution.
+   */
+  resolve(nodes: PendingNode[]): void {
+    if (nodes.length === 0) return;
+
+    // Step 1: Group by baseId
+    const groups = new Map<string, PendingNode[]>();
+    for (const node of nodes) {
+      let group = groups.get(node.baseId);
+      if (!group) {
+        group = [];
+        groups.set(node.baseId, group);
+      }
+      group.push(node);
+    }
+
+    // Step 2: Process each group
+    for (const [baseId, group] of groups) {
+      if (group.length === 1) {
+        // Unique -- base ID is final
+        group[0].collectionRef.id = baseId;
+        continue;
+      }
+
+      // Sort by insertion order for deterministic counter assignment
+      group.sort((a, b) => a.insertionOrder - b.insertionOrder);
+
+      // Compute hashes for all nodes in group
+      const hashes = group.map(n => computeContentHash(n.contentHints));
+
+      // Sub-group by hash
+      const hashGroups = new Map<string, number[]>();
+      for (let i = 0; i < group.length; i++) {
+        const hash = hashes[i];
+        let hg = hashGroups.get(hash);
+        if (!hg) {
+          hg = [];
+          hashGroups.set(hash, hg);
+        }
+        hg.push(i);
+      }
+
+      // Assign final IDs
+      for (const [hash, indices] of hashGroups) {
+        if (indices.length === 1) {
+          // Unique hash within collision group
+          const node = group[indices[0]];
+          node.collectionRef.id = this.appendHash(baseId, hash);
+        } else {
+          // Hash collision -- need counter
+          for (let c = 0; c < indices.length; c++) {
+            const node = group[indices[c]];
+            node.collectionRef.id = this.appendHashAndCounter(baseId, hash, c);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Append content hash to base ID.
+   *
+   * "file->TYPE->name" -> "file->TYPE->name[h:xxxx]"
+   * "file->TYPE->name[in:parent]" -> "file->TYPE->name[in:parent,h:xxxx]"
+   */
+  private appendHash(baseId: string, hash: string): string {
+    const bracketIdx = baseId.indexOf('[');
+    if (bracketIdx === -1) {
+      return `${baseId}[h:${hash}]`;
+    }
+    // Insert hash before closing bracket
+    return `${baseId.slice(0, -1)},h:${hash}]`;
+  }
+
+  /**
+   * Append content hash and counter to base ID.
+   * Counter 0 is omitted (first occurrence doesn't need disambiguation).
+   */
+  private appendHashAndCounter(baseId: string, hash: string, counter: number): string {
+    const withHash = this.appendHash(baseId, hash);
+    if (counter === 0) return withHash;
+    return `${withHash}#${counter}`;
+  }
+}

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

@@ -0,0 +1,291 @@
+/** FunctionBodyContext - all local state for analyzeFunctionBody() traversal. */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { getLine, getColumn } from './utils/location.js';
+import type { ScopeTracker } from '../../../core/ScopeTracker.js';
+import type {
+  FunctionInfo, ScopeInfo, BranchInfo, LoopInfo,
+  TryBlockInfo, CatchBlockInfo, FinallyBlockInfo,
+  VariableDeclarationInfo, CallSiteInfo, MethodCallInfo,
+  EventListenerInfo, MethodCallbackInfo, ClassInstantiationInfo,
+  ConstructorCallInfo, HttpRequestInfo, LiteralInfo,
+  VariableAssignmentInfo, ObjectLiteralInfo, ObjectPropertyInfo,
+  ReturnStatementInfo, YieldExpressionInfo, UpdateExpressionInfo,
+  PromiseExecutorContext, PromiseResolutionInfo, RejectionPatternInfo,
+  CatchesFromInfo, ParameterInfo, CounterRef, ProcessedNodes,
+} from './types.js';
+import type { VisitorModule, VisitorCollections } from './visitors/index.js';
+
+/** Tracks if/else scope transitions during traversal (Phase 3: includes branchId). */
+export interface IfElseScopeInfo {
+  inElse: boolean;
+  hasElse: boolean;
+  ifScopeId: string;
+  elseScopeId: string | null;
+  branchId: string;
+}
+
+/** Tracks try/catch/finally scope transitions during traversal. */
+export interface TryScopeInfo {
+  tryScopeId: string;
+  catchScopeId: string | null;
+  finallyScopeId: string | null;
+  currentBlock: 'try' | 'catch' | 'finally';
+  tryBlockId: string;
+  catchBlockId: string | null;
+  finallyBlockId: string | null;
+}
+
+/** Phase 6 (REG-267): Control flow tracking state for cyclomatic complexity. */
+export interface ControlFlowState {
+  branchCount: number;
+  loopCount: number;
+  caseCount: number;
+  logicalOpCount: number;
+  hasTryCatch: boolean;
+  hasEarlyReturn: boolean;
+  hasThrow: boolean;
+  returnCount: number;
+  totalStatements: number;
+  tryBlockDepth: number;   // REG-311: O(1) isInsideTry
+  loopDepth: number;       // REG-298: O(1) isInsideLoop
+}
+
+/** All local state needed by function body traversal handlers. */
+export interface FunctionBodyContext {
+  // Function identity
+  funcPath: NodePath<t.Function | t.StaticBlock>;
+  funcNode: t.Function | t.StaticBlock;
+  functionNode: t.Function | null;
+  functionPath: NodePath<t.Function> | null;
+  funcLine: number;
+  funcColumn: number;
+  currentFunctionId: string | null;
+  matchingFunction: FunctionInfo | undefined;
+  // Module & scope
+  module: VisitorModule;
+  collections: VisitorCollections;
+  parentScopeId: string;
+  scopeIdStack: string[];
+  getCurrentScopeId: () => string;
+  scopeTracker: ScopeTracker | undefined;
+  // Collections extracted from VisitorCollections
+  functions: FunctionInfo[];
+  scopes: ScopeInfo[];
+  variableDeclarations: VariableDeclarationInfo[];
+  callSites: CallSiteInfo[];
+  methodCalls: MethodCallInfo[];
+  eventListeners: EventListenerInfo[];
+  methodCallbacks: MethodCallbackInfo[];
+  classInstantiations: ClassInstantiationInfo[];
+  constructorCalls: ConstructorCallInfo[];
+  httpRequests: HttpRequestInfo[];
+  literals: LiteralInfo[];
+  variableAssignments: VariableAssignmentInfo[];
+  parameters: ParameterInfo[];
+  returnStatements: ReturnStatementInfo[];
+  yieldExpressions: YieldExpressionInfo[];
+  updateExpressions: UpdateExpressionInfo[];
+  objectLiterals: ObjectLiteralInfo[];
+  objectProperties: ObjectPropertyInfo[];
+  // Control flow
+  loops: LoopInfo[];
+  branches: BranchInfo[];
+  tryBlocks: TryBlockInfo[];
+  catchBlocks: CatchBlockInfo[];
+  finallyBlocks: FinallyBlockInfo[];
+  // Promise & error tracking
+  promiseExecutorContexts: Map<string, PromiseExecutorContext>;
+  promiseResolutions: PromiseResolutionInfo[];
+  rejectionPatterns: RejectionPatternInfo[];
+  catchesFromInfos: CatchesFromInfo[];
+  // Counter refs
+  objectLiteralCounterRef: CounterRef;
+  loopCounterRef: CounterRef;
+  branchCounterRef: CounterRef;
+  tryBlockCounterRef: CounterRef;
+  catchBlockCounterRef: CounterRef;
+  finallyBlockCounterRef: CounterRef;
+  ifScopeCounterRef: CounterRef;
+  scopeCounterRef: CounterRef;
+  varDeclCounterRef: CounterRef;
+  callSiteCounterRef: CounterRef;
+  functionCounterRef: CounterRef;
+  httpRequestCounterRef: CounterRef;
+  literalCounterRef: CounterRef;
+  anonymousFunctionCounterRef: CounterRef;
+  // Processed nodes (deduplication)
+  processedNodes: ProcessedNodes;
+  processedCallSites: Set<string>;
+  processedMethodCalls: Set<string>;
+  processedVarDecls: Set<string>;
+  processedEventListeners: Set<string>;
+  parentScopeVariables: Set<{ name: string; id: string; scopeId: string }>;
+  // Scope tracking maps
+  ifElseScopeMap: Map<t.IfStatement, IfElseScopeInfo>;
+  tryScopeMap: Map<t.TryStatement, TryScopeInfo>;
+  // Parameter invocation tracking (REG-401, REG-416, REG-417)
+  paramNameToIndex: Map<string, number>;
+  paramNameToPropertyPath: Map<string, string[]>;
+  restParamNames: Set<string>;
+  invokedParamIndexes: Set<number>;
+  invokesParamBindings: { paramIndex: number; propertyPath: string[] }[];
+  aliasToParamIndex: Map<string, number>;
+  // Control flow state (REG-267)
+  controlFlowState: ControlFlowState;
+}
+
+function ensure<T>(c: VisitorCollections, k: string, fb: () => unknown): T {
+  if (!c[k]) { c[k] = fb(); }
+  return c[k] as T;
+}
+function extract<T>(c: VisitorCollections, k: string): T[] { return (c[k] ?? []) as T[]; }
+function counter(c: VisitorCollections, k: string): CounterRef { return (c[k] ?? { value: 0 }) as CounterRef; }
+
+/** Creates FunctionBodyContext matching analyzeFunctionBody() lines 3507-3763 init logic. */
+export function createFunctionBodyContext(
+  funcPath: NodePath<t.Function | t.StaticBlock>,
+  parentScopeId: string,
+  module: VisitorModule,
+  collections: VisitorCollections,
+  functions: FunctionInfo[],
+  extractNamesFromPatternFn: (pattern: t.ObjectPattern | t.ArrayPattern) => { name: string; propertyPath?: string[] }[],
+): FunctionBodyContext {
+  const c = collections;
+  const scopes = extract<ScopeInfo>(c, 'scopes');
+  const variableDeclarations = extract<VariableDeclarationInfo>(c, 'variableDeclarations');
+  const callSites = extract<CallSiteInfo>(c, 'callSites');
+  const methodCalls = extract<MethodCallInfo>(c, 'methodCalls');
+  const eventListeners = extract<EventListenerInfo>(c, 'eventListeners');
+  const methodCallbacks = extract<MethodCallbackInfo>(c, 'methodCallbacks');
+  const classInstantiations = extract<ClassInstantiationInfo>(c, 'classInstantiations');
+  const constructorCalls = extract<ConstructorCallInfo>(c, 'constructorCalls');
+  const httpRequests = extract<HttpRequestInfo>(c, 'httpRequests');
+  const literals = extract<LiteralInfo>(c, 'literals');
+  const variableAssignments = extract<VariableAssignmentInfo>(c, 'variableAssignments');
+  const parameters = extract<ParameterInfo>(c, 'parameters');
+  const returnStatements = extract<ReturnStatementInfo>(c, 'returnStatements');
+  const updateExpressions = extract<UpdateExpressionInfo>(c, 'updateExpressions');
+  const ifScopeCounterRef = counter(c, 'ifScopeCounterRef');
+  const scopeCounterRef = counter(c, 'scopeCounterRef');
+  const varDeclCounterRef = counter(c, 'varDeclCounterRef');
+  const callSiteCounterRef = counter(c, 'callSiteCounterRef');
+  const functionCounterRef = counter(c, 'functionCounterRef');
+  const httpRequestCounterRef = counter(c, 'httpRequestCounterRef');
+  const literalCounterRef = counter(c, 'literalCounterRef');
+  const anonymousFunctionCounterRef = counter(c, 'anonymousFunctionCounterRef');
+  const scopeTracker = c.scopeTracker as ScopeTracker | undefined;
+  const objectLiterals = ensure<ObjectLiteralInfo[]>(c, 'objectLiterals', () => []);
+  const objectProperties = ensure<ObjectPropertyInfo[]>(c, 'objectProperties', () => []);
+  const objectLiteralCounterRef = ensure<CounterRef>(c, 'objectLiteralCounterRef', () => ({ value: 0 }));
+  const yieldExpressions = ensure<YieldExpressionInfo[]>(c, 'yieldExpressions', () => []);
+  const loops = ensure<LoopInfo[]>(c, 'loops', () => []);
+  const loopCounterRef = ensure<CounterRef>(c, 'loopCounterRef', () => ({ value: 0 }));
+  const branches = ensure<BranchInfo[]>(c, 'branches', () => []);
+  const branchCounterRef = ensure<CounterRef>(c, 'branchCounterRef', () => ({ value: 0 }));
+  const tryBlocks = ensure<TryBlockInfo[]>(c, 'tryBlocks', () => []);
+  const catchBlocks = ensure<CatchBlockInfo[]>(c, 'catchBlocks', () => []);
+  const finallyBlocks = ensure<FinallyBlockInfo[]>(c, 'finallyBlocks', () => []);
+  const tryBlockCounterRef = ensure<CounterRef>(c, 'tryBlockCounterRef', () => ({ value: 0 }));
+  const catchBlockCounterRef = ensure<CounterRef>(c, 'catchBlockCounterRef', () => ({ value: 0 }));
+  const finallyBlockCounterRef = ensure<CounterRef>(c, 'finallyBlockCounterRef', () => ({ value: 0 }));
+  const promiseExecutorContexts = ensure<Map<string, PromiseExecutorContext>>(
+    c, 'promiseExecutorContexts', () => new Map<string, PromiseExecutorContext>());
+  const promiseResolutions = ensure<PromiseResolutionInfo[]>(c, 'promiseResolutions', () => []);
+  const rejectionPatterns = ensure<RejectionPatternInfo[]>(c, 'rejectionPatterns', () => []);
+  const catchesFromInfos = ensure<CatchesFromInfo[]>(c, 'catchesFromInfos', () => []);
+
+  const processedNodes: ProcessedNodes = c.processedNodes ?? {
+    functions: new Set<string>(), classes: new Set<string>(),
+    imports: new Set<string>(), exports: new Set<string>(),
+    variables: new Set<string>(), callSites: new Set<string>(),
+    methodCalls: new Set<string>(), varDecls: new Set<string>(),
+    eventListeners: new Set<string>(),
+  };
+
+  const scopeIdStack: string[] = [parentScopeId];
+  const getCurrentScopeId = (): string => scopeIdStack[scopeIdStack.length - 1];
+
+  // Function identity
+  const funcNode = funcPath.node;
+  const functionNode = t.isFunction(funcNode) ? funcNode : null;
+  const functionPath = functionNode ? (funcPath as NodePath<t.Function>) : null;
+  const funcLine = getLine(funcNode);
+  const funcColumn = getColumn(funcNode);
+  let currentFunctionId: string | null = null;
+
+  const matchingFunction = funcNode.type !== 'StaticBlock'
+    ? functions.find(f =>
+        f.file === module.file && f.line === funcLine &&
+        (f.column === undefined || f.column === funcColumn))
+    : undefined;
+  if (matchingFunction) { currentFunctionId = matchingFunction.id; }
+
+  // Parameter invocation tracking (REG-401, REG-416, REG-417)
+  const paramNameToIndex = new Map<string, number>();
+  const paramNameToPropertyPath = new Map<string, string[]>();
+  const restParamNames = new Set<string>();
+  const invokedParamIndexes = new Set<number>();
+  const invokesParamBindings: { paramIndex: number; propertyPath: string[] }[] = [];
+  const aliasToParamIndex = new Map<string, number>();
+
+  if (functionNode) {
+    for (let i = 0; i < functionNode.params.length; i++) {
+      const param = functionNode.params[i];
+      if (t.isIdentifier(param)) {
+        paramNameToIndex.set(param.name, i);
+      } else if (t.isAssignmentPattern(param)) {
+        if (t.isIdentifier(param.left)) {
+          paramNameToIndex.set(param.left.name, i);
+        } else if (t.isObjectPattern(param.left) || t.isArrayPattern(param.left)) {
+          for (const info of extractNamesFromPatternFn(param.left)) {
+            paramNameToIndex.set(info.name, i);
+            if (info.propertyPath) { paramNameToPropertyPath.set(info.name, info.propertyPath); }
+          }
+        }
+      } else if (t.isObjectPattern(param) || t.isArrayPattern(param)) {
+        for (const info of extractNamesFromPatternFn(param)) {
+          paramNameToIndex.set(info.name, i);
+          if (info.propertyPath) { paramNameToPropertyPath.set(info.name, info.propertyPath); }
+        }
+      } else if (t.isRestElement(param) && t.isIdentifier(param.argument)) {
+        paramNameToIndex.set(param.argument.name, i);
+        restParamNames.add(param.argument.name);
+      }
+    }
+  }
+
+  const controlFlowState: ControlFlowState = {
+    branchCount: 0, loopCount: 0, caseCount: 0, logicalOpCount: 0,
+    hasTryCatch: false, hasEarlyReturn: false, hasThrow: false,
+    returnCount: 0, totalStatements: 0, tryBlockDepth: 0, loopDepth: 0,
+  };
+
+  return {
+    funcPath, funcNode, functionNode, functionPath, funcLine, funcColumn, currentFunctionId, matchingFunction,
+    module, collections, parentScopeId, scopeIdStack, getCurrentScopeId, scopeTracker,
+    functions, scopes, variableDeclarations, callSites, methodCalls,
+    eventListeners, methodCallbacks, classInstantiations, constructorCalls,
+    httpRequests, literals, variableAssignments, parameters,
+    returnStatements, yieldExpressions, updateExpressions,
+    objectLiterals, objectProperties,
+    loops, branches, tryBlocks, catchBlocks, finallyBlocks,
+    promiseExecutorContexts, promiseResolutions, rejectionPatterns, catchesFromInfos,
+    objectLiteralCounterRef, loopCounterRef, branchCounterRef,
+    tryBlockCounterRef, catchBlockCounterRef, finallyBlockCounterRef,
+    ifScopeCounterRef, scopeCounterRef, varDeclCounterRef,
+    callSiteCounterRef, functionCounterRef, httpRequestCounterRef,
+    literalCounterRef, anonymousFunctionCounterRef,
+    processedNodes,
+    processedCallSites: processedNodes.callSites,
+    processedMethodCalls: processedNodes.methodCalls,
+    processedVarDecls: processedNodes.varDecls,
+    processedEventListeners: processedNodes.eventListeners,
+    parentScopeVariables: new Set<{ name: string; id: string; scopeId: string }>(),
+    ifElseScopeMap: new Map<t.IfStatement, IfElseScopeInfo>(),
+    tryScopeMap: new Map<t.TryStatement, TryScopeInfo>(),
+    paramNameToIndex, paramNameToPropertyPath, restParamNames,
+    invokedParamIndexes, invokesParamBindings, aliasToParamIndex,
+    controlFlowState,
+  };
+}