@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.323686

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';
+      isNegated?: boolean;
+    }>;
+  };
 }
 
 /**
@@ -204,6 +235,39 @@ export interface FunctionCallInfo {
   schema?: Record<string, string>;
   /** Traces argument data back to original source */
   equivalencies?: Record<string, ScopeVariable[]>;
+  /**
+   * All call signatures that were merged into this entry.
+   * When multiple method calls on the same object (e.g., logger.info, logger.debug)
+   * are encountered, they get merged into one FunctionCallInfo but we track all signatures.
+   */
+  allCallSignatures?: string[];
+  /**
+   * Variable names that receive the return value of each call.
+   * For example, in `const result1 = db.select(query1)`, the receiving variable is 'result1'.
+   * This enables generating separate mock data for each call site.
+   */
+  receivingVariableNames?: string[];
+  /**
+   * Maps each call signature to the variable that receives its return value.
+   * For example: { "db.select(query1)": "result1", "db.select(query2)": "result2" }
+   */
+  callSignatureToVariable?: Record<string, string>;
+  /**
+   * 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>>;
 }
 
 /**
@@ -270,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))
@@ -301,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([
@@ -346,6 +428,36 @@ export class ScopeDataStructure {
     }>
   > = {};
 
+  /**
+   * 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;
@@ -364,6 +476,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({
@@ -522,6 +638,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;
         }
       }
@@ -549,13 +667,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(
@@ -886,8 +1042,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,
@@ -913,13 +1069,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');
     }
 
@@ -1077,15 +1289,59 @@ 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,
           ...functionCallInfo.equivalencies,
         };
+
+        // Track all call signatures that get merged (e.g., logger.info, logger.debug, etc.)
+        if (!existingFunctionCall.allCallSignatures) {
+          existingFunctionCall.allCallSignatures = [
+            existingFunctionCall.callSignature,
+          ];
+        }
+        if (
+          !existingFunctionCall.allCallSignatures.includes(
+            functionCallInfo.callSignature,
+          )
+        ) {
+          existingFunctionCall.allCallSignatures.push(
+            functionCallInfo.callSignature,
+          );
+        }
       } else {
         const functionCallInfoNameParts = this.splitPath(functionCallInfo.name);
         const isExternal =
@@ -1097,8 +1353,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();
+          }
         }
       }
     }
@@ -1206,6 +1469,18 @@ 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];
 
@@ -1273,6 +1548,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: {
@@ -1297,6 +1589,60 @@ 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;
+      }
+    }
+
+    // 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);
   }
@@ -1365,6 +1711,10 @@ export class ScopeDataStructure {
   }
 
   private determineEquivalenciesAndBuildSchema(scopeNode: ScopeNode) {
+    if (!scopeNode.analysis) {
+      return;
+    }
+
     const { isolatedStructure, isolatedEquivalentVariables } =
       scopeNode.analysis;
 
@@ -1380,11 +1730,24 @@ export class ScopeDataStructure {
       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,
-        );
+        // 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,
@@ -1394,6 +1757,47 @@ export class ScopeDataStructure {
           'original equivalency',
         );
 
+        // Propagate equivalencies involving parent-scope variables to those parent scopes.
+        // This handles patterns like: collected.push({...entity}) where 'collected' is defined
+        // in a parent scope. The equivalency collected[] -> push().signature[0] needs to be
+        // visible when tracing from the parent scope.
+        const rootVariable = this.extractRootVariable(path);
+        const equivalentRootVariable =
+          this.extractRootVariable(equivalentValue);
+
+        // Skip propagation for self-referential reassignment patterns like:
+        //   x = x.method().functionCallReturnValue
+        // where the path IS the variable itself (not a sub-path like x[] or x.prop).
+        // These create circular references since both sides reference the same variable.
+        //
+        // But DO propagate for patterns like collected[] -> collected.push(...).signature[0]
+        // where the path has additional segments beyond the root variable.
+        const pathIsJustRootVariable = path === rootVariable;
+        const isSelfReferentialReassignment =
+          pathIsJustRootVariable && rootVariable === equivalentRootVariable;
+
+        if (
+          rootVariable &&
+          !isSelfReferentialReassignment &&
+          scopeNode.parentInstantiatedVariables?.includes(rootVariable)
+        ) {
+          // Find the parent scope where this variable is defined
+          for (const parentScopeName of scopeNode.tree || []) {
+            const parentScope = this.scopeNodes[parentScopeName];
+            if (parentScope?.instantiatedVariables?.includes(rootVariable)) {
+              // Add the equivalency to the parent scope as well
+              this.addEquivalency(
+                path,
+                equivalentValue,
+                scopeNode.name, // The equivalent path's scope remains the child scope
+                parentScope, // But store it in the parent scope's equivalencies
+                'propagated parent-variable equivalency',
+              );
+              break;
+            }
+          }
+        }
+
         // Propagate sub-property equivalencies when the equivalentValue is a simple variable
         // that has sub-properties defined in the isolatedEquivalentVariables.
         // This handles cases like: dataItem={{ structure: completeDataStructure }}
@@ -1470,6 +1874,16 @@ export class ScopeDataStructure {
             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);
         }
       }
     }
@@ -1479,7 +1893,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)) {
@@ -1520,7 +1934,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;
 
@@ -1540,6 +1966,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.
    *
@@ -2017,6 +2503,21 @@ export class ScopeDataStructure {
 
       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', {
@@ -2887,10 +3388,68 @@ 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;
-    return schema;
+
+    // For root scope, merge in external function call schemas
+    // This ensures that imported objects used as method call targets (like logger.error())
+    // appear in the schema as objects with function properties
+    if (
+      scopeName === undefined ||
+      scopeName === this.scopeTreeManager.getRootName()
+    ) {
+      const mergedSchema = { ...schema };
+      for (const efc of this.externalFunctionCalls) {
+        // Add the base object name (e.g., "logger") as an object
+        const baseName = this.splitPath(efc.name)[0];
+        if (!mergedSchema[baseName]) {
+          mergedSchema[baseName] = 'object';
+        }
+
+        // Get all call signatures (use allCallSignatures if available, otherwise just the single callSignature)
+        const signatures = efc.allCallSignatures ?? [efc.callSignature];
+        for (const signature of signatures) {
+          // Add the method as a function (e.g., "logger.error")
+          // Extract method name from callSignature like "logger.error(args...)"
+          // Get everything before the first '(' to get "logger.error"
+          const parenIndex = signature.indexOf('(');
+          if (parenIndex > 0) {
+            const methodPath = signature.substring(0, parenIndex);
+            if (methodPath.includes('.') && !mergedSchema[methodPath]) {
+              mergedSchema[methodPath] = 'function';
+            }
+          }
+        }
+      }
+      return this.filterDuplicateKeys(mergedSchema);
+    }
+
+    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) {
@@ -2954,6 +3513,7 @@ export class ScopeDataStructure {
         (candidate) => candidate.scopeNodeName === scopeNode.name,
       ),
     );
+
     return entries.reduce(
       (acc, entry) => {
         if (entry.usages.length === 0) return acc;
@@ -2997,12 +3557,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';
@@ -3018,7 +3580,60 @@ 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;
+        }
+      }
+    }
+
+    // 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]) {
+            tempScopeNode.schema[signatureKey] = schema[schemaKey];
+          }
+        }
+      }
+    }
+
+    return this.filterDuplicateKeys(tempScopeNode.schema);
   }
 
   getReturnValue({
@@ -3028,6 +3643,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];
 
@@ -3038,7 +3662,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),
         );
@@ -3070,7 +3695,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) => {
@@ -3080,7 +3715,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];
+              }
             }
           }
 
@@ -3094,14 +3732,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>,
@@ -3117,10 +3814,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;
@@ -3186,17 +3883,320 @@ export class ScopeDataStructure {
       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;
         }
-      }
-    }
 
-    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;
+              }
+            }
+            equivalentSignatureVariables[path] = hookCallPath;
+          }
+        }
 
-  getVariableInfo(
-    variableName: string,
+        // 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
+        ) {
+          // Only add if we haven't already captured this variable in Case 1 or 2
+          if (!(path in equivalentSignatureVariables)) {
+            equivalentSignatureVariables[path] = equivalentValue.schemaPath;
+          }
+        }
+
+        // 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
+        ) {
+          equivalentSignatureVariables[path] = equivalentValue.schemaPath;
+        }
+
+        // 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
+        ) {
+          equivalentSignatureVariables[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)
+          !(path in equivalentSignatureVariables) // not already captured
+        ) {
+          // 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
+            equivalentSignatureVariables[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
+            if (!(path in equivalentSignatureVariables)) {
+              equivalentSignatureVariables[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
+
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+      let changed = false;
+
+      for (const [varName, sourcePath] of Object.entries(
+        equivalentSignatureVariables,
+      )) {
+        // 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];
+              // 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) {
+          const baseResolved = equivalentSignatureVariables[baseVar];
+          // 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 {
@@ -3242,7 +4242,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,
@@ -3251,8 +4256,123 @@ 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.
+    return this.externalFunctionCalls.map((efc) =>
+      this.cleanCyScopeFromFunctionCallInfo(efc),
+    );
+  }
+
+  /**
+   * 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() {
@@ -3295,29 +4415,145 @@ 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.
+   */
+  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.
    */
-  getEnrichedConditionalUsages(): Record<
+  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[]> = {};
 
     for (const [path, usages] of Object.entries(this.rawConditionalUsages)) {
       // Try to trace this path back to a data source
@@ -3340,35 +4576,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[]>,
@@ -3377,7 +4664,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[]>,
@@ -3386,36 +4674,406 @@ 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;
+          }
+        }
+
+        return {
+          name: efc.name,
+          callSignature: efc.callSignature,
+          callScope: efc.callScope,
+          schema: efc.schema,
+          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
@@ -3425,13 +5083,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,
     };
   }