@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.bd4126b

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

@@ -82,21 +82,36 @@
 import { ScopeAnalysis } from '~codeyam/types';
 import { EquivalencyManager } from './equivalencyManagers/EquivalencyManager';
 import fillInSchemaGapsAndUnknowns from './helpers/fillInSchemaGapsAndUnknowns';
+import { clearCleanKnownObjectFunctionsCache } from './helpers/cleanKnownObjectFunctions';
+import { clearCleanNonObjectFunctionsCache } from './helpers/cleanNonObjectFunctions';
+
+/**
+ * Patterns that indicate recursive type structures in schema paths.
+ * Used by hasExcessivePatternRepetition() to detect exponential path blowup.
+ */
+const RECURSIVE_PATH_PATTERNS = [
+  /\.attributes\.properties\[\]/g, // TypeScript AST JSX nodes
+  /\.children\[\]/g, // Tree structures
+  /\.elements\[\]/g, // Array-like structures
+  /\.members\[\]/g, // Class/interface members
+  /\.properties\[\]/g, // Object properties
+  /\.items\[\]/g, // Generic items arrays
+];
 import ensureSchemaConsistency from './helpers/ensureSchemaConsistency';
 import cleanPath from './helpers/cleanPath';
 import { PathManager } from './helpers/PathManager';
 import {
   uniqueId,
-  uniqueScopeVariables,
   uniqueScopeAndPaths,
+  uniqueScopeVariables,
 } 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,
+  ScopeTreeManager,
   ScopeTreeNode,
 } from './helpers/ScopeTreeManager';
 import cleanScopeNodeName from './helpers/cleanScopeNodeName';
@@ -108,6 +123,7 @@ import type {
   SerializableFunctionCallInfo,
   SerializableFunctionResult,
   SerializableScopeVariable,
+  EnrichedConditionalUsage,
 } from '../worker/SerializableDataStructure';
 
 /**
@@ -125,6 +141,21 @@ export interface ScopeInfo {
   isStatic?: boolean;
   isClassScope?: boolean;
   analysis?: any;
+  /** For JSX child scopes, the original JSX tag name (e.g., 'ChildViewer') */
+  jsxTagName?: string;
+  /**
+   * Gating conditions detected during JSX extraction (before JSX is simplified).
+   * Maps child component name to conditions that must be true for it to render.
+   * This is populated by processJSXForScope in isolateScopes.ts.
+   */
+  extractedGatingConditions?: {
+    [childComponentName: string]: Array<{
+      path: string;
+      conditionType: 'truthiness' | 'comparison';
+      location: 'if' | 'ternary' | 'logical-and' | 'switch' | 'unconditional';
+      isNegated?: boolean;
+    }>;
+  };
 }
 
 /**
@@ -210,6 +241,33 @@ export interface FunctionCallInfo {
    * 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>;
+  /**
+   * Stores individual schemas per call signature BEFORE merging.
+   * When multiple calls to the same function are merged into one FunctionCallInfo,
+   * this preserves each call's distinct schema.
+   * Key is the call signature (e.g., "useFetcher()").
+   * Used internally; converted to perVariableSchemas in toSerializable().
+   */
+  perCallSignatureSchemas?: Record<string, Record<string, string>>;
+  /**
+   * Stores individual return value schemas per receiving variable, BEFORE merging.
+   * When multiple calls to the same function have different return types
+   * (e.g., useFetcher<UserData>() vs useFetcher<ReportData>()), this preserves
+   * each call's distinct schema for mock data generation.
+   * Key is the receiving variable name (e.g., "userFetcher", "reportFetcher").
+   */
+  perVariableSchemas?: Record<string, Record<string, string>>;
 }
 
 /**
@@ -276,6 +334,19 @@ export function resetScopeDataStructureMetrics() {
   followEquivalenciesEarlyExitPhase1Count = 0;
   followEquivalenciesWithWorkCount = 0;
   addEquivalencyCallCount = 0;
+
+  // Clear module-level caches to prevent unbounded memory growth across entities
+  const knownObjectCache = clearCleanKnownObjectFunctionsCache();
+  const nonObjectCache = clearCleanNonObjectFunctionsCache();
+  if (knownObjectCache.count > 0 || nonObjectCache.count > 0) {
+    const totalBytes =
+      knownObjectCache.estimatedBytes + nonObjectCache.estimatedBytes;
+    console.log('CodeYam: Cleared analysis caches', {
+      knownObjectCache: `${knownObjectCache.count} entries, ${(knownObjectCache.estimatedBytes / 1024).toFixed(1)}KB`,
+      nonObjectCache: `${nonObjectCache.count} entries, ${(nonObjectCache.estimatedBytes / 1024).toFixed(1)}KB`,
+      totalKB: `${(totalBytes / 1024).toFixed(1)}KB`,
+    });
+  }
 }
 
 // Performance: Pre-computed Sets for equivalency reason filtering (O(1) vs O(n))
@@ -307,7 +378,12 @@ const ALLOWED_EQUIVALENCY_REASONS = new Set([
   '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
+  'MUI DataGrid renderCell params.row equivalency', // Added: links DataGrid renderCell params.row to rows array elements
+  'MUI Autocomplete getOptionLabel option equivalency', // Added: links Autocomplete getOptionLabel callback param to options array
+  'MUI Autocomplete renderOption option equivalency', // Added: links Autocomplete renderOption callback param to options array
+  'MUI Autocomplete option property equivalency', // Added: propagates property accesses from Autocomplete callbacks
 ]);
 
 const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
@@ -321,6 +397,7 @@ const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
   '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',
+  // 'transformed non-object function equivalency - Explicit array deconstruction equivalency value',
 ]);
 
 export class ScopeDataStructure {
@@ -348,10 +425,40 @@ export class ScopeDataStructure {
       path: string;
       conditionType: 'truthiness' | 'comparison' | 'switch';
       comparedValues?: string[];
-      location: 'if' | 'ternary' | 'logical-and' | 'switch';
+      location: 'if' | 'ternary' | 'logical-and' | 'switch' | 'unconditional';
     }>
   > = {};
 
+  /**
+   * Conditional effects collected during AST analysis.
+   * Tracks what setter calls happen inside conditionals (if, switch, ternary).
+   */
+  private rawConditionalEffects: import('../astScopes/types').ConditionalEffect[] =
+    [];
+
+  /**
+   * Compound conditionals collected during AST analysis.
+   * Groups conditions that must all be true together (e.g., a && b && c).
+   */
+  private rawCompoundConditionals: import('../astScopes/types').CompoundConditional[] =
+    [];
+
+  /**
+   * Gating conditions for child component boundaries.
+   * Maps child component name to the conditions that must be true for it to render.
+   */
+  private rawChildBoundaryGatingConditions: Record<
+    string,
+    import('../astScopes/types').ConditionalUsage[]
+  > = {};
+
+  /**
+   * JSX rendering usages collected during AST analysis.
+   * Tracks arrays rendered via .map() and strings interpolated in JSX.
+   */
+  private rawJsxRenderingUsages: import('../astScopes/types').JsxRenderingUsage[] =
+    [];
+
   private lastAddToSchemaId = 0;
   private lastEquivalencyId = 0;
   private lastEquivalencyDatabaseId = 0;
@@ -370,6 +477,10 @@ export class ScopeDataStructure {
   private externalFunctionCallsIndex: Map<string, FunctionCallInfo> | null =
     null;
 
+  // Tracks internal functions that have been filtered out during captureCompleteSchema
+  // Prevents re-adding them via subsequent equivalency propagation (e.g., from getReturnValue)
+  private filteredInternalFunctions: Set<string> = new Set();
+
   // Debug tracer for selective path/scope tracing
   // Enable via: CODEYAM_DEBUG=true CODEYAM_DEBUG_PATHS="user.*,signature" npm test
   private tracer: DebugTracer = new DebugTracer({
@@ -528,6 +639,8 @@ export class ScopeDataStructure {
       const efcName = this.pathManager.stripGenerics(efc.name);
       for (const manager of this.equivalencyManagers) {
         if (manager.internalFunctions.has(efcName)) {
+          // Track this so we don't re-add it via subsequent finalize calls
+          this.filteredInternalFunctions.add(efcName);
           return false;
         }
       }
@@ -555,13 +668,51 @@ export class ScopeDataStructure {
         const baseName = this.pathManager.stripGenerics(
           candidate.scopeNodeName,
         );
+        // Check if this is a local variable path (doesn't contain function call pattern)
+        // Local variables like "surveys[]" or "items[]" are important for tracing data flow
+        // from parent to child components (e.g., surveys[] -> SurveyCard().signature[0].survey)
+        const isLocalVariablePath =
+          !candidate.schemaPath.includes('()') &&
+          !candidate.schemaPath.startsWith('signature[') &&
+          !candidate.schemaPath.startsWith('returnValue');
+
         return (
           validExternalFacingScopeNames.has(baseName) &&
           (candidate.schemaPath.startsWith('signature[') ||
-            candidate.schemaPath.startsWith(baseName)) &&
+            candidate.schemaPath.startsWith(baseName) ||
+            isLocalVariablePath) &&
           !containsArrayMethod(candidate.schemaPath)
         );
       });
+
+      // If all sourceCandidates were filtered out (e.g., because they belonged to
+      // internal functions like useState), look for the highest-order intermediate
+      // that belongs to a valid external-facing scope
+      if (
+        entry.sourceCandidates.length === 0 &&
+        Object.keys(entry.intermediatesOrder).length > 0
+      ) {
+        // Find intermediates that belong to valid external-facing scopes
+        const validIntermediates = Object.entries(entry.intermediatesOrder)
+          .filter(([pathId]) => {
+            const [scopeNodeName, schemaPath] = pathId.split('::');
+            if (!scopeNodeName || !schemaPath) return false;
+            const baseName = this.pathManager.stripGenerics(scopeNodeName);
+            return (
+              validExternalFacingScopeNames.has(baseName) &&
+              !containsArrayMethod(schemaPath)
+            );
+          })
+          .sort((a, b) => b[1] - a[1]); // Sort by order descending (highest first)
+
+        if (validIntermediates.length > 0) {
+          const [pathId] = validIntermediates[0];
+          const [scopeNodeName, schemaPath] = pathId.split('::');
+          if (scopeNodeName && schemaPath) {
+            entry.sourceCandidates.push({ scopeNodeName, schemaPath });
+          }
+        }
+      }
     }
 
     this.propagateSourceAndUsageEquivalencies(
@@ -649,6 +800,11 @@ export class ScopeDataStructure {
       return;
     }
 
+    // PERF: Early exit for paths with repeated function-call signature patterns
+    if (this.hasExcessivePatternRepetition(path)) {
+      return;
+    }
+
     // Update chain metadata for database tracking
     if (equivalencyValueChain.length > 0) {
       equivalencyValueChain[equivalencyValueChain.length - 1].addToSchemaId =
@@ -892,8 +1048,8 @@ export class ScopeDataStructure {
     equivalencyValueChain?: EquivalencyValueChainItem[],
     traceId?: number,
   ) {
-    // DEBUG: Detect infinite loops
     addEquivalencyCallCount++;
+
     if (addEquivalencyCallCount > 50000) {
       console.error('INFINITE LOOP DETECTED in addEquivalency', {
         callCount: addEquivalencyCallCount,
@@ -919,13 +1075,69 @@ export class ScopeDataStructure {
       }
     }
 
+    // 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');
     }
 
@@ -1083,10 +1295,38 @@ export class ScopeDataStructure {
       const existingFunctionCall =
         this.getExternalFunctionCallsIndex().get(searchKey);
       if (existingFunctionCall) {
-        existingFunctionCall.schema = {
+        // Preserve per-call schemas BEFORE merging to enable per-variable mock data.
+        // This is critical for hooks like useFetcher<UserData>() vs useFetcher<ReportData>()
+        // where each call returns different typed data.
+        if (!existingFunctionCall.perCallSignatureSchemas) {
+          // First merge - save the existing call's schema
+          existingFunctionCall.perCallSignatureSchemas = {
+            [existingFunctionCall.callSignature]: {
+              ...existingFunctionCall.schema,
+            },
+          };
+        }
+        // Save the new call's schema before it gets merged
+        existingFunctionCall.perCallSignatureSchemas[
+          functionCallInfo.callSignature
+        ] = { ...functionCallInfo.schema };
+
+        // Merge schemas using selectBestValue to preserve specific types like 'null'
+        // over generic types like 'unknown'. This ensures ref variables detected
+        // earlier (marked as 'null') aren't overwritten by later 'unknown' values.
+        const mergedSchema: Record<string, string> = {
           ...existingFunctionCall.schema,
-          ...functionCallInfo.schema,
         };
+        for (const key in functionCallInfo.schema) {
+          const existingValue = existingFunctionCall.schema[key];
+          const newValue = functionCallInfo.schema[key];
+          mergedSchema[key] = selectBestValue(
+            existingValue,
+            newValue,
+            newValue,
+          );
+        }
+        existingFunctionCall.schema = mergedSchema;
 
         existingFunctionCall.equivalencies = {
           ...existingFunctionCall.equivalencies,
@@ -1119,8 +1359,15 @@ export class ScopeDataStructure {
           );
 
         if (isExternal) {
-          this.externalFunctionCalls.push(functionCallInfo);
-          this.invalidateExternalFunctionCallsIndex();
+          // Check if this function was already filtered out as an internal function
+          // (e.g., useState was filtered in captureCompleteSchema but finalize is trying to re-add it)
+          const strippedName = this.pathManager.stripGenerics(
+            functionCallInfo.name,
+          );
+          if (!this.filteredInternalFunctions.has(strippedName)) {
+            this.externalFunctionCalls.push(functionCallInfo);
+            this.invalidateExternalFunctionCallsIndex();
+          }
         }
       }
     }
@@ -1228,11 +1475,32 @@ export class ScopeDataStructure {
         const equivalentSchemaPath = equivalentSchemaPathMap.get(remainingKey);
 
         if (equivalentSchemaPath) {
+          // Skip propagation when there's a structural mismatch:
+          // - schemaPath ends with [] (array element, represents an object)
+          // - equivalentSchemaPath doesn't end with [] (non-array prop, usually a scalar)
+          // This prevents incorrectly typing array elements as strings when they're
+          // equivalent to scalar props like JSX keys (e.g., workouts[] ↔ Card().key)
+          const schemaPathEndsWithArray = schemaPath.endsWith('[]');
+          const equivalentEndsWithArray = equivalentSchemaPath.endsWith('[]');
+          if (schemaPathEndsWithArray !== equivalentEndsWithArray) {
+            // Don't propagate between array element paths and non-array paths
+            continue;
+          }
+
           const value1 = scopeNode.schema[schemaPath];
           const value2 = equivalentScopeNode.schema[equivalentSchemaPath];
 
           const bestValue = selectBestValue(value1, value2);
 
+          // PERF: Skip paths with repeated function-call signature patterns
+          // to prevent recursive type expansion (e.g., string.localeCompare returns string)
+          if (
+            this.hasExcessivePatternRepetition(schemaPath) ||
+            this.hasExcessivePatternRepetition(equivalentSchemaPath)
+          ) {
+            continue;
+          }
+
           scopeNode.schema[schemaPath] = bestValue;
           equivalentScopeNode.schema[equivalentSchemaPath] = bestValue;
         } else if (
@@ -1246,6 +1514,11 @@ export class ScopeDataStructure {
             ...remainingSchemaPathParts,
           ]);
 
+          // PERF: Skip paths with repeated function-call signature patterns
+          if (this.hasExcessivePatternRepetition(newEquivalentPath)) {
+            continue;
+          }
+
           equivalentScopeNode.schema[newEquivalentPath] =
             scopeNode.schema[schemaPath];
         }
@@ -1295,6 +1568,23 @@ export class ScopeDataStructure {
     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);
+    }
+    return firstPart;
+  }
+
   // PRIVATE METHODS //
 
   private uniqueId(params: {
@@ -1319,6 +1609,77 @@ export class ScopeDataStructure {
     return this.pathManager.isValidPath(path);
   }
 
+  /**
+   * Detects if a path contains excessive repetition of the same pattern.
+   *
+   * This prevents exponential blowup when analyzing recursive type structures.
+   * For example, TypeScript AST nodes have `.attributes.properties[]` where each
+   * property is also a node with `.attributes.properties[]`. Without this check,
+   * paths like `signature[0].attributes.properties[].attributes.properties[].attributes.properties[]...`
+   * would be generated exponentially.
+   *
+   * Two detection strategies:
+   * 1. Known patterns: Check RECURSIVE_PATH_PATTERNS for common recursive structures
+   * 2. Generic detection: For longer paths, detect any 2-3 part segment that repeats
+   *
+   * @param path - The schema path to check
+   * @param maxRepetitions - Maximum allowed repetitions of any pattern (default: 2)
+   * @returns true if the path has excessive repetition
+   */
+  private hasExcessivePatternRepetition(
+    path: string,
+    maxRepetitions = 2,
+  ): boolean {
+    // Check known recursive patterns
+    for (const pattern of RECURSIVE_PATH_PATTERNS) {
+      const matches = path.match(pattern);
+      if (matches && matches.length > maxRepetitions) {
+        return true;
+      }
+    }
+
+    // Check for repeated function calls that indicate recursive type expansion.
+    // E.g., localeCompare(b[])...localeCompare(b[]) means string.localeCompare
+    // returns a type that again has localeCompare, causing infinite expansion.
+    // We extract all function call patterns like "funcName(args)" and check if
+    // the same normalized call appears more than once.
+    const funcCallPattern = /(?:^|\.)[^.([]+\([^)]*\)/g;
+    const funcCallMatches = path.match(funcCallPattern);
+    if (funcCallMatches && funcCallMatches.length > 1) {
+      const seen = new Set<string>();
+      for (const match of funcCallMatches) {
+        // Strip leading dot and normalize array indices
+        const normalized = match.replace(/^\./, '').replace(/\[\d+\]/g, '[]');
+        if (seen.has(normalized)) return true;
+        seen.add(normalized);
+      }
+    }
+
+    // For longer paths, detect any repeated multi-part segments we haven't explicitly listed
+    const pathParts = this.splitPath(path);
+    if (pathParts.length <= 6) {
+      return false;
+    }
+
+    // Check for repeated sequences of 2-3 consecutive parts
+    for (let segmentLength = 2; segmentLength <= 3; segmentLength++) {
+      const seen = new Map<string, number>();
+
+      for (let i = 0; i <= pathParts.length - segmentLength; i++) {
+        const segment = pathParts.slice(i, i + segmentLength).join('.');
+        const normalizedSegment = segment.replace(/\[\d+\]/g, '[]');
+        const count = (seen.get(normalizedSegment) || 0) + 1;
+        seen.set(normalizedSegment, count);
+
+        if (count > maxRepetitions) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   private addToTree(pathParts: string[]) {
     this.scopeTreeManager.addPath(pathParts);
   }
@@ -1326,17 +1687,26 @@ export class ScopeDataStructure {
   private setInstantiatedVariables(scopeNode: ScopeNode) {
     let instantiatedVariables = scopeNode.analysis?.instantiatedVariables ?? [];
 
-    for (const [path, equivalentPath] of Object.entries(
+    for (const [path, rawEquivalentPath] of Object.entries(
       scopeNode.analysis.isolatedEquivalentVariables ?? {},
     )) {
-      if (typeof equivalentPath !== 'string') {
-        continue;
-      }
+      // Normalize to array for consistent handling (supports both string and string[])
+      const equivalentPaths = Array.isArray(rawEquivalentPath)
+        ? rawEquivalentPath
+        : rawEquivalentPath
+          ? [rawEquivalentPath]
+          : [];
+
+      for (const equivalentPath of equivalentPaths) {
+        if (typeof equivalentPath !== 'string') {
+          continue;
+        }
 
-      if (equivalentPath.startsWith('signature[')) {
-        const equivalentPathParts = this.splitPath(equivalentPath);
-        instantiatedVariables.push(equivalentPathParts[0]);
-        instantiatedVariables.push(path);
+        if (equivalentPath.startsWith('signature[')) {
+          const equivalentPathParts = this.splitPath(equivalentPath);
+          instantiatedVariables.push(equivalentPathParts[0]);
+          instantiatedVariables.push(path);
+        }
       }
 
       const duplicateInstantiated = instantiatedVariables.find(
@@ -1349,9 +1719,14 @@ export class ScopeDataStructure {
       }
     }
 
-    instantiatedVariables = instantiatedVariables.filter(
-      (varName, index, self) => self.indexOf(varName) === index,
-    );
+    const instantiatedSeen = new Set<string>();
+    instantiatedVariables = instantiatedVariables.filter((varName) => {
+      if (instantiatedSeen.has(varName)) {
+        return false;
+      }
+      instantiatedSeen.add(varName);
+      return true;
+    });
 
     scopeNode.instantiatedVariables = instantiatedVariables;
 
@@ -1372,13 +1747,19 @@ export class ScopeDataStructure {
       ...parentScopeNode.instantiatedVariables.filter(
         (v) => !v.startsWith('signature[') && !v.startsWith('returnValue'),
       ),
-    ].filter(
-      (varName, index, self) =>
-        !instantiatedVariables.includes(varName) &&
-        self.indexOf(varName) === index,
-    );
+    ].filter((varName) => !instantiatedSeen.has(varName));
+
+    const parentInstantiatedSeen = new Set<string>();
+    const dedupedParentInstantiatedVariables =
+      parentInstantiatedVariables.filter((varName) => {
+        if (parentInstantiatedSeen.has(varName)) {
+          return false;
+        }
+        parentInstantiatedSeen.add(varName);
+        return true;
+      });
 
-    scopeNode.parentInstantiatedVariables = parentInstantiatedVariables;
+    scopeNode.parentInstantiatedVariables = dedupedParentInstantiatedVariables;
   }
 
   private trackFunctionCalls(scopeNode: ScopeNode) {
@@ -1387,111 +1768,205 @@ export class ScopeDataStructure {
   }
 
   private determineEquivalenciesAndBuildSchema(scopeNode: ScopeNode) {
+    if (!scopeNode.analysis) {
+      return;
+    }
+
     const { isolatedStructure, isolatedEquivalentVariables } =
       scopeNode.analysis;
 
+    // Flatten isolatedEquivalentVariables values for allPaths (handles both string and string[])
+    const flattenedEquivValues = Object.values(
+      isolatedEquivalentVariables || {},
+    ).flatMap((v) => (Array.isArray(v) ? v : [v]));
+
     const allPaths = Array.from(
       new Set([
         ...Object.keys(isolatedStructure || {}),
         ...Object.keys(isolatedEquivalentVariables || {}),
-        ...Object.values(isolatedEquivalentVariables || {}),
+        ...flattenedEquivValues,
       ]),
     );
 
     for (let path in isolatedEquivalentVariables) {
-      let equivalentValue = isolatedEquivalentVariables?.[path];
-
-      if (equivalentValue && this.isValidPath(equivalentValue)) {
-        path = cleanPath(path.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
-        equivalentValue = cleanPath(
-          equivalentValue.replace(/::cyDuplicateKey\d+::/g, ''),
-          allPaths,
-        );
+      const rawEquivalentValue = isolatedEquivalentVariables?.[path];
+      // Normalize to array for consistent handling
+      const equivalentValues = Array.isArray(rawEquivalentValue)
+        ? rawEquivalentValue
+        : [rawEquivalentValue];
+
+      for (let equivalentValue of equivalentValues) {
+        if (equivalentValue && this.isValidPath(equivalentValue)) {
+          // IMPORTANT: DO NOT strip ::cyDuplicateKey:: markers from equivalencies.
+          // These markers are critical for distinguishing variable reassignments.
+          // For example, with:
+          //   let fetcher = useFetcher<ConfigData>();
+          //   const configData = fetcher.data?.data;
+          //   fetcher = useFetcher<SettingsData>();
+          //   const settingsData = fetcher.data?.data;
+          //
+          // mergeStatements creates:
+          //   fetcher → useFetcher<ConfigData>()...
+          //   fetcher::cyDuplicateKey1:: → useFetcher<SettingsData>()...
+          //   configData → fetcher.data.data
+          //   settingsData → fetcher::cyDuplicateKey1::.data.data
+          //
+          // If we strip ::cyDuplicateKey::, settingsData would incorrectly trace
+          // to useFetcher<ConfigData>() instead of useFetcher<SettingsData>().
+          path = cleanPath(path, allPaths);
+          equivalentValue = cleanPath(equivalentValue, allPaths);
+
+          this.addEquivalency(
+            path,
+            equivalentValue,
+            scopeNode.name,
+            scopeNode,
+            'original equivalency',
+          );
 
-        this.addEquivalency(
-          path,
-          equivalentValue,
-          scopeNode.name,
-          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;
 
-        // 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 (
+            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;
+              }
+            }
+          }
 
-                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',
+          // 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, rawSubValue] of Object.entries(
+                checkScope.analysis.isolatedEquivalentVariables,
+              )) {
+                // Normalize to array for consistent handling
+                const subValues = Array.isArray(rawSubValue)
+                  ? rawSubValue
+                  : rawSubValue
+                    ? [rawSubValue]
+                    : [];
+
+                // 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);
+
+                  for (const subValue of subValues) {
+                    if (typeof subValue !== 'string') continue;
+                    const newEquivalentValue = cleanPath(
+                      subValue.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,
-                );
+                // Also check if equivalentValue itself maps to a functionCallReturnValue
+                // e.g., result = useMemo(...).functionCallReturnValue
+                for (const subValue of subValues) {
+                  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,
-          );
+          // 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);
+          }
         }
       }
     }
@@ -1501,7 +1976,7 @@ export class ScopeDataStructure {
     this.batchProcessor = new BatchSchemaProcessor();
     this.batchQueuedSet = new Set();
 
-    for (const key of Array.from(allPaths)) {
+    for (const key of allPaths) {
       let value = isolatedStructure[key] ?? 'unknown';
 
       if (['null', 'undefined'].includes(value)) {
@@ -1542,7 +2017,19 @@ export class ScopeDataStructure {
   private processBatchQueue(): void {
     if (!this.batchProcessor) return;
 
+    let iterations = 0;
+
     while (this.batchProcessor.hasWork()) {
+      iterations++;
+
+      // Safety: detect potential infinite loops
+      if (iterations > 100000) {
+        console.error(
+          `[ScopeDataStructure] processBatchQueue exceeded 100k iterations, possible infinite loop!`,
+        );
+        break;
+      }
+
       const item = this.batchProcessor.getNextWork();
       if (!item) break;
 
@@ -1562,6 +2049,66 @@ export class ScopeDataStructure {
     }
   }
 
+  /**
+   * 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);
+
+    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.
    *
@@ -1600,9 +2147,18 @@ export class ScopeDataStructure {
         const checkScope = this.scopeNodes[scopeName];
         if (!checkScope?.analysis?.isolatedEquivalentVariables) continue;
 
-        const functionRef =
+        const rawFunctionRef =
           checkScope.analysis.isolatedEquivalentVariables[functionName];
-        if (typeof functionRef === 'string' && functionRef.endsWith('F')) {
+        // Normalize to array and find first string ending with 'F'
+        const functionRefs = Array.isArray(rawFunctionRef)
+          ? rawFunctionRef
+          : rawFunctionRef
+            ? [rawFunctionRef]
+            : [];
+        const functionRef = functionRefs.find(
+          (r) => typeof r === 'string' && r.endsWith('F'),
+        );
+        if (typeof functionRef === 'string') {
           callbackScopeName = functionRef.slice(0, -1);
           break;
         }
@@ -1630,19 +2186,24 @@ export class ScopeDataStructure {
 
     const isolatedVars = callbackScope.analysis.isolatedEquivalentVariables;
 
+    // Get the first returnValue equivalency (normalize array to single value for these checks)
+    const rawReturnValue = isolatedVars.returnValue;
+    const firstReturnValue = Array.isArray(rawReturnValue)
+      ? rawReturnValue[0]
+      : rawReturnValue;
+
     // 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
+      typeof firstReturnValue === 'string' && !firstReturnValue.includes('.')
+        ? firstReturnValue
         : 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(
+    if (typeof firstReturnValue === 'string') {
+      const reduceMatch = firstReturnValue.match(
         /^Object\.keys\((\w+)\)\.reduce\(.*\)\.functionCallReturnValue$/,
       );
       if (reduceMatch) {
@@ -1650,7 +2211,14 @@ export class ScopeDataStructure {
       }
     }
 
-    for (const [subPath, subValue] of Object.entries(isolatedVars)) {
+    for (const [subPath, rawSubValue] of Object.entries(isolatedVars)) {
+      // Normalize to array for consistent handling
+      const subValues = Array.isArray(rawSubValue)
+        ? rawSubValue
+        : rawSubValue
+          ? [rawSubValue]
+          : [];
+
       // Check for direct returnValue.* sub-properties
       const isReturnValueSub =
         subPath.startsWith('returnValue.') ||
@@ -1668,57 +2236,59 @@ export class ScopeDataStructure {
         (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,
-      );
+      if (!isReturnValueSub && !isAliasSub && !isReduceSourceSub) continue;
+
+      for (const subValue of subValues) {
+        if (typeof subValue !== 'string') 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;
+        // 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;
+        if (!newEquivalentValue || !this.isValidPath(newEquivalentValue))
+          continue;
 
-      this.addEquivalency(
-        newPath,
-        newEquivalentValue,
-        equivalentScopeName,
-        scopeNode,
-        'propagated function call return sub-property equivalency',
-      );
+        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,
-      );
+        // Ensure the database entry has the usage path
+        this.addUsageToEquivalencyDatabaseEntry(
+          newPath,
+          newEquivalentValue,
+          equivalentScopeName,
+          scopeNode.name,
+        );
+      }
     }
   }
 
@@ -1758,8 +2328,15 @@ export class ScopeDataStructure {
       const parentScope = this.scopeNodes[parentScopeName];
       if (!parentScope?.analysis?.isolatedEquivalentVariables) continue;
 
-      const rootEquiv =
+      const rawRootEquiv =
         parentScope.analysis.isolatedEquivalentVariables[rootVar];
+      // Normalize to array and use first string value
+      const rootEquivs = Array.isArray(rawRootEquiv)
+        ? rawRootEquiv
+        : rawRootEquiv
+          ? [rawRootEquiv]
+          : [];
+      const rootEquiv = rootEquivs.find((r) => typeof r === 'string');
       if (typeof rootEquiv === 'string') {
         return {
           resolvedPath: cleanPath(rootEquiv + restOfPath, allPaths),
@@ -2034,11 +2611,27 @@ export class ScopeDataStructure {
         relevantSubPathParts.every((part, i) => part === schemaPathParts[i]) &&
         equivalentValue.scopeNodeName === scopeNode.name
       ) {
+        // DEBUG
         continue;
       }
 
       const newEquivalentPath = this.joinPathParts([schemaPath, remainingPath]);
 
+      // PERF: Detect repeated patterns in paths to prevent exponential blowup
+      // Paths like `signature[0].attributes.properties[].attributes.properties[]...`
+      // indicate recursive type structures that cause exponential schema explosion
+      if (this.hasExcessivePatternRepetition(newEquivalentPath)) {
+        if (traceId && debugLevel > 0) {
+          console.info(
+            'Debug: skipping path with excessive pattern repetition',
+            {
+              path: newEquivalentPath,
+            },
+          );
+        }
+        continue;
+      }
+
       if (!equivalentScopeNode) {
         if (traceId) {
           console.info('Debug Propagation: missing equivalent scope info', {
@@ -2205,6 +2798,8 @@ export class ScopeDataStructure {
             usageEquivalency.scopeNodeName,
           ) as ScopeNode;
 
+          if (!usageScopeNode) continue;
+
           // Guard against infinite recursion by tracking which paths we've already
           // added from addComplexSourcePathVariables
           if (
@@ -2284,6 +2879,8 @@ export class ScopeDataStructure {
             usageEquivalency.scopeNodeName,
           ) as ScopeNode;
 
+          if (!usageScopeNode) continue;
+
           // This is put in place to avoid propagating array functions like 'filter' through complex equivalencies
           // but may cause problems if the funtion call is not on a known object (e.g. string or array)
           if (
@@ -2410,13 +3007,108 @@ export class ScopeDataStructure {
       this.intermediatesOrderIndex.set(pathId, databaseEntry);
 
       if (intermediateIndex === 0) {
-        const isValidSourceCandidate =
+        let isValidSourceCandidate =
           pathInfo.schemaPath.startsWith('signature[') ||
           pathInfo.schemaPath.includes('functionCallReturnValue');
-        if (isValidSourceCandidate) {
-          databaseEntry.sourceCandidates.push(pathInfo);
-        }
-      } else {
+
+        // Check if path STARTS with a spread pattern like [...var]
+        // This handles cases like [...files][][0] or [...files].sort(...).functionCallReturnValue[][0]
+        // where the spread source variable needs to be resolved to a signature path.
+        // We do this REGARDLESS of isValidSourceCandidate because even paths containing
+        // functionCallReturnValue may need spread resolution to trace back to the signature.
+        const spreadMatch = pathInfo.schemaPath.match(/^\[\.\.\.(\w+)\]/);
+        if (spreadMatch) {
+          const spreadVar = spreadMatch[1];
+          const spreadPattern = spreadMatch[0]; // The full [...var] match
+          const scopeNode = this.scopeNodes[pathInfo.scopeNodeName];
+
+          if (scopeNode?.equivalencies) {
+            // Follow the equivalency chain to find a signature path
+            // e.g., files (cyScope1) → files (root) → signature[0].files
+            const resolveToSignature = (
+              varName: string,
+              currentScopeName: string,
+              visited: Set<string>,
+            ): { schemaPath: string; scopeNodeName: string } | null => {
+              const visitKey = `${currentScopeName}::${varName}`;
+              if (visited.has(visitKey)) return null;
+              visited.add(visitKey);
+
+              const currentScope = this.scopeNodes[currentScopeName];
+              if (!currentScope?.equivalencies) return null;
+
+              const varEquivs = currentScope.equivalencies[varName];
+              if (!varEquivs) return null;
+
+              // First check if any equivalency directly points to a signature path
+              const signatureEquiv = varEquivs.find((eq) =>
+                eq.schemaPath.startsWith('signature['),
+              );
+              if (signatureEquiv) {
+                return signatureEquiv;
+              }
+
+              // Otherwise, follow the chain to other scopes
+              for (const equiv of varEquivs) {
+                // If the equivalency points to the same variable in a different scope,
+                // follow the chain
+                if (
+                  equiv.schemaPath === varName &&
+                  equiv.scopeNodeName !== currentScopeName
+                ) {
+                  const result = resolveToSignature(
+                    varName,
+                    equiv.scopeNodeName,
+                    visited,
+                  );
+                  if (result) return result;
+                }
+              }
+
+              return null;
+            };
+
+            const signatureEquiv = resolveToSignature(
+              spreadVar,
+              pathInfo.scopeNodeName,
+              new Set(),
+            );
+            if (signatureEquiv) {
+              // Replace ONLY the [...var] part with the resolved signature path
+              // This preserves any suffix like .sort(...).functionCallReturnValue[][0]
+              const resolvedPath = pathInfo.schemaPath.replace(
+                spreadPattern,
+                signatureEquiv.schemaPath,
+              );
+              // Add the resolved path as a source candidate
+              if (
+                !databaseEntry.sourceCandidates.some(
+                  (sc) =>
+                    sc.schemaPath === resolvedPath &&
+                    sc.scopeNodeName === pathInfo.scopeNodeName,
+                )
+              ) {
+                databaseEntry.sourceCandidates.push({
+                  scopeNodeName: pathInfo.scopeNodeName,
+                  schemaPath: resolvedPath,
+                });
+              }
+              isValidSourceCandidate = true;
+            }
+          }
+        }
+
+        if (
+          isValidSourceCandidate &&
+          !databaseEntry.sourceCandidates.some(
+            (sc) =>
+              sc.schemaPath === pathInfo.schemaPath &&
+              sc.scopeNodeName === pathInfo.scopeNodeName,
+          )
+        ) {
+          databaseEntry.sourceCandidates.push(pathInfo);
+        }
+      } else {
         const existingSourceCandidateIndex =
           databaseEntry.sourceCandidates.findIndex(
             (sc) =>
@@ -2641,6 +3333,14 @@ export class ScopeDataStructure {
       }
     }
 
+    // Ensure parameter-to-signature equivalencies are fully propagated.
+    // When a parameter variable (e.g., `node`) is equivalenced to `signature[N]`,
+    // all sub-paths of that variable should also appear under `signature[N]`.
+    // This handles cases where the sub-path was added to the schema via a propagation
+    // chain that already included the variable↔signature equivalency, causing the
+    // cycle detection to prevent the reverse mapping.
+    this.propagateParameterToSignaturePaths(scopeNode);
+
     fillInSchemaGapsAndUnknowns(scopeNode, fillInUnknowns);
 
     if (final) {
@@ -2655,6 +3355,97 @@ export class ScopeDataStructure {
     }
   }
 
+  /**
+   * For each equivalency where a simple variable maps to signature[N],
+   * ensure all sub-paths of that variable are reflected under signature[N].
+   */
+  private propagateParameterToSignaturePaths(scopeNode: ScopeNode) {
+    // Helper: check if a type is a concrete scalar that cannot have sub-properties.
+    const SCALAR_TYPES = new Set([
+      'string',
+      'number',
+      'boolean',
+      'bigint',
+      'symbol',
+      'void',
+      'never',
+    ]);
+    const isDefinitelyScalar = (type: string): boolean => {
+      const parts = type.split('|').map((s) => s.trim());
+      const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
+      return base.length > 0 && base.every((b) => SCALAR_TYPES.has(b));
+    };
+
+    // Find variable → signature[N] equivalencies
+    for (const [varName, equivalencies] of Object.entries(
+      scopeNode.equivalencies,
+    )) {
+      // Only process simple variable names (no dots, brackets, or parens)
+      if (
+        varName.includes('.') ||
+        varName.includes('[') ||
+        varName.includes('(')
+      ) {
+        continue;
+      }
+
+      for (const equiv of equivalencies) {
+        if (
+          equiv.scopeNodeName === scopeNode.name &&
+          equiv.schemaPath.startsWith('signature[')
+        ) {
+          const signaturePath = equiv.schemaPath;
+          const varPrefix = varName + '.';
+          const varBracketPrefix = varName + '[';
+
+          // Find all schema keys starting with the variable
+          for (const key in scopeNode.schema) {
+            if (key.startsWith(varPrefix) || key.startsWith(varBracketPrefix)) {
+              const suffix = key.slice(varName.length);
+              const sigKey = signaturePath + suffix;
+
+              // Only add if the signature path doesn't already exist
+              if (!scopeNode.schema[sigKey]) {
+                // Check if this path represents variable conflation:
+                // When a standalone variable (e.g., showWorkoutForm from useState)
+                // appears as a sub-property of a scalar-typed ancestor (e.g.,
+                // activity_type = "string"), it's from scope conflation, not real
+                // property access. Block these while allowing legitimate built-in
+                // accesses like string.length or string.slice.
+                let isConflatedPath = false;
+                let checkPos = signaturePath.length;
+                while (true) {
+                  checkPos = sigKey.indexOf('.', checkPos + 1);
+                  if (checkPos === -1) break;
+                  const ancestorPath = sigKey.substring(0, checkPos);
+                  const ancestorType = scopeNode.schema[ancestorPath];
+                  if (ancestorType && isDefinitelyScalar(ancestorType)) {
+                    // Ancestor is scalar — check if the immediate sub-property
+                    // is also a standalone variable (indicating conflation)
+                    const afterDot = sigKey.substring(checkPos + 1);
+                    const nextSep = afterDot.search(/[.\[]/);
+                    const subPropName =
+                      nextSep === -1
+                        ? afterDot
+                        : afterDot.substring(0, nextSep);
+                    if (scopeNode.schema[subPropName] !== undefined) {
+                      isConflatedPath = true;
+                      break;
+                    }
+                  }
+                }
+
+                if (!isConflatedPath) {
+                  scopeNode.schema[sigKey] = scopeNode.schema[key];
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
   private filterAndConvertSchema({
     filterPath,
     newPath,
@@ -2741,6 +3532,9 @@ export class ScopeDataStructure {
                 equivalentValueSchemaPathParts.length,
               ),
             ]);
+            // PERF: Skip keys with repeated function-call signature patterns
+            // to prevent recursive type expansion (e.g., string.localeCompare returns string)
+            if (this.hasExcessivePatternRepetition(newKey)) continue;
             resolvedSchema[newKey] = value;
           }
         }
@@ -2763,6 +3557,8 @@ export class ScopeDataStructure {
         if (!subSchema) continue;
 
         for (const resolvedKey in subSchema) {
+          // PERF: Skip keys with repeated function-call signature patterns
+          if (this.hasExcessivePatternRepetition(resolvedKey)) continue;
           if (
             !resolvedSchema[resolvedKey] ||
             subSchema[resolvedKey] === 'unknown'
@@ -2909,7 +3705,12 @@ export class ScopeDataStructure {
       );
     }
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. See comment in getFunctionSignature.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(scopeNode, true, fillInUnknowns);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
 
     const { schema } = scopeNode;
 
@@ -2943,10 +3744,29 @@ export class ScopeDataStructure {
           }
         }
       }
-      return mergedSchema;
+      return this.filterDuplicateKeys(mergedSchema);
     }
 
-    return schema;
+    return this.filterDuplicateKeys(schema);
+  }
+
+  /**
+   * Filter out ::cyDuplicateKey:: entries from a schema.
+   * These are internal markers for tracking variable reassignments
+   * and should not appear in output schemas or LLM prompts.
+   */
+  private filterDuplicateKeys(
+    schema: Record<string, string>,
+  ): Record<string, string> {
+    return Object.entries(schema).reduce(
+      (acc, [key, value]) => {
+        if (!key.includes('::cyDuplicateKey')) {
+          acc[key] = value;
+        }
+        return acc;
+      },
+      {} as Record<string, string>,
+    );
   }
 
   getEquivalencies(scopeName?: string) {
@@ -2976,26 +3796,270 @@ export class ScopeDataStructure {
       return {};
     }
 
+    // Collect all descendant scope names (including the scope itself)
+    // This ensures we include external calls from nested scopes like cyScope2
+    const getAllDescendantScopeNames = (
+      node: import('./helpers/ScopeTreeManager').ScopeTreeNode,
+    ): Set<string> => {
+      const names = new Set<string>([node.name]);
+      for (const child of node.children) {
+        for (const name of getAllDescendantScopeNames(child)) {
+          names.add(name);
+        }
+      }
+      return names;
+    };
+
+    const treeNode = this.scopeTreeManager.findNode(scopeNode.name);
+    const descendantScopeNames = treeNode
+      ? getAllDescendantScopeNames(treeNode)
+      : new Set<string>([scopeNode.name]);
+
+    // Get all external function calls made from this scope or any descendant scope
+    // This allows us to include prop equivalencies from JSX components
+    // that were rendered in nested scopes (e.g., FileTableRow called from cyScope2)
+    const externalCallsFromScope = this.externalFunctionCalls.filter((efc) =>
+      descendantScopeNames.has(efc.callScope),
+    );
+    const externalCallNames = new Set(
+      externalCallsFromScope.map((efc) => efc.name),
+    );
+
+    // Helper to check if a usage belongs to this scope (directly, via descendant, or via external call)
+    const usageMatchesScope = (usage: { scopeNodeName: string }) =>
+      descendantScopeNames.has(usage.scopeNodeName) ||
+      externalCallNames.has(usage.scopeNodeName);
+
     const entries = this.equivalencyDatabase.filter((entry) =>
-      entry.usages.some((usage) => usage.scopeNodeName === scopeNode.name),
+      entry.usages.some(usageMatchesScope),
     );
-    return entries.reduce(
-      (acc, entry) => {
-        if (entry.sourceCandidates.length === 0) return acc;
-        const usages = entry.usages.filter(
-          (u) => u.scopeNodeName === scopeNode.name,
-        );
+
+    // Helper to resolve a source candidate through equivalency chains to find signature paths
+    const resolveToSignature = (
+      source: Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>,
+      visited: Set<string>,
+    ): Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[] => {
+      const visitKey = `${source.scopeNodeName}::${source.schemaPath}`;
+      if (visited.has(visitKey)) return [];
+      visited.add(visitKey);
+
+      // If already a signature path, return as-is
+      if (source.schemaPath.startsWith('signature[')) {
+        return [source];
+      }
+
+      const currentScope = this.scopeNodes[source.scopeNodeName];
+      if (!currentScope?.equivalencies) return [source];
+
+      // Check for direct equivalencies FIRST (full path match)
+      // This ensures paths like "useMemo(...).functionCallReturnValue" follow to "cyScope1::returnValue"
+      // before prefix matching tries "useMemo(...)" which goes to the useMemo scope
+      const directEquivs = currentScope.equivalencies[source.schemaPath];
+      if (directEquivs?.length > 0) {
+        const results: Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[] =
+          [];
+        for (const equiv of directEquivs) {
+          const resolved = resolveToSignature(
+            {
+              scopeNodeName: equiv.scopeNodeName,
+              schemaPath: equiv.schemaPath,
+            },
+            visited,
+          );
+          results.push(...resolved);
+        }
+        if (results.length > 0) return results;
+      }
+
+      // Handle spread patterns like [...items].sort().functionCallReturnValue
+      // Extract the spread variable and resolve it through the equivalency chain
+      const spreadMatch = source.schemaPath.match(/^\[\.\.\.(\w+)\]/);
+      if (spreadMatch) {
+        const spreadVar = spreadMatch[1];
+        const spreadPattern = spreadMatch[0];
+        const varEquivs = currentScope.equivalencies[spreadVar];
+
+        if (varEquivs?.length > 0) {
+          const results: Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[] =
+            [];
+          for (const equiv of varEquivs) {
+            // Follow the variable equivalency and then resolve from there
+            const resolvedVar = resolveToSignature(
+              {
+                scopeNodeName: equiv.scopeNodeName,
+                schemaPath: equiv.schemaPath,
+              },
+              visited,
+            );
+            // For each resolved variable path, create the full path with array element suffix
+            for (const rv of resolvedVar) {
+              if (rv.schemaPath.startsWith('signature[')) {
+                // Get the suffix after the spread pattern
+                let suffix = source.schemaPath.slice(spreadPattern.length);
+
+                // Clean the suffix: strip array method chains like .sort(...).functionCallReturnValue[]
+                // These don't change the data identity, just transform it.
+                // Keep only the final element access parts like [0], [1], etc.
+                // Pattern: strip everything from a method call up through functionCallReturnValue[]
+                suffix = suffix.replace(
+                  /\.\w+\([^)]*\)\.functionCallReturnValue\[\]/g,
+                  '',
+                );
+                // Also handle simpler case without nested parens
+                suffix = suffix.replace(
+                  /\.sort\(\w*\(\)\)\.functionCallReturnValue\[\]/g,
+                  '',
+                );
+
+                // Add [] to indicate array element access from the spread
+                const resolvedPath = rv.schemaPath + '[]' + suffix;
+                results.push({
+                  scopeNodeName: rv.scopeNodeName,
+                  schemaPath: resolvedPath,
+                });
+              }
+            }
+          }
+          if (results.length > 0) return results;
+        }
+      }
+
+      // Try to find prefix equivalencies that can resolve this path
+      // For path like "cyScope3().signature[0][0]", check "cyScope3().signature[0]", etc.
+      const pathParts = this.splitPath(source.schemaPath);
+      for (let i = pathParts.length - 1; i > 0; i--) {
+        const prefix = this.joinPathParts(pathParts.slice(0, i));
+        const suffix = this.joinPathParts(pathParts.slice(i));
+        const prefixEquivs = currentScope.equivalencies[prefix];
+
+        if (prefixEquivs?.length > 0) {
+          const results: Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[] =
+            [];
+          for (const equiv of prefixEquivs) {
+            const newPath = this.joinPathParts([equiv.schemaPath, suffix]);
+            const resolved = resolveToSignature(
+              { scopeNodeName: equiv.scopeNodeName, schemaPath: newPath },
+              visited,
+            );
+            results.push(...resolved);
+          }
+          if (results.length > 0) return results;
+        }
+      }
+
+      return [source];
+    };
+
+    const acc = entries.reduce(
+      (result, entry) => {
+        if (entry.sourceCandidates.length === 0) return result;
+        const usages = entry.usages.filter(usageMatchesScope);
         for (const usage of usages) {
-          acc[usage.schemaPath] ||= [];
-          acc[usage.schemaPath].push(...entry.sourceCandidates);
+          result[usage.schemaPath] ||= [];
+          // Resolve each source candidate through the equivalency chain
+          for (const source of entry.sourceCandidates) {
+            const resolvedSources = resolveToSignature(source, new Set());
+            result[usage.schemaPath].push(...resolvedSources);
+          }
         }
-        return acc;
+        return result;
       },
       {} as Record<
         string,
         Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[]
       >,
     );
+
+    // Post-processing: enrich useState-backed sources with co-located external
+    // function calls. When a useState value resolves to a setter variable that
+    // lives in the same scope as a fetch/API call, that fetch is a data source.
+    this.enrichUseStateSourcesWithCoLocatedCalls(acc);
+
+    return acc;
+  }
+
+  /**
+   * For each source that ends at a useState path, check if the setter was called
+   * from a scope that also contains external function calls (like fetch).
+   * If so, add those external calls as additional source candidates.
+   */
+  private enrichUseStateSourcesWithCoLocatedCalls(
+    acc: Record<string, Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[]>,
+  ) {
+    const rootScopeName = this.scopeTreeManager.getRootName();
+    const rootScope = this.scopeNodes[rootScopeName];
+    if (!rootScope) return;
+
+    // Collect all descendants for each scope node
+    const getAllDescendants = (
+      node: import('./helpers/ScopeTreeManager').ScopeTreeNode,
+    ): Set<string> => {
+      const names = new Set<string>([node.name]);
+      for (const child of node.children) {
+        for (const name of getAllDescendants(child)) {
+          names.add(name);
+        }
+      }
+      return names;
+    };
+
+    for (const [usagePath, sources] of Object.entries(acc)) {
+      const additionalSources: Pick<
+        ScopeVariable,
+        'scopeNodeName' | 'schemaPath'
+      >[] = [];
+
+      for (const source of sources) {
+        // Check if this source is a useState-related terminal path
+        // (e.g., useState(X).functionCallReturnValue[1] or useState(X).signature[0])
+        if (!source.schemaPath.match(/^useState\([^)]*\)\./)) continue;
+
+        // Find the useState call from the source path
+        const useStateCallMatch = source.schemaPath.match(
+          /^(useState\([^)]*\))\./,
+        );
+        if (!useStateCallMatch) continue;
+        const useStateCall = useStateCallMatch[1];
+
+        // Look in the root scope for the useState value equivalency
+        // which tells us where the setter was called from
+        const valuePath = `${useStateCall}.functionCallReturnValue[0]`;
+        const valueEquivs = rootScope.equivalencies[valuePath];
+        if (!valueEquivs) continue;
+
+        for (const equiv of valueEquivs) {
+          // Find the scope where the setter was called
+          const setterScopeName = equiv.scopeNodeName;
+          const setterScopeTree =
+            this.scopeTreeManager.findNode(setterScopeName);
+          if (!setterScopeTree) continue;
+
+          // Get all descendant scope names from the setter scope
+          const relatedScopes = getAllDescendants(setterScopeTree);
+
+          // Find external function calls in those scopes whose return values
+          // are actually consumed (assigned to a variable). This excludes
+          // fire-and-forget calls like analytics.track() or console.log().
+          const coLocatedCalls = this.externalFunctionCalls.filter(
+            (efc) =>
+              relatedScopes.has(efc.callScope) &&
+              efc.receivingVariableNames &&
+              efc.receivingVariableNames.length > 0,
+          );
+
+          for (const call of coLocatedCalls) {
+            additionalSources.push({
+              scopeNodeName: call.callScope,
+              schemaPath: `${call.callSignature}.functionCallReturnValue`,
+            });
+          }
+        }
+      }
+
+      if (additionalSources.length > 0) {
+        acc[usagePath].push(...additionalSources);
+      }
+    }
   }
 
   getUsageEquivalencies(functionName?: string) {
@@ -3010,6 +4074,7 @@ export class ScopeDataStructure {
         (candidate) => candidate.scopeNodeName === scopeNode.name,
       ),
     );
+
     return entries.reduce(
       (acc, entry) => {
         if (entry.usages.length === 0) return acc;
@@ -3053,12 +4118,14 @@ export class ScopeDataStructure {
       );
 
     const equivalencies = this.getEquivalencies(functionName);
+    const scopeName = functionName ?? this.scopeTreeManager.getRootName();
+
     for (const equivalenceKey in equivalencies ?? {}) {
       for (const equivalenceValue of equivalencies[equivalenceKey]) {
         const schemaPath = equivalenceValue.schemaPath;
         if (
           schemaPath.startsWith('signature[') &&
-          equivalenceValue.scopeNodeName === functionName &&
+          equivalenceValue.scopeNodeName === scopeName &&
           !signatureInSchema[schemaPath]
         ) {
           signatureInSchema[schemaPath] = 'unknown';
@@ -3074,7 +4141,188 @@ export class ScopeDataStructure {
 
     this.validateSchema(tempScopeNode, true, fillInUnknowns);
 
-    return tempScopeNode.schema;
+    // After validateSchema has filled in types, propagate nested paths from
+    // variables to their signature equivalents.
+    // e.g., workouts[].activity_type -> signature[0].workouts[].activity_type
+    //
+    // Build a map of variable names that are equivalent to signature paths
+    // e.g., { 'workouts': 'signature[0].workouts' }
+    const variableToSignatureMap: Record<string, string> = {};
+
+    for (const equivalenceKey in equivalencies ?? {}) {
+      for (const equivalenceValue of equivalencies[equivalenceKey]) {
+        const schemaPath = equivalenceValue.schemaPath;
+        // Track which variables map to signature paths
+        // equivalenceKey is the variable name (e.g., 'workouts')
+        // schemaPath is where it comes from (e.g., 'signature[0].workouts')
+        if (
+          schemaPath.startsWith('signature[') &&
+          equivalenceValue.scopeNodeName === scopeName
+        ) {
+          variableToSignatureMap[equivalenceKey] = schemaPath;
+        }
+      }
+    }
+
+    // Enrich schema with deeply nested paths from internal function call scopes.
+    // When a function call like traverse(tree) exists, and traverse's scope has
+    // signature[0].children[path][entityName] (from propagateParameterToSignaturePaths),
+    // we need to map those paths back to the argument variable (tree) in this scope.
+    // This handles cases where cycle detection prevented the equivalency chain from
+    // propagating deep paths during Phase 2 batch queue processing.
+    for (const equivalenceKey in equivalencies ?? {}) {
+      // Look for keys matching function call pattern: funcName(...).signature[N]
+      const funcCallMatch = equivalenceKey.match(
+        /^([^(]+)\(.*?\)\.(signature\[\d+\])$/,
+      );
+      if (!funcCallMatch) continue;
+
+      const calledFunctionName = funcCallMatch[1];
+      const signatureParam = funcCallMatch[2]; // e.g., "signature[0]"
+
+      for (const equivalenceValue of equivalencies[equivalenceKey]) {
+        if (equivalenceValue.scopeNodeName !== scopeName) continue;
+
+        const targetVariable = equivalenceValue.schemaPath;
+
+        // Get the called function's schema (includes propagated parameter paths)
+        const childSchema = this.getSchema({
+          scopeName: calledFunctionName,
+        });
+        if (!childSchema) continue;
+
+        // Map child function's signature paths to parent variable paths
+        const sigPrefix = signatureParam + '.';
+        const sigBracketPrefix = signatureParam + '[';
+        for (const childKey in childSchema) {
+          let suffix: string | null = null;
+          if (childKey.startsWith(sigPrefix)) {
+            suffix = childKey.slice(signatureParam.length);
+          } else if (childKey.startsWith(sigBracketPrefix)) {
+            suffix = childKey.slice(signatureParam.length);
+          }
+
+          if (suffix !== null) {
+            const parentKey = targetVariable + suffix;
+            if (!schema[parentKey]) {
+              schema[parentKey] = childSchema[childKey];
+            }
+          }
+        }
+      }
+    }
+
+    // Helper: check if a type is a concrete scalar that cannot have sub-properties.
+    // e.g., "string", "number | undefined", "boolean | null" are scalar.
+    // "object", "array", "function", "unknown", "Workout", etc. are NOT scalar.
+    const SCALAR_TYPES = new Set([
+      'string',
+      'number',
+      'boolean',
+      'bigint',
+      'symbol',
+      'void',
+      'never',
+    ]);
+    const isDefinitelyScalarType = (type: string): boolean => {
+      const parts = type.split('|').map((s) => s.trim());
+      const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
+      return base.length > 0 && base.every((b) => SCALAR_TYPES.has(b));
+    };
+
+    // Propagate nested paths from variables to their signature equivalents
+    // e.g., if workouts = signature[0].workouts, then workouts[].title becomes
+    // signature[0].workouts[].title
+    for (const schemaKey in schema) {
+      // Skip keys that already start with signature[
+      if (schemaKey.startsWith('signature[')) continue;
+
+      // Check if this key starts with a variable that maps to a signature path
+      for (const [variableName, signaturePath] of Object.entries(
+        variableToSignatureMap,
+      )) {
+        // Check if schemaKey starts with variableName followed by a property accessor
+        // e.g., 'workouts[]' starts with 'workouts'
+        if (
+          schemaKey === variableName ||
+          schemaKey.startsWith(variableName + '.') ||
+          schemaKey.startsWith(variableName + '[')
+        ) {
+          // Transform the path: replace the variable prefix with the signature path
+          const suffix = schemaKey.slice(variableName.length);
+          const signatureKey = signaturePath + suffix;
+
+          // Add to schema if not already present
+          if (!tempScopeNode.schema[signatureKey]) {
+            // Check if this path represents variable conflation:
+            // When a standalone variable (e.g., showWorkoutForm from useState)
+            // appears as a sub-property of a scalar-typed ancestor (e.g.,
+            // activity_type = "string"), it's from scope conflation, not real
+            // property access. Block these while allowing legitimate built-in
+            // accesses like string.length or string.slice.
+            let isConflatedPath = false;
+            let checkPos = signaturePath.length;
+            while (true) {
+              checkPos = signatureKey.indexOf('.', checkPos + 1);
+              if (checkPos === -1) break;
+              const ancestorPath = signatureKey.substring(0, checkPos);
+              const ancestorType = tempScopeNode.schema[ancestorPath];
+              if (ancestorType && isDefinitelyScalarType(ancestorType)) {
+                // Ancestor is scalar — check if the immediate sub-property
+                // is also a standalone variable (indicating conflation)
+                const afterDot = signatureKey.substring(checkPos + 1);
+                const nextSep = afterDot.search(/[.\[]/);
+                const subPropName =
+                  nextSep === -1 ? afterDot : afterDot.substring(0, nextSep);
+                if (schema[subPropName] !== undefined) {
+                  isConflatedPath = true;
+                  break;
+                }
+              }
+            }
+
+            if (!isConflatedPath) {
+              tempScopeNode.schema[signatureKey] = schema[schemaKey];
+            }
+          }
+        }
+      }
+    }
+
+    // Post-process: filter out conflated signature paths.
+    // During phase 2 scope analysis, useState(false) conflation can create
+    // bad paths like signature[0].mockWorkouts[].activity_type.showWorkoutForm
+    // directly in scopeNode.schema. These flow through signatureInSchema into
+    // tempScopeNode.schema without any guard. Filter them out here by checking:
+    //   1. An ancestor in the path has a concrete scalar type (string, number, boolean, etc.)
+    //   2. The immediate sub-property of that scalar ancestor is also a standalone
+    //      variable in the schema (indicating conflation, not a real property access)
+    for (const key of Object.keys(tempScopeNode.schema)) {
+      if (!key.startsWith('signature[')) continue;
+
+      // Walk through the path looking for scalar-typed ancestors
+      let pos = 0;
+      while (true) {
+        pos = key.indexOf('.', pos + 1);
+        if (pos === -1) break;
+        const ancestorPath = key.substring(0, pos);
+        const ancestorType = tempScopeNode.schema[ancestorPath];
+        if (ancestorType && isDefinitelyScalarType(ancestorType)) {
+          // Found a scalar ancestor — check if the sub-property name
+          // is a standalone variable in the getSchema() result
+          const afterDot = key.substring(pos + 1);
+          const nextSep = afterDot.search(/[.\[]/);
+          const subPropName =
+            nextSep === -1 ? afterDot : afterDot.substring(0, nextSep);
+          if (schema[subPropName] !== undefined) {
+            delete tempScopeNode.schema[key];
+            break;
+          }
+        }
+      }
+    }
+
+    return this.filterDuplicateKeys(tempScopeNode.schema);
   }
 
   getReturnValue({
@@ -3084,6 +4332,15 @@ export class ScopeDataStructure {
     functionName?: string;
     fillInUnknowns?: boolean;
   }) {
+    // Trigger finalization on all managers to apply any pending updates
+    // (e.g., ref type propagation to external function call schemas)
+    const rootScope = this.scopeNodes[this.scopeTreeManager.getRootName()];
+    if (rootScope) {
+      for (const manager of this.equivalencyManagers) {
+        manager.finalize(rootScope, this);
+      }
+    }
+
     const scopeName = functionName ?? this.scopeTreeManager.getRootName();
     const scopeNode = this.scopeNodes[scopeName];
 
@@ -3094,7 +4351,8 @@ export class ScopeDataStructure {
         scopeNode: scopeNode,
       });
     } else {
-      for (const externalFunctionCall of this.externalFunctionCalls) {
+      // Use getExternalFunctionCalls() which cleans cyScope from schemas
+      for (const externalFunctionCall of this.getExternalFunctionCalls()) {
         const functionNameParts = this.splitPath(functionName).map((p) =>
           this.functionOrScopeName(p),
         );
@@ -3126,7 +4384,17 @@ export class ScopeDataStructure {
           // Include function paths even if their return value wasn't captured
           // This ensures methods like onAuthStateChange are included in the schema
           // But exclude signature entries (they should only be included via functionCallReturnValue paths)
-          (schema[key] === 'function' && key.indexOf('signature[') === -1),
+          // Also exclude bare function call signatures - paths that are JUST a call like
+          // "useCustomSizes(projectSlug)" should not be included as return values.
+          // These represent "the function exists" not actual return data, and including
+          // them causes nested path bugs in dependencySchemas.
+          (schema[key] === 'function' &&
+            key.indexOf('signature[') === -1 &&
+            // Exclude bare call signatures: function calls with no dots OUTSIDE parentheses
+            // e.g., "useCustomSizes(projectSlug)" is bare (exclude)
+            // e.g., "loadProject({nested.property})" is bare - dots are inside args (exclude)
+            // e.g., "getSupabase().auth.method()" has dots outside - method chain (include)
+            !this.isBareCallSignature(key)),
       )
       .reduce(
         (acc, key) => {
@@ -3136,7 +4404,10 @@ export class ScopeDataStructure {
           for (const path in schema) {
             const pathParts = this.splitPath(path);
             if (pathParts.every((p, i) => keyParts[i] === p)) {
-              acc[path] = schema[path];
+              // Also exclude bare call signatures from prefix paths
+              if (!this.isBareCallSignature(path)) {
+                acc[path] = schema[path];
+              }
             }
           }
 
@@ -3150,14 +4421,73 @@ export class ScopeDataStructure {
 
     const tempScopeNode = this.createTempScopeNode(scopeName, resolvedSchema);
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. See comment in getFunctionSignature.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(tempScopeNode, true, fillInUnknowns);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
+
+    // Remove bare call signatures from the return value schema.
+    // fillInSchemaGapsAndUnknowns may add parent paths like "useCustomSizes(projectSlug)"
+    // when it sees "useCustomSizes(projectSlug).functionCallReturnValue". These bare
+    // call signatures represent "the function exists" not actual return data, and
+    // including them causes nested path bugs in dependencySchemas.
+    const resultSchema = tempScopeNode.schema;
+    for (const key of Object.keys(resultSchema)) {
+      if (this.isBareCallSignature(key)) {
+        delete resultSchema[key];
+      }
+    }
+
+    return resultSchema;
+  }
+
+  /**
+   * Checks if a schema key is a "bare call signature" - a function call with no
+   * method chain before it and no path segments after it.
+   *
+   * A bare call signature represents "this function exists" rather than actual
+   * return data, and including them causes nested path bugs in dependencySchemas.
+   *
+   * Examples:
+   * - "useCustomSizes(projectSlug)" -> bare (true)
+   * - "loadProject({nested.property})" -> bare (dots are inside args, true)
+   * - "getSupabase().auth.method()" -> not bare (has dots outside parens, false)
+   * - "useProject().functionCallReturnValue" -> not bare (has path after, false)
+   */
+  private isBareCallSignature(key: string): boolean {
+    // Must end with ) and contain ( to be a call
+    if (!key.endsWith(')') || key.indexOf('(') === -1) {
+      return false;
+    }
+
+    // Check if there are any dots OUTSIDE of parentheses
+    // Strip out content inside balanced parentheses, then check for dots
+    let depth = 0;
+    let hasDotsOutsideParens = false;
+
+    for (let i = 0; i < key.length; i++) {
+      const char = key[i];
+      if (char === '(') {
+        depth++;
+      } else if (char === ')') {
+        depth--;
+      } else if (char === '.' && depth === 0) {
+        hasDotsOutsideParens = true;
+        break;
+      }
+    }
 
-    return tempScopeNode.schema;
+    // It's a bare call signature if there are no dots outside parentheses
+    return !hasDotsOutsideParens;
   }
 
   /**
    * Replaces cyScope placeholder references (e.g., cyScope10()) in schema keys
    * with the actual callback function text from the corresponding scope node.
+   * If the scope text can't be found, uses a generic fallback to avoid leaking
+   * internal cyScope names into stored data.
    */
   private replaceCyScopePlaceholders(
     schema: Record<string, string>,
@@ -3173,10 +4503,10 @@ export class ScopeDataStructure {
       for (const match of matches) {
         const cyScopeName = `cyScope${match[1]}`;
         const scopeText = this.findCyScopeText(cyScopeName);
-        if (scopeText) {
-          // Replace cyScope10() with the actual callback text
-          newKey = newKey.replace(match[0], scopeText);
-        }
+        // Always replace cyScope references - use actual text if available,
+        // otherwise use a generic callback placeholder
+        const replacement = scopeText || '() => {}';
+        newKey = newKey.replace(match[0], replacement);
       }
 
       result[newKey] = value;
@@ -3234,45 +4564,455 @@ export class ScopeDataStructure {
     return scopeText;
   }
 
-  getEquivalentSignatureVariables() {
+  getEquivalentSignatureVariables(): Record<string, string | string[]> {
     const scopeNode = this.scopeNodes[this.scopeTreeManager.getRootName()];
 
-    const equivalentSignatureVariables: Record<string, string> = {};
+    const equivalentSignatureVariables: Record<string, string | string[]> = {};
+
+    // Helper to add equivalencies - accumulates into array if multiple values for same key
+    // This is critical for OR expressions like `x = a || b` where x should map to both a and b
+    const addEquivalency = (key: string, value: string) => {
+      const existing = equivalentSignatureVariables[key];
+      if (existing === undefined) {
+        // First value - store as string
+        equivalentSignatureVariables[key] = value;
+      } else if (typeof existing === 'string') {
+        if (existing !== value) {
+          // Second different value - convert to array
+          equivalentSignatureVariables[key] = [existing, value];
+        }
+        // Same value - no change needed
+      } else {
+        // Already an array - add if not already present
+        if (!existing.includes(value)) {
+          existing.push(value);
+        }
+      }
+    };
+
     for (const [path, equivalentValues] of Object.entries(
       scopeNode.equivalencies,
     )) {
       for (const equivalentValue of equivalentValues) {
+        // Case 1: Props/signature equivalencies (existing behavior)
+        // Maps local variable names to their signature paths
+        // e.g., "propValue" -> "signature[0].prop"
         if (path.startsWith('signature[')) {
-          equivalentSignatureVariables[equivalentValue.schemaPath] = path;
+          addEquivalency(equivalentValue.schemaPath, path);
         }
-      }
-    }
 
-    return equivalentSignatureVariables;
-  }
+        // Case 2: Hook variable equivalencies (new behavior)
+        // The equivalencies are stored as: path = variable name, schemaPath = data source
+        // e.g., path = "debugFetcher", schemaPath = "useFetcher<...>().functionCallReturnValue"
+        // We need to map: "debugFetcher" -> "useFetcher<...>()"
+        // This enables resolving paths like "debugFetcher.state" to
+        // "useFetcher<...>().state" for execution flow validation
+        if (equivalentValue.schemaPath.endsWith('.functionCallReturnValue')) {
+          // Extract the hook call path (everything before .functionCallReturnValue)
+          let hookCallPath = equivalentValue.schemaPath.slice(
+            0,
+            -'.functionCallReturnValue'.length,
+          );
+          // Only include if it looks like a hook call (contains parentheses)
+          // and the variable name (path) is a simple identifier (no dots)
+          if (hookCallPath.includes('(') && !path.includes('.')) {
+            // Special case: If hookCallPath is a callback scope (cyScope pattern),
+            // trace through it to find what the callback actually returns.
+            // This handles useState(() => { return prop; }) patterns.
+            const cyScopeMatch = hookCallPath.match(/^(cyScope\d+)\(\)$/);
+            if (cyScopeMatch) {
+              // Use the equivalency database to trace the callback's return value
+              // to its actual source (e.g., viewModeFromUrl -> segments -> params -> useParams)
+              const dbEntry = this.getEquivalenciesDatabaseEntry(
+                scopeNode.name, // Component scope
+                path, // variable name (e.g., viewMode)
+              );
+              if (dbEntry?.sourceCandidates?.length > 0) {
+                // Use the traced source instead of the callback scope
+                hookCallPath = dbEntry.sourceCandidates[0].schemaPath;
+              }
+            }
+            addEquivalency(path, hookCallPath);
+          }
+        }
 
-  getVariableInfo(
-    variableName: string,
-    scopeName?: string,
-    final?: boolean,
-  ): VariableInfo | undefined {
-    const scopeNode = this.getScopeOrFunctionCallInfo(
-      scopeName ?? this.scopeTreeManager.getRootName(),
-    );
-    if (!scopeNode) return;
+        // Case 3: Destructured variables from local variables
+        // e.g., const { scenarios } = currentEntityAnalysis;
+        // This creates: path = "scenarios", schemaPath = "currentEntityAnalysis.scenarios"
+        // We need to map: "scenarios" -> "currentEntityAnalysis.scenarios"
+        // AND resolve transitively if currentEntityAnalysis is itself equivalent to a hook call
+        if (
+          !path.includes('.') && // path is a simple identifier
+          !equivalentValue.schemaPath.startsWith('signature[') && // not a signature path
+          !equivalentValue.schemaPath.endsWith('.functionCallReturnValue') // not already handled above
+        ) {
+          // Skip bare "returnValue" from child scopes — this is the child's return value,
+          // not a meaningful data source path in the parent scope
+          if (
+            equivalentValue.schemaPath === 'returnValue' &&
+            equivalentValue.scopeNodeName !==
+              this.scopeTreeManager.getRootName()
+          ) {
+            continue;
+          }
+          // Add equivalency (will accumulate if multiple values for OR expressions)
+          addEquivalency(path, equivalentValue.schemaPath);
+        }
 
-    let equivalents = scopeNode.equivalencies[variableName];
+        // Case 4: Child component prop mappings (Fix 22)
+        // When parent renders <ChildComponent prop={value} />, we get equivalencies like:
+        //   path = "ChildComponent().signature[0].prop"
+        //   schemaPath = "value" (the variable passed as the prop)
+        // We need to include these so translateChildPathToParent can work.
+        // Pattern: ComponentName().signature[N] or ComponentName().signature[N].propName
+        if (
+          path.includes('().signature[') &&
+          !equivalentValue.schemaPath.includes('()') // schemaPath is a simple variable, not a function call
+        ) {
+          addEquivalency(path, equivalentValue.schemaPath);
+        }
 
-    if (!equivalents || equivalents.length === 0) {
-      equivalents = [
-        {
-          id: -1,
-          scopeNodeName: scopeNode.name,
-          schemaPath: variableName,
-          equivalencyReason: 'missing equivalency',
-        },
-      ];
-    }
+        // Case 5: Destructured function parameters (Fix 25)
+        // When a function has destructured props: function Comp({ propA, propB }: Props)
+        // We get equivalencies like:
+        //   path = "propA" (the destructured variable name)
+        //   schemaPath = "signature[0].propA" (the signature path)
+        // We need to map: "propA" -> "signature[0].propA"
+        // This enables translateChildPathToParent to resolve child variable paths
+        // to their signature paths when merging execution flows.
+        if (
+          !path.includes('.') && // path is a simple identifier (destructured prop name)
+          equivalentValue.schemaPath.startsWith('signature[') // schemaPath IS a signature path
+        ) {
+          addEquivalency(path, equivalentValue.schemaPath);
+        }
+
+        // Case 7: Method calls on variables that result in .functionCallReturnValue (Fix 33)
+        // When we have patterns like:
+        //   path = "segments" (simple identifier)
+        //   schemaPath = "splat.split('/').functionCallReturnValue"
+        // This is a method call on a variable (not a hook call), but we still need to
+        // track it so transitive resolution can resolve `splat` to its actual source.
+        // E.g., if splat -> useParams().functionCallReturnValue['*'], then
+        // segments -> useParams().functionCallReturnValue['*'].split('/').functionCallReturnValue
+        if (
+          !path.includes('.') && // path is a simple identifier
+          equivalentValue.schemaPath.endsWith('.functionCallReturnValue') && // ends with function return
+          equivalentValue.schemaPath.includes('.') // has property access (method call)
+        ) {
+          // Check if this looks like a method call on a variable (not a hook call)
+          // Hook calls look like: hookName() or hookName<T>()
+          // Method calls look like: variable.method() or variable.method<T>()
+          const hookCallPath = equivalentValue.schemaPath.slice(
+            0,
+            -'.functionCallReturnValue'.length,
+          );
+          // If it's a method call (contains a dot before the parenthesis), include it
+          const dotBeforeParen = hookCallPath.indexOf('.');
+          const parenPos = hookCallPath.indexOf('(');
+          if (dotBeforeParen !== -1 && dotBeforeParen < parenPos) {
+            // This is a method call like "splat.split('/')", not a hook call
+            addEquivalency(path, equivalentValue.schemaPath);
+          }
+        }
+      }
+    }
+
+    // Case 6: Collect JSX child prop equivalencies from child scopes (Fix 26)
+    // When a parent component renders <ChildComponent prop={value} />, the JSX
+    // return statement may be in a child scope (e.g., cyScope2). The equivalencies
+    // like ChildComponent().signature[0].prop -> value get stored in that child scope.
+    // But translateChildPathToParent needs to find them from the parent scope's context.
+    // So we collect Case 4 patterns from ALL child scopes that belong to this root scope.
+    const rootName = this.scopeTreeManager.getRootName();
+    for (const [scopeName, childScopeNode] of Object.entries(this.scopeNodes)) {
+      // Skip the root scope (already processed above)
+      if (scopeName === rootName) continue;
+
+      // Only include scopes that are children of the root (their tree includes root)
+      if (!childScopeNode.tree?.includes(rootName)) continue;
+
+      // Look for Case 4 patterns in the child scope
+      for (const [path, equivalentValues] of Object.entries(
+        childScopeNode.equivalencies || {},
+      )) {
+        for (const equivalentValue of equivalentValues) {
+          // Case 4 pattern: ChildComponent().signature[0].propName -> parentVariable
+          if (
+            path.includes('().signature[') &&
+            !equivalentValue.schemaPath.includes('()') // schemaPath is a simple variable
+          ) {
+            // Only add if not already present from the root scope
+            // Root scope values take precedence over child scope values
+            if (!(path in equivalentSignatureVariables)) {
+              addEquivalency(path, equivalentValue.schemaPath);
+            }
+          }
+        }
+      }
+    }
+
+    // Transitive resolution: Resolve variable chains through multiple levels
+    // E.g., analysis → currentEntityAnalysis → useLoaderData().functionCallReturnValue.currentEntityAnalysis
+    // We need multiple passes because resolutions can depend on each other
+    const maxIterations = 5; // Prevent infinite loops
+
+    // Helper function to resolve a single source path using equivalencies
+    const resolveSourcePath = (
+      sourcePath: string,
+      equivMap: Record<string, string | string[]>,
+    ): string | null => {
+      // Extract base variable from the path
+      const dotIndex = sourcePath.indexOf('.');
+      const bracketIndex = sourcePath.indexOf('[');
+
+      let baseVar: string;
+      let rest: string;
+
+      if (dotIndex === -1 && bracketIndex === -1) {
+        baseVar = sourcePath;
+        rest = '';
+      } else if (dotIndex === -1) {
+        baseVar = sourcePath.slice(0, bracketIndex);
+        rest = sourcePath.slice(bracketIndex);
+      } else if (bracketIndex === -1) {
+        baseVar = sourcePath.slice(0, dotIndex);
+        rest = sourcePath.slice(dotIndex);
+      } else {
+        const firstIndex = Math.min(dotIndex, bracketIndex);
+        baseVar = sourcePath.slice(0, firstIndex);
+        rest = sourcePath.slice(firstIndex);
+      }
+
+      // Look up the base variable in equivalencies
+      if (baseVar in equivMap && equivMap[baseVar] !== sourcePath) {
+        const baseResolved = equivMap[baseVar];
+        // Skip if baseResolved is an array (handle later)
+        if (Array.isArray(baseResolved)) return null;
+        // If it resolves to a signature path, build the full resolved path
+        if (
+          baseResolved.startsWith('signature[') ||
+          baseResolved.includes('()')
+        ) {
+          if (baseResolved.endsWith('()')) {
+            return baseResolved + '.functionCallReturnValue' + rest;
+          }
+          return baseResolved + rest;
+        }
+      }
+      return null;
+    };
+
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+      let changed = false;
+
+      for (const [varName, sourcePathOrArray] of Object.entries(
+        equivalentSignatureVariables,
+      )) {
+        // Handle arrays (OR expressions) by resolving each element
+        if (Array.isArray(sourcePathOrArray)) {
+          const resolvedArray: string[] = [];
+          let arrayChanged = false;
+          for (const sourcePath of sourcePathOrArray) {
+            // Try to resolve this path using transitive resolution
+            const resolved = resolveSourcePath(
+              sourcePath,
+              equivalentSignatureVariables,
+            );
+            if (resolved && resolved !== sourcePath) {
+              resolvedArray.push(resolved);
+              arrayChanged = true;
+            } else {
+              resolvedArray.push(sourcePath);
+            }
+          }
+          if (arrayChanged) {
+            equivalentSignatureVariables[varName] = resolvedArray;
+            changed = true;
+          }
+          continue;
+        }
+        const sourcePath = sourcePathOrArray;
+
+        // Skip if already fully resolved (contains function call syntax)
+        // BUT first check for computed value patterns that need resolution (Fix 28)
+        // AND method call patterns that need base variable resolution (Fix 33)
+        if (sourcePath.includes('()')) {
+          // Fix 28: Handle computed value patterns with dependency arrays
+          // Patterns like `functionName(arg, [dep1, dep2, ...])` are NOT controllable
+          // data sources. We trace through the dependencies to find controllable sources.
+          const bracketStart = sourcePath.indexOf('[');
+          const bracketEnd = sourcePath.lastIndexOf(']');
+
+          if (bracketStart !== -1 && bracketEnd > bracketStart) {
+            const arrayContent = sourcePath.slice(bracketStart + 1, bracketEnd);
+            const items = arrayContent.split(',').map((s) => s.trim());
+
+            // Only process if this looks like a dependency array:
+            // multiple items that are all simple identifiers (not numbers or expressions)
+            const isIdentifier = (s: string) =>
+              /^\w+$/.test(s) && !/^\d+$/.test(s);
+            if (items.length > 1 && items.every(isIdentifier)) {
+              // Look for a dependency that's already resolved to a controllable source
+              for (const dep of items) {
+                if (dep in equivalentSignatureVariables) {
+                  const resolvedDep = equivalentSignatureVariables[dep];
+                  // Use if it's a controllable path (contains hook call)
+                  // and is NOT another unresolved computed pattern (has comma-separated deps)
+                  const hasCommaInBrackets =
+                    resolvedDep.includes('[') &&
+                    resolvedDep.includes(',') &&
+                    resolvedDep.indexOf(',') > resolvedDep.indexOf('[');
+                  if (resolvedDep.includes('()') && !hasCommaInBrackets) {
+                    // Computed value is typically an element from an array
+                    equivalentSignatureVariables[varName] = resolvedDep + '[]';
+                    changed = true;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+
+          // Fix 33: Handle method call patterns on variables
+          // Patterns like: "splat.split('/').functionCallReturnValue"
+          // We need to resolve the base variable (splat) to its actual source
+          // Check if this is a method call on a variable (dot before first parenthesis)
+          const dotIndex = sourcePath.indexOf('.');
+          const parenIndex = sourcePath.indexOf('(');
+          if (
+            dotIndex !== -1 &&
+            dotIndex < parenIndex &&
+            !sourcePath.startsWith('use') // Not a hook call like useState()
+          ) {
+            // Extract the base variable (before the first dot)
+            const baseVar = sourcePath.slice(0, dotIndex);
+            const rest = sourcePath.slice(dotIndex); // includes ".method(...).functionCallReturnValue"
+
+            // Check if the base variable can be resolved
+            if (
+              baseVar in equivalentSignatureVariables &&
+              baseVar !== varName
+            ) {
+              const baseResolved = equivalentSignatureVariables[baseVar];
+              // Skip if baseResolved is an array (OR expression)
+              if (Array.isArray(baseResolved)) continue;
+              // Only resolve if the base resolved to something useful (contains () or .)
+              if (baseResolved.includes('()') || baseResolved.includes('.')) {
+                const newPath = baseResolved + rest;
+                if (newPath !== equivalentSignatureVariables[varName]) {
+                  equivalentSignatureVariables[varName] = newPath;
+                  changed = true;
+                }
+              }
+            }
+          }
+
+          // Fix 38: Handle cyScope lazy initializer return values
+          // When we have viewMode -> cyScope20(), trace through to find what cyScope20 returns.
+          // The lazy initializer's return value should be the controllable data source.
+          // Pattern: cyScopeN() where N is a number
+          const cyScopeMatch = sourcePath.match(/^(cyScope\d+)\(\)$/);
+          if (cyScopeMatch) {
+            const cyScopeName = cyScopeMatch[1];
+            const cyScopeNode = this.scopeNodes[cyScopeName];
+
+            if (cyScopeNode?.equivalencies) {
+              // Look for returnValue equivalency in the cyScope
+              const returnValueEquivs =
+                cyScopeNode.equivalencies['returnValue'];
+              if (returnValueEquivs && returnValueEquivs.length > 0) {
+                // Get the first return value source
+                const returnSource = returnValueEquivs[0].schemaPath;
+
+                // If the return source is a simple variable (not a complex path),
+                // resolve varName directly to that variable
+                if (
+                  returnSource &&
+                  !returnSource.includes('(') &&
+                  !returnSource.includes('[')
+                ) {
+                  // Update varName to point to the return source
+                  if (equivalentSignatureVariables[varName] !== returnSource) {
+                    equivalentSignatureVariables[varName] = returnSource;
+                    changed = true;
+                  }
+                }
+              }
+            }
+          }
+
+          continue;
+        }
+
+        // Check if the source path starts with a variable that's also in the map
+        const dotIndex = sourcePath.indexOf('.');
+        let baseVar: string;
+        let rest: string;
+
+        if (dotIndex > 0) {
+          // Path has a dot: "a.b.c" -> baseVar="a", rest=".b.c"
+          baseVar = sourcePath.slice(0, dotIndex);
+          rest = sourcePath.slice(dotIndex); // includes the leading dot
+        } else {
+          // Path is a simple identifier: "currentEntityAnalysis" -> baseVar="currentEntityAnalysis", rest=""
+          baseVar = sourcePath;
+          rest = '';
+        }
+
+        if (baseVar in equivalentSignatureVariables && baseVar !== varName) {
+          // Handle array case (OR expressions) - use first element
+          const rawBaseResolved = equivalentSignatureVariables[baseVar];
+          const baseResolved = Array.isArray(rawBaseResolved)
+            ? rawBaseResolved[0]
+            : rawBaseResolved;
+          if (!baseResolved) continue;
+          // If the base resolves to a hook call, add .functionCallReturnValue
+          if (baseResolved.endsWith('()')) {
+            const newPath = baseResolved + '.functionCallReturnValue' + rest;
+            if (newPath !== equivalentSignatureVariables[varName]) {
+              equivalentSignatureVariables[varName] = newPath;
+              changed = true;
+            }
+          } else if (baseResolved !== sourcePath) {
+            const newPath = baseResolved + rest;
+            if (newPath !== equivalentSignatureVariables[varName]) {
+              equivalentSignatureVariables[varName] = newPath;
+              changed = true;
+            }
+          }
+        }
+      }
+
+      // Stop if no changes were made in this iteration
+      if (!changed) break;
+    }
+
+    return equivalentSignatureVariables;
+  }
+
+  getVariableInfo(
+    variableName: string,
+    scopeName?: string,
+    final?: boolean,
+  ): VariableInfo | undefined {
+    const scopeNode = this.getScopeOrFunctionCallInfo(
+      scopeName ?? this.scopeTreeManager.getRootName(),
+    );
+    if (!scopeNode) return;
+
+    let equivalents = scopeNode.equivalencies[variableName];
+
+    if (!equivalents || equivalents.length === 0) {
+      equivalents = [
+        {
+          id: -1,
+          scopeNodeName: scopeNode.name,
+          schemaPath: variableName,
+          equivalencyReason: 'missing equivalency',
+        },
+      ];
+    }
 
     const relevantSchema = equivalents.reduce(
       (acc, eq) => {
@@ -3298,7 +5038,12 @@ export class ScopeDataStructure {
       relevantSchema,
     );
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. See comment in getFunctionSignature.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(tempScopeNode, true, final);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
 
     return {
       name: variableName,
@@ -3307,8 +5052,223 @@ export class ScopeDataStructure {
     };
   }
 
-  getExternalFunctionCalls() {
-    return this.externalFunctionCalls;
+  getExternalFunctionCalls(): FunctionCallInfo[] {
+    // Replace cyScope placeholders in all external function call data
+    // This ensures call signatures and schema paths use actual callback text
+    // instead of internal cyScope names, preventing mock data merge conflicts.
+    const rootScopeName = this.scopeTreeManager.getRootName();
+    const rootSchema = this.scopeNodes[rootScopeName]?.schema ?? {};
+
+    return this.externalFunctionCalls.map((efc) => {
+      const cleaned = this.cleanCyScopeFromFunctionCallInfo(efc);
+      return this.filterConflatedExternalPaths(cleaned, rootSchema);
+    });
+  }
+
+  /**
+   * Filters out conflated paths from external function call schemas.
+   *
+   * When multiple useState(false) calls create equivalency conflation during
+   * Phase 1 analysis, standalone boolean state variables (like showWorkoutForm,
+   * showGoalForm) can bleed into external function call schemas as sub-properties
+   * of unrelated data fields (like data[].activity_type.showWorkoutForm).
+   *
+   * Detection: group sub-properties by parent path. If 2+ sub-properties of
+   * the same parent all match standalone root scope variable names, treat them
+   * as conflation artifacts and remove them.
+   */
+  private filterConflatedExternalPaths(
+    efc: FunctionCallInfo,
+    rootSchema: Record<string, string>,
+  ): FunctionCallInfo {
+    // Build a set of top-level root scope variable names (simple names, no dots/brackets)
+    const topLevelRootVars = new Set<string>();
+    for (const key of Object.keys(rootSchema)) {
+      if (!key.includes('.') && !key.includes('[')) {
+        topLevelRootVars.add(key);
+      }
+    }
+
+    if (topLevelRootVars.size === 0) return efc;
+
+    // Group sub-property matches by their parent path.
+    // For a path like "...data[].activity_type.showWorkoutForm",
+    // parent = "...data[].activity_type", child = "showWorkoutForm"
+    const parentToConflatedKeys = new Map<string, string[]>();
+
+    for (const key of Object.keys(efc.schema)) {
+      const lastDot = key.lastIndexOf('.');
+      if (lastDot === -1) continue;
+
+      const parent = key.substring(0, lastDot);
+      const child = key.substring(lastDot + 1);
+
+      // Skip array access or function call patterns
+      if (child.includes('[') || child.includes('(')) continue;
+
+      // Only consider paths inside array element chains (contains []).
+      // Direct children of functionCallReturnValue are legitimate destructured
+      // return values, not conflation. Conflation happens deeper in the chain
+      // when array element fields get corrupted sub-properties.
+      if (!parent.includes('[')) continue;
+
+      if (topLevelRootVars.has(child)) {
+        if (!parentToConflatedKeys.has(parent)) {
+          parentToConflatedKeys.set(parent, []);
+        }
+        parentToConflatedKeys.get(parent)!.push(key);
+      }
+    }
+
+    // Only filter when 2+ sub-properties of the same parent match root scope vars.
+    // This threshold avoids false positives from coincidental name matches.
+    const keysToRemove = new Set<string>();
+    const parentsToRestore = new Set<string>();
+
+    for (const [parent, conflatedKeys] of parentToConflatedKeys) {
+      if (conflatedKeys.length >= 2) {
+        for (const key of conflatedKeys) {
+          keysToRemove.add(key);
+        }
+        parentsToRestore.add(parent);
+      }
+    }
+
+    if (keysToRemove.size === 0) return efc;
+
+    // Create a new schema without the conflated paths
+    const newSchema: Record<string, string> = {};
+    for (const [key, value] of Object.entries(efc.schema)) {
+      if (keysToRemove.has(key)) continue;
+
+      // Restore parent type: if it was changed to "object" because of conflated
+      // sub-properties, and now all those sub-properties are removed, change it
+      // back to "unknown" (we don't know the original type)
+      if (parentsToRestore.has(key) && value === 'object') {
+        // Check if there are any remaining sub-properties
+        const hasRemainingSubProps = Object.keys(efc.schema).some(
+          (k) =>
+            !keysToRemove.has(k) &&
+            k !== key &&
+            (k.startsWith(key + '.') || k.startsWith(key + '[')),
+        );
+        newSchema[key] = hasRemainingSubProps ? value : 'unknown';
+      } else {
+        newSchema[key] = value;
+      }
+    }
+
+    return { ...efc, schema: newSchema };
+  }
+
+  /**
+   * Cleans cyScope placeholder references from a FunctionCallInfo.
+   * Replaces cyScopeN() with the actual callback text in:
+   * - callSignature
+   * - allCallSignatures
+   * - schema keys
+   */
+  private cleanCyScopeFromFunctionCallInfo(
+    efc: FunctionCallInfo,
+  ): FunctionCallInfo {
+    const cyScopePattern = /cyScope\d+\(\)/g;
+
+    // Check if any cleaning is needed
+    const hasCyScope =
+      cyScopePattern.test(efc.callSignature) ||
+      (efc.allCallSignatures &&
+        efc.allCallSignatures.some((sig) => /cyScope\d+\(\)/.test(sig))) ||
+      (efc.schema &&
+        Object.keys(efc.schema).some((key) => /cyScope\d+\(\)/.test(key)));
+
+    if (!hasCyScope) {
+      return efc;
+    }
+
+    // Create cleaned copy
+    const cleaned: FunctionCallInfo = { ...efc };
+
+    // Clean callSignature
+    cleaned.callSignature = this.replaceCyScopeInString(efc.callSignature);
+
+    // Clean allCallSignatures
+    if (efc.allCallSignatures) {
+      cleaned.allCallSignatures = efc.allCallSignatures.map((sig) =>
+        this.replaceCyScopeInString(sig),
+      );
+    }
+
+    // Clean schema keys
+    if (efc.schema) {
+      cleaned.schema = this.replaceCyScopePlaceholders(efc.schema);
+    }
+
+    // Clean callSignatureToVariable keys
+    if (efc.callSignatureToVariable) {
+      cleaned.callSignatureToVariable = Object.entries(
+        efc.callSignatureToVariable,
+      ).reduce(
+        (acc, [key, value]) => {
+          acc[this.replaceCyScopeInString(key)] = value;
+          return acc;
+        },
+        {} as Record<string, string>,
+      );
+    }
+
+    return cleaned;
+  }
+
+  /**
+   * Replaces cyScope placeholder references in a single string.
+   * If the scope text can't be found, uses a generic fallback to avoid leaking
+   * internal cyScope names into stored data.
+   *
+   * Handles two patterns:
+   * 1. Function call style: cyScope7() - matched by cyScope(\d+)\(\)
+   * 2. Scope name style: parentName____cyScopeXX or cyScopeXX - matched by (\w+____)?cyScope([0-9A-Fa-f]+)
+   */
+  private replaceCyScopeInString(str: string): string {
+    let result = str;
+
+    // Pattern 1: Function call style - cyScope7()
+    const functionCallPattern = /cyScope(\d+)\(\)/g;
+    const functionCallMatches = [...str.matchAll(functionCallPattern)];
+    for (const match of functionCallMatches) {
+      const cyScopeName = `cyScope${match[1]}`;
+      const scopeText = this.findCyScopeText(cyScopeName);
+      // Always replace cyScope references - use actual text if available,
+      // otherwise use a generic callback placeholder
+      const replacement = scopeText || '() => {}';
+      result = result.replace(match[0], replacement);
+    }
+
+    // Pattern 2: Scope name style - parentName____cyScopeXX or just cyScopeXX
+    // This handles hex-encoded scope IDs like cyScope1F
+    const scopeNamePattern = /(\w+____)?cyScope([0-9A-Fa-f]+)/g;
+    const scopeNameMatches = [...result.matchAll(scopeNamePattern)];
+    for (const match of scopeNameMatches) {
+      const fullMatch = match[0];
+      const prefix = match[1] || ''; // e.g., "getTitleColor____"
+      const cyScopeId = match[2]; // e.g., "1F"
+      const cyScopeName = `cyScope${cyScopeId}`;
+
+      // Try to find the scope text, checking both with and without prefix
+      let scopeText = this.findCyScopeText(cyScopeName);
+      if (!scopeText && prefix) {
+        // Try looking up with the full prefixed name
+        scopeText = this.findCyScopeText(`${prefix}${cyScopeName}`);
+      }
+
+      if (scopeText) {
+        result = result.replace(fullMatch, scopeText);
+      } else {
+        // Replace with a generic identifier to avoid leaking internal names
+        result = result.replace(fullMatch, 'callback');
+      }
+    }
+
+    return result;
   }
 
   getEnvironmentVariables() {
@@ -3326,7 +5286,7 @@ export class ScopeDataStructure {
         path: string;
         conditionType: 'truthiness' | 'comparison' | 'switch';
         comparedValues?: string[];
-        location: 'if' | 'ternary' | 'logical-and' | 'switch';
+        location: 'if' | 'ternary' | 'logical-and' | 'switch' | 'unconditional';
       }>
     >,
   ): void {
@@ -3351,29 +5311,149 @@ export class ScopeDataStructure {
   }
 
   /**
-   * Get enriched conditional usages with source tracing.
-   * Uses explainPath to trace each local variable back to its data source.
+   * Add conditional effects from AST analysis.
+   * Called during scope analysis to collect all setter calls inside conditionals.
    */
-  getEnrichedConditionalUsages(): Record<
+  addConditionalEffects(
+    effects: import('../astScopes/types').ConditionalEffect[],
+  ): void {
+    // Add effects, avoiding duplicates based on effect stateVariable and condition paths
+    for (const effect of effects) {
+      const exists = this.rawConditionalEffects.some((existing) => {
+        // Same effect target (stateVariable + value)
+        const sameEffect =
+          existing.effect.stateVariable === effect.effect.stateVariable &&
+          existing.effect.value === effect.effect.value;
+        if (!sameEffect) return false;
+
+        // Same condition(s)
+        if (existing.condition && effect.condition) {
+          return (
+            existing.condition.path === effect.condition.path &&
+            existing.condition.requiredValue === effect.condition.requiredValue
+          );
+        }
+        if (existing.conditions && effect.conditions) {
+          if (existing.conditions.length !== effect.conditions.length)
+            return false;
+          return existing.conditions.every((ec, i) => {
+            const newCond = effect.conditions![i];
+            return (
+              ec.path === newCond.path &&
+              ec.requiredValue === newCond.requiredValue
+            );
+          });
+        }
+        return false;
+      });
+      if (!exists) {
+        this.rawConditionalEffects.push(effect);
+      }
+    }
+  }
+
+  /**
+   * Get conditional effects collected during analysis.
+   */
+  getConditionalEffects(): import('../astScopes/types').ConditionalEffect[] {
+    return this.rawConditionalEffects;
+  }
+
+  /**
+   * Add compound conditionals from AST analysis.
+   * Called during scope analysis to collect grouped conditions (e.g., a && b && c).
+   */
+  addCompoundConditionals(
+    compounds: import('../astScopes/types').CompoundConditional[],
+  ): void {
+    // Add compounds, avoiding duplicates based on chainId
+    for (const compound of compounds) {
+      const exists = this.rawCompoundConditionals.some(
+        (existing) => existing.chainId === compound.chainId,
+      );
+      if (!exists) {
+        this.rawCompoundConditionals.push(compound);
+      }
+    }
+  }
+
+  /**
+   * Get compound conditionals collected during analysis.
+   */
+  getCompoundConditionals(): import('../astScopes/types').CompoundConditional[] {
+    return this.rawCompoundConditionals;
+  }
+
+  /**
+   * Add child boundary gating conditions from AST analysis.
+   * These track which conditions must be true for a child component to render.
+   */
+  addChildBoundaryGatingConditions(
+    conditions: Record<string, import('../astScopes/types').ConditionalUsage[]>,
+  ): void {
+    for (const [childName, usages] of Object.entries(conditions)) {
+      if (!this.rawChildBoundaryGatingConditions[childName]) {
+        this.rawChildBoundaryGatingConditions[childName] = [];
+      }
+      // Add usages, avoiding duplicates
+      for (const usage of usages) {
+        const exists = this.rawChildBoundaryGatingConditions[childName].some(
+          (existing) =>
+            existing.path === usage.path &&
+            existing.conditionType === usage.conditionType &&
+            existing.isNegated === usage.isNegated,
+        );
+        if (!exists) {
+          this.rawChildBoundaryGatingConditions[childName].push(usage);
+        }
+      }
+    }
+  }
+
+  /**
+   * Get enriched child boundary gating conditions with source tracing.
+   * Similar to getEnrichedConditionalUsages but for gating conditions.
+   */
+  getEnrichedChildBoundaryGatingConditions(): Record<
     string,
-    Array<{
-      path: string;
-      conditionType: 'truthiness' | 'comparison' | 'switch';
-      comparedValues?: string[];
-      location: 'if' | 'ternary' | 'logical-and' | 'switch';
-      sourceDataPath?: string;
-    }>
+    EnrichedConditionalUsage[]
   > {
-    const enriched: Record<
-      string,
-      Array<{
-        path: string;
-        conditionType: 'truthiness' | 'comparison' | 'switch';
-        comparedValues?: string[];
-        location: 'if' | 'ternary' | 'logical-and' | 'switch';
-        sourceDataPath?: string;
-      }>
-    > = {};
+    const enriched: Record<string, EnrichedConditionalUsage[]> = {};
+    const rootScopeName = this.scopeTreeManager.getTree().name;
+
+    for (const [childName, usages] of Object.entries(
+      this.rawChildBoundaryGatingConditions,
+    )) {
+      enriched[childName] = usages.map((usage) => {
+        // Try to trace this path back to a data source
+        const explanation = this.explainPath(rootScopeName, usage.path);
+
+        let sourceDataPath: string | undefined;
+        if (explanation.source) {
+          sourceDataPath = `${explanation.source.scope}.${explanation.source.path}`;
+        }
+
+        return {
+          ...usage,
+          sourceDataPath,
+        };
+      });
+    }
+
+    return enriched;
+  }
+
+  /**
+   * Get enriched conditional usages with source tracing.
+   * Uses explainPath to trace each local variable back to its data source.
+   * Preserves all fields from the raw conditional usages including derivedFrom.
+   */
+  getEnrichedConditionalUsages(): Record<string, EnrichedConditionalUsage[]> {
+    const enriched: Record<string, EnrichedConditionalUsage[]> = {};
+
+    console.log(
+      `[getEnrichedConditionalUsages] Processing ${Object.keys(this.rawConditionalUsages).length} conditional paths: [${Object.keys(this.rawConditionalUsages).join(', ')}]`,
+    );
 
     for (const [path, usages] of Object.entries(this.rawConditionalUsages)) {
       // Try to trace this path back to a data source
@@ -3383,10 +5463,69 @@ export class ScopeDataStructure {
 
       let sourceDataPath: string | undefined;
       if (explanation.source) {
-        // Build the full data path: scopeName.path
-        sourceDataPath = `${explanation.source.scope}.${explanation.source.path}`;
+        const { scope, path: sourcePath } = explanation.source;
+
+        // Build initial path — avoid redundant prefix when path already contains the scope call
+        let fullPath: string;
+        if (sourcePath.startsWith(`${scope}(`)) {
+          fullPath = sourcePath;
+        } else {
+          fullPath = `${scope}.${sourcePath}`;
+        }
+
+        sourceDataPath = fullPath;
+        console.log(
+          `[getEnrichedConditionalUsages] "${path}" explainPath → scope="${scope}", sourcePath="${sourcePath}" → sourceDataPath="${sourceDataPath}"`,
+        );
+      } else {
+        console.log(
+          `[getEnrichedConditionalUsages] "${path}" explainPath → no source found`,
+        );
+      }
+
+      // If explainPath didn't find a useful external source (e.g., it traced to
+      // useState or just to the component scope itself), check sourceEquivalencies
+      // for an external function call source like a fetch call
+      const hasExternalSource = sourceDataPath?.includes(
+        '.functionCallReturnValue',
+      );
+      if (!hasExternalSource) {
+        console.log(
+          `[getEnrichedConditionalUsages] "${path}" no external source (sourceDataPath="${sourceDataPath}"), checking sourceEquivalencies fallback...`,
+        );
+        const sourceEquiv = this.getSourceEquivalencies();
+        const returnValueKey = `returnValue.${path}`;
+        const sources = sourceEquiv[returnValueKey];
+        if (sources) {
+          console.log(
+            `[getEnrichedConditionalUsages] "${path}" sourceEquivalencies["${returnValueKey}"] has ${sources.length} sources: [${sources.map((s: { schemaPath: string }) => s.schemaPath).join(', ')}]`,
+          );
+          const externalSource = sources.find(
+            (s: { schemaPath: string }) =>
+              s.schemaPath.includes('.functionCallReturnValue') &&
+              !s.schemaPath.startsWith('useState('),
+          );
+          if (externalSource) {
+            console.log(
+              `[getEnrichedConditionalUsages] "${path}" sourceEquivalencies fallback found external source: "${externalSource.schemaPath}"`,
+            );
+            sourceDataPath = externalSource.schemaPath;
+          } else {
+            console.log(
+              `[getEnrichedConditionalUsages] "${path}" sourceEquivalencies fallback found no external function call source`,
+            );
+          }
+        } else {
+          console.log(
+            `[getEnrichedConditionalUsages] "${path}" sourceEquivalencies["${returnValueKey}"] not found`,
+          );
+        }
       }
 
+      console.log(
+        `[getEnrichedConditionalUsages] "${path}" FINAL sourceDataPath="${sourceDataPath ?? '(none)'}" (${usages.length} usages)`,
+      );
+
       enriched[path] = usages.map((usage) => ({
         ...usage,
         sourceDataPath,
@@ -3396,35 +5535,86 @@ export class ScopeDataStructure {
     return enriched;
   }
 
+  /**
+   * Add JSX rendering usages from AST analysis.
+   * These track arrays rendered via .map() and strings interpolated in JSX.
+   */
+  addJsxRenderingUsages(
+    usages: import('../astScopes/types').JsxRenderingUsage[],
+  ): void {
+    // Add usages, avoiding duplicates based on path and renderingType
+    for (const usage of usages) {
+      const exists = this.rawJsxRenderingUsages.some(
+        (existing) =>
+          existing.path === usage.path &&
+          existing.renderingType === usage.renderingType,
+      );
+      if (!exists) {
+        this.rawJsxRenderingUsages.push(usage);
+      }
+    }
+  }
+
+  /**
+   * Get JSX rendering usages collected during analysis.
+   */
+  getJsxRenderingUsages(): import('../astScopes/types').JsxRenderingUsage[] {
+    return this.rawJsxRenderingUsages;
+  }
+
   toSerializable(): SerializableDataStructure {
-    // Helper to convert ScopeVariable to SerializableScopeVariable
+    // Helper to clean cyScope and cyDuplicateKey from a string for output
+    const cleanCyScope = (str: string): string =>
+      this.replaceCyScopeInString(str).replace(/::cyDuplicateKey\d+::/g, '');
+
+    // Helper to convert ScopeVariable to SerializableScopeVariable (with cyScope cleaned)
     const toSerializableVariable = (
       vars:
         | ScopeVariable[]
         | Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[],
     ): SerializableScopeVariable[] =>
       vars.map((v) => ({
-        scopeNodeName: v.scopeNodeName,
-        schemaPath: v.schemaPath,
+        scopeNodeName: cleanCyScope(v.scopeNodeName),
+        schemaPath: cleanCyScope(v.schemaPath),
       }));
 
+    // Helper to clean cyScope from all keys in a schema
+    const cleanSchemaKeys = (
+      schema: Record<string, string>,
+    ): Record<string, string> => {
+      return Object.entries(schema).reduce(
+        (acc, [key, value]) => {
+          acc[cleanCyScope(key)] = value;
+          return acc;
+        },
+        {} as Record<string, string>,
+      );
+    };
+
     // Helper to get function result for a given function name
     const getFunctionResult = (
       functionName?: string,
     ): SerializableFunctionResult => {
       return {
-        signature: this.getFunctionSignature({ functionName }) ?? {},
-        signatureWithUnknowns:
+        signature: cleanSchemaKeys(
+          this.getFunctionSignature({ functionName }) ?? {},
+        ),
+        signatureWithUnknowns: cleanSchemaKeys(
           this.getFunctionSignature({ functionName, fillInUnknowns: true }) ??
-          {},
-        returnValue: this.getReturnValue({ functionName }) ?? {},
-        returnValueWithUnknowns:
+            {},
+        ),
+        returnValue: cleanSchemaKeys(
+          this.getReturnValue({ functionName }) ?? {},
+        ),
+        returnValueWithUnknowns: cleanSchemaKeys(
           this.getReturnValue({ functionName, fillInUnknowns: true }) ?? {},
+        ),
         usageEquivalencies: Object.entries(
           this.getUsageEquivalencies(functionName) ?? {},
         ).reduce(
           (acc, [key, vars]) => {
-            acc[key] = toSerializableVariable(vars);
+            // Clean cyScope from the key as well as variable properties
+            acc[cleanCyScope(key)] = toSerializableVariable(vars);
             return acc;
           },
           {} as Record<string, SerializableScopeVariable[]>,
@@ -3433,7 +5623,8 @@ export class ScopeDataStructure {
           this.getSourceEquivalencies(functionName) ?? {},
         ).reduce(
           (acc, [key, vars]) => {
-            acc[key] = toSerializableVariable(vars);
+            // Clean cyScope from the key as well as variable properties
+            acc[cleanCyScope(key)] = toSerializableVariable(vars);
             return acc;
           },
           {} as Record<string, SerializableScopeVariable[]>,
@@ -3442,36 +5633,417 @@ export class ScopeDataStructure {
       };
     };
 
-    // Convert external function calls
+    // Convert external function calls - use getExternalFunctionCalls() which cleans cyScope
+    const cleanedExternalCalls = this.getExternalFunctionCalls();
+
+    // Get root scope schema for building per-variable return value schemas
+    const rootScopeName = this.scopeTreeManager.getRootName();
+    const rootScope = this.scopeNodes[rootScopeName];
+    const rootSchema = rootScope?.schema ?? {};
+
     const externalFunctionCalls: SerializableFunctionCallInfo[] =
-      this.externalFunctionCalls.map((efc) => ({
-        name: efc.name,
-        callSignature: efc.callSignature,
-        callScope: efc.callScope,
-        schema: efc.schema,
-        equivalencies: efc.equivalencies
-          ? Object.entries(efc.equivalencies).reduce(
-              (acc, [key, vars]) => {
-                acc[key] = toSerializableVariable(vars);
-                return acc;
-              },
-              {} as Record<string, SerializableScopeVariable[]>,
-            )
-          : undefined,
-      }));
+      cleanedExternalCalls.map((efc) => {
+        // Build perVariableSchemas from perCallSignatureSchemas when available.
+        // This preserves distinct schemas per variable when the same function is called
+        // multiple times with DIFFERENT call signatures (e.g., different type parameters).
+        //
+        // When field accesses happen in child scopes (like JSX expressions), the
+        // rootSchema doesn't contain the detailed paths - they end up in child scope
+        // schemas. Using perCallSignatureSchemas ensures we get the correct schema
+        // for each call, regardless of where field accesses occur.
+        let perVariableSchemas:
+          | Record<string, Record<string, string>>
+          | undefined;
+
+        // Use perCallSignatureSchemas only when:
+        // 1. It exists and has distinct entries for different call signatures
+        // 2. The number of distinct call signatures >= number of receiving variables
+        //
+        // This prevents using it when all calls have the same signature (e.g., useFetcher() x 2)
+        // because in that case, perCallSignatureSchemas only has one entry.
+        const numCallSignatures = efc.perCallSignatureSchemas
+          ? Object.keys(efc.perCallSignatureSchemas).length
+          : 0;
+        const numReceivingVars = efc.receivingVariableNames?.length ?? 0;
+        const hasDistinctSchemas =
+          numCallSignatures >= numReceivingVars && numCallSignatures > 1;
+
+        // CASE 1: Multiple call signatures with distinct schemas - use indexed variable names
+        if (
+          hasDistinctSchemas &&
+          efc.perCallSignatureSchemas &&
+          efc.callSignatureToVariable
+        ) {
+          perVariableSchemas = {};
+
+          // Build a reverse map: variable -> array of call signatures (in order)
+          // This handles the case where the same variable name is reused for different calls
+          const varToCallSigs: Record<string, string[]> = {};
+          for (const [callSig, varName] of Object.entries(
+            efc.callSignatureToVariable,
+          )) {
+            if (!varToCallSigs[varName]) {
+              varToCallSigs[varName] = [];
+            }
+            varToCallSigs[varName].push(callSig);
+          }
+
+          // Track how many times each variable name has been seen
+          const varNameCounts: Record<string, number> = {};
+
+          // For each receiving variable, get its original schema from perCallSignatureSchemas
+          for (const varName of efc.receivingVariableNames ?? []) {
+            const occurrence = varNameCounts[varName] ?? 0;
+            varNameCounts[varName] = occurrence + 1;
+
+            const callSigs = varToCallSigs[varName];
+            // Use the nth call signature for the nth occurrence of this variable
+            const callSig = callSigs?.[occurrence];
+
+            if (callSig && efc.perCallSignatureSchemas[callSig]) {
+              // Use indexed key if this variable name is reused (e.g., fetcher, fetcher[1])
+              const key =
+                occurrence === 0 ? varName : `${varName}[${occurrence}]`;
+              // Clone the schema to avoid shared references
+              perVariableSchemas[key] = {
+                ...efc.perCallSignatureSchemas[callSig],
+              };
+            }
+          }
+
+          // Only include if we have entries for ALL receiving variables
+          if (Object.keys(perVariableSchemas).length < numReceivingVars) {
+            // Not all variables have schemas - fall back to rootSchema extraction
+            perVariableSchemas = undefined;
+          } else {
+            // Also check that at least one schema is non-empty
+            // Bug fix: perCallSignatureSchemas may have entries but with empty schemas {}
+            // In this case, we should fall through to Fallback which uses rootSchema
+            const hasNonEmptySchema = Object.values(perVariableSchemas).some(
+              (schema) => Object.keys(schema).length > 0,
+            );
+            if (!hasNonEmptySchema) {
+              perVariableSchemas = undefined;
+            }
+          }
+        }
+
+        // CASE 2: Single call signature with single variable - use perCallSignatureSchemas directly
+        // This handles parameterized calls like useFetcher<ConfigData>() where each is a separate efc entry
+        if (
+          !perVariableSchemas &&
+          efc.perCallSignatureSchemas &&
+          numCallSignatures === 1 &&
+          numReceivingVars === 1
+        ) {
+          const varName = efc.receivingVariableNames![0];
+          const callSig = Object.keys(efc.perCallSignatureSchemas)[0];
+          const schema = efc.perCallSignatureSchemas[callSig];
+          if (schema && Object.keys(schema).length > 0) {
+            perVariableSchemas = { [varName]: { ...schema } };
+          }
+        }
+
+        // CASE 3: Extract from efc.schema when perCallSignatureSchemas is missing or empty
+        // This handles two scenarios:
+        // 1. Parameterized calls that create SEPARATE efc entries (no perCallSignatureSchemas)
+        // 2. Destructuring where perCallSignatureSchemas exists but has EMPTY schemas
+        //
+        // When useFetcher<ConfigData>() and useFetcher<SettingsData>() are called, they create separate
+        // efc entries because getFunctionCallRoot preserves type parameters. Each entry has its own
+        // `schema` field, but due to variable reassignment, the schema may be contaminated with paths
+        // from other calls (the tracer attributes field accesses to ALL equivalencies).
+        //
+        // Solution: Filter efc.schema to only include paths that match THIS entry's call signature.
+        // The schema paths include the full call signature prefix, so we can filter by it.
+        //
+        // Example: ConfigData entry has paths like:
+        //   "useFetcher<{ data: ConfigData | null }>().functionCallReturnValue.data.data.theme"
+        // But also (contaminated):
+        //   "useFetcher<{ data: ConfigData | null }>().functionCallReturnValue.data.data.notifications"
+        //
+        // We filter to only keep paths that should belong to THIS call by checking if the
+        // receiving variable's equivalency points to this call's return value.
+        //
+        // BUG FIX: The old condition `!efc.perCallSignatureSchemas` was FALSE when the object
+        // existed (even with empty schemas), causing this case to be skipped. We now also check
+        // if all schemas in perCallSignatureSchemas are empty.
+        const hasNonEmptyPerCallSignatureSchemas =
+          efc.perCallSignatureSchemas &&
+          Object.values(efc.perCallSignatureSchemas).some(
+            (schema) => Object.keys(schema).length > 0,
+          );
+
+        // Build the call signature prefix that paths should start with
+        const callSigPrefix = `${efc.callSignature}.functionCallReturnValue`;
+
+        // Check if efc.schema has variable-specific paths (indicating destructuring).
+        // Destructuring: const { entities, gitStatus } = useLoaderData()
+        // - efc.schema has paths like: useLoaderData().functionCallReturnValue.entities...
+        // Multiple calls: const x = useFetcher(); const y = useFetcher();
+        // - efc.schema has paths like: useFetcher().functionCallReturnValue.data...
+        // CASE 3 should only run for destructuring (variable-specific paths exist).
+        const hasVariableSpecificPaths = (
+          efc.receivingVariableNames ?? []
+        ).some((varName) =>
+          Object.keys(efc.schema).some((path) =>
+            path.startsWith(`${callSigPrefix}.${varName}`),
+          ),
+        );
+
+        if (
+          !perVariableSchemas &&
+          !hasNonEmptyPerCallSignatureSchemas &&
+          numReceivingVars >= 1 &&
+          hasVariableSpecificPaths
+        ) {
+          // Filter efc.schema to only include paths matching this call signature
+          const filteredSchema: Record<string, string> = {};
+          for (const [path, type] of Object.entries(efc.schema)) {
+            if (path.startsWith(callSigPrefix) || path === efc.callSignature) {
+              filteredSchema[path] = type;
+            }
+          }
+
+          // Build perVariableSchemas from the filtered schema
+          // For destructuring, filter paths by variable name
+          if (Object.keys(filteredSchema).length > 0) {
+            perVariableSchemas = {};
+            for (const varName of efc.receivingVariableNames ?? []) {
+              // For destructuring, extract only paths specific to this variable
+              const varSpecificPrefix = `${callSigPrefix}.${varName}`;
+              const varSchema: Record<string, string> = {};
+
+              for (const [path, type] of Object.entries(filteredSchema)) {
+                if (path.startsWith(varSpecificPrefix)) {
+                  // Transform: useLoaderData().functionCallReturnValue.entities.sha
+                  //         -> functionCallReturnValue.entities.sha (keep the variable name)
+                  const suffix = path.slice(callSigPrefix.length);
+                  const returnValuePath = `functionCallReturnValue${suffix}`;
+                  varSchema[returnValuePath] = type;
+                } else if (path === efc.callSignature) {
+                  // Include the function call type itself
+                  varSchema[path] = type;
+                }
+              }
+              if (Object.keys(varSchema).length > 0) {
+                perVariableSchemas[varName] = varSchema;
+              }
+            }
+            // Only include if we have entries
+            if (Object.keys(perVariableSchemas).length === 0) {
+              perVariableSchemas = undefined;
+            }
+          }
+        }
+
+        // Fallback: extract from root scope schema when perCallSignatureSchemas is not available
+        // or doesn't have distinct entries for each variable.
+        // This works when field accesses are in the root scope.
+        if (
+          !perVariableSchemas &&
+          efc.receivingVariableNames &&
+          efc.receivingVariableNames.length > 0
+        ) {
+          perVariableSchemas = {};
+          for (const varName of efc.receivingVariableNames) {
+            const varSchema: Record<string, string> = {};
+            for (const [path, type] of Object.entries(rootSchema)) {
+              // Check if path starts with this variable name
+              if (
+                path === varName ||
+                path.startsWith(varName + '.') ||
+                path.startsWith(varName + '[')
+              ) {
+                // Transform to functionCallReturnValue format
+                // e.g., userFetcher.data.id -> functionCallReturnValue.data.id
+                const suffix = path.slice(varName.length);
+                const returnValuePath = `functionCallReturnValue${suffix}`;
+                varSchema[returnValuePath] = type;
+              }
+            }
+            if (Object.keys(varSchema).length > 0) {
+              // Clean the variable name when using as key in output
+              perVariableSchemas[cleanCyScope(varName)] = varSchema;
+            }
+          }
+          // Only include if we have any entries
+          if (Object.keys(perVariableSchemas).length === 0) {
+            perVariableSchemas = undefined;
+          }
+        }
+
+        // Enrich the schema with inferred types by applying fillInSchemaGapsAndUnknowns.
+        // This ensures the serialized schema has the same type inference as getReturnValue().
+        // Without this, evidence like "entities[].analyses: array" becomes "unknown".
+        const enrichedSchema = { ...efc.schema };
+        const tempScopeNode = {
+          name: efc.name,
+          schema: enrichedSchema,
+          equivalencies: efc.equivalencies ?? {},
+        };
+        fillInSchemaGapsAndUnknowns(tempScopeNode, true);
+
+        return {
+          name: efc.name,
+          callSignature: efc.callSignature,
+          callScope: efc.callScope,
+          schema: enrichedSchema,
+          equivalencies: efc.equivalencies
+            ? Object.entries(efc.equivalencies).reduce(
+                (acc, [key, vars]) => {
+                  // Clean cyScope from the key as well as variable properties
+                  acc[cleanCyScope(key)] = toSerializableVariable(vars);
+                  return acc;
+                },
+                {} as Record<string, SerializableScopeVariable[]>,
+              )
+            : undefined,
+          allCallSignatures: efc.allCallSignatures,
+          receivingVariableNames: efc.receivingVariableNames?.map(cleanCyScope),
+          callSignatureToVariable: efc.callSignatureToVariable
+            ? Object.fromEntries(
+                Object.entries(efc.callSignatureToVariable).map(([k, v]) => [
+                  k,
+                  cleanCyScope(v),
+                ]),
+              )
+            : undefined,
+          perVariableSchemas,
+        };
+      });
+
+    // POST-PROCESSING: Deduplicate schemas across parameterized calls to same base function
+    // When useFetcher<ConfigData>() and useFetcher<SettingsData>() are called, they create
+    // separate entries. Due to variable reassignment, BOTH entries may have ALL fields.
+    // We deduplicate by assigning each field to ONLY ONE entry based on order of appearance.
+    //
+    // Strategy: Fields that appear first in order belong to the first entry,
+    // fields that appear later belong to later entries (split evenly).
+    const deduplicateParameterizedEntries = (
+      entries: typeof externalFunctionCalls,
+    ): typeof externalFunctionCalls => {
+      // Group entries by base function name (without type parameters)
+      const groups = new Map<string, typeof externalFunctionCalls>();
+      for (const entry of entries) {
+        // Extract base function name by stripping type parameters
+        // e.g., "useFetcher<{ data: ConfigData | null }>" -> "useFetcher"
+        const baseName = entry.name.replace(/<.*>$/, '');
+        const group = groups.get(baseName) || [];
+        group.push(entry);
+        groups.set(baseName, group);
+      }
+
+      // Process groups with multiple parameterized entries
+      for (const [, group] of groups) {
+        if (group.length <= 1) continue;
+
+        // Check if these are parameterized calls (have type parameters in name)
+        const hasTypeParams = group.every((e) => e.name.includes('<'));
+        if (!hasTypeParams) continue;
+
+        // Collect ALL unique field suffixes across all entries (in order of first appearance)
+        // Field suffix is the path after functionCallReturnValue, e.g., ".data.data.theme"
+        const allFieldSuffixes: string[] = [];
+        for (const entry of group) {
+          if (!entry.perVariableSchemas) continue;
+          for (const varSchema of Object.values(entry.perVariableSchemas)) {
+            for (const path of Object.keys(varSchema)) {
+              // Skip the base "functionCallReturnValue" entry
+              if (path === 'functionCallReturnValue') continue;
+              // Extract field suffix
+              const match = path.match(/functionCallReturnValue(.+)/);
+              if (!match) continue;
+              const fieldSuffix = match[1];
+              if (!allFieldSuffixes.includes(fieldSuffix)) {
+                allFieldSuffixes.push(fieldSuffix);
+              }
+            }
+          }
+        }
+
+        // Assign fields to entries: split evenly based on order
+        // First N/2 fields go to first entry, remaining go to second entry
+        const fieldToEntryMap = new Map<string, number>();
+        const fieldsPerEntry = Math.ceil(
+          allFieldSuffixes.length / group.length,
+        );
+        for (let i = 0; i < allFieldSuffixes.length; i++) {
+          const fieldSuffix = allFieldSuffixes[i];
+          const entryIdx = Math.min(
+            Math.floor(i / fieldsPerEntry),
+            group.length - 1,
+          );
+          fieldToEntryMap.set(fieldSuffix, entryIdx);
+        }
+
+        // Filter each entry's perVariableSchemas to only include its assigned fields
+        for (let i = 0; i < group.length; i++) {
+          const entry = group[i];
+          if (!entry.perVariableSchemas) continue;
+
+          const filteredPerVarSchemas: Record<
+            string,
+            Record<string, string>
+          > = {};
+          for (const [varName, varSchema] of Object.entries(
+            entry.perVariableSchemas,
+          )) {
+            const filteredVarSchema: Record<string, string> = {};
+            for (const [path, type] of Object.entries(varSchema)) {
+              // Always keep the base functionCallReturnValue
+              if (path === 'functionCallReturnValue') {
+                filteredVarSchema[path] = type;
+                continue;
+              }
+              // Extract field suffix
+              const match = path.match(/functionCallReturnValue(.+)/);
+              if (!match) {
+                // Keep non-field paths
+                filteredVarSchema[path] = type;
+                continue;
+              }
+              const fieldSuffix = match[1];
+              // Only include if this entry owns this field
+              if (fieldToEntryMap.get(fieldSuffix) === i) {
+                filteredVarSchema[path] = type;
+              }
+            }
+            if (Object.keys(filteredVarSchema).length > 0) {
+              filteredPerVarSchemas[varName] = filteredVarSchema;
+            }
+          }
+          entry.perVariableSchemas =
+            Object.keys(filteredPerVarSchemas).length > 0
+              ? filteredPerVarSchemas
+              : undefined;
+        }
+      }
+
+      return entries;
+    };
+
+    // Apply deduplication
+    const deduplicatedExternalFunctionCalls = deduplicateParameterizedEntries(
+      externalFunctionCalls,
+    );
+
+    // IMPORTANT: Get equivalent signature variables BEFORE calling getFunctionResult
+    // because getFunctionResult calls validateSchema which may remove equivalencies
+    // during the finalize step (e.g., cleanNonObjectFunctions removes method call
+    // equivalencies like `segments -> splat.split('/').functionCallReturnValue`).
+    // Fix 33: Move this call before any schema validation to preserve method call chains.
+    const equivalentSignatureVariables = this.getEquivalentSignatureVariables();
 
     // Get root function result
     const rootFunction = getFunctionResult();
 
-    // Get results for each external function
+    // Get results for each external function (use cleaned calls for consistency)
     const functionResults: Record<string, SerializableFunctionResult> = {};
-    for (const efc of this.externalFunctionCalls) {
+    for (const efc of cleanedExternalCalls) {
       functionResults[efc.name] = getFunctionResult(efc.name);
     }
 
-    // Get equivalent signature variables
-    const equivalentSignatureVariables = this.getEquivalentSignatureVariables();
-
     const environmentVariables = this.getEnvironmentVariables();
 
     // Get enriched conditional usages with source tracing
@@ -3481,13 +6053,43 @@ export class ScopeDataStructure {
         ? enrichedConditionalUsages
         : undefined;
 
+    // Get conditional effects (setter calls inside conditionals)
+    const conditionalEffects =
+      this.rawConditionalEffects.length > 0
+        ? this.rawConditionalEffects
+        : undefined;
+
+    // Get compound conditionals (grouped conditions that must all be true)
+    const compoundConditionals =
+      this.rawCompoundConditionals.length > 0
+        ? this.rawCompoundConditionals
+        : undefined;
+
+    // Get child boundary gating conditions
+    const enrichedGatingConditions =
+      this.getEnrichedChildBoundaryGatingConditions();
+    const childBoundaryGatingConditions =
+      Object.keys(enrichedGatingConditions).length > 0
+        ? enrichedGatingConditions
+        : undefined;
+
+    // Get JSX rendering usages (arrays via .map(), strings via interpolation)
+    const jsxRenderingUsages =
+      this.rawJsxRenderingUsages.length > 0
+        ? this.rawJsxRenderingUsages
+        : undefined;
+
     return {
-      externalFunctionCalls,
+      externalFunctionCalls: deduplicatedExternalFunctionCalls,
       rootFunction,
       functionResults,
       equivalentSignatureVariables,
       environmentVariables,
       conditionalUsages,
+      conditionalEffects,
+      compoundConditionals,
+      childBoundaryGatingConditions,
+      jsxRenderingUsages,
     };
   }