@codeyam/codeyam-cli 0.1.0-staging.d0ad4ae → 0.1.0-staging.d52b24f

package/analyzer-template/packages/analyze/src/lib/files/scenarios/enrichArrayTypesFromChildSignatures.ts

@@ -9,8 +9,12 @@ import { DataStructure } from '~codeyam/types';
  * enriches the mocked dependency's returnValueSchema so the LLM knows what fields
  * to generate for array elements.
  *
+ * Uses usageEquivalencies to trace data flow and ONLY enrich arrays with fields
+ * from children that actually receive elements from that array.
+ *
  * Example:
  * - getSurveysAction returns { data: array }
+ * - usageEquivalencies shows: surveys[] -> SurveyCard().signature[0].survey
  * - SurveyCard expects signature[0].survey.updatedAt: date
  * - After enrichment: getSurveysAction().data[]: object, data[].updatedAt: date
  */
@@ -21,6 +25,7 @@ export default function enrichArrayTypesFromChildSignatures(
     isMocked?: boolean;
   }[],
   dependencySchemas: DataStructure['dependencySchemas'],
+  usageEquivalencies?: DataStructure['usageEquivalencies'],
 ): void {
   // Find all mocked dependencies with array return types
   const mockedArrayPaths: {
@@ -43,7 +48,8 @@ export default function enrichArrayTypesFromChildSignatures(
     //   - wrapThrows().data.createdBy (deeply nested)
     //   - getStatusOptions().functionCallReturnValue (direct array return - usually options/primitives)
     for (const [path, type] of Object.entries(schema)) {
-      if (type !== 'array') continue;
+      // Check if type is array (including nullable/optional variants like 'array | undefined')
+      if (!type.startsWith('array')) continue;
 
       // Skip paths with computed property patterns like [key], [i], [0], etc.
       // These represent dynamic access patterns, not simple data arrays
@@ -81,115 +87,226 @@ export default function enrichArrayTypesFromChildSignatures(
 
   if (mockedArrayPaths.length === 0) return;
 
-  // Find all non-mocked child components and extract their signature fields
-  // We check both direct imports AND all schemas in dependencySchemas because
-  // transitive dependencies (e.g., SurveyCard imported by SurveysList imported by SurveysPage)
-  // may have signature schemas that we need to use for enrichment.
-  const childSignatureFields: {
-    filePath: string;
-    entityName: string;
-    // Map of prop paths to types, e.g., { "survey.id": "string", "survey.updatedAt": "date" }
-    propFields: Record<string, string>;
-  }[] = [];
+  // Build a map from child component signature paths to their prop fields
+  // e.g., "SurveyCard().signature[0].survey" -> { "id": "string", "updatedAt": "date" }
+  const childSignatureFieldsByPath: Map<
+    string,
+    { propName: string; fields: Record<string, string> }
+  > = new Map();
 
-  // Helper to extract prop fields from a signature schema
-  const extractPropFields = (
+  // Helper to extract prop name and fields from a signature schema
+  const extractSignatureInfo = (
+    entityName: string,
     schema: Record<string, string>,
-  ): Record<string, string> => {
-    const propFields: Record<string, string> = {};
+  ): void => {
+    // Group by prop name (e.g., signature[0].survey.id, signature[0].survey.name -> "survey")
+    const propGroups: Record<string, Record<string, string>> = {};
+    // Also collect direct fields on signature[0] (e.g., signature[0].filePath -> "filePath")
+    const directFields: Record<string, string> = {};
+
     for (const [path, type] of Object.entries(schema)) {
-      // Match signature[0].propName.field patterns
-      const match = path.match(/^signature\[0\]\.(\w+)\.(.+)$/);
-      if (match) {
-        const [, , fieldPath] = match;
-        // Store as "fieldPath" without the prop name prefix
-        // e.g., signature[0].survey.updatedAt -> updatedAt
-        propFields[fieldPath] = type;
+      // Match signature[0].propName.field or signature[0].propName[].field patterns
+      // The (?:\[\])? makes array props optional, handling both:
+      // - signature[0].survey.updatedAt (object prop)
+      // - signature[0].questionAnswers[].question.questionText (array prop)
+      const nestedMatch = path.match(/^signature\[0\]\.(\w+)(?:\[\])?\.(.+)$/);
+      if (nestedMatch) {
+        const [, propName, fieldPath] = nestedMatch;
+        propGroups[propName] ||= {};
+        propGroups[propName][fieldPath] = type;
+        continue;
       }
-    }
-    return propFields;
-  };
-
-  // First, check direct imports (non-mocked)
-  const processedSchemas = new Set<string>();
-  for (const importedExport of importedExports) {
-    // Skip mocked dependencies - we want child components
-    if (importedExport.isMocked || !importedExport.filePath) continue;
 
-    const schemaKey = `${importedExport.filePath}::${importedExport.name}`;
-    processedSchemas.add(schemaKey);
+      // Also match direct fields: signature[0].fieldName (single level, no nested path)
+      // This handles cases like TruncatedFilePath where filePath is passed directly
+      const directMatch = path.match(/^signature\[0\]\.(\w+)$/);
+      if (directMatch) {
+        const [, fieldName] = directMatch;
+        directFields[fieldName] = type;
+      }
+    }
 
-    const schema =
-      dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
-        ?.signatureSchema;
-    if (!schema) continue;
+    // Store nested prop groups with the full signature path as key
+    for (const [propName, fields] of Object.entries(propGroups)) {
+      if (Object.keys(fields).length > 0) {
+        const signaturePath = `${entityName}().signature[0].${propName}`;
+        childSignatureFieldsByPath.set(signaturePath, { propName, fields });
+      }
+    }
 
-    const propFields = extractPropFields(schema);
-    if (Object.keys(propFields).length > 0) {
-      childSignatureFields.push({
-        filePath: importedExport.filePath,
-        entityName: importedExport.name,
-        propFields,
+    // Store direct fields with signature[0] as key (for when entire object is passed)
+    if (Object.keys(directFields).length > 0) {
+      const signaturePath = `${entityName}().signature[0]`;
+      childSignatureFieldsByPath.set(signaturePath, {
+        propName: '',
+        fields: directFields,
       });
     }
-  }
+  };
 
-  // Also check all schemas in dependencySchemas for transitive child components
-  // that may not be in importedExports but have signature schemas with prop fields
+  // Process all schemas in dependencySchemas
   if (dependencySchemas) {
-    for (const [filePath, entities] of Object.entries(dependencySchemas)) {
+    for (const [, entities] of Object.entries(dependencySchemas)) {
       for (const [entityName, schemas] of Object.entries(entities)) {
-        const schemaKey = `${filePath}::${entityName}`;
-        // Skip already processed schemas
-        if (processedSchemas.has(schemaKey)) continue;
-
         const signatureSchema = schemas?.signatureSchema;
-        if (!signatureSchema) continue;
-
-        const propFields = extractPropFields(signatureSchema);
-        if (Object.keys(propFields).length > 0) {
-          childSignatureFields.push({
-            filePath,
-            entityName,
-            propFields,
-          });
+        if (signatureSchema) {
+          extractSignatureInfo(entityName, signatureSchema);
         }
       }
     }
   }
 
-  if (childSignatureFields.length === 0) return;
+  if (childSignatureFieldsByPath.size === 0) return;
+
+  // Helper to check if a local variable name could be derived from a mocked function name
+  // e.g., "getSurveys" -> "surveys", "fetchUsers" -> "users", "loadData" -> "data"
+  // e.g., "getSurveysAction" -> "surveys" (removes "Action" suffix too)
+  const couldBeDerivedFrom = (
+    localVarName: string,
+    mockedFunctionName: string,
+  ): boolean => {
+    const normalizedVar = localVarName.toLowerCase().replace(/\[\]$/, '');
+    let normalizedFunc = mockedFunctionName.toLowerCase();
 
-  // Enrich mocked dependency arrays with child signature fields
-  // Only enrich arrays that don't already have element types defined
-  // A more sophisticated approach would trace the data flow to match specific arrays to specific children
+    // Direct match (e.g., "surveys" from function "surveys")
+    if (normalizedFunc === normalizedVar) return true;
+
+    // Remove common prefixes like "get", "fetch", "load", "use"
+    const prefixPattern = /^(get|fetch|load|use)/i;
+    normalizedFunc = normalizedFunc.replace(prefixPattern, '');
+
+    // Remove common suffixes like "Action", "Query", "Mutation", "Handler"
+    const suffixPattern = /(action|query|mutation|handler)$/i;
+    normalizedFunc = normalizedFunc.replace(suffixPattern, '');
+
+    // Check if function name (without prefix/suffix) matches the variable name
+    if (normalizedFunc === normalizedVar) return true;
+
+    // Check for singular/plural relationship
+    // e.g., "survey" from "getSurveys" or "surveys" from "getSurvey"
+    if (
+      normalizedFunc.endsWith('s') &&
+      normalizedFunc.slice(0, -1) === normalizedVar
+    )
+      return true;
+    if (
+      normalizedVar.endsWith('s') &&
+      normalizedVar.slice(0, -1) === normalizedFunc
+    )
+      return true;
+
+    // Check if the array property name (like "data") is in the variable
+    // This handles cases like "const { data: surveys } = getSurveys()" where
+    // the local var might be the renamed destructured property
+    // Skip this for now as it's too loose
+
+    return false;
+  };
+
+  // For each mocked array, find which child signatures it flows to via usageEquivalencies
   for (const { filePath, entityName, arrayPath } of mockedArrayPaths) {
     const schema = dependencySchemas[filePath][entityName].returnValueSchema;
 
-    // Check if this array already has element type definitions
+    // Check if this array already has INDEXED element type definitions (e.g., [0]: null)
     // If so, skip it - it's likely a specialized array like [null] for refs
+    // But DON'T skip if it only has general [] element types - those can be enriched
     const elementPathPrefix = `${arrayPath}[`;
-    const hasExistingElementType = Object.keys(schema).some((path) =>
-      path.startsWith(elementPathPrefix),
-    );
+    const hasIndexedElementType = Object.keys(schema).some((path) => {
+      if (!path.startsWith(elementPathPrefix)) return false;
+      // Check if it's an indexed type like [0], [1], etc. vs general []
+      const afterPrefix = path.slice(elementPathPrefix.length);
+      // Indexed types start with a digit: [0], [1], etc.
+      return /^\d/.test(afterPrefix);
+    });
 
-    if (hasExistingElementType) {
-      // Array already has element type info (e.g., useAutoAnimate()[0]: null)
+    if (hasIndexedElementType) {
+      // Array already has indexed element type info (e.g., useAutoAnimate()[0]: null)
       // Don't override it with child signature fields
       continue;
     }
 
-    // Add array element type
+    // Find matching child signatures via usageEquivalencies
+    // Look for equivalencies where this array (or local variables derived from it)
+    // flows to a child component's signature
+    const matchedFields: Record<string, string> = {};
+
+    if (usageEquivalencies) {
+      // Check all equivalency entries for paths that could be derived from this array
+      for (const [sourcePath, targets] of Object.entries(usageEquivalencies)) {
+        // Check if this source path relates to our mocked array
+        // Direct match: "getSurveysAction().functionCallReturnValue.data[]"
+        // Indirect match: local variable like "surveys[]" that comes from the array
+        if (!sourcePath.endsWith('[]')) continue;
+
+        // Get the local variable name from the source path (e.g., "surveys[]" -> "surveys")
+        const localVarName = sourcePath.replace(/\[\]$/, '');
+
+        // Check if this local variable could have come from this mocked function
+        // Use heuristics: name matching (getSurveys -> surveys, getUsers -> users)
+        // Also check if the array path ends with the local variable name
+        // e.g., useLoaderData().functionCallReturnValue.entities ends with .entities
+        const arrayEndsWithLocalVar = arrayPath.endsWith(`.${localVarName}`);
+        // Full-path usageEquivalencies (e.g., from same-file child components) use
+        // the complete call path as the local var name, which matches arrayPath exactly
+        const exactPathMatch = localVarName === arrayPath;
+        if (
+          !exactPathMatch &&
+          !couldBeDerivedFrom(localVarName, entityName) &&
+          !arrayEndsWithLocalVar
+        ) {
+          continue;
+        }
+
+        for (const target of targets) {
+          // Target should be something like "SurveyCard().signature[0].survey"
+          // or "SurveyCard().signature[0].surveys[]"
+          const { schemaPath } = target;
+
+          // Look for signature fields that match this target
+          // Handle both singular (survey) and plural (surveys[]) forms
+          const normalizedTarget = schemaPath.replace(/\[\]$/, '');
+
+          for (const [signaturePath, info] of childSignatureFieldsByPath) {
+            if (normalizedTarget === signaturePath) {
+              // Found a match! Add all fields from this child signature
+              for (const [fieldPath, type] of Object.entries(info.fields)) {
+                if (!matchedFields[fieldPath]) {
+                  matchedFields[fieldPath] = type;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // If no equivalencies matched, skip this array entirely
+    // This prevents the bug where ALL child signatures get merged into ALL arrays
+    if (Object.keys(matchedFields).length === 0) {
+      continue;
+    }
+
+    // Add array element type and matched fields
     const elementPath = `${arrayPath}[]`;
     schema[elementPath] = 'object';
 
-    // Add fields from all child signatures to the array element
-    for (const { propFields } of childSignatureFields) {
-      for (const [fieldPath, type] of Object.entries(propFields)) {
-        const fullPath = `${elementPath}.${fieldPath}`;
-        if (!schema[fullPath]) {
+    for (const [fieldPath, type] of Object.entries(matchedFields)) {
+      const fullPath = `${elementPath}.${fieldPath}`;
+      const existingType = schema[fullPath];
+      if (!existingType) {
+        schema[fullPath] = type;
+      } else {
+        // Prefer the more specific (narrower) type
+        const existingIsOptional =
+          existingType.includes('| undefined') ||
+          existingType.includes('| null');
+        const newIsOptional =
+          type.includes('| undefined') || type.includes('| null');
+        if (existingIsOptional && !newIsOptional) {
+          // Use the new type - it's more specific
           schema[fullPath] = type;
         }
+        // Otherwise keep existing (same specificity or existing is more specific)
       }
     }
   }

package/analyzer-template/packages/analyze/src/lib/files/scenarios/gatherDataForMocks.ts

@@ -1,7 +1,8 @@
-// import { writeFile } from 'fs/promises';
 import {
   convertDotNotation,
   fillInDirectSchemaGapsAndUnknowns,
+  buildSchemaIndexes,
+  type SchemaIndexes,
   joinParenthesesAndArrays,
   mergeJsonTypeDefinitions,
   splitOutsideParenthesesAndArrays,
@@ -166,6 +167,7 @@ function processCall(
   variableNameOccurrence: number | undefined,
   options: GatherDataForMocksOptions | undefined,
   hookCallIndex: number,
+  prebuiltIndexes?: SchemaIndexes,
 ): { key: string; value: JsonTypeDefinition } | null {
   const callName = importedExport.calls?.[callIndex] ?? importedExport.name;
 
@@ -270,21 +272,87 @@ function processCall(
     baseHasMultipleTypeParamVariants = typeParamVariantsInBase.size > 1;
   }
 
-  // For type-parameterized calls where the base schema has MULTIPLE different type
-  // parameter variants, use ONLY the call-specific schema to avoid contamination.
-  // Otherwise, merge with base schema for complete coverage (e.g., array element details).
-  const mergedSchema =
-    hasCallSpecificSchema && hasTypeParams && baseHasMultipleTypeParamVariants
-      ? rawSchema // Use ONLY the call-specific schema when base has mixed type params
-      : Object.keys(rawSchema).length === 0
-        ? baseSchema
-        : { ...baseSchema, ...rawSchema };
+  // For type-parameterized calls where we have a call-specific schema, we need to
+  // be careful about merging with the base schema. The base schema may contain
+  // merged data from ALL type parameter variants, which would pollute the result.
+  let mergedSchema: Record<string, string>;
+  if (hasCallSpecificSchema && hasTypeParams) {
+    if (baseHasMultipleTypeParamVariants) {
+      // Base schema has paths with different type parameters - filter to only
+      // include paths matching the current type parameter.
+      const typeParamMatch = callName.match(/<([^>]+)>/);
+      const currentTypeParam = typeParamMatch ? typeParamMatch[1] : null;
+      const baseFunctionName = cleanFunctionName(callName.split('(')[0]);
+
+      if (currentTypeParam) {
+        // Filter base schema to only include paths that:
+        // 1. Match current type param (e.g., useLoaderData<LoaderData>())
+        // 2. OR don't have any type param (generic paths like useLoaderData())
+        const filteredBaseSchema: Record<string, string> = {};
+        for (const [path, type] of Object.entries(baseSchema)) {
+          // Check if path has a type parameter for this function
+          const pathTypeParamMatch = path.match(
+            new RegExp(`^${escapeRegExp(baseFunctionName)}<([^>]+)>\\(`),
+          );
+          if (pathTypeParamMatch) {
+            // Path has a type param - only include if it matches current
+            if (pathTypeParamMatch[1] === currentTypeParam) {
+              filteredBaseSchema[path] = type;
+            }
+            // Otherwise skip (it's for a different type param variant)
+          } else {
+            // Path doesn't have a type param for this function - include it
+            // (could be generic paths or paths for other functions)
+            filteredBaseSchema[path] = type;
+          }
+        }
+        mergedSchema = { ...filteredBaseSchema, ...rawSchema };
+      } else {
+        // Couldn't extract type param - fall back to rawSchema only
+        mergedSchema = rawSchema;
+      }
+    } else {
+      // Base schema has zero or one type-parameterized variant.
+      // When there's only one variant, the base schema paths are safe to merge
+      // (no contamination from other variants). This is important for cases like:
+      // - Array element details (gitStatus[].path) that are in base but not call-specific
+      // - Enriched paths that should be preserved
+      // Filter to only include paths matching current type param or generic paths.
+      const typeParamMatch = callName.match(/<([^>]+)>/);
+      const currentTypeParam = typeParamMatch ? typeParamMatch[1] : null;
+      const baseFunctionName = cleanFunctionName(callName.split('(')[0]);
+
+      if (currentTypeParam) {
+        const filteredBaseSchema: Record<string, string> = {};
+        for (const [path, type] of Object.entries(baseSchema)) {
+          const pathTypeParamMatch = path.match(
+            new RegExp(`^${escapeRegExp(baseFunctionName)}<([^>]+)>\\(`),
+          );
+          if (pathTypeParamMatch) {
+            // Path has a type param - only include if it matches current
+            if (pathTypeParamMatch[1] === currentTypeParam) {
+              filteredBaseSchema[path] = type;
+            }
+          } else {
+            // Path doesn't have a type param - include generic paths
+            filteredBaseSchema[path] = type;
+          }
+        }
+        mergedSchema = { ...filteredBaseSchema, ...rawSchema };
+      } else {
+        // No type param to extract - merge normally
+        mergedSchema = { ...baseSchema, ...rawSchema };
+      }
+    }
+  } else if (Object.keys(rawSchema).length === 0) {
+    mergedSchema = baseSchema;
+  } else {
+    mergedSchema = { ...baseSchema, ...rawSchema };
+  }
 
   // Preprocess to filter signatures and extract functionCallReturnValue
   let preprocessedSchema = preprocessSchemaForMocks(mergedSchema);
 
-  const functionNames: string[] = [];
-
   const isFunctionNameWithoutFunction = (
     path: string,
     functionName: string,
@@ -369,38 +437,66 @@ function processCall(
     }
   }
 
-  const relevantMergedDependencySchema = Object.keys(preprocessedSchema).reduce(
-    (acc, path) => {
-      if (path.endsWith(')')) {
-        const pathParts = splitOutsideParenthesesAndArrays(path);
-        const functionName = joinParenthesesAndArrays([
-          ...pathParts.slice(0, -1),
-          pathParts[pathParts.length - 1].split('(')[0],
-        ]);
-        functionNames.push(functionName);
-        for (const existingPath in acc) {
-          if (isFunctionNameWithoutFunction(existingPath, functionName)) {
-            delete acc[existingPath];
-          }
-        }
-      }
+  // Two-pass function name filtering to avoid O(k²) retroactive deletion.
+  // Pass 1: Discover all unique function names from paths ending with ')'
+  const functionNameSet = new Set<string>();
+  const schemaKeys = Object.keys(preprocessedSchema);
+  for (const path of schemaKeys) {
+    if (path.endsWith(')')) {
+      const pathParts = splitOutsideParenthesesAndArrays(path);
+      const functionName = joinParenthesesAndArrays([
+        ...pathParts.slice(0, -1),
+        pathParts[pathParts.length - 1].split('(')[0],
+      ]);
+      functionNameSet.add(functionName);
+    }
+  }
 
-      if (functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))) {
-        return acc;
-      }
+  // Index function names by first segment for O(1) bucket lookup instead of
+  // checking all function names for every path. Most paths only need to check
+  // 1-2 function names instead of all F.
+  const fnByFirstSegment = new Map<string, string[]>();
+  for (const fn of functionNameSet) {
+    const dotIdx = fn.indexOf('.');
+    const firstSeg = dotIdx >= 0 ? fn.slice(0, dotIdx) : fn;
+    let bucket = fnByFirstSegment.get(firstSeg);
+    if (!bucket) {
+      bucket = [];
+      fnByFirstSegment.set(firstSeg, bucket);
+    }
+    bucket.push(fn);
+  }
 
-      acc[path] = preprocessedSchema[path];
-      return acc;
-    },
-    {} as Record<string, string>,
-  );
+  // Pass 2: Filter paths that match any discovered function name prefix.
+  // Use indexed lookup: extract path's first segment, check only matching function names.
+  const relevantMergedDependencySchema: Record<string, string> = {};
+  for (const path of schemaKeys) {
+    // Extract first segment of path (before first '.', '(', or '<')
+    const dotIdx = path.indexOf('.');
+    const parenIdx = path.indexOf('(');
+    const angleIdx = path.indexOf('<');
+    let minIdx = path.length;
+    if (dotIdx >= 0 && dotIdx < minIdx) minIdx = dotIdx;
+    if (parenIdx >= 0 && parenIdx < minIdx) minIdx = parenIdx;
+    if (angleIdx >= 0 && angleIdx < minIdx) minIdx = angleIdx;
+    const firstSeg = path.slice(0, minIdx);
+
+    const candidates = fnByFirstSegment.get(firstSeg);
+    if (
+      !candidates ||
+      !candidates.some((fn) => isFunctionNameWithoutFunction(path, fn))
+    ) {
+      relevantMergedDependencySchema[path] = preprocessedSchema[path];
+    }
+  }
 
-  const schema = convertDotNotation(
-    fillInDirectSchemaGapsAndUnknowns({
-      scopeName: importedExport.name,
-      schema: relevantMergedDependencySchema,
-    }),
-  );
+  const filledSchema = fillInDirectSchemaGapsAndUnknowns({
+    scopeName: importedExport.name,
+    schema: relevantMergedDependencySchema,
+    prebuiltIndexes,
+  });
+
+  const schema = convertDotNotation(filledSchema);
 
   // Determine if this is an object-style or hook-style dependency:
   // - Hook-style: calls = ['useAuth()'] - call starts with name + '('
@@ -501,6 +597,33 @@ export default function gatherDataForMocks(
   dependencySchemas: DataStructure['dependencySchemas'],
   options?: GatherDataForMocksOptions,
 ) {
+  // Build schema indexes ONCE from all dependency schemas combined.
+  // This avoids rebuilding indexes (~1-2 seconds for 18k keys) for each processCall.
+  //
+  // IMPORTANT: We must preprocess schemas BEFORE building indexes!
+  // The schemas contain .functionCallReturnValue paths that get stripped during processing.
+  // If we build indexes from original paths, lookups with preprocessed paths will fail.
+  // Example: 'hook().functionCallReturnValue.x.length' → index maps 'hook().functionCallReturnValue.x' → ['length']
+  //          But preprocessed path 'hook().x.length' looks for 'hook().x' which doesn't exist in the index.
+  const allSchemaKeys: Record<string, string> = {};
+  if (dependencySchemas) {
+    for (const filePath in dependencySchemas) {
+      for (const entityName in dependencySchemas[filePath]) {
+        const schema =
+          dependencySchemas[filePath][entityName]?.returnValueSchema;
+        if (schema) {
+          // Preprocess each schema to remove .functionCallReturnValue before collecting
+          const preprocessed = preprocessSchemaForMocks(schema);
+          Object.assign(allSchemaKeys, preprocessed);
+        }
+      }
+    }
+  }
+  const prebuiltIndexes =
+    Object.keys(allSchemaKeys).length > 0
+      ? buildSchemaIndexes(allSchemaKeys)
+      : undefined;
+
   // Track the global index for each hook name across all imports
   // This enables canonical keys like EntityName::useLoaderData::0, EntityName::useFetcher::0, etc.
   const hookCallIndices: Record<string, number> = {};
@@ -586,6 +709,7 @@ export default function gatherDataForMocks(
             undefined,
             options,
             hookCallIndex,
+            prebuiltIndexes,
           );
 
           if (processResult) {
@@ -650,7 +774,42 @@ export default function gatherDataForMocks(
             occurrence,
             options,
             hookCallIndex,
+            prebuiltIndexes,
+          );
+          if (processResult) {
+            addResultToAccumulator(acc, processResult.key, processResult.value);
+          }
+        }
+      } else if (
+        // Handle multiple UNIQUE type-parameterized direct calls when variable count doesn't match.
+        // This happens when a hook is called with different type parameters (useFetcher<TypeA>(), useFetcher<TypeB>()),
+        // but the callVariableNames count doesn't match directCallCount (common with rest spread patterns).
+        // Each unique call signature should get its own entry in dataForMocks.
+        uniqueDirectCalls.length > 1 &&
+        !allDirectCallsIdentical(directCalls) &&
+        hasDirectFunctionCall
+      ) {
+        // Process each UNIQUE direct call signature
+        for (let i = 0; i < uniqueDirectCalls.length; i++) {
+          const callSignature = uniqueDirectCalls[i];
+
+          // Find the index of this call in the original calls array
+          const callIndex = (importedExport.calls ?? []).indexOf(callSignature);
+          if (callIndex === -1) continue;
+
+          const hookCallIndex = hookCallIndices[hookName] ?? 0;
+          hookCallIndices[hookName] = hookCallIndex + 1;
+
+          const processResult = processCall(
+            importedExport,
+            dependencySchemas,
+            callIndex,
+            undefined,
+            options,
+            hookCallIndex,
+            prebuiltIndexes,
           );
+
           if (processResult) {
             addResultToAccumulator(acc, processResult.key, processResult.value);
           }
@@ -669,6 +828,7 @@ export default function gatherDataForMocks(
           undefined,
           options,
           hookCallIndex,
+          prebuiltIndexes,
         );
 
         // Check if we got a meaningful result (not empty object or null)
@@ -713,6 +873,7 @@ export default function gatherDataForMocks(
                 0, // Use 0 to trigger variable-qualified lookup
                 options,
                 hookCallIndex,
+                prebuiltIndexes,
               );
               if (varQualifiedResult && varQualifiedResult.value) {
                 mergedValue = mergeJsonTypeDefinitions(
@@ -749,6 +910,7 @@ export default function gatherDataForMocks(
               0, // Use 0 to trigger variable-qualified lookup
               options,
               hookCallIndex,
+              prebuiltIndexes,
             );
             if (varQualifiedResult && varQualifiedResult.value) {
               // Deep merge the value into the accumulated result