@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

package/analyzer-template/packages/ai/src/lib/dataStructure/ScopeDataStructure.ts

@@ -1,36 +1,104 @@
-/* ScopeDataStructure
+/**
+ * ScopeDataStructure
  *
- * The ScopeDateStructure takes the output of the ASTAnalyzer and merges
- * all scopes to determine a complete schema for the function.
+ * The core engine for CodeYam's static analysis. Takes AST analysis output and
+ * determines the complete data schema for a function by tracking how data flows
+ * through the code.
  *
- * It does two passes through all scopes.
+ * ## High-Level Architecture
  *
- * The first establishes equivalencies,
- * such as implicit parent scope -> nested child scope equivalencies.
+ * ```
+ * ┌─────────────────┐     ┌─────────────────────────────────────────────┐
+ * │  AST Analyzer   │────▶│           ScopeDataStructure                │
+ * │ (per-scope)     │     │                                             │
+ * └─────────────────┘     │  Phase 1: Discovery (onlyEquivalencies)     │
+ *                         │  ├─ Process each scope's analysis           │
+ *                         │  ├─ Build equivalency relationships         │
+ *                         │  └─ Track nested scope hierarchy            │
+ *                         │                                             │
+ *                         │  Phase 2: Schema Building                   │
+ *                         │  ├─ Follow all equivalencies                │
+ *                         │  ├─ Build complete schemas at data sources  │
+ *                         │  └─ Populate equivalencyDatabase            │
+ *                         └─────────────────────────────────────────────┘
+ *                                           │
+ *                                           ▼
+ *                         ┌─────────────────────────────────────────────┐
+ *                         │              Output                          │
+ *                         │  • Function signature schemas               │
+ *                         │  • Return value types                       │
+ *                         │  • External API call schemas                │
+ *                         │  • Data flow (source → usage) mappings      │
+ *                         └─────────────────────────────────────────────┘
+ * ```
  *
- * The second pass follows all equivalencies to build up a complete schema at the
- * source of the data (either the function's signature arguments or an external
- * API call made from within the function). While following the equivalencies the
- * second pass populates the equivalencyDatabase which tracks all equivalent values
- * and provides easy access to determine where data comes from and where it is used
- * to call external functions. This makes it possible to combine schemas between
- * functions to create a complete schema for a dependency tree.
+ * ## Key Concepts
  *
- * There are a number of getter functions that provide easy access to signature data
- * and return values for the function being analyzed and any function called from the
- * function being analyzed.
+ * ### Equivalencies
+ * When code assigns one variable to another (`const user = props.user`), we create
+ * an "equivalency" linking the two paths. Following these links lets us trace data
+ * back to its source (function arguments or API returns).
+ *
+ * ### Schema Paths
+ * Dot-separated strings describing data structure:
+ * - `signature[0].user.id` - First arg's user.id property
+ * - `items[].name` - name property of array elements
+ * - `functionCallReturnValue(fetch).data` - Return from fetch() call
+ *
+ * ### Two-Phase Processing
+ * 1. **Phase 1 (Discovery)**: `onlyEquivalencies = true`
+ *    - Processes scopes, builds equivalency graph
+ *    - Does NOT populate schemas yet
+ *
+ * 2. **Phase 2 (Schema Building)**: `captureCompleteSchema()`
+ *    - Follows equivalencies to build complete schemas
+ *    - Populates `equivalencyDatabase` for source/usage queries
+ *
+ * ## Key Methods (Entry Points)
+ *
+ * - `constructor(scopeName, scopeText, managers, scopeAnalysis)` - Initialize with root scope
+ * - `addScopeAnalysis(scopeName, text, analysis)` - Add nested scope
+ * - `captureCompleteSchema()` - Trigger Phase 2 processing
+ * - `getSchema({scopeName})` - Get schema for a scope
+ * - `getFunctionSignature({functionName})` - Get function signature schema
+ * - `getSourceEquivalencies()` - Find where data comes from
+ * - `getUsageEquivalencies()` - Find where data is used
+ *
+ * ## Debugging Tips
+ *
+ * - Enable metrics: `addToSchemaCallCount`, `followEquivalenciesCallCount`
+ * - Check `scopeNode.equivalencies` for raw equivalency data
+ * - Use `getEquivalenciesDatabaseEntry(scope, path)` to trace a specific path
+ * - The `visitedTracker` prevents infinite loops - if data is missing, check if
+ *   it was already visited with a different value
+ *
+ * ## Related Files
+ *
+ * - `helpers/` - Extracted utility modules (PathManager, VisitedTracker, etc.)
+ * - `equivalencyManagers/` - Plugins that create equivalencies from AST patterns
+ * - `helpers/README.md` - Overview of the helper module architecture
  */
 
 import { ScopeAnalysis } from '~codeyam/types';
-import {
-  joinParenthesesAndArrays,
-  splitOutsideParenthesesAndArrays,
-} from '../splitOutsideParentheses';
 import { EquivalencyManager } from './equivalencyManagers/EquivalencyManager';
 import fillInSchemaGapsAndUnknowns from './helpers/fillInSchemaGapsAndUnknowns';
 import ensureSchemaConsistency from './helpers/ensureSchemaConsistency';
-import cleanOutBoundary from '../cleanOutBoundary';
 import cleanPath from './helpers/cleanPath';
+import { PathManager } from './helpers/PathManager';
+import {
+  uniqueId,
+  uniqueScopeVariables,
+  uniqueScopeAndPaths,
+} from './helpers/uniqueIdUtils';
+import selectBestValue from './helpers/selectBestValue';
+import { VisitedTracker } from './helpers/VisitedTracker';
+import { DebugTracer } from './helpers/DebugTracer';
+import { BatchSchemaProcessor } from './helpers/BatchSchemaProcessor';
+import {
+  ScopeTreeManager,
+  ROOT_SCOPE_NAME,
+  ScopeTreeNode,
+} from './helpers/ScopeTreeManager';
 import cleanScopeNodeName from './helpers/cleanScopeNodeName';
 import getFunctionCallRoot from './helpers/getFunctionCallRoot';
 import cleanPathOfNonTransformingFunctions from './helpers/cleanPathOfNonTransformingFunctions';
@@ -42,38 +110,10 @@ import type {
   SerializableScopeVariable,
 } from '../worker/SerializableDataStructure';
 
-// import { appendFileSync } from 'node:fs';
-// function writeEquivalencyToFile(
-//   scopeNodeName: string,
-//   path: string,
-//   equivalentScopeNodeName: string,
-//   equivalentPath: string,
-//   newEquivalentPath: string,
-//   equivalencyReason: string,
-// ) {
-//   if ([
-//     'original equivalency'
-//   ].includes(equivalencyReason)) {
-//     return
-//   }
-
-//   appendFileSync('equivalencies.txt', '\n\n');
-//   appendFileSync('equivalencies.txt',
-//     JSON.stringify(
-//       {
-//         newEquivalentPath,
-//         scopeNodeName,
-//         path,
-//         equivalentScopeNodeName,
-//         equivalentPath,
-//         equivalencyReason,
-//       },
-//       null,
-//       2,
-//     ),
-//   );
-// }
-
+/**
+ * ScopeInfo represents a function scope discovered during AST analysis.
+ * Contains the raw analysis data before it's processed into a ScopeNode.
+ */
 export interface ScopeInfo {
   name: string;
   text: string;
@@ -87,46 +127,111 @@ export interface ScopeInfo {
   analysis?: any;
 }
 
+/**
+ * ScopeNode is the processed representation of a function scope.
+ * Contains the schema and equivalencies built during analysis.
+ *
+ * Key fields:
+ * - `schema`: Map of path → type (e.g., `{ 'user.id': 'string' }`)
+ * - `equivalencies`: Map of path → equivalent paths in other scopes
+ * - `functionCalls`: External function calls made from this scope
+ */
 export interface ScopeNode {
+  /** Unique scope name, may include suffix like `____cyScope0A` for disambiguation */
   name: string;
+  /** Path from root scope to this scope (e.g., ['outer', 'inner']) */
   tree: string[];
+  /** Original source code text of the function */
   text: string;
+  /** Raw AST analysis output */
   analysis: ScopeAnalysis;
+  /** True if this is a static class method */
   isStatic?: boolean;
+  /** The built schema: maps schema paths to type values */
   schema: Record<string, string>;
-  equivalencies: Record<string, ScopeVariable[]>; // Trace data attributes to the source of the data
+  /** Maps local paths to equivalent paths in other scopes (for tracing data flow) */
+  equivalencies: Record<string, ScopeVariable[]>;
+  /** External function calls made from this scope */
   functionCalls: FunctionCallInfo[];
+  /** True if this scope is a function definition (vs. class/module) */
   isFunctionDefinition: boolean;
-  instantiatedVariables?: string[]; // Variables instantiated in this scope
-  parentInstantiatedVariables?: string[]; // Variables instantiated in the parent scope that are available in this scope
+  /** Variables created in this scope (e.g., via `const x = ...`) */
+  instantiatedVariables?: string[];
+  /** Variables from parent scope accessible in this scope */
+  parentInstantiatedVariables?: string[];
 }
 
-export interface ScopeTreeNode {
-  name: string;
-  children: ScopeTreeNode[];
-}
+// Re-export ScopeTreeNode from ScopeTreeManager for backward compatibility
+export type { ScopeTreeNode };
 
+/**
+ * ScopeVariable represents a reference to a specific path in a specific scope.
+ * Used in equivalency chains to track data flow.
+ */
 export interface ScopeVariable {
-  id: number; // Never go through the same equivalency twice
+  /** Unique ID to prevent processing the same equivalency twice */
+  id: number;
+  /** Name of the scope containing this variable */
   scopeNodeName: string;
+  /** Schema path (e.g., 'signature[0].user.id') */
   schemaPath: string;
+  /** Why this equivalency exists (e.g., 'destructuring', 'assignment') */
   equivalencyReason: string;
 }
 
+/**
+ * VariableInfo is the public representation of a tracked variable.
+ * Returned by getter methods like `getVariableInfo()`.
+ */
 export interface VariableInfo {
   name: string;
   equivalentTo?: ScopeVariable[];
   schema: Record<string, string>;
 }
 
+/**
+ * FunctionCallInfo tracks an external function call and its data flow.
+ * Used to understand what data is passed to external APIs.
+ */
 export interface FunctionCallInfo {
+  /** Function name (e.g., 'fetch', 'console.log') */
   name: string;
+  /** How the function was called (e.g., 'fetch(url, options)') */
   callSignature: string;
+  /** Scope where the call was made */
   callScope: string;
-  schema?: Record<string, string>; // For tracking schema of external function calls
-  equivalencies?: Record<string, ScopeVariable[]>; // Trace all signature data back to original source (either root scope signature of functionCallReturnValue of another external function call)
+  /** Schema of arguments passed to the function */
+  schema?: Record<string, string>;
+  /** Traces argument data back to original source */
+  equivalencies?: Record<string, ScopeVariable[]>;
+  /**
+   * All call signatures that were merged into this entry.
+   * When multiple method calls on the same object (e.g., logger.info, logger.debug)
+   * are encountered, they get merged into one FunctionCallInfo but we track all signatures.
+   */
+  allCallSignatures?: string[];
+  /**
+   * Variable names that receive the return value of each call.
+   * For example, in `const result1 = db.select(query1)`, the receiving variable is 'result1'.
+   * This enables generating separate mock data for each call site.
+   */
+  receivingVariableNames?: string[];
+  /**
+   * Maps each call signature to the variable that receives its return value.
+   * For example: { "db.select(query1)": "result1", "db.select(query2)": "result2" }
+   */
+  callSignatureToVariable?: Record<string, string>;
 }
 
+/**
+ * EquivalencyValueChainItem tracks a single step in an equivalency chain.
+ * Used internally during schema building to trace data from usage back to source.
+ *
+ * Example chain for `const { user } = props; return user.name;`:
+ * 1. returnValue → user.name (reason: 'return statement')
+ * 2. user.name → props.user.name (reason: 'destructuring')
+ * 3. props.user.name → signature[0].user.name (reason: 'parameter')
+ */
 export interface EquivalencyValueChainItem {
   id: number;
   addToSchemaId?: number;
@@ -145,41 +250,125 @@ export interface EquivalencyValueChainItem {
   traceId?: number;
 }
 
+/**
+ * EquivalencyDatabaseEntry links data sources to their usages.
+ *
+ * After analysis, use `getSourceEquivalencies()` and `getUsageEquivalencies()`
+ * to query this database and understand data flow:
+ * - sourceCandidates: Where the data originates (function args, API returns)
+ * - usages: Where the data is consumed (return values, JSX props, API calls)
+ * - intermediatesOrder: All paths in the chain, ordered by distance from source
+ */
 export interface EquivalencyDatabaseEntry {
   id: number;
+  /** Paths where data originates (signature args, API returns) */
   sourceCandidates: Pick<ScopeVariable, 'schemaPath' | 'scopeNodeName'>[];
+  /** Paths where data is consumed (return values, JSX props) */
   usages: Pick<ScopeVariable, 'schemaPath' | 'scopeNodeName'>[];
+  /** All intermediate paths with their distance from source (0 = source) */
   intermediatesOrder: Record<string, number>;
-  complexSourceEquivalencies: Set<string>; // subsets of this equivalent path that each have different data sources (e.g. the variable analysisEntityPair has a different source for analysisEntityPair.analysis vs analysisEntityPair.entity)
+  /** Paths with multiple distinct sources (e.g., object with props from different origins) */
+  complexSourceEquivalencies: Set<string>;
 }
 
-const ROOT_SCOPE_NAME = 'root';
-
 // DEBUG: Performance metrics
 export let maxEquivalencyChainDepth = 0;
 export let addToSchemaCallCount = 0;
 export let followEquivalenciesCallCount = 0;
+export let followEquivalenciesEarlyExitCount = 0;
+export let followEquivalenciesEarlyExitPhase1Count = 0;
+export let followEquivalenciesWithWorkCount = 0;
+export let addEquivalencyCallCount = 0;
 export function resetScopeDataStructureMetrics() {
   maxEquivalencyChainDepth = 0;
   addToSchemaCallCount = 0;
   followEquivalenciesCallCount = 0;
+  followEquivalenciesEarlyExitCount = 0;
+  followEquivalenciesEarlyExitPhase1Count = 0;
+  followEquivalenciesWithWorkCount = 0;
+  addEquivalencyCallCount = 0;
 }
 
+// Performance: Pre-computed Sets for equivalency reason filtering (O(1) vs O(n))
+const ALLOWED_EQUIVALENCY_REASONS = new Set([
+  'original equivalency',
+  'implicit parent equivalency',
+  'explicit parent equivalency',
+  'transformed non-object function equivalency - original equivalency',
+  'equivalency to external function call',
+  'functionCall to function signature equivalency',
+  'explicit parent signature',
+  'useState setter call equivalency',
+  'non-object function argument function signature equivalency1',
+  'non-object function argument function signature equivalency2',
+  'returnValue to functionCallReturnValue equivalency',
+  '.map() function deconstruction',
+  'useMemo return value equivalent to first argument return value',
+  'useState value equivalency',
+  'Node .then() equivalency',
+  'Explicit array deconstruction equivalency value',
+  'forwardRef equivalency',
+  'forwardRef signature to child signature equivalency',
+  'captured function call return value equivalency',
+  'original equivalency - rerouted via useCallback',
+  'non-object function argument function signature equivalency1 - rerouted via useCallback',
+  'non-object function argument function signature equivalency2 - rerouted via useCallback',
+  'implicit parent equivalency - rerouted via useCallback',
+  'Spread operator equivalency key update: implicit parent equivalency',
+  'Array.from() equivalency',
+  'propagated sub-property equivalency',
+  'propagated function call return sub-property equivalency',
+  'propagated parent-variable equivalency', // Added: propagate child scope equivalencies to parent scope when variable is defined in parent
+  'where was this function called from', // Added: tracks which scope called an external function
+]);
+
+const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
+  'signature of functionCall',
+  'transformed non-object function equivalency - implicit parent equivalency',
+  'transformed non-object function equivalency - non-object function argument function signature equivalency1',
+  'transformed non-object function equivalency - non-object function argument function signature equivalency2',
+  'transformed non-object function equivalency - equivalency to external function call',
+  'Explicit array deconstruction equivalency key',
+  'transformed non-object function equivalency - useState setter call equivalency',
+  'transformed non-object function equivalency - implicit parent equivalency - rerouted via useCallback',
+  'transformed non-object function equivalency - Array.from() equivalency',
+  'Spread operator equivalency key update: Explicit array deconstruction equivalency value',
+]);
+
 export class ScopeDataStructure {
   debugCount = 0;
   onlyEquivalencies = true;
   equivalencyManagers: EquivalencyManager[] = [];
   scopeNodes: Record<string, ScopeNode> = {};
-  scopeTree: ScopeTreeNode = { name: ROOT_SCOPE_NAME, children: [] };
+  private scopeTreeManager: ScopeTreeManager = new ScopeTreeManager();
   externalFunctionCalls: FunctionCallInfo[] = [];
+
+  // Getter for backward compatibility - returns the tree structure
+  get scopeTree(): ScopeTreeNode {
+    return this.scopeTreeManager.getTree();
+  }
   environmentVariables: string[] = [];
   equivalencyDatabase: EquivalencyDatabaseEntry[] = [];
 
+  /**
+   * Conditional usages collected during AST analysis.
+   * Maps local variable path to array of usages.
+   */
+  private rawConditionalUsages: Record<
+    string,
+    Array<{
+      path: string;
+      conditionType: 'truthiness' | 'comparison' | 'switch';
+      comparedValues?: string[];
+      location: 'if' | 'ternary' | 'logical-and' | 'switch';
+    }>
+  > = {};
+
   private lastAddToSchemaId = 0;
   private lastEquivalencyId = 0;
   private lastEquivalencyDatabaseId = 0;
-  private pathPartsCache: Map<string, string[]> = new Map();
-  private pathJoinCache: Map<string, string> = new Map();
+  private pathManager: PathManager = new PathManager();
+  private visitedTracker: VisitedTracker = new VisitedTracker();
   private equivalencyDatabaseCache: Map<
     string,
     EquivalencyDatabaseEntry | undefined
@@ -187,7 +376,31 @@ export class ScopeDataStructure {
   // Inverted index: maps uniqueId -> EquivalencyDatabaseEntry for O(1) lookup
   private intermediatesOrderIndex: Map<string, EquivalencyDatabaseEntry> =
     new Map();
-  private globalVisited: Set<string> = new Set();
+
+  // Index for O(1) lookup of external function calls by name
+  // Invalidated by setting to null; rebuilt lazily on next access
+  private externalFunctionCallsIndex: Map<string, FunctionCallInfo> | null =
+    null;
+
+  // Debug tracer for selective path/scope tracing
+  // Enable via: CODEYAM_DEBUG=true CODEYAM_DEBUG_PATHS="user.*,signature" npm test
+  private tracer: DebugTracer = new DebugTracer({
+    enabled: process.env.CODEYAM_DEBUG === 'true',
+    pathPatterns: process.env.CODEYAM_DEBUG_PATHS
+      ? process.env.CODEYAM_DEBUG_PATHS.split(',').map((p) => new RegExp(p))
+      : [],
+    scopePatterns: process.env.CODEYAM_DEBUG_SCOPES
+      ? process.env.CODEYAM_DEBUG_SCOPES.split(',').map((p) => new RegExp(p))
+      : [],
+    maxDepth: 20,
+  });
+
+  // Batch processor for converting recursive addToSchema calls to iterative processing
+  // This eliminates deep recursion and allows for better work deduplication
+  private batchProcessor: BatchSchemaProcessor | null = null;
+  // Track items already in the batch queue to prevent duplicates
+  // For external function calls, uses path-only keys (no value) for more aggressive deduplication
+  private batchQueuedSet: Set<string> | null = null;
 
   constructor(
     managers: EquivalencyManager[],
@@ -196,7 +409,7 @@ export class ScopeDataStructure {
     scopeAnalysis: ScopeAnalysis,
   ) {
     this.equivalencyManagers.push(...managers);
-    this.scopeTree.name = scopeName;
+    this.scopeTreeManager.setRootName(scopeName);
     this.addScopeAnalysis(scopeName, scopeText, scopeAnalysis);
   }
 
@@ -208,8 +421,11 @@ export class ScopeDataStructure {
     isStatic?: boolean,
   ) {
     try {
-      if (scopeNodeName !== this.scopeTree.name && !parentScopeName) {
-        parentScopeName = this.scopeTree.name;
+      if (
+        scopeNodeName !== this.scopeTreeManager.getRootName() &&
+        !parentScopeName
+      ) {
+        parentScopeName = this.scopeTreeManager.getRootName();
       }
 
       let tree: any[] = [];
@@ -262,7 +478,7 @@ export class ScopeDataStructure {
         'CodeYam Error: Failed to add scope analysis for scope:',
         JSON.stringify(
           {
-            rootScopeName: this.scopeTree.name,
+            rootScopeName: this.scopeTreeManager.getRootName(),
             scopeNodeName,
             scopeNodeText: scopeText,
             isolatedStructure: scopeAnalysis.isolatedStructure,
@@ -277,30 +493,51 @@ export class ScopeDataStructure {
     }
   }
 
+  /**
+   * Phase 2: Build complete schemas by following all equivalencies.
+   *
+   * This is the main entry point for schema building. Call this after all
+   * scopes have been added via `addScopeAnalysis()`.
+   *
+   * ## What Happens
+   *
+   * 1. Resets state (visited tracker, schemas, database)
+   * 2. For each scope, follows equivalencies to build complete schemas
+   * 3. Filters out internal function calls (keeps only external-facing)
+   * 4. Propagates source/usage relationships for querying
+   *
+   * ## After Calling
+   *
+   * You can then use:
+   * - `getSchema()` - Get the built schema for a scope
+   * - `getSourceEquivalencies()` - Find where data comes from
+   * - `getUsageEquivalencies()` - Find where data is used
+   */
   async captureCompleteSchema() {
+    // Reset state for Phase 2
     this.onlyEquivalencies = false;
     this.equivalencyDatabase = [];
-    this.equivalencyDatabaseCache.clear(); // Clear cache when database is reset
-    this.intermediatesOrderIndex.clear(); // Clear inverted index when database is reset
-    this.globalVisited = new Set([]);
+    this.equivalencyDatabaseCache.clear();
+    this.intermediatesOrderIndex.clear();
+    this.visitedTracker.resetGlobalVisited();
 
     for (const externalFunctionCall of this.externalFunctionCalls) {
       externalFunctionCall.schema = {};
     }
 
-    // for (const scopeNode of Object.values(this.scopeNodes)) {
+    // Build schemas for all scopes in parallel
     await Promise.all(
       Object.values(this.scopeNodes).map(async (scopeNode) => {
         scopeNode.schema = {};
         await this.determineEquivalenciesAndBuildSchema(scopeNode);
       }),
     );
-    // }
+
     const validExternalFacingScopeNames = new Set<string>([
-      this.scopeTree.name,
+      this.scopeTreeManager.getRootName(),
     ]);
     this.externalFunctionCalls = this.externalFunctionCalls.filter((efc) => {
-      const efcName = efc.name.split('<')[0];
+      const efcName = this.pathManager.stripGenerics(efc.name);
       for (const manager of this.equivalencyManagers) {
         if (manager.internalFunctions.has(efcName)) {
           return false;
@@ -309,65 +546,71 @@ export class ScopeDataStructure {
       validExternalFacingScopeNames.add(efcName);
       return true;
     });
+    this.invalidateExternalFunctionCallsIndex();
+
+    // Pre-compute array methods list once (avoids Array.from() in hot loop)
+    const arrayMethodsList = Array.from(arrayMethodsSet);
+    const containsArrayMethod = (path: string) =>
+      arrayMethodsList.some((method) => path.includes(`.${method}(`));
 
     for (const entry of this.equivalencyDatabase) {
-      entry.usages = entry.usages.filter(
-        (usage) =>
-          validExternalFacingScopeNames.has(
-            usage.scopeNodeName.split('<')[0],
-          ) &&
+      entry.usages = entry.usages.filter((usage) => {
+        const baseName = this.pathManager.stripGenerics(usage.scopeNodeName);
+        return (
+          validExternalFacingScopeNames.has(baseName) &&
           (usage.schemaPath.startsWith('returnValue') ||
-            usage.schemaPath.startsWith(usage.scopeNodeName.split('<')[0])) &&
-          !Array.from(arrayMethodsSet).some((method) =>
-            usage.schemaPath.includes(`.${method}(`),
-          ),
-      );
-      entry.sourceCandidates = entry.sourceCandidates.filter(
-        (candidate) =>
-          validExternalFacingScopeNames.has(
-            candidate.scopeNodeName.split('<')[0],
-          ) &&
+            usage.schemaPath.startsWith(baseName)) &&
+          !containsArrayMethod(usage.schemaPath)
+        );
+      });
+      entry.sourceCandidates = entry.sourceCandidates.filter((candidate) => {
+        const baseName = this.pathManager.stripGenerics(
+          candidate.scopeNodeName,
+        );
+        return (
+          validExternalFacingScopeNames.has(baseName) &&
           (candidate.schemaPath.startsWith('signature[') ||
-            candidate.schemaPath.startsWith(
-              candidate.scopeNodeName.split('<')[0],
-            )) &&
-          !Array.from(arrayMethodsSet).some((method) =>
-            candidate.schemaPath.includes(`.${method}(`),
-          ),
-      );
+            candidate.schemaPath.startsWith(baseName)) &&
+          !containsArrayMethod(candidate.schemaPath)
+        );
+      });
     }
 
     this.propagateSourceAndUsageEquivalencies(
-      this.scopeNodes[this.scopeTree.name],
+      this.scopeNodes[this.scopeTreeManager.getRootName()],
     );
 
     for (const externalFunctionCall of this.externalFunctionCalls) {
-      const t = new Date().getTime();
-      // console.info("Start Propagating", JSON.stringify({
-      //   externalFunctionCallName: externalFunctionCall.name,
-      //   // sourceEquivalencies: externalFunctionCall.sourceEquivalencies,
-      // }, null, 2));
-
       this.propagateSourceAndUsageEquivalencies(externalFunctionCall);
-
-      const elapsedTime = new Date().getTime() - t;
-      if (elapsedTime > 100) {
-        console.warn('Long Propagation Time', {
-          externalFunctionCallName: externalFunctionCall.name,
-          time: elapsedTime,
-        });
-        // throw new Error("STOP - LONG PROPAGATION TIME")
-      }
-
-      // console.info("Done Propagating", JSON.stringify({
-      //   externalFunctionCallName: externalFunctionCall.name,
-      //   // sourceEquivalencies: externalFunctionCall.sourceEquivalencies,
-      //   // usageEquivalencies: externalFunctionCall.usageEquivalencies,
-      //   time: elapsedTime
-      // }, null, 2))
     }
   }
 
+  /**
+   * Core method: Adds a path/value to a scope's schema and follows equivalencies.
+   *
+   * This is the heart of schema building. For each path, it:
+   * 1. Validates the path and checks if already visited
+   * 2. Adds the path → value mapping to the scope's schema
+   * 3. Follows any equivalencies to propagate the schema to linked paths
+   * 4. Tracks the equivalency chain for source/usage database
+   *
+   * ## Cycle Detection
+   *
+   * Uses `visitedTracker.checkAndMarkGlobalVisited()` to prevent infinite loops.
+   * A path is considered visited if the exact (scope, path, value) tuple has
+   * been processed before.
+   *
+   * ## Equivalency Following
+   *
+   * When a path has equivalencies (e.g., `user` → `props.user`), this method
+   * recursively calls itself to add the equivalent path to its scope's schema.
+   *
+   * @param path - Schema path to add (e.g., 'user.id')
+   * @param value - Type value (e.g., 'string', 'number')
+   * @param scopeNode - The scope to add to
+   * @param equivalencyValueChain - Tracks the chain for database population
+   * @param traceId - Debug ID for tracing specific paths
+   */
   addToSchema({
     path,
     value,
@@ -382,11 +625,34 @@ export class ScopeDataStructure {
     traceId?: number;
   }) {
     addToSchemaCallCount++;
+
+    // Trace entry for debugging
+    this.tracer.traceEnter('addToSchema', {
+      path,
+      scope: scopeNode?.name,
+      value,
+      chainDepth: equivalencyValueChain.length,
+    });
+
+    // Safety: Detect runaway recursion
+    if (addToSchemaCallCount > 500000) {
+      console.error('INFINITE LOOP DETECTED in addToSchema', {
+        callCount: addToSchemaCallCount,
+        path,
+        value,
+        scopeNodeName: scopeNode?.name,
+      });
+      throw new Error(
+        `Infinite loop detected: addToSchema called ${addToSchemaCallCount} times`,
+      );
+    }
     // Track max chain depth
     if (equivalencyValueChain.length > maxEquivalencyChainDepth) {
       maxEquivalencyChainDepth = equivalencyValueChain.length;
     }
-    if (!scopeNode) return;
+    if (!scopeNode) {
+      return;
+    }
 
     if (!this.isValidPath(path)) {
       if (traceId) {
@@ -395,6 +661,7 @@ export class ScopeDataStructure {
       return;
     }
 
+    // Update chain metadata for database tracking
     if (equivalencyValueChain.length > 0) {
       equivalencyValueChain[equivalencyValueChain.length - 1].addToSchemaId =
         ++this.lastAddToSchemaId;
@@ -405,78 +672,18 @@ export class ScopeDataStructure {
       };
     }
 
-    // Use this debugging to track down an infinite loop
-    // traceId ||= 0;
-    // traceId += 1;
-    // if (traceId) {
-    //   console.info(JSON.stringify({ traceId, path, value, scopeNodeName: scopeNode.name }, null, 2));
-    // }
-    // if (traceId > 30) {
-    //   console.warn(
-    //     'HIGH TRACEID',
-    //     JSON.stringify(
-    //       {
-    //         path,
-    //         value,
-    //         scopeNodeName: scopeNode.name,
-    //         equivalencyValueChain,
-    //       },
-    //       null,
-    //       2,
-    //     ),
-    //   );
-    //   throw new Error('STOP - HIGH TRACEID');
-    // }
-
-    // Use this debugging to trace a specific path through the propagation
-    const debugLevel = 0; // 0 for minimal, 1 for executed paths, 2 for all paths info
-    // if ((!this.onlyEquivalencies && path === 'entity.sha') || traceId) {
-    //   traceId ||= 0;
-    //   traceId += 1;
-    //   if (traceId === 1) {
-    //     this.debugCount += 1;
-    //     if (this.debugCount > 5) throw new Error('STOP - HIGH DEBUG COUNT');
-    //     console.warn('START');
-    //   }
-
-    //   console.info(
-    //     'Debug Propagation: Adding to schema',
-    //     JSON.stringify(
-    //       {
-    //         // traceId,
-    //         path,
-    //         value,
-    //         scopeNodeName: scopeNode.name,
-    //         reason:
-    //           equivalencyValueChain[equivalencyValueChain.length - 1]?.reason,
-    //         // previous:
-    //         //   equivalencyValueChain[equivalencyValueChain.length - 1],
-    //         text: scopeNode.text,
-    //         // tree: scopeNode.tree,
-    //         // onlyEquivalencies: this.onlyEquivalencies,
-    //         // equivalencyValueChain,
-    //         // scopeNode
-    //         // instatiatedVeriables: scopeNode.instantiatedVariables,
-    //         // parentInstantiatedVariables: scopeNode.parentInstantiatedVariables,
-    //         // isolatedStructure: scopeNode.analysis.isolatedStructure,
-    //         // isolatedEquivalencies: scopeNode.analysis.isolatedEquivalentVariables,
-    //         // equivalencies: traceId === 1 ? scopeNode.equivalencies : 'skipped',
-    //         // functionCalls: scopeNode.functionCalls,
-    //         // externalFunctionCalls: this.externalFunctionCalls.filter(fc => fc.callScope.includes(scopeNode.name))
-    //       },
-    //       null,
-    //       2,
-    //     ),
-    //   );
-    //   // if (traceId > 1) traceId = undefined;
-    //   throw new Error('STOP ON ADD');
-    // }
+    // Debug level: 0=minimal, 1=executed paths, 2=all paths (set via traceId)
+    const debugLevel = 0;
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // SECTION 1: Handle complex source paths (paths with multiple data origins)
+    // ─────────────────────────────────────────────────────────────────────────
     const equivalenciesDatabaseEntry = this.getEquivalenciesDatabaseEntry(
       scopeNode.name,
       path,
     );
 
+    // Process complex source paths (before visited check, per original design)
     this.addComplexSourcePathVariables(
       equivalenciesDatabaseEntry,
       scopeNode,
@@ -485,23 +692,19 @@ export class ScopeDataStructure {
       traceId,
     );
 
-    const uniqueIdentifier = `${scopeNode.name}::${path}::${value}`;
-
-    if (this.globalVisited.has(uniqueIdentifier)) {
+    // ─────────────────────────────────────────────────────────────────────────
+    // SECTION 2: Cycle detection - skip if already visited with this value
+    // ─────────────────────────────────────────────────────────────────────────
+    if (
+      this.visitedTracker.checkAndMarkGlobalVisited(scopeNode.name, path, value)
+    ) {
       if (traceId) {
-        console.info(
-          'Debug propagation: already globally visited path',
-          JSON.stringify(
-            {
-              uniqueIdentifier,
-              // equivalencyValueChain,
-            },
-            null,
-            2,
-          ),
-        );
+        console.info('Debug: already visited', {
+          key: `${scopeNode.name}::${path}::${value}`,
+        });
       }
 
+      // Still record in database even if visited (captures full chain)
       if (!this.onlyEquivalencies) {
         this.addToEquivalencyDatabase(equivalencyValueChain, traceId);
       }
@@ -509,8 +712,7 @@ export class ScopeDataStructure {
       return;
     }
 
-    this.globalVisited.add(uniqueIdentifier);
-
+    // Continue complex source processing after visited check
     this.captureComplexSourcePaths(
       equivalenciesDatabaseEntry,
       scopeNode,
@@ -519,6 +721,10 @@ export class ScopeDataStructure {
       traceId,
     );
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // SECTION 3: Process each subpath to follow equivalencies
+    // For path "user.profile.name", processes: "user", "user.profile", "user.profile.name"
+    // ─────────────────────────────────────────────────────────────────────────
     const pathParts = this.splitPath(path);
 
     this.checkForArrayItemPath(pathParts, scopeNode, equivalencyValueChain);
@@ -637,6 +843,11 @@ export class ScopeDataStructure {
       }
     }
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // SECTION 4: Write to schema if appropriate
+    // Only writes if: (a) path not set or is 'unknown', AND
+    //                 (b) path belongs to this scope (instantiated, signature, or return)
+    // ─────────────────────────────────────────────────────────────────────────
     const writeToCurrentScopeSchema =
       (!scopeNode.schema[path] || scopeNode.schema[path] === 'unknown') &&
       (!scopeNode.instantiatedVariables ||
@@ -644,50 +855,35 @@ export class ScopeDataStructure {
         pathParts[0].startsWith('signature[') ||
         pathParts[0].startsWith('returnValue'));
 
-    // Safe early exit: if we've already set this exact schema value, skip processing
+    // Early exit if schema already has this exact value
     if (scopeNode.schema[path] === value && value !== 'unknown') {
       return;
     }
 
     if (writeToCurrentScopeSchema) {
       if (traceId && debugLevel > 0) {
-        console.info('Debug Propagation: currentScope executed', {
-          traceId,
+        console.info('Debug: writing schema', {
           path,
-          pathParts,
-          scopeNodeName: scopeNode.name,
+          value,
+          scope: scopeNode.name,
         });
       }
       scopeNode.schema[path] = value;
     }
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // SECTION 5: Record in equivalency database (Phase 2 only)
+    // ─────────────────────────────────────────────────────────────────────────
     if (!this.onlyEquivalencies) {
       this.addToEquivalencyDatabase(equivalencyValueChain, traceId);
     }
 
     if (traceId) {
-      console.info(
-        'Debug Propagation: exiting',
-        JSON.stringify(
-          {
-            traceId,
-            scopeNodeName: scopeNode.name,
-            path,
-            value,
-            // schemaValue: scopeNode.schema[path],
-            // propagated,
-            // scopeInfoText: scopeNode.text,
-            // equivalencyValueChain//: equivalencyValueChain.map(
-            //   (ev) => ev.currentPath.schemaPath,
-            // ),
-            // sourceEquivalencies: scopeNode.sourceEquivalencies[path] ?? [],
-            // usageEquivalencies: scopeNode.usageEquivalencies[path] ?? [],
-            // checkpoints,
-          },
-          null,
-          2,
-        ),
-      );
+      console.info('Debug: addToSchema complete', {
+        scope: scopeNode.name,
+        path,
+        value,
+      });
     }
   }
 
@@ -708,76 +904,143 @@ export class ScopeDataStructure {
     equivalencyValueChain?: EquivalencyValueChainItem[],
     traceId?: number,
   ) {
-    // Temporary debugging to track down unnecessary equivalencies
-    if (
-      ![
-        'original equivalency',
-        'implicit parent equivalency',
-        'explicit parent equivalency',
-        'transformed non-object function equivalency - original equivalency',
-        'equivalency to external function call',
-        'functionCall to function signature equivalency', // 1 failure
-        'explicit parent signature',
-        'useState setter call equivalency',
-        'non-object function argument function signature equivalency1',
-        'non-object function argument function signature equivalency2',
-        'returnValue to functionCallReturnValue equivalency', // 2 failures
-        '.map() function deconstruction', // 1 failure
-        'useMemo return value equivalent to first argument return value',
-        'useState value equivalency', // 1 failure
-        'Node .then() equivalency', // 1 failure
-        'Explicit array deconstruction equivalency value', // 1 failure
-        'forwardRef equivalency',
-        'forwardRef signature to child signature equivalency', // 1 failure
-        'captured function call return value equivalency', // 1 failure (in ScopeDataStructure.test.ts)
-        'original equivalency - rerouted via useCallback', // 1 failure
-        'non-object function argument function signature equivalency1 - rerouted via useCallback', // 1 failure
-        'non-object function argument function signature equivalency2 - rerouted via useCallback', // 1 failure
-        'implicit parent equivalency - rerouted via useCallback', // 1 failure
-        'Spread operator equivalency key update: implicit parent equivalency', // 1 failure
-        'Array.from() equivalency',
-      ].includes(equivalencyReason)
-    ) {
-      if (
-        [
-          'signature of functionCall',
-          'transformed non-object function equivalency - implicit parent equivalency',
-          'transformed non-object function equivalency - non-object function argument function signature equivalency1',
-          'transformed non-object function equivalency - non-object function argument function signature equivalency2',
-          'transformed non-object function equivalency - equivalency to external function call',
-          'Explicit array deconstruction equivalency key',
-          'transformed non-object function equivalency - useState setter call equivalency',
-          'transformed non-object function equivalency - implicit parent equivalency - rerouted via useCallback',
-          'transformed non-object function equivalency - Array.from() equivalency',
-          'Spread operator equivalency key update: Explicit array deconstruction equivalency value',
-        ].includes(equivalencyReason)
-      ) {
+    // DEBUG: Detect infinite loops
+    addEquivalencyCallCount++;
+    if (addEquivalencyCallCount > 50000) {
+      console.error('INFINITE LOOP DETECTED in addEquivalency', {
+        callCount: addEquivalencyCallCount,
+        path,
+        equivalentPath,
+        equivalentScopeName,
+        scopeNodeName: scopeNode.name,
+        equivalencyReason,
+      });
+      throw new Error(
+        `Infinite loop detected: addEquivalency called ${addEquivalencyCallCount} times`,
+      );
+    }
+    // Filter equivalency reasons - use pre-computed Sets for O(1) lookup
+    if (!ALLOWED_EQUIVALENCY_REASONS.has(equivalencyReason)) {
+      if (SILENTLY_IGNORED_EQUIVALENCY_REASONS.has(equivalencyReason)) {
         return;
       } else {
+        // Log and skip - if an equivalency reason isn't in ALLOWED or SILENTLY_IGNORED,
+        // it shouldn't be stored (was previously missing the return)
         console.info('Not tracked equivalency reason', { equivalencyReason });
+        return;
       }
     }
 
+    // Skip self-referential equivalencies that would create infinite loops.
+    // Case 1: Direct self-reference (path === equivalentPath)
+    // FunctionCallManager adds equivalency(subPath, subPath, externalFunctionName, ...)
+    // For simple calls like buildBranchFileMap(), this is fine.
+    // But for chained calls like query.where().where().where(), each method call adds
+    // a .functionCallReturnValue segment, and the equivalency processing creates an infinite loop.
+    // We detect chained calls by counting .functionCallReturnValue occurrences in the path.
+    if (
+      path === equivalentPath &&
+      equivalencyReason === 'equivalency to external function call'
+    ) {
+      // Count how many .functionCallReturnValue segments are in the path
+      const functionCallReturnValueCount = (
+        path.match(/\.functionCallReturnValue/g) || []
+      ).length;
+      // Skip if there are multiple chained calls (2+ .functionCallReturnValue segments)
+      if (functionCallReturnValueCount >= 2) {
+        return;
+      }
+    }
+
+    // Case 2: Circular reference where equivalentPath contains path as a prefix
+    // e.g., path="query" and equivalentPath="query.where(...).functionCallReturnValue"
+    // This happens with method chaining patterns where a variable is reassigned to
+    // the result of a method call on itself: query = query.where(...)
+    // Resolving this equivalency would require resolving query first, creating infinite recursion.
+    if (
+      equivalentPath.startsWith(path + '.') ||
+      equivalentPath.startsWith(path + '(')
+    ) {
+      return;
+    }
+
     if (!equivalentScopeName) {
-      console.warn('Debug Propagation: missing equivalent scope name', {
-        path,
-        equivalentPath,
-        equivalentScopeName,
-        scopeNodeName: scopeNode.name,
-      });
+      console.error(
+        'CodeYam Error: Missing equivalent scope name - FULL CONTEXT:',
+        JSON.stringify(
+          {
+            path,
+            equivalentPath,
+            equivalentScopeName,
+            scopeNodeName: scopeNode.name,
+            equivalencyReason,
+            tree: scopeNode.tree,
+            equivalencyValueChain: equivalencyValueChain?.map((ev) => ({
+              id: ev.id,
+              source: ev.source,
+              reason: ev.reason,
+              currentPath: ev.currentPath,
+              previousPath: ev.previousPath,
+            })),
+            scopeNodeFunctionCalls: scopeNode.functionCalls?.map((fc) => ({
+              name: fc.name,
+              callSignature: fc.callSignature,
+              callScope: fc.callScope,
+            })),
+            instantiatedVariables: scopeNode.instantiatedVariables,
+            parentInstantiatedVariables: scopeNode.parentInstantiatedVariables,
+          },
+          null,
+          2,
+        ),
+      );
       throw new Error('CodeYam Error: Missing equivalent scope name');
     }
 
     scopeNode.equivalencies[path] ||= [];
 
     const existing = scopeNode.equivalencies[path];
-    if (
-      existing.find(
-        (v) =>
-          v.schemaPath === equivalentPath &&
-          v.scopeNodeName === equivalentScopeName,
-      )
-    ) {
+    const existingEquivalency = existing.find(
+      (v) =>
+        v.schemaPath === equivalentPath &&
+        v.scopeNodeName === equivalentScopeName,
+    );
+    if (existingEquivalency) {
+      // During Phase 2 (onlyEquivalencies=false), we need to still process the equivalency
+      // to build the chain and add to the database, even if the equivalency already exists
+      if (!this.onlyEquivalencies) {
+        const equivalentScopeNode = this.getScopeOrFunctionCallInfo(
+          equivalentScopeName,
+        ) as ScopeNode;
+        if (equivalentScopeNode) {
+          // Extract function call name from path if it looks like a function call path
+          // e.g., "ChildComponent().signature[0].dataItem" -> "ChildComponent"
+          const pathMatch = path.match(/^([^().]+)\(\)/);
+          const previousPathScopeNodeName = pathMatch
+            ? pathMatch[1]
+            : scopeNode.name;
+
+          this.addToSchema({
+            path: equivalentPath,
+            value: 'unknown',
+            scopeNode: equivalentScopeNode,
+            equivalencyValueChain: [
+              ...(equivalencyValueChain ?? []),
+              {
+                id: existingEquivalency.id,
+                source: 'duplicate equivalency - Phase 2',
+                reason: equivalencyReason,
+                previousPath: {
+                  scopeNodeName: previousPathScopeNodeName,
+                  schemaPath: path,
+                  value: scopeNode.schema[path],
+                },
+              },
+            ],
+            traceId,
+          });
+        }
+      }
       return;
     }
 
@@ -884,9 +1147,9 @@ export class ScopeDataStructure {
         functionCallInfo.equivalencies = {};
       }
 
-      const existingFunctionCall = this.externalFunctionCalls.find(
-        (fc) => getFunctionCallRoot(functionCallInfo.callSignature) === fc.name,
-      );
+      const searchKey = getFunctionCallRoot(functionCallInfo.callSignature);
+      const existingFunctionCall =
+        this.getExternalFunctionCallsIndex().get(searchKey);
       if (existingFunctionCall) {
         existingFunctionCall.schema = {
           ...existingFunctionCall.schema,
@@ -897,6 +1160,22 @@ export class ScopeDataStructure {
           ...existingFunctionCall.equivalencies,
           ...functionCallInfo.equivalencies,
         };
+
+        // Track all call signatures that get merged (e.g., logger.info, logger.debug, etc.)
+        if (!existingFunctionCall.allCallSignatures) {
+          existingFunctionCall.allCallSignatures = [
+            existingFunctionCall.callSignature,
+          ];
+        }
+        if (
+          !existingFunctionCall.allCallSignatures.includes(
+            functionCallInfo.callSignature,
+          )
+        ) {
+          existingFunctionCall.allCallSignatures.push(
+            functionCallInfo.callSignature,
+          );
+        }
       } else {
         const functionCallInfoNameParts = this.splitPath(functionCallInfo.name);
         const isExternal =
@@ -909,6 +1188,7 @@ export class ScopeDataStructure {
 
         if (isExternal) {
           this.externalFunctionCalls.push(functionCallInfo);
+          this.invalidateExternalFunctionCallsIndex();
         }
       }
     }
@@ -935,7 +1215,7 @@ export class ScopeDataStructure {
     // }
 
     const getRootOrExternalFunctionCallInfo = (name: string) => {
-      return name === this.scopeTree.name
+      return name === this.scopeTreeManager.getRootName()
         ? this.getScopeNode()
         : this.getExternalFunctionCallInfo(name);
     };
@@ -966,6 +1246,40 @@ export class ScopeDataStructure {
         },
       );
 
+      // PERF: Build a Map for O(1) lookup instead of O(n) inner loop
+      // Map from "remaining parts joined" to equivalentSchemaPath
+      const equivalentSchemaPathMap = new Map<string, string>();
+      for (const equivalentSchemaPath of Object.keys(
+        equivalentScopeNode.schema,
+      )) {
+        // Quick string check before expensive path splitting
+        if (
+          !(
+            equivalentSchemaPath.startsWith(equivalentPath) ||
+            equivalentSchemaPath === equivalentPath ||
+            equivalentPath.startsWith(equivalentSchemaPath)
+          )
+        ) {
+          continue;
+        }
+
+        const equivalentSchemaPathParts = this.splitPath(equivalentSchemaPath);
+
+        if (
+          !equivalentPathParts.every(
+            (p, i) => equivalentSchemaPathParts[i] === p,
+          )
+        ) {
+          continue;
+        }
+
+        const remainingEquivalentSchemaPathParts =
+          equivalentSchemaPathParts.slice(equivalentPathParts.length);
+        // Use | as separator since it won't appear in path parts
+        const key = remainingEquivalentSchemaPathParts.join('|');
+        equivalentSchemaPathMap.set(key, equivalentSchemaPath);
+      }
+
       for (const schemaPath of relevantSchemaPaths) {
         const schemaPathParts = this.splitPath(schemaPath);
 
@@ -977,106 +1291,29 @@ export class ScopeDataStructure {
           pathParts.length,
         );
 
-        let missingEquivalentPath = false;
-
-        // Performance optimization: pre-filter equivalent schema paths
-        const relevantEquivalentSchemaPaths = Object.keys(
-          equivalentScopeNode.schema,
-        ).filter((equivalentSchemaPath) => {
-          // Quick string check before expensive path splitting
-          return (
-            equivalentSchemaPath.startsWith(equivalentPath) ||
-            equivalentSchemaPath === equivalentPath ||
-            equivalentPath.startsWith(equivalentSchemaPath)
-          );
-        });
-
-        for (const equivalentSchemaPath of relevantEquivalentSchemaPaths) {
-          const equivalentSchemaPathParts =
-            this.splitPath(equivalentSchemaPath);
-
-          if (
-            !equivalentPathParts.every(
-              (p, i) => equivalentSchemaPathParts[i] === p,
-            )
-          ) {
-            continue;
-          }
-
-          const remainingEquivalentSchemaPathParts =
-            equivalentSchemaPathParts.slice(equivalentPathParts.length);
-
-          if (
-            remainingSchemaPathParts.length !==
-              remainingEquivalentSchemaPathParts.length ||
-            !remainingEquivalentSchemaPathParts.every(
-              (p, i) => p === remainingSchemaPathParts[i],
-            )
-          ) {
-            missingEquivalentPath = true;
-            continue;
-          }
-          missingEquivalentPath = false;
+        // PERF: O(1) Map lookup instead of O(n) inner loop
+        const remainingKey = remainingSchemaPathParts.join('|');
+        const equivalentSchemaPath = equivalentSchemaPathMap.get(remainingKey);
 
+        if (equivalentSchemaPath) {
           const value1 = scopeNode.schema[schemaPath];
           const value2 = equivalentScopeNode.schema[equivalentSchemaPath];
 
-          let bestValue = value1 ?? value2 ?? 'unknown';
-          if (
-            value2 &&
-            ((bestValue === 'unknown' && value2 !== 'unknown') ||
-              (bestValue.includes('unknown') && !value2.includes('unknown')))
-          ) {
-            bestValue = value2;
-          }
+          const bestValue = selectBestValue(value1, value2);
 
           scopeNode.schema[schemaPath] = bestValue;
           equivalentScopeNode.schema[equivalentSchemaPath] = bestValue;
-
-          // if (traceId) {
-          //   console.info('Debug Propagate: Assign Best Value', {
-          //     traceId,
-          //     sourceScopeNodeName: scopeNode.name,
-          //     path,
-          //     schemaPath,
-          //     usageScopeNodeName: equivalentScopeNode.name,
-          //     equivalentPath,
-          //     equivalentSchemaPath,
-          //     remainingSchemaPathParts,
-          //     remainingEquivalentSchemaPathParts,
-          //     value1,
-          //     value2,
-          //     bestValue,
-          //   });
-          // }
-          break;
-        }
-
-        if (
-          missingEquivalentPath &&
-          (scopeNode.name.includes('____cyScope') ||
-            !('instantiatedVariables' in equivalentScopeNode))
+        } else if (
+          scopeNode.name.includes('____cyScope') ||
+          !('instantiatedVariables' in equivalentScopeNode)
         ) {
+          // No matching equivalent path found - create one if needed
           // Only necessary for internal function scopes or external function scopes
           const newEquivalentPath = this.joinPathParts([
             equivalentPath,
             ...remainingSchemaPathParts,
           ]);
 
-          // if (traceId) {
-          //   console.info('Debug Propagate: missing equivalent path', {
-          //     traceId,
-          //     scopeNodeName: scopeNode.name,
-          //     path,
-          //     equivalentPath,
-          //     schemaPath,
-          //     remainingSchemaPathParts,
-          //     equivalentScopeNodeName: equivalentScopeNode.name,
-          //     // equivalentScopeNodeSchema: equivalentScopeNode.schema,
-          //     newEquivalentPath,
-          //   });
-          // }
-
           equivalentScopeNode.schema[newEquivalentPath] =
             scopeNode.schema[schemaPath];
         }
@@ -1118,111 +1355,57 @@ export class ScopeDataStructure {
     }
   }
 
-  splitPath(path: string): string[] {
-    if (this.pathPartsCache.has(path)) {
-      return structuredClone(this.pathPartsCache.get(path)!);
-    }
-    const pathParts = splitOutsideParenthesesAndArrays(path);
-    this.pathPartsCache.set(path, structuredClone(pathParts));
-    return pathParts;
+  splitPath(path: string): readonly string[] {
+    return this.pathManager.splitPath(path);
   }
 
-  joinPathParts(pathParts: string[]): string {
-    const cacheKey = pathParts.join('|');
-    if (this.pathJoinCache.has(cacheKey)) {
-      return this.pathJoinCache.get(cacheKey)!;
+  joinPathParts(pathParts: readonly string[]): string {
+    return this.pathManager.joinPathParts(pathParts);
+  }
+
+  /**
+   * Extracts the root variable name from a path.
+   * E.g., "collected[]" -> "collected", "foo.bar" -> "foo", "collected[0]" -> "collected"
+   */
+  extractRootVariable(path: string): string | null {
+    const parts = this.splitPath(path);
+    if (parts.length === 0) return null;
+
+    const firstPart = parts[0];
+    // Strip array notation: "collected[]" -> "collected", "collected[0]" -> "collected"
+    const bracketIndex = firstPart.indexOf('[');
+    if (bracketIndex > 0) {
+      return firstPart.substring(0, bracketIndex);
     }
-    const result = joinParenthesesAndArrays(pathParts);
-    this.pathJoinCache.set(cacheKey, result);
-    return result;
+    return firstPart;
   }
 
   // PRIVATE METHODS //
 
-  private uniqueId({
-    scopeNodeName,
-    schemaPath,
-    value,
-  }: {
+  private uniqueId(params: {
     scopeNodeName: string;
     schemaPath: string;
     value?: string;
   }): string {
-    const parts = [scopeNodeName, schemaPath, value].filter(Boolean);
-    return parts.join('::');
+    return uniqueId(params);
   }
 
   private uniqueScopeVariables(scopeVariables: ScopeVariable[]) {
-    return this.uniqueScopeAndPaths(scopeVariables) as ScopeVariable[];
+    return uniqueScopeVariables(scopeVariables);
   }
 
   private uniqueScopeAndPaths(
     scopeVariables: Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[],
   ) {
-    if (!scopeVariables || scopeVariables.length === 0) return [];
-
-    // Optimize from O(n²) to O(n) using Set for deduplication
-    const seen = new Set<string>();
-    return scopeVariables.filter((varItem) => {
-      const key = `${varItem.scopeNodeName}::${varItem.schemaPath}`;
-      if (seen.has(key)) {
-        return false;
-      }
-      seen.add(key);
-      return true;
-    });
+    return uniqueScopeAndPaths(scopeVariables);
   }
 
   private isValidPath(path: string): boolean {
-    if (typeof path !== 'string') {
-      return false;
-    }
-
-    if (!path) {
-      return false;
-    }
-
-    if (path === 'true' || path === 'false') {
-      return false;
-    }
-
-    if (!isNaN(Number(path))) {
-      return false;
-    }
-
-    if (path.match(/^['"]/)) {
-      return false;
-    }
-
-    return this.splitPath(path).every((part) => {
-      if (
-        cleanOutBoundary(
-          cleanOutBoundary(cleanOutBoundary(part, '<', '>'), '[', ']'),
-        ).match(/\s/)
-      ) {
-        return false;
-      }
-      return true;
-    });
+    return this.pathManager.isValidPath(path);
   }
 
   private addToTree(pathParts: string[]) {
-    let scopeTreeNode = { children: [this.scopeTree] };
-    for (const pathPart of pathParts) {
-      const existingChild = scopeTreeNode.children.find(
-        (child) => child.name === pathPart,
-      );
-      if (existingChild) {
-        scopeTreeNode = existingChild;
-      } else {
-        const childScopeTreeNode = {
-          name: pathPart,
-          children: [] as any[],
-        };
-        scopeTreeNode.children.push(childScopeTreeNode);
-        scopeTreeNode = childScopeTreeNode;
-      }
-    }
+    this.scopeTreeManager.addPath(pathParts);
   }
 
   private setInstantiatedVariables(scopeNode: ScopeNode) {
@@ -1292,6 +1475,41 @@ export class ScopeDataStructure {
     const { isolatedStructure, isolatedEquivalentVariables } =
       scopeNode.analysis;
 
+    // DEBUG: Log all equivalencies related to useFetcher
+    if (
+      Object.keys(isolatedEquivalentVariables || {}).some(
+        (k) => k.includes('Fetcher') || k.includes('fetcher'),
+      )
+    ) {
+      console.log(
+        'CodeYam DEBUG determineEquivalenciesAndBuildSchema:',
+        JSON.stringify(
+          {
+            scopeNodeName: scopeNode.name,
+            fetcherEquivalencies: Object.entries(
+              isolatedEquivalentVariables || {},
+            )
+              .filter(
+                ([k, v]) =>
+                  k.includes('Fetcher') ||
+                  k.includes('fetcher') ||
+                  String(v).includes('Fetcher') ||
+                  String(v).includes('fetcher'),
+              )
+              .reduce(
+                (acc, [k, v]) => {
+                  acc[k] = v;
+                  return acc;
+                },
+                {} as Record<string, string>,
+              ),
+          },
+          null,
+          2,
+        ),
+      );
+    }
+
     const allPaths = Array.from(
       new Set([
         ...Object.keys(isolatedStructure || {}),
@@ -1317,9 +1535,143 @@ export class ScopeDataStructure {
           scopeNode,
           'original equivalency',
         );
+
+        // Propagate equivalencies involving parent-scope variables to those parent scopes.
+        // This handles patterns like: collected.push({...entity}) where 'collected' is defined
+        // in a parent scope. The equivalency collected[] -> push().signature[0] needs to be
+        // visible when tracing from the parent scope.
+        const rootVariable = this.extractRootVariable(path);
+        const equivalentRootVariable =
+          this.extractRootVariable(equivalentValue);
+
+        // Skip propagation for self-referential reassignment patterns like:
+        //   x = x.method().functionCallReturnValue
+        // where the path IS the variable itself (not a sub-path like x[] or x.prop).
+        // These create circular references since both sides reference the same variable.
+        //
+        // But DO propagate for patterns like collected[] -> collected.push(...).signature[0]
+        // where the path has additional segments beyond the root variable.
+        const pathIsJustRootVariable = path === rootVariable;
+        const isSelfReferentialReassignment =
+          pathIsJustRootVariable && rootVariable === equivalentRootVariable;
+
+        if (
+          rootVariable &&
+          !isSelfReferentialReassignment &&
+          scopeNode.parentInstantiatedVariables?.includes(rootVariable)
+        ) {
+          // Find the parent scope where this variable is defined
+          for (const parentScopeName of scopeNode.tree || []) {
+            const parentScope = this.scopeNodes[parentScopeName];
+            if (parentScope?.instantiatedVariables?.includes(rootVariable)) {
+              // Add the equivalency to the parent scope as well
+              this.addEquivalency(
+                path,
+                equivalentValue,
+                scopeNode.name, // The equivalent path's scope remains the child scope
+                parentScope, // But store it in the parent scope's equivalencies
+                'propagated parent-variable equivalency',
+              );
+              break;
+            }
+          }
+        }
+
+        // Propagate sub-property equivalencies when the equivalentValue is a simple variable
+        // that has sub-properties defined in the isolatedEquivalentVariables.
+        // This handles cases like: dataItem={{ structure: completeDataStructure }}
+        // where completeDataStructure has sub-properties like completeDataStructure['Function Arguments']
+        // We need to propagate these to create: dataItem.structure['Function Arguments'] equivalencies
+        const isSimpleVariable =
+          !equivalentValue.startsWith('signature[') &&
+          !equivalentValue.includes('functionCallReturnValue') &&
+          !equivalentValue.includes('.') &&
+          !equivalentValue.includes('[');
+
+        if (isSimpleVariable) {
+          // Look in current scope and all parent scopes for sub-properties
+          const scopesToCheck = [scopeNode.name, ...scopeNode.tree];
+          for (const scopeName of scopesToCheck) {
+            const checkScope = this.scopeNodes[scopeName];
+            if (!checkScope?.analysis?.isolatedEquivalentVariables) continue;
+
+            for (const [subPath, subValue] of Object.entries(
+              checkScope.analysis.isolatedEquivalentVariables,
+            )) {
+              // Check if this is a sub-property of the equivalentValue variable
+              // e.g., completeDataStructure['Function Arguments'] or completeDataStructure.foo
+              const matchesDot = subPath.startsWith(equivalentValue + '.');
+              const matchesBracket = subPath.startsWith(equivalentValue + '[');
+              if (matchesDot || matchesBracket) {
+                const subPropertyPath = subPath.substring(
+                  equivalentValue.length,
+                );
+                const newPath = cleanPath(path + subPropertyPath, allPaths);
+                const newEquivalentValue = cleanPath(
+                  (subValue as string).replace(/::cyDuplicateKey\d+::/g, ''),
+                  allPaths,
+                );
+
+                if (
+                  newEquivalentValue &&
+                  this.isValidPath(newEquivalentValue)
+                ) {
+                  this.addEquivalency(
+                    newPath,
+                    newEquivalentValue,
+                    checkScope.name, // Use the scope where the sub-property was found
+                    scopeNode,
+                    'propagated sub-property equivalency',
+                  );
+                }
+              }
+
+              // Also check if equivalentValue itself maps to a functionCallReturnValue
+              // e.g., result = useMemo(...).functionCallReturnValue
+              if (
+                subPath === equivalentValue &&
+                typeof subValue === 'string' &&
+                subValue.endsWith('.functionCallReturnValue')
+              ) {
+                this.propagateFunctionCallReturnSubProperties(
+                  path,
+                  subValue,
+                  scopeNode,
+                  allPaths,
+                );
+              }
+            }
+          }
+        }
+
+        // Handle function call return values by propagating returnValue.* sub-properties
+        // from the callback scope to the usage path
+        if (equivalentValue.endsWith('.functionCallReturnValue')) {
+          this.propagateFunctionCallReturnSubProperties(
+            path,
+            equivalentValue,
+            scopeNode,
+            allPaths,
+          );
+
+          // Track which variable receives the return value of each function call
+          // This enables generating separate mock data for each call site
+          this.trackReceivingVariable(path, equivalentValue);
+        }
+
+        // Also track variables that receive destructured properties from function call return values
+        // e.g., "userData" -> "db.query('users').functionCallReturnValue.data"
+        if (equivalentValue.includes('.functionCallReturnValue.')) {
+          this.trackReceivingVariable(path, equivalentValue);
+        }
       }
     }
 
+    // PERF: Enable batch processing to convert recursive addToSchema calls to iterative
+    // This eliminates deep call stacks and improves deduplication
+    this.batchProcessor = new BatchSchemaProcessor();
+    this.batchQueuedSet = new Set();
+
     for (const key of Array.from(allPaths)) {
       let value = isolatedStructure[key] ?? 'unknown';
 
@@ -1327,7 +1679,6 @@ export class ScopeDataStructure {
         value = 'unknown';
       }
 
-      const startTime = new Date().getTime();
       this.addToSchema({
         path: cleanPath(key, allPaths),
         value,
@@ -1341,31 +1692,388 @@ export class ScopeDataStructure {
         ],
       });
 
-      // const timeDiff = new Date().getTime() - startTime;
-      // if (timeDiff / 1000 > 1) {
-      //   console.info('SLOW', {
-      //     timeDiff,
-      //     root: this.scopeTree.name,
-      //     scopeNodeName: scopeNode.name,
-      //     schemaPath: key,
-      //     onlyEquivalencies: this.onlyEquivalencies,
-      //   });
-      // }
+      // Process any work queued by followEquivalencies
+      this.processBatchQueue();
     }
 
+    // Final pass to ensure all queued work is processed
+    this.processBatchQueue();
+
+    // Clean up batch processor
+    this.batchProcessor = null;
+    this.batchQueuedSet = null;
+
     this.validateSchema(scopeNode, false, false);
   }
 
+  /**
+   * Process all items in the batch queue.
+   * Each item may queue more work via followEquivalencies.
+   */
+  private processBatchQueue(): void {
+    if (!this.batchProcessor) return;
+
+    while (this.batchProcessor.hasWork()) {
+      const item = this.batchProcessor.getNextWork();
+      if (!item) break;
+
+      const scopeNode = this.getScopeOrFunctionCallInfo(
+        item.scopeNodeName,
+      ) as ScopeNode;
+      if (!scopeNode) continue;
+
+      this.addToSchema({
+        path: item.path,
+        value: item.value,
+        scopeNode,
+        equivalencyValueChain:
+          item.equivalencyValueChain as EquivalencyValueChainItem[],
+        traceId: item.traceId,
+      });
+    }
+  }
+
+  /**
+   * Tracks which variable receives the return value of a function call.
+   *
+   * When we encounter an equivalency like:
+   *   result1 -> db.select(query1).functionCallReturnValue
+   *
+   * This method extracts the call signature (db.select(query1)) and maps it
+   * to the receiving variable (result1) on the corresponding FunctionCallInfo.
+   *
+   * This enables generating separate mock data for each call site when the same
+   * function is called multiple times with different arguments.
+   */
+  private trackReceivingVariable(
+    receivingVariable: string,
+    equivalentValue: string,
+  ): void {
+    // Extract the call signature by finding the .functionCallReturnValue part
+    // and taking everything before it
+    // Handles both:
+    //   "db.select(query1).functionCallReturnValue" -> "db.select(query1)"
+    //   "db.query('users').functionCallReturnValue.data" -> "db.query('users')"
+    const funcReturnIdx = equivalentValue.indexOf('.functionCallReturnValue');
+    if (funcReturnIdx === -1) {
+      return;
+    }
+    const callSignature = equivalentValue.substring(0, funcReturnIdx);
+
+    // Skip if the receiving variable is not a simple identifier
+    // (e.g., skip if it's a path like "obj.property" or contains array access)
+    if (receivingVariable.includes('.') || receivingVariable.includes('[')) {
+      return;
+    }
+
+    // Find the FunctionCallInfo that matches this call signature
+    const searchKey = getFunctionCallRoot(callSignature);
+    const functionCallInfo =
+      this.getExternalFunctionCallsIndex().get(searchKey);
+
+    // DEBUG: Track useFetcher calls
+    if (searchKey === 'useFetcher' || callSignature.includes('useFetcher')) {
+      console.log(
+        'CodeYam DEBUG trackReceivingVariable:',
+        JSON.stringify(
+          {
+            receivingVariable,
+            equivalentValue,
+            callSignature,
+            searchKey,
+            foundFunctionCallInfo: !!functionCallInfo,
+            existingRecvVars: functionCallInfo?.receivingVariableNames,
+            existingCallSigToVar: functionCallInfo?.callSignatureToVariable,
+          },
+          null,
+          2,
+        ),
+      );
+    }
+
+    if (!functionCallInfo) {
+      return;
+    }
+
+    // Initialize arrays if needed
+    if (!functionCallInfo.receivingVariableNames) {
+      functionCallInfo.receivingVariableNames = [];
+    }
+    if (!functionCallInfo.callSignatureToVariable) {
+      functionCallInfo.callSignatureToVariable = {};
+    }
+
+    // Add the receiving variable to the list (if not already present)
+    if (!functionCallInfo.receivingVariableNames.includes(receivingVariable)) {
+      functionCallInfo.receivingVariableNames.push(receivingVariable);
+    }
+
+    // Map the call signature to its receiving variable
+    // Use the full call signature (not the search key) for precise mapping
+    functionCallInfo.callSignatureToVariable[callSignature] = receivingVariable;
+  }
+
+  /**
+   * Propagates returnValue.* sub-properties from a callback scope to the usage path.
+   *
+   * When we have an equivalency like:
+   *   DataItemEditor().signature[0].structure -> getData().functionCallReturnValue
+   *
+   * And the callback scope for getData has:
+   *   returnValue.args -> dataStructure.arguments
+   *
+   * This method creates the transitive equivalency:
+   *   DataItemEditor().signature[0].structure.args -> signature[0].dataStructure.arguments
+   *
+   * It also resolves variable references through parent scopes (e.g., dataStructure -> signature[0].dataStructure)
+   * and ensures the database entry is updated with the usage path.
+   */
+  private propagateFunctionCallReturnSubProperties(
+    path: string,
+    equivalentValue: string,
+    scopeNode: ScopeNode,
+    allPaths: string[],
+  ) {
+    // Try to find the callback scope name from different patterns:
+    // 1. "getData().functionCallReturnValue" → look up getData variable to find scope
+    // 2. "useMemo(cyScope1(), [...]).functionCallReturnValue" → extract cyScope1 directly
+    let callbackScopeName: string | undefined;
+
+    // Pattern 1: Simple function call like getData().functionCallReturnValue
+    const simpleFunctionMatch = equivalentValue.match(
+      /^(\w+)\(\)\.functionCallReturnValue$/,
+    );
+    if (simpleFunctionMatch) {
+      const functionName = simpleFunctionMatch[1];
+      // Find the function reference in current or parent scopes
+      const scopesToCheck = [scopeNode.name, ...scopeNode.tree];
+      for (const scopeName of scopesToCheck) {
+        const checkScope = this.scopeNodes[scopeName];
+        if (!checkScope?.analysis?.isolatedEquivalentVariables) continue;
+
+        const functionRef =
+          checkScope.analysis.isolatedEquivalentVariables[functionName];
+        if (typeof functionRef === 'string' && functionRef.endsWith('F')) {
+          callbackScopeName = functionRef.slice(0, -1);
+          break;
+        }
+      }
+    }
+
+    // Pattern 2: useMemo/useCallback with callback scope
+    // e.g., "useMemo(cyScope1(), [deps]).functionCallReturnValue"
+    if (!callbackScopeName) {
+      const useMemoMatch = equivalentValue.match(
+        /^useMemo\((\w+)\(\),\s*\[.*\]\)\.functionCallReturnValue$/,
+      );
+      if (useMemoMatch) {
+        callbackScopeName = useMemoMatch[1];
+      }
+    }
+
+    if (!callbackScopeName) return;
+
+    const callbackScope = this.scopeNodes[callbackScopeName];
+    if (!callbackScope) return;
+
+    // Look for returnValue.* sub-properties in the callback scope
+    if (!callbackScope.analysis?.isolatedEquivalentVariables) return;
+
+    const isolatedVars = callbackScope.analysis.isolatedEquivalentVariables;
+
+    // First, check if returnValue is an alias to another variable (e.g., returnValue = intermediate)
+    // If so, we need to look for that variable's sub-properties too
+    const returnValueAlias =
+      typeof isolatedVars.returnValue === 'string' &&
+      !isolatedVars.returnValue.includes('.')
+        ? isolatedVars.returnValue
+        : undefined;
+
+    // Pattern 3: Object.keys(X).reduce() - the reduce result has the same sub-properties as X
+    // When returnValue = "Object.keys(source).reduce(...).functionCallReturnValue", look for source.* sub-properties
+    let reduceSourceVar: string | undefined;
+    if (typeof isolatedVars.returnValue === 'string') {
+      const reduceMatch = isolatedVars.returnValue.match(
+        /^Object\.keys\((\w+)\)\.reduce\(.*\)\.functionCallReturnValue$/,
+      );
+      if (reduceMatch) {
+        reduceSourceVar = reduceMatch[1];
+      }
+    }
+
+    for (const [subPath, subValue] of Object.entries(isolatedVars)) {
+      // Check for direct returnValue.* sub-properties
+      const isReturnValueSub =
+        subPath.startsWith('returnValue.') ||
+        subPath.startsWith('returnValue[');
+
+      // Also check for alias.* sub-properties (e.g., intermediate.args when returnValue = intermediate)
+      const isAliasSub =
+        returnValueAlias &&
+        (subPath.startsWith(returnValueAlias + '.') ||
+          subPath.startsWith(returnValueAlias + '['));
+
+      // Also check for reduce source.* sub-properties (e.g., source['Function Arguments'] when returnValue = Object.keys(source).reduce())
+      const isReduceSourceSub =
+        reduceSourceVar &&
+        (subPath.startsWith(reduceSourceVar + '.') ||
+          subPath.startsWith(reduceSourceVar + '['));
+
+      if (
+        typeof subValue !== 'string' ||
+        (!isReturnValueSub && !isAliasSub && !isReduceSourceSub)
+      )
+        continue;
+
+      // Convert alias/reduceSource paths to returnValue paths
+      let effectiveSubPath = subPath;
+      if (isAliasSub && !isReturnValueSub) {
+        // Replace the alias prefix with returnValue
+        effectiveSubPath =
+          'returnValue' + subPath.substring(returnValueAlias!.length);
+      } else if (isReduceSourceSub && !isReturnValueSub && !isAliasSub) {
+        // Replace the reduce source prefix with returnValue
+        effectiveSubPath =
+          'returnValue' + subPath.substring(reduceSourceVar!.length);
+      }
+      const subPropertyPath = effectiveSubPath.substring('returnValue'.length);
+      const newPath = cleanPath(path + subPropertyPath, allPaths);
+      let newEquivalentValue = cleanPath(
+        subValue.replace(/::cyDuplicateKey\d+::/g, ''),
+        allPaths,
+      );
+
+      // Resolve variable references through parent scope equivalencies
+      const resolved = this.resolveVariableThroughParentScopes(
+        newEquivalentValue,
+        callbackScope,
+        allPaths,
+      );
+      newEquivalentValue = resolved.resolvedPath;
+      const equivalentScopeName = resolved.scopeName;
+
+      if (!newEquivalentValue || !this.isValidPath(newEquivalentValue))
+        continue;
+
+      this.addEquivalency(
+        newPath,
+        newEquivalentValue,
+        equivalentScopeName,
+        scopeNode,
+        'propagated function call return sub-property equivalency',
+      );
+
+      // Ensure the database entry has the usage path
+      this.addUsageToEquivalencyDatabaseEntry(
+        newPath,
+        newEquivalentValue,
+        equivalentScopeName,
+        scopeNode.name,
+      );
+    }
+  }
+
+  /**
+   * Resolves a variable path through parent scope equivalencies.
+   *
+   * For example, if the path is "dataStructure.arguments" and the parent scope has
+   * dataStructure -> signature[0].dataStructure, this returns:
+   *   { resolvedPath: "signature[0].dataStructure.arguments", scopeName: "ParentScope" }
+   */
+  private resolveVariableThroughParentScopes(
+    path: string | undefined,
+    callbackScope: ScopeNode,
+    allPaths: string[],
+  ): { resolvedPath: string | undefined; scopeName: string } {
+    if (!path)
+      return { resolvedPath: undefined, scopeName: callbackScope.name };
+
+    // Extract the root variable name
+    const dotIndex = path.indexOf('.');
+    const bracketIndex = path.indexOf('[');
+    let firstDelimiter = -1;
+    if (dotIndex > -1 && bracketIndex > -1) {
+      firstDelimiter = Math.min(dotIndex, bracketIndex);
+    } else {
+      firstDelimiter = dotIndex > -1 ? dotIndex : bracketIndex;
+    }
+
+    if (firstDelimiter === -1)
+      return { resolvedPath: path, scopeName: callbackScope.name };
+
+    const rootVar = path.substring(0, firstDelimiter);
+    const restOfPath = path.substring(firstDelimiter);
+
+    // Look in parent scopes for the root variable's equivalency
+    for (const parentScopeName of callbackScope.tree || []) {
+      const parentScope = this.scopeNodes[parentScopeName];
+      if (!parentScope?.analysis?.isolatedEquivalentVariables) continue;
+
+      const rootEquiv =
+        parentScope.analysis.isolatedEquivalentVariables[rootVar];
+      if (typeof rootEquiv === 'string') {
+        return {
+          resolvedPath: cleanPath(rootEquiv + restOfPath, allPaths),
+          scopeName: parentScopeName,
+        };
+      }
+    }
+
+    return { resolvedPath: path, scopeName: callbackScope.name };
+  }
+
+  /**
+   * Adds a usage path to the equivalency database entry that has the given source.
+   *
+   * The addEquivalency call creates the equivalency but doesn't always properly
+   * link the usage in the database, so we need to do it explicitly.
+   */
+  private addUsageToEquivalencyDatabaseEntry(
+    usagePath: string,
+    sourcePath: string,
+    sourceScopeName: string,
+    fallbackScopeName: string,
+  ) {
+    const usageEntry = {
+      scopeNodeName: usagePath.match(/^([^().]+)\(\)/)
+        ? (usagePath.match(/^([^().]+)\(\)/)?.[1] ?? fallbackScopeName)
+        : fallbackScopeName,
+      schemaPath: usagePath,
+    };
+
+    const sourceKey = `${sourceScopeName}::${sourcePath}`;
+    for (const entry of this.equivalencyDatabase) {
+      if (
+        entry.intermediatesOrder[sourceKey] === 0 ||
+        entry.sourceCandidates.some(
+          (sc) =>
+            sc.scopeNodeName === sourceScopeName &&
+            sc.schemaPath === sourcePath,
+        )
+      ) {
+        const usageExists = entry.usages.some(
+          (u) =>
+            u.scopeNodeName === usageEntry.scopeNodeName &&
+            u.schemaPath === usageEntry.schemaPath,
+        );
+        if (!usageExists) {
+          entry.usages.push(usageEntry);
+        }
+        break;
+      }
+    }
+  }
+
   private checkForArrayItemPath(
-    pathParts: string[],
+    pathParts: readonly string[],
     scopeNode: ScopeNode,
     equivalencyValueChain: EquivalencyValueChainItem[],
   ) {
-    const arrayItemPath = joinParenthesesAndArrays([...pathParts, '[]']);
+    const arrayItemPath = this.joinPathParts([...pathParts, '[]']);
     if (scopeNode.equivalencies[arrayItemPath]) {
       const firstEquivalency = equivalencyValueChain[0].currentPath;
-      const newFirstEquivalencyPath = joinParenthesesAndArrays([
-        ...splitOutsideParenthesesAndArrays(firstEquivalency.schemaPath),
+      const newFirstEquivalencyPath = this.joinPathParts([
+        ...this.splitPath(firstEquivalency.schemaPath),
         '[]',
       ]);
       this.addToSchema({
@@ -1383,41 +2091,95 @@ export class ScopeDataStructure {
     }
   }
 
+  /**
+   * Follows equivalencies for a subpath and recursively calls addToSchema.
+   *
+   * This is the recursive heart of schema propagation. When we have:
+   *   `user` equivalent to `props.user`
+   * And we're processing `user.id`, this method will:
+   * 1. Find the equivalency `user` → `props.user`
+   * 2. Reconstruct the full path: `props.user.id`
+   * 3. Recursively call addToSchema for the equivalent scope
+   *
+   * ## Function-Ambivalent Paths
+   *
+   * Handles paths like `data.map(fn)` by also checking equivalencies
+   * for `data.map` (without the function argument). This allows
+   * array method chains to propagate correctly.
+   *
+   * @param scopeNode - Current scope being processed
+   * @param path - Full original path (e.g., 'user.profile.name')
+   * @param pathParts - Split version of path
+   * @param subPath - Current subpath being checked (e.g., 'user.profile')
+   * @param subPathParts - Split version of subPath
+   * @param value - Type value to propagate
+   * @param equivalencyValueChain - Chain tracking for database
+   * @param traceId - Debug ID
+   * @param debugLevel - 0=minimal, 1=executed, 2=verbose
+   */
   private followEquivalencies(
     scopeNode: ScopeNode,
     path: string,
-    pathParts: string[],
+    pathParts: readonly string[],
     subPath: string,
-    subPathParts: string[],
+    subPathParts: readonly string[],
     value: string,
     equivalencyValueChain: EquivalencyValueChainItem[],
     traceId?: number,
     debugLevel = 0,
   ) {
     followEquivalenciesCallCount++;
+
+    // Trace for debugging
+    this.tracer.trace('followEquivalencies', {
+      path,
+      scope: scopeNode.name,
+      subPath,
+      hasEquivalencies: (scopeNode.equivalencies[subPath]?.length ?? 0) > 0,
+    });
+
     let propagated = false;
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Step 1: Collect equivalencies (including function-ambivalent paths)
+    // ─────────────────────────────────────────────────────────────────────────
     let equivalentValues = scopeNode.equivalencies[subPath] ?? [];
     let functionAmbivalentSubPath = subPath;
     let functionAmbivalentSubPathParts = subPathParts;
 
-    if (subPathParts[subPathParts.length - 1].indexOf('(') > -1) {
+    // For paths like `data.map(fn)`, also check `data.map` equivalencies
+    // PERF: Only do the expensive function-ambivalent processing if:
+    // 1. No equivalencies found yet, AND
+    // 2. The subpath ends with a function call (contains '(')
+    const lastPart = subPathParts[subPathParts.length - 1];
+    if (lastPart.indexOf('(') > -1) {
+      // Check function-ambivalent path for equivalencies
       functionAmbivalentSubPathParts = [
         ...subPathParts.slice(0, -1),
-        subPathParts[subPathParts.length - 1].split('(')[0],
+        lastPart.split('(')[0],
       ];
       functionAmbivalentSubPath = this.joinPathParts(
         functionAmbivalentSubPathParts,
       );
-      equivalentValues = [
-        ...(equivalentValues ?? []),
-        ...(scopeNode.equivalencies[functionAmbivalentSubPath] ?? []),
-      ];
+      const functionAmbivalentEquivalencies =
+        scopeNode.equivalencies[functionAmbivalentSubPath];
+      if (functionAmbivalentEquivalencies?.length > 0) {
+        equivalentValues = [
+          ...equivalentValues,
+          ...functionAmbivalentEquivalencies,
+        ];
+      }
     }
 
     // Early exit optimization: if no equivalencies to follow, skip expensive processing
     if (equivalentValues.length === 0) {
+      followEquivalenciesEarlyExitCount++;
+      if (this.onlyEquivalencies) {
+        followEquivalenciesEarlyExitPhase1Count++;
+      }
       return false;
     }
+    followEquivalenciesWithWorkCount++;
 
     if (traceId && debugLevel > 1) {
       console.info(
@@ -1443,12 +2205,21 @@ export class ScopeDataStructure {
 
     const uniqueEquivalentValues = this.uniqueScopeVariables(equivalentValues);
 
+    // PERF: Only create Set when chain is non-empty (common case avoids allocation)
+    // Pre-compute Set of chain IDs for O(1) cycle detection instead of O(n) .some()
+    const chainIdSet =
+      equivalencyValueChain.length > 0
+        ? new Set(equivalencyValueChain.map((ev) => ev.id))
+        : null;
+
     for (let index = 0; index < uniqueEquivalentValues.length; ++index) {
       const equivalentValue = uniqueEquivalentValues[index];
 
+      // O(1) cycle check using Set instead of O(n) .some()
       if (
+        chainIdSet &&
         equivalentValue.id !== -1 &&
-        equivalencyValueChain.some((ev) => ev.id === equivalentValue.id)
+        chainIdSet.has(equivalentValue.id)
       ) {
         if (traceId) {
           console.info(
@@ -1499,8 +2270,12 @@ export class ScopeDataStructure {
         schemaPathParts[schemaPathParts.length - 1] ===
           lastRelevantSubPathPart.split('(')[0]
       ) {
-        schemaPathParts[schemaPathParts.length - 1] = lastRelevantSubPathPart;
-        schemaPath = this.joinPathParts(schemaPathParts);
+        // PERF: Don't mutate the array - create a new one to avoid requiring structuredClone
+        const updatedSchemaPathParts = [
+          ...schemaPathParts.slice(0, -1),
+          lastRelevantSubPathPart,
+        ];
+        schemaPath = this.joinPathParts(updatedSchemaPathParts);
       }
 
       const remainingPathParts = pathParts.slice(relevantSubPathParts.length);
@@ -1559,26 +2334,28 @@ export class ScopeDataStructure {
             ),
           );
         }
-
-        const localEquivalencyValueChain = structuredClone(
-          equivalencyValueChain,
-        );
-        localEquivalencyValueChain.push({
-          id: equivalentValue.id,
-          source: 'equivalence',
-          previousPath: {
-            scopeNodeName: scopeNode.name,
-            schemaPath: path,
-            value,
-          },
-          currentPath: {
-            scopeNodeName: equivalentScopeNode.name,
-            schemaPath: newEquivalentPath,
-            value,
+
+        // PERF: Use spread instead of structuredClone - the chain items are immutable
+        // so shallow copy is sufficient and much faster (structuredClone is expensive)
+        const localEquivalencyValueChain = [
+          ...equivalencyValueChain,
+          {
+            id: equivalentValue.id,
+            source: 'equivalence',
+            previousPath: {
+              scopeNodeName: scopeNode.name,
+              schemaPath: path,
+              value,
+            },
+            currentPath: {
+              scopeNodeName: equivalentScopeNode.name,
+              schemaPath: newEquivalentPath,
+              value,
+            },
+            reason: equivalentValue.equivalencyReason,
+            traceId,
           },
-          reason: equivalentValue.equivalencyReason,
-          traceId,
-        });
+        ];
 
         // writeEquivalencyToFile(
         //   scopeNode.name,
@@ -1590,13 +2367,57 @@ export class ScopeDataStructure {
         // )
 
         propagated = true;
-        this.addToSchema({
-          path: newEquivalentPath,
-          value,
-          scopeNode: equivalentScopeNode,
-          equivalencyValueChain: localEquivalencyValueChain,
-          traceId,
-        });
+
+        // PERF: If batch processor is active, queue work instead of recursing
+        // This converts deep recursion to iterative processing
+        if (this.batchProcessor) {
+          // PERF OPTIMIZATION: For external function calls, use path-only key (ignore value)
+          // External FCs don't have internals to analyze, so processing the same path
+          // with different values is redundant - we're just tracking data flow
+          const isExternalFc =
+            equivalentValue.equivalencyReason ===
+              'equivalency to external function call' ||
+            this.getExternalFunctionCallInfo(equivalentScopeNode.name) !==
+              undefined;
+          const queueKey = isExternalFc
+            ? `${equivalentScopeNode.name}::${newEquivalentPath}` // path-only for external FC
+            : `${equivalentScopeNode.name}::${newEquivalentPath}::${value}`; // full key otherwise
+
+          // Always check visited - it catches already-processed items
+          const alreadyVisited = this.visitedTracker.hasGlobalVisited(
+            equivalentScopeNode.name,
+            newEquivalentPath,
+            value,
+          );
+          // For external FCs, queueKey is path-only so this catches any-value duplicates
+          const alreadyQueued = this.batchQueuedSet?.has(queueKey);
+
+          if (alreadyVisited || alreadyQueued) {
+            // Still record in database to capture the chain (as addToSchema does)
+            this.addToEquivalencyDatabase(
+              localEquivalencyValueChain as EquivalencyValueChainItem[],
+              traceId,
+            );
+          } else {
+            // Mark as queued to prevent duplicate queue entries
+            this.batchQueuedSet?.add(queueKey);
+            this.batchProcessor.addWork({
+              scopeNodeName: equivalentScopeNode.name,
+              path: newEquivalentPath,
+              value,
+              equivalencyValueChain: localEquivalencyValueChain,
+              traceId,
+            });
+          }
+        } else {
+          this.addToSchema({
+            path: newEquivalentPath,
+            value,
+            scopeNode: equivalentScopeNode,
+            equivalencyValueChain: localEquivalencyValueChain,
+            traceId,
+          });
+        }
       }
     }
 
@@ -1635,6 +2456,17 @@ export class ScopeDataStructure {
             usageEquivalency.scopeNodeName,
           ) as ScopeNode;
 
+          // Guard against infinite recursion by tracking which paths we've already
+          // added from addComplexSourcePathVariables
+          if (
+            this.visitedTracker.checkAndMarkComplexSourceVisited(
+              usageScopeNode.name,
+              newUsageEquivalentPath,
+            )
+          ) {
+            continue;
+          }
+
           this.addToSchema({
             path: newUsageEquivalentPath,
             value: 'unknown',
@@ -1785,6 +2617,7 @@ export class ScopeDataStructure {
 
     for (let i = 0; i < cleanEquivalencyValueChain.length; ++i) {
       const pathInfo = cleanEquivalencyValueChain[i].currentPath;
+      const previousPath = cleanEquivalencyValueChain[i].previousPath;
 
       const schemaPathParts = this.splitPath(pathInfo.schemaPath);
       const isSignaturePath =
@@ -1798,6 +2631,21 @@ export class ScopeDataStructure {
         databaseEntry.usages.push(pathInfo);
       }
 
+      // Also add previousPath as a usage if it matches the criteria
+      // This handles propagated sub-property equivalencies where the JSX prop path
+      // is in previousPath and should be tracked as a usage
+      if (previousPath) {
+        const prevSchemaPathParts = this.splitPath(previousPath.schemaPath);
+        const isPrevSignaturePath =
+          prevSchemaPathParts.findIndex((p) => p.startsWith('signature[')) > 0;
+        if (
+          prevSchemaPathParts[0].startsWith('returnValue') ||
+          isPrevSignaturePath
+        ) {
+          databaseEntry.usages.push(previousPath);
+        }
+      }
+
       const pathId = this.uniqueId(pathInfo);
       let intermediateIndex = cleanEquivalencyValueChain.length - i - 1;
       const existingIntermediateIndex =
@@ -1905,6 +2753,7 @@ export class ScopeDataStructure {
       if (functionScope) {
         functionScope.functionCalls.push(externalFunctionCallInfo);
         this.externalFunctionCalls.splice(i, 1);
+        this.invalidateExternalFunctionCallsIndex();
 
         for (const equivalentPath in externalFunctionCallInfo.equivalencies) {
           let localEquivalentPath = equivalentPath;
@@ -1972,18 +2821,21 @@ export class ScopeDataStructure {
     for (const key in scopeNode.equivalencies) {
       const keyParts = this.splitPath(key);
       if (keyParts.length > 1) {
-        const lastPart = keyParts.pop();
+        // PERF: Don't mutate the array - use indexing instead of pop() to avoid requiring structuredClone
+        const lastPart = keyParts[keyParts.length - 1];
         if (lastPart.startsWith('signature[')) {
-          const functionCall = keyParts[keyParts.length - 1];
+          const keyPartsWithoutLast = keyParts.slice(0, -1);
+          const functionCall =
+            keyPartsWithoutLast[keyPartsWithoutLast.length - 1];
           const argumentsIndex = functionCall.indexOf('(');
           const functionName = this.joinPathParts([
-            ...keyParts.slice(0, -1),
+            ...keyPartsWithoutLast.slice(0, -1),
             functionCall.slice(
               0,
               argumentsIndex === -1 ? undefined : argumentsIndex,
             ),
           ]);
-          const callSignature = this.joinPathParts(keyParts);
+          const callSignature = this.joinPathParts(keyPartsWithoutLast);
 
           const functionCallInfo = {
             name: functionName,
@@ -2000,19 +2852,21 @@ export class ScopeDataStructure {
           equivalentValues.schemaPath,
         );
         if (equivalentValueParts.length > 1) {
-          const lastPart = equivalentValueParts.pop();
+          // PERF: Don't mutate the array - use indexing instead of pop() to avoid requiring structuredClone
+          const lastPart =
+            equivalentValueParts[equivalentValueParts.length - 1];
           if (lastPart.startsWith('functionCallReturnValue')) {
-            const functionCall =
-              equivalentValueParts[equivalentValueParts.length - 1];
+            const partsWithoutLast = equivalentValueParts.slice(0, -1);
+            const functionCall = partsWithoutLast[partsWithoutLast.length - 1];
             const argumentsIndex = functionCall.indexOf('(');
             const functionName = this.joinPathParts([
-              ...equivalentValueParts.slice(0, -1),
+              ...partsWithoutLast.slice(0, -1),
               functionCall.slice(
                 0,
                 argumentsIndex === -1 ? undefined : argumentsIndex,
               ),
             ]);
-            const callSignature = this.joinPathParts(equivalentValueParts);
+            const callSignature = this.joinPathParts(partsWithoutLast);
 
             const functionCallInfo = {
               name: functionName,
@@ -2213,7 +3067,8 @@ export class ScopeDataStructure {
   }
 
   getScopeNode(scopeName?: string): ScopeNode | undefined {
-    const scopeNode = this.scopeNodes[scopeName ?? this.scopeTree.name];
+    const scopeNode =
+      this.scopeNodes[scopeName ?? this.scopeTreeManager.getRootName()];
     if (scopeNode) return scopeNode;
 
     for (const scopeNodeName in this.scopeNodes) {
@@ -2223,18 +3078,54 @@ export class ScopeDataStructure {
     }
   }
 
+  /**
+   * Gets or builds the external function calls index for O(1) lookup.
+   * The index maps both the full name and the name without generics to the FunctionCallInfo.
+   */
+  private getExternalFunctionCallsIndex(): Map<string, FunctionCallInfo> {
+    if (this.externalFunctionCallsIndex === null) {
+      this.externalFunctionCallsIndex = new Map();
+      for (const efc of this.externalFunctionCalls) {
+        this.externalFunctionCallsIndex.set(efc.name, efc);
+        // Also index by name without generics (e.g., 'MyFunction<T>' -> 'MyFunction')
+        const nameWithoutGenerics = this.pathManager.stripGenerics(efc.name);
+        if (nameWithoutGenerics !== efc.name) {
+          this.externalFunctionCallsIndex.set(nameWithoutGenerics, efc);
+        }
+      }
+    }
+    return this.externalFunctionCallsIndex;
+  }
+
+  /**
+   * Invalidates the external function calls index.
+   * Call this after any mutation to externalFunctionCalls array.
+   */
+  private invalidateExternalFunctionCallsIndex(): void {
+    this.externalFunctionCallsIndex = null;
+  }
+
   getExternalFunctionCallInfo(
     functionName: string,
   ): FunctionCallInfo | undefined {
+    const searchKey = getFunctionCallRoot(functionName);
+    const index = this.getExternalFunctionCallsIndex();
+
+    // First try exact match
+    const exact = index.get(searchKey);
+    if (exact) return exact;
+
+    // Fallback to the original find for edge cases not covered by index
     return this.externalFunctionCalls.find(
       (efc) =>
-        efc.name === getFunctionCallRoot(functionName) ||
-        efc.name.split('<')[0] === getFunctionCallRoot(functionName),
+        efc.name === searchKey ||
+        this.pathManager.stripGenerics(efc.name) === searchKey,
     );
   }
 
   getScopeAnalysis(scopeName?: string): ScopeAnalysis | undefined {
-    return this.scopeNodes[scopeName ?? this.scopeTree.name].analysis;
+    return this.scopeNodes[scopeName ?? this.scopeTreeManager.getRootName()]
+      .analysis;
   }
 
   getAnalysisTree(): ScopeTreeNode {
@@ -2248,12 +3139,13 @@ export class ScopeDataStructure {
     scopeName?: string;
     fillInUnknowns?: boolean;
   }): any {
-    const scopeNode = this.scopeNodes[scopeName ?? this.scopeTree.name];
+    const scopeNode =
+      this.scopeNodes[scopeName ?? this.scopeTreeManager.getRootName()];
 
     if (!scopeNode) {
-      const externalFunctionCallSchema = this.externalFunctionCalls.find(
-        (call) => call.name === getFunctionCallRoot(scopeName),
-      )?.schema;
+      const searchKey = getFunctionCallRoot(scopeName);
+      const externalFunctionCallSchema =
+        this.getExternalFunctionCallsIndex().get(searchKey)?.schema;
 
       if (!externalFunctionCallSchema) return;
 
@@ -2271,6 +3163,40 @@ export class ScopeDataStructure {
     this.validateSchema(scopeNode, true, fillInUnknowns);
 
     const { schema } = scopeNode;
+
+    // For root scope, merge in external function call schemas
+    // This ensures that imported objects used as method call targets (like logger.error())
+    // appear in the schema as objects with function properties
+    if (
+      scopeName === undefined ||
+      scopeName === this.scopeTreeManager.getRootName()
+    ) {
+      const mergedSchema = { ...schema };
+      for (const efc of this.externalFunctionCalls) {
+        // Add the base object name (e.g., "logger") as an object
+        const baseName = this.splitPath(efc.name)[0];
+        if (!mergedSchema[baseName]) {
+          mergedSchema[baseName] = 'object';
+        }
+
+        // Get all call signatures (use allCallSignatures if available, otherwise just the single callSignature)
+        const signatures = efc.allCallSignatures ?? [efc.callSignature];
+        for (const signature of signatures) {
+          // Add the method as a function (e.g., "logger.error")
+          // Extract method name from callSignature like "logger.error(args...)"
+          // Get everything before the first '(' to get "logger.error"
+          const parenIndex = signature.indexOf('(');
+          if (parenIndex > 0) {
+            const methodPath = signature.substring(0, parenIndex);
+            if (methodPath.includes('.') && !mergedSchema[methodPath]) {
+              mergedSchema[methodPath] = 'function';
+            }
+          }
+        }
+      }
+      return mergedSchema;
+    }
+
     return schema;
   }
 
@@ -2286,9 +3212,9 @@ export class ScopeDataStructure {
       return this.equivalencyDatabaseCache.get(cacheKey);
     }
 
-    const result = this.equivalencyDatabase.find(
-      (entry) => entry.intermediatesOrder[cacheKey] !== undefined,
-    );
+    // PERF: Use inverted index for O(1) lookup instead of O(n) array scan
+    // The intermediatesOrderIndex maps pathId (scopeNodeName::schemaPath) to entry
+    const result = this.intermediatesOrderIndex.get(cacheKey);
 
     this.equivalencyDatabaseCache.set(cacheKey, result);
     return result;
@@ -2392,7 +3318,7 @@ export class ScopeDataStructure {
     }
 
     const tempScopeNode = this.createTempScopeNode(
-      functionName ?? this.scopeTree.name,
+      functionName ?? this.scopeTreeManager.getRootName(),
       signatureInSchema,
       equivalencies,
     );
@@ -2409,7 +3335,7 @@ export class ScopeDataStructure {
     functionName?: string;
     fillInUnknowns?: boolean;
   }) {
-    const scopeName = functionName ?? this.scopeTree.name;
+    const scopeName = functionName ?? this.scopeTreeManager.getRootName();
     const scopeNode = this.scopeNodes[scopeName];
 
     let schema: ScopeNode['schema'] = {};
@@ -2434,14 +3360,7 @@ export class ScopeDataStructure {
           for (const schemaPath in externalFunctionCall.schema) {
             const value1 = schema[schemaPath];
             const value2 = externalFunctionCall.schema[schemaPath];
-            let bestValue = value1 ?? value2;
-            if (
-              bestValue === 'unknown' ||
-              (bestValue.includes('unknown') && !value2.includes('unknown'))
-            ) {
-              bestValue = value2;
-            }
-            schema[schemaPath] = bestValue;
+            schema[schemaPath] = selectBestValue(value1, value2, value2);
           }
         }
       }
@@ -2567,7 +3486,7 @@ export class ScopeDataStructure {
   }
 
   getEquivalentSignatureVariables() {
-    const scopeNode = this.scopeNodes[this.scopeTree.name];
+    const scopeNode = this.scopeNodes[this.scopeTreeManager.getRootName()];
 
     const equivalentSignatureVariables: Record<string, string> = {};
     for (const [path, equivalentValues] of Object.entries(
@@ -2589,7 +3508,7 @@ export class ScopeDataStructure {
     final?: boolean,
   ): VariableInfo | undefined {
     const scopeNode = this.getScopeOrFunctionCallInfo(
-      scopeName ?? this.scopeTree.name,
+      scopeName ?? this.scopeTreeManager.getRootName(),
     );
     if (!scopeNode) return;
 
@@ -2626,7 +3545,7 @@ export class ScopeDataStructure {
     );
 
     const tempScopeNode = this.createTempScopeNode(
-      scopeName ?? this.scopeTree.name,
+      scopeName ?? this.scopeTreeManager.getRootName(),
       relevantSchema,
     );
 
@@ -2647,6 +3566,87 @@ export class ScopeDataStructure {
     return this.environmentVariables;
   }
 
+  /**
+   * Add conditional usages from AST analysis.
+   * Called during scope analysis to collect all conditionals.
+   */
+  addConditionalUsages(
+    usages: Record<
+      string,
+      Array<{
+        path: string;
+        conditionType: 'truthiness' | 'comparison' | 'switch';
+        comparedValues?: string[];
+        location: 'if' | 'ternary' | 'logical-and' | 'switch';
+      }>
+    >,
+  ): void {
+    for (const [path, pathUsages] of Object.entries(usages)) {
+      if (!this.rawConditionalUsages[path]) {
+        this.rawConditionalUsages[path] = [];
+      }
+      // Deduplicate usages
+      for (const usage of pathUsages) {
+        const exists = this.rawConditionalUsages[path].some(
+          (existing) =>
+            existing.location === usage.location &&
+            existing.conditionType === usage.conditionType &&
+            JSON.stringify(existing.comparedValues) ===
+              JSON.stringify(usage.comparedValues),
+        );
+        if (!exists) {
+          this.rawConditionalUsages[path].push(usage);
+        }
+      }
+    }
+  }
+
+  /**
+   * Get enriched conditional usages with source tracing.
+   * Uses explainPath to trace each local variable back to its data source.
+   */
+  getEnrichedConditionalUsages(): Record<
+    string,
+    Array<{
+      path: string;
+      conditionType: 'truthiness' | 'comparison' | 'switch';
+      comparedValues?: string[];
+      location: 'if' | 'ternary' | 'logical-and' | 'switch';
+      sourceDataPath?: string;
+    }>
+  > {
+    const enriched: Record<
+      string,
+      Array<{
+        path: string;
+        conditionType: 'truthiness' | 'comparison' | 'switch';
+        comparedValues?: string[];
+        location: 'if' | 'ternary' | 'logical-and' | 'switch';
+        sourceDataPath?: string;
+      }>
+    > = {};
+
+    for (const [path, usages] of Object.entries(this.rawConditionalUsages)) {
+      // Try to trace this path back to a data source
+      // First, try the root scope
+      const rootScopeName = this.scopeTreeManager.getTree().name;
+      const explanation = this.explainPath(rootScopeName, path);
+
+      let sourceDataPath: string | undefined;
+      if (explanation.source) {
+        // Build the full data path: scopeName.path
+        sourceDataPath = `${explanation.source.scope}.${explanation.source.path}`;
+      }
+
+      enriched[path] = usages.map((usage) => ({
+        ...usage,
+        sourceDataPath,
+      }));
+    }
+
+    return enriched;
+  }
+
   toSerializable(): SerializableDataStructure {
     // Helper to convert ScopeVariable to SerializableScopeVariable
     const toSerializableVariable = (
@@ -2709,6 +3709,9 @@ export class ScopeDataStructure {
               {} as Record<string, SerializableScopeVariable[]>,
             )
           : undefined,
+        allCallSignatures: efc.allCallSignatures,
+        receivingVariableNames: efc.receivingVariableNames,
+        callSignatureToVariable: efc.callSignatureToVariable,
       }));
 
     // Get root function result
@@ -2725,12 +3728,598 @@ export class ScopeDataStructure {
 
     const environmentVariables = this.getEnvironmentVariables();
 
+    // Get enriched conditional usages with source tracing
+    const enrichedConditionalUsages = this.getEnrichedConditionalUsages();
+    const conditionalUsages =
+      Object.keys(enrichedConditionalUsages).length > 0
+        ? enrichedConditionalUsages
+        : undefined;
+
     return {
       externalFunctionCalls,
       rootFunction,
       functionResults,
       equivalentSignatureVariables,
       environmentVariables,
+      conditionalUsages,
+    };
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // DEBUGGING HELPERS
+  // These methods help understand what's happening during analysis.
+  // Use them when investigating why a path is missing or has the wrong type.
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Explains a path by tracing its equivalencies and showing where data comes from.
+   *
+   * @example
+   * ```typescript
+   * const explanation = sds.explainPath('MyComponent', 'user.id');
+   * console.log(explanation);
+   * // {
+   * //   path: 'user.id',
+   * //   scope: 'MyComponent',
+   * //   schemaValue: 'string',
+   * //   equivalencies: [
+   * //     { scope: 'MyComponent', path: 'signature[0].user.id' },
+   * //     { scope: 'UserProfile', path: 'props.user.id' }
+   * //   ],
+   * //   source: { scope: 'fetchUser', path: 'functionCallReturnValue(fetch).data.user.id' }
+   * // }
+   * ```
+   */
+  explainPath(
+    scopeName: string,
+    path: string,
+  ): {
+    path: string;
+    scope: string;
+    schemaValue: string | undefined;
+    equivalencies: Array<{ scope: string; path: string; reason?: string }>;
+    databaseEntry: EquivalencyDatabaseEntry | undefined;
+    source: { scope: string; path: string } | undefined;
+  } {
+    const scopeNode = this.getScopeOrFunctionCallInfo(scopeName);
+    if (!scopeNode) {
+      return {
+        path,
+        scope: scopeName,
+        schemaValue: undefined,
+        equivalencies: [],
+        databaseEntry: undefined,
+        source: undefined,
+      };
+    }
+
+    const schemaValue = scopeNode.schema?.[path];
+    const rawEquivalencies = scopeNode.equivalencies?.[path] ?? [];
+
+    const equivalencies = rawEquivalencies.map((eq) => ({
+      scope: eq.scopeNodeName,
+      path: eq.schemaPath,
+      reason: eq.equivalencyReason,
+    }));
+
+    const databaseEntry = this.getEquivalenciesDatabaseEntry(scopeName, path);
+    const source =
+      databaseEntry?.sourceCandidates?.[0] &&
+      databaseEntry.sourceCandidates.length > 0
+        ? {
+            scope: databaseEntry.sourceCandidates[0].scopeNodeName,
+            path: databaseEntry.sourceCandidates[0].schemaPath,
+          }
+        : undefined;
+
+    return {
+      path,
+      scope: scopeName,
+      schemaValue,
+      equivalencies,
+      databaseEntry,
+      source,
+    };
+  }
+
+  /**
+   * Dumps the current state of analysis for inspection.
+   * Useful for understanding the overall state or finding issues.
+   *
+   * @param options - What to include in the dump
+   * @returns A summary object with requested data
+   */
+  dumpState(options?: {
+    includeSchemas?: boolean;
+    includeEquivalencies?: boolean;
+    scopeFilter?: string;
+  }): {
+    scopeCount: number;
+    externalCallCount: number;
+    equivalencyDatabaseSize: number;
+    metrics: {
+      addToSchemaCallCount: number;
+      followEquivalenciesCallCount: number;
+      maxEquivalencyChainDepth: number;
+    };
+    scopes: Array<{
+      name: string;
+      schemaKeyCount: number;
+      equivalencyKeyCount: number;
+      functionCallCount: number;
+      schema?: Record<string, string>;
+      equivalencies?: Record<string, Array<{ scope: string; path: string }>>;
+    }>;
+  } {
+    const includeSchemas = options?.includeSchemas ?? false;
+    const includeEquivalencies = options?.includeEquivalencies ?? false;
+    const scopeFilter = options?.scopeFilter;
+
+    const scopeNames = Object.keys(this.scopeNodes).filter(
+      (name) => !scopeFilter || name.includes(scopeFilter),
+    );
+
+    const scopes = scopeNames.map((name) => {
+      const node = this.scopeNodes[name];
+      const result: {
+        name: string;
+        schemaKeyCount: number;
+        equivalencyKeyCount: number;
+        functionCallCount: number;
+        schema?: Record<string, string>;
+        equivalencies?: Record<string, Array<{ scope: string; path: string }>>;
+      } = {
+        name,
+        schemaKeyCount: Object.keys(node.schema ?? {}).length,
+        equivalencyKeyCount: Object.keys(node.equivalencies ?? {}).length,
+        functionCallCount: node.functionCalls?.length ?? 0,
+      };
+
+      if (includeSchemas) {
+        result.schema = node.schema;
+      }
+
+      if (includeEquivalencies) {
+        result.equivalencies = Object.entries(node.equivalencies ?? {}).reduce(
+          (acc, [key, vals]) => {
+            acc[key] = vals.map((v) => ({
+              scope: v.scopeNodeName,
+              path: v.schemaPath,
+            }));
+            return acc;
+          },
+          {} as Record<string, Array<{ scope: string; path: string }>>,
+        );
+      }
+
+      return result;
+    });
+
+    return {
+      scopeCount: Object.keys(this.scopeNodes).length,
+      externalCallCount: this.externalFunctionCalls.length,
+      equivalencyDatabaseSize: this.equivalencyDatabase.length,
+      metrics: {
+        addToSchemaCallCount,
+        followEquivalenciesCallCount,
+        maxEquivalencyChainDepth,
+      },
+      scopes,
+    };
+  }
+
+  /**
+   * Traces the full equivalency chain for a path, showing how data flows.
+   * This is the most detailed debugging tool for understanding data tracing.
+   *
+   * @example
+   * ```typescript
+   * const chain = sds.traceEquivalencyChain('MyComponent', 'user.id');
+   * // Returns array of steps showing how user.id is traced back to its source
+   * ```
+   */
+  traceEquivalencyChain(
+    scopeName: string,
+    path: string,
+    maxDepth = 20,
+  ): Array<{
+    step: number;
+    scope: string;
+    path: string;
+    schemaValue?: string;
+    nextEquivalencies: Array<{ scope: string; path: string; reason?: string }>;
+  }> {
+    const chain: Array<{
+      step: number;
+      scope: string;
+      path: string;
+      schemaValue?: string;
+      nextEquivalencies: Array<{
+        scope: string;
+        path: string;
+        reason?: string;
+      }>;
+    }> = [];
+
+    const visited = new Set<string>();
+    const queue: Array<{ scope: string; path: string; depth: number }> = [
+      { scope: scopeName, path, depth: 0 },
+    ];
+
+    while (queue.length > 0 && chain.length < maxDepth) {
+      const current = queue.shift()!;
+      const key = `${current.scope}::${current.path}`;
+
+      if (visited.has(key)) continue;
+      visited.add(key);
+
+      const scopeNode = this.getScopeOrFunctionCallInfo(current.scope);
+      const schemaValue = scopeNode?.schema?.[current.path];
+      const rawEquivalencies = scopeNode?.equivalencies?.[current.path] ?? [];
+
+      const nextEquivalencies = rawEquivalencies.map((eq) => ({
+        scope: eq.scopeNodeName,
+        path: eq.schemaPath,
+        reason: eq.equivalencyReason,
+      }));
+
+      chain.push({
+        step: chain.length + 1,
+        scope: current.scope,
+        path: current.path,
+        schemaValue,
+        nextEquivalencies,
+      });
+
+      // Add next equivalencies to queue for further tracing
+      for (const eq of nextEquivalencies) {
+        const nextKey = `${eq.scope}::${eq.path}`;
+        if (!visited.has(nextKey)) {
+          queue.push({
+            scope: eq.scope,
+            path: eq.path,
+            depth: current.depth + 1,
+          });
+        }
+      }
+    }
+
+    return chain;
+  }
+
+  /**
+   * Finds all paths in a scope that match a pattern.
+   * Useful for finding related paths when debugging.
+   *
+   * @example
+   * ```typescript
+   * const paths = sds.findPaths('MyComponent', /user/);
+   * // Returns all schema paths containing "user"
+   * ```
+   */
+  findPaths(
+    scopeName: string,
+    pattern: RegExp | string,
+  ): Array<{ path: string; value: string; hasEquivalencies: boolean }> {
+    const scopeNode = this.getScopeOrFunctionCallInfo(scopeName);
+    if (!scopeNode) return [];
+
+    const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+    const results: Array<{
+      path: string;
+      value: string;
+      hasEquivalencies: boolean;
+    }> = [];
+
+    // Search in schema
+    for (const [path, value] of Object.entries(scopeNode.schema ?? {})) {
+      if (regex.test(path)) {
+        results.push({
+          path,
+          value,
+          hasEquivalencies: !!scopeNode.equivalencies?.[path]?.length,
+        });
+      }
+    }
+
+    // Also search equivalency keys that might not be in schema
+    for (const path of Object.keys(scopeNode.equivalencies ?? {})) {
+      if (regex.test(path) && !results.find((r) => r.path === path)) {
+        results.push({
+          path,
+          value: scopeNode.schema?.[path] ?? 'not-in-schema',
+          hasEquivalencies: true,
+        });
+      }
+    }
+
+    return results.sort((a, b) => a.path.localeCompare(b.path));
+  }
+
+  /**
+   * Returns a summary of why a path might be missing from the schema.
+   * Checks common issues that cause paths to not appear.
+   */
+  diagnoseMissingPath(
+    scopeName: string,
+    path: string,
+  ): {
+    exists: boolean;
+    inSchema: boolean;
+    inEquivalencies: boolean;
+    possibleReasons: string[];
+    suggestions: string[];
+  } {
+    const scopeNode = this.getScopeOrFunctionCallInfo(scopeName);
+    const possibleReasons: string[] = [];
+    const suggestions: string[] = [];
+
+    if (!scopeNode) {
+      possibleReasons.push(`Scope "${scopeName}" does not exist`);
+      suggestions.push(
+        `Available scopes: ${Object.keys(this.scopeNodes).join(', ')}`,
+      );
+      return {
+        exists: false,
+        inSchema: false,
+        inEquivalencies: false,
+        possibleReasons,
+        suggestions,
+      };
+    }
+
+    const inSchema = path in (scopeNode.schema ?? {});
+    const inEquivalencies = path in (scopeNode.equivalencies ?? {});
+
+    if (inSchema) {
+      return {
+        exists: true,
+        inSchema: true,
+        inEquivalencies,
+        possibleReasons: [],
+        suggestions: [],
+      };
+    }
+
+    // Check for similar paths
+    const allPaths = [
+      ...Object.keys(scopeNode.schema ?? {}),
+      ...Object.keys(scopeNode.equivalencies ?? {}),
+    ];
+
+    const similarPaths = allPaths.filter((p) => {
+      const pathParts = path.split('.');
+      const pParts = p.split('.');
+      return (
+        pathParts.some((part) => pParts.includes(part)) ||
+        p.includes(path) ||
+        path.includes(p)
+      );
+    });
+
+    if (similarPaths.length > 0) {
+      possibleReasons.push(`Path "${path}" not found but similar paths exist`);
+      suggestions.push(`Similar paths: ${similarPaths.slice(0, 5).join(', ')}`);
+    }
+
+    // Check if it's a partial path
+    const parentPath = path.split('.').slice(0, -1).join('.');
+    if (parentPath && scopeNode.schema?.[parentPath]) {
+      possibleReasons.push(
+        `Parent path "${parentPath}" exists with value "${scopeNode.schema[parentPath]}"`,
+      );
+      suggestions.push(
+        `The property might not have been accessed in the analyzed code`,
+      );
+    }
+
+    // Check visited tracker
+    const wasVisited = this.visitedTracker.wasVisited(scopeName, path);
+    if (wasVisited) {
+      possibleReasons.push(`Path was visited during analysis but not written`);
+      suggestions.push(
+        `Check if the path was filtered by isValidPath() or hit cycle detection`,
+      );
+    }
+
+    if (possibleReasons.length === 0) {
+      possibleReasons.push(
+        `Path "${path}" was never encountered during analysis`,
+      );
+      suggestions.push(
+        `Verify the path is accessed in the source code being analyzed`,
+      );
+    }
+
+    return {
+      exists: false,
+      inSchema,
+      inEquivalencies,
+      possibleReasons,
+      suggestions,
+    };
+  }
+
+  /**
+   * Analyzes the stored equivalencies to provide aggregate statistics.
+   * Call this AFTER analysis completes to understand equivalency patterns.
+   *
+   * @example
+   * ```typescript
+   * const analysis = sds.analyzeEquivalencies();
+   * console.log(analysis.byReason); // Count by reason
+   * console.log(analysis.byScope);  // Count by scope
+   * console.log(analysis.hotSpots); // Scopes with most equivalencies
+   * ```
+   */
+  analyzeEquivalencies(): {
+    total: number;
+    byReason: Record<string, number>;
+    byScope: Record<string, number>;
+    hotSpots: Array<{ scope: string; count: number }>;
+    unusedReasons: string[];
+  } {
+    const byReason: Record<string, number> = {};
+    const byScope: Record<string, number> = {};
+    let total = 0;
+
+    // Collect from all scope nodes
+    for (const scopeName of Object.keys(this.scopeNodes)) {
+      const scopeNode = this.scopeNodes[scopeName];
+      const equivalencies = scopeNode.equivalencies ?? {};
+
+      for (const path of Object.keys(equivalencies)) {
+        for (const eq of equivalencies[path]) {
+          total++;
+          const reason = eq.equivalencyReason ?? 'unknown';
+          byReason[reason] = (byReason[reason] ?? 0) + 1;
+          byScope[scopeName] = (byScope[scopeName] ?? 0) + 1;
+        }
+      }
+    }
+
+    // Also check external function calls
+    for (const fc of this.externalFunctionCalls) {
+      const equivalencies = fc.equivalencies ?? {};
+      for (const path of Object.keys(equivalencies)) {
+        for (const eq of equivalencies[path]) {
+          total++;
+          const reason = eq.equivalencyReason ?? 'unknown';
+          byReason[reason] = (byReason[reason] ?? 0) + 1;
+          byScope[fc.name] = (byScope[fc.name] ?? 0) + 1;
+        }
+      }
+    }
+
+    // Find hot spots (scopes with most equivalencies)
+    const hotSpots = Object.entries(byScope)
+      .map(([scope, count]) => ({ scope, count }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 10);
+
+    // Find reasons that appear in stored equivalencies but aren't in ALLOWED list
+    const unusedReasons = Object.keys(byReason).filter(
+      (reason) => !ALLOWED_EQUIVALENCY_REASONS.has(reason),
+    );
+
+    return {
+      total,
+      byReason,
+      byScope,
+      hotSpots,
+      unusedReasons,
     };
   }
+
+  /**
+   * Validates equivalencies and identifies potential problems.
+   * Returns actionable issues that may indicate bugs or optimization opportunities.
+   *
+   * @example
+   * ```typescript
+   * const issues = sds.validateEquivalencies();
+   * if (issues.length > 0) {
+   *   console.log('Found issues:', issues);
+   * }
+   * ```
+   */
+  validateEquivalencies(): Array<{
+    type: 'broken_reference' | 'dead_end' | 'long_chain' | 'circular';
+    severity: 'error' | 'warning';
+    scope: string;
+    path: string;
+    details: string;
+  }> {
+    const issues: Array<{
+      type: 'broken_reference' | 'dead_end' | 'long_chain' | 'circular';
+      severity: 'error' | 'warning';
+      scope: string;
+      path: string;
+      details: string;
+    }> = [];
+
+    const allScopeNames = new Set([
+      ...Object.keys(this.scopeNodes),
+      ...this.externalFunctionCalls.map((fc) => fc.name),
+    ]);
+
+    // Check all scope nodes
+    for (const scopeName of Object.keys(this.scopeNodes)) {
+      const scopeNode = this.scopeNodes[scopeName];
+      const equivalencies = scopeNode.equivalencies ?? {};
+
+      for (const [path, eqs] of Object.entries(equivalencies)) {
+        for (const eq of eqs) {
+          // Check 1: Does the target scope exist?
+          if (!allScopeNames.has(eq.scopeNodeName)) {
+            issues.push({
+              type: 'broken_reference',
+              severity: 'error',
+              scope: scopeName,
+              path,
+              details: `Equivalency points to non-existent scope "${eq.scopeNodeName}"`,
+            });
+            continue;
+          }
+
+          // Check 2: Does the target path exist in target scope's schema or equivalencies?
+          const targetScope = this.getScopeOrFunctionCallInfo(eq.scopeNodeName);
+          if (targetScope) {
+            const hasInSchema = eq.schemaPath in (targetScope.schema ?? {});
+            const hasInEquivalencies =
+              eq.schemaPath in (targetScope.equivalencies ?? {});
+
+            // Only flag as dead end if it's a leaf path (no sub-properties exist)
+            if (!hasInSchema && !hasInEquivalencies) {
+              const hasSubPaths = Object.keys(targetScope.schema ?? {}).some(
+                (p) =>
+                  p.startsWith(eq.schemaPath + '.') ||
+                  p.startsWith(eq.schemaPath + '['),
+              );
+              if (!hasSubPaths) {
+                issues.push({
+                  type: 'dead_end',
+                  severity: 'warning',
+                  scope: scopeName,
+                  path,
+                  details: `Equivalency to "${eq.scopeNodeName}::${eq.schemaPath}" - path not in schema`,
+                });
+              }
+            }
+          }
+        }
+
+        // Check 3: Trace chain depth
+        const chain = this.traceEquivalencyChain(scopeName, path, 50);
+        if (chain.length >= 20) {
+          issues.push({
+            type: 'long_chain',
+            severity: 'warning',
+            scope: scopeName,
+            path,
+            details: `Equivalency chain depth is ${chain.length} (may impact performance)`,
+          });
+        }
+
+        // Check for potential cycles (chain that returns to starting point)
+        const visited = new Set<string>();
+        for (const step of chain) {
+          const key = `${step.scope}::${step.path}`;
+          if (visited.has(key)) {
+            issues.push({
+              type: 'circular',
+              severity: 'warning',
+              scope: scopeName,
+              path,
+              details: `Circular reference detected at ${key}`,
+            });
+            break;
+          }
+          visited.add(key);
+        }
+      }
+    }
+
+    return issues;
+  }
 }