@codeyam/codeyam-cli 0.1.0-staging.8e7b1bd → 0.1.0-staging.b8a55ba

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

@@ -221,6 +221,22 @@ export interface FunctionCallInfo {
    * 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>>;
 }
 
 /**
@@ -320,6 +336,10 @@ const ALLOWED_EQUIVALENCY_REASONS = new Set([
   '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([
@@ -382,6 +402,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({
@@ -540,6 +564,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;
         }
       }
@@ -567,13 +593,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(
@@ -965,12 +1029,35 @@ export class ScopeDataStructure {
     }
 
     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');
     }
 
@@ -1128,10 +1215,38 @@ export class ScopeDataStructure {
       const existingFunctionCall =
         this.getExternalFunctionCallsIndex().get(searchKey);
       if (existingFunctionCall) {
-        existingFunctionCall.schema = {
+        // Preserve per-call schemas BEFORE merging to enable per-variable mock data.
+        // This is critical for hooks like useFetcher<UserData>() vs useFetcher<ReportData>()
+        // where each call returns different typed data.
+        if (!existingFunctionCall.perCallSignatureSchemas) {
+          // First merge - save the existing call's schema
+          existingFunctionCall.perCallSignatureSchemas = {
+            [existingFunctionCall.callSignature]: {
+              ...existingFunctionCall.schema,
+            },
+          };
+        }
+        // Save the new call's schema before it gets merged
+        existingFunctionCall.perCallSignatureSchemas[
+          functionCallInfo.callSignature
+        ] = { ...functionCallInfo.schema };
+
+        // Merge schemas using selectBestValue to preserve specific types like 'null'
+        // over generic types like 'unknown'. This ensures ref variables detected
+        // earlier (marked as 'null') aren't overwritten by later 'unknown' values.
+        const mergedSchema: Record<string, string> = {
           ...existingFunctionCall.schema,
-          ...functionCallInfo.schema,
         };
+        for (const key in functionCallInfo.schema) {
+          const existingValue = existingFunctionCall.schema[key];
+          const newValue = functionCallInfo.schema[key];
+          mergedSchema[key] = selectBestValue(
+            existingValue,
+            newValue,
+            newValue,
+          );
+        }
+        existingFunctionCall.schema = mergedSchema;
 
         existingFunctionCall.equivalencies = {
           ...existingFunctionCall.equivalencies,
@@ -1164,8 +1279,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();
+          }
         }
       }
     }
@@ -3137,7 +3259,12 @@ export class ScopeDataStructure {
       );
     }
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. See comment in getFunctionSignature.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(scopeNode, true, fillInUnknowns);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
 
     const { schema } = scopeNode;
 
@@ -3238,6 +3365,7 @@ export class ScopeDataStructure {
         (candidate) => candidate.scopeNodeName === scopeNode.name,
       ),
     );
+
     return entries.reduce(
       (acc, entry) => {
         if (entry.usages.length === 0) return acc;
@@ -3300,7 +3428,14 @@ export class ScopeDataStructure {
       equivalencies,
     );
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. validateSchema triggers manager.finalize which
+    // can call addToSchema -> addToEquivalencyDatabase -> mergeEquivalencyDatabaseEntries,
+    // which would incorrectly remove entries from the database.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(tempScopeNode, true, fillInUnknowns);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
 
     return tempScopeNode.schema;
   }
@@ -3312,6 +3447,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];
 
@@ -3322,7 +3466,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),
         );
@@ -3378,7 +3523,12 @@ 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;
 
     return tempScopeNode.schema;
   }
@@ -3386,6 +3536,8 @@ export class ScopeDataStructure {
   /**
    * 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>,
@@ -3401,10 +3553,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;
@@ -3526,7 +3678,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,
@@ -3535,8 +3692,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() {
@@ -3625,34 +3897,58 @@ export class ScopeDataStructure {
   }
 
   toSerializable(): SerializableDataStructure {
-    // Helper to convert ScopeVariable to SerializableScopeVariable
+    // Helper to clean cyScope from a string
+    const cleanCyScope = (str: string): string =>
+      this.replaceCyScopeInString(str);
+
+    // 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[]>,
@@ -3661,7 +3957,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[]>,
@@ -3670,33 +3967,347 @@ 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,
-        allCallSignatures: efc.allCallSignatures,
-        receivingVariableNames: efc.receivingVariableNames,
-        callSignatureToVariable: efc.callSignatureToVariable,
-      }));
+      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;
+          }
+        }
+
+        // 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: Parameterized calls that create SEPARATE efc entries (no perCallSignatureSchemas)
+        // 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.
+        if (
+          !perVariableSchemas &&
+          !efc.perCallSignatureSchemas &&
+          numReceivingVars >= 1
+        ) {
+          // Build the call signature prefix that paths should start with
+          const callSigPrefix = `${efc.callSignature}.functionCallReturnValue`;
+
+          // 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
+          if (Object.keys(filteredSchema).length > 0) {
+            perVariableSchemas = {};
+            for (const varName of efc.receivingVariableNames ?? []) {
+              // For each variable, extract paths and transform to functionCallReturnValue format
+              const varSchema: Record<string, string> = {};
+              for (const [path, type] of Object.entries(filteredSchema)) {
+                if (path.startsWith(callSigPrefix)) {
+                  // Transform to generic functionCallReturnValue path
+                  // e.g., "useFetcher<ConfigData>().functionCallReturnValue.data.data.theme"
+                  //     -> "functionCallReturnValue.data.data.theme"
+                  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) {
+              perVariableSchemas[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,
+          callSignatureToVariable: efc.callSignatureToVariable,
+          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,
+    );
 
     // 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);
     }
 
@@ -3713,7 +4324,7 @@ export class ScopeDataStructure {
         : undefined;
 
     return {
-      externalFunctionCalls,
+      externalFunctionCalls: deduplicatedExternalFunctionCalls,
       rootFunction,
       functionResults,
       equivalentSignatureVariables,