@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.323686

package/analyzer-template/packages/ai/src/lib/worker/analyzeScopeWorker.ts

@@ -9,13 +9,14 @@ import { Entity } from '~codeyam/types';
 import { FileAnalyzer, ProjectAnalyzer } from '~codeyam/analyze';
 import { analyzeScopeLocal } from '../analyzeScope';
 import {
-  ScopeInfo,
   resetScopeDataStructureMetrics,
+  ScopeInfo,
 } from '../dataStructure/ScopeDataStructure';
 import { SerializableDataStructure } from './SerializableDataStructure';
 import { AI } from '~codeyam/ai';
 import { setThreadContext } from '~codeyam/utils';
 import { threadId } from 'worker_threads';
+import v8 from 'v8';
 
 // Set thread context for logging
 setThreadContext(`<worker-${threadId}>`);
@@ -45,6 +46,80 @@ let projectAnalyzerKey: string | null = null;
 let fileAnalyzer: FileAnalyzer | null = null;
 let fileAnalyzerPath: string | null = null;
 
+// Memory tracking
+let entitiesProcessed = 0;
+let lastMemoryLogAt = 0;
+const MEMORY_LOG_INTERVAL = 100; // Log every N entities
+const MEMORY_LOG_TIME_INTERVAL = 60_000; // Or every 60 seconds
+
+/**
+ * Get memory stats for logging
+ */
+function getWorkerMemoryStats() {
+  const mem = process.memoryUsage();
+  const heapStats = v8.getHeapStatistics();
+  return {
+    rss: `${Math.round(mem.rss / 1024 / 1024)}MB`,
+    heapUsed: `${Math.round(mem.heapUsed / 1024 / 1024)}MB`,
+    heapTotal: `${Math.round(mem.heapTotal / 1024 / 1024)}MB`,
+    external: `${Math.round(mem.external / 1024 / 1024)}MB`,
+    // V8 heap stats give more detail
+    v8TotalHeapSize: `${Math.round(heapStats.total_heap_size / 1024 / 1024)}MB`,
+    v8UsedHeapSize: `${Math.round(heapStats.used_heap_size / 1024 / 1024)}MB`,
+    v8HeapSizeLimit: `${Math.round(heapStats.heap_size_limit / 1024 / 1024)}MB`,
+    v8MallocedMemory: `${Math.round(heapStats.malloced_memory / 1024 / 1024)}MB`,
+  };
+}
+
+/**
+ * Get ts.Program stats for understanding TypeScript memory usage
+ */
+function getTsProgramStats(pa: ProjectAnalyzer) {
+  const sourceFiles = pa.program.getSourceFiles();
+  const projectSourceFiles = sourceFiles.filter(
+    (sf) => !sf.fileName.includes('node_modules'),
+  );
+  const nodeModulesFiles = sourceFiles.filter((sf) =>
+    sf.fileName.includes('node_modules'),
+  );
+
+  // Estimate AST size by sampling text length (rough proxy)
+  let totalProjectTextLength = 0;
+  for (const sf of projectSourceFiles) {
+    totalProjectTextLength += sf.getFullText().length;
+  }
+
+  return {
+    totalSourceFiles: sourceFiles.length,
+    projectSourceFiles: projectSourceFiles.length,
+    nodeModulesFiles: nodeModulesFiles.length,
+    projectTextSizeMB: `${(totalProjectTextLength / 1024 / 1024).toFixed(1)}MB`,
+    // Note: Actual AST memory is typically 10-20x the source text size
+    estimatedAstSizeMB: `${((totalProjectTextLength * 15) / 1024 / 1024).toFixed(0)}MB`,
+  };
+}
+
+/**
+ * Write a heap snapshot for detailed profiling.
+ * The snapshot can be loaded in Chrome DevTools for analysis.
+ *
+ * TODO: Once we understand memory usage, change this back to env-var controlled
+ */
+const HEAP_SNAPSHOT_MODE: 'off' | 'once' | 'periodic' = 'off';
+
+function maybeWriteHeapSnapshot(label: string) {
+  if (HEAP_SNAPSHOT_MODE === 'off') return;
+
+  try {
+    const filename = v8.writeHeapSnapshot();
+    console.log(
+      `CodeYam Worker: Heap snapshot written (${label}): ${filename}`,
+    );
+  } catch (error) {
+    console.error('CodeYam Worker: Failed to write heap snapshot:', error);
+  }
+}
+
 /**
  * Main worker function called by Piscina
  */
@@ -61,8 +136,25 @@ export default async function runAnalyzeScope(
     // Create or reuse ProjectAnalyzer
     const paKey = `${dirPath}`;
     if (!projectAnalyzer || projectAnalyzerKey !== paKey) {
-      projectAnalyzer = await ProjectAnalyzer.from({ project, dirPath });
+      const memBefore = process.memoryUsage();
+      console.log('CodeYam Worker: Creating ProjectAnalyzer (ts.Program)...', {
+        memBefore: getWorkerMemoryStats(),
+      });
+
+      projectAnalyzer = ProjectAnalyzer.from({ project, dirPath });
       projectAnalyzerKey = paKey;
+
+      const memAfter = process.memoryUsage();
+      const tsProgramStats = getTsProgramStats(projectAnalyzer);
+      console.log('CodeYam Worker: ProjectAnalyzer created', {
+        memAfter: getWorkerMemoryStats(),
+        rssDelta: `+${Math.round((memAfter.rss - memBefore.rss) / 1024 / 1024)}MB`,
+        heapDelta: `+${Math.round((memAfter.heapUsed - memBefore.heapUsed) / 1024 / 1024)}MB`,
+        tsProgramStats,
+      });
+
+      // Optionally write heap snapshot after ts.Program creation
+      maybeWriteHeapSnapshot('after-ts-program');
     }
 
     // Create or reuse FileAnalyzer
@@ -95,6 +187,26 @@ export default async function runAnalyzeScope(
       );
     }
 
+    // Periodic memory logging
+    entitiesProcessed++;
+    const now = Date.now();
+    const shouldLogMemory =
+      entitiesProcessed % MEMORY_LOG_INTERVAL === 0 ||
+      now - lastMemoryLogAt > MEMORY_LOG_TIME_INTERVAL;
+
+    if (shouldLogMemory) {
+      lastMemoryLogAt = now;
+      console.log('CodeYam Worker: Memory stats', {
+        entitiesProcessed,
+        ...getWorkerMemoryStats(),
+      });
+
+      // Optionally write periodic heap snapshots
+      if (HEAP_SNAPSHOT_MODE === 'periodic' && entitiesProcessed % 500 === 0) {
+        maybeWriteHeapSnapshot(`after-${entitiesProcessed}-entities`);
+      }
+    }
+
     return { dataStructure: dataStructure.toSerializable() };
   } catch (error) {
     console.error(

package/analyzer-template/packages/analyze/src/lib/analysisContext.ts

@@ -48,6 +48,12 @@ export class AnalysisContext implements ImmutableAnalysisContext {
   public analysesAdded: Analysis[]; // TODO: Remove this when we switch to immutable maps
   private projectNodeModuleMocks: Mock[];
   private baselineMode: boolean = false;
+  /**
+   * Parent context for delegating lookups when not found locally.
+   * Used by private contexts created via forEntityAnalysis() to see analyses
+   * added to the main context after the fork.
+   */
+  private parentContext?: AnalysisContext;
 
   /**
    * Create a new AnalysisContext with optional initial maps and mocks
@@ -56,16 +62,19 @@ export class AnalysisContext implements ImmutableAnalysisContext {
     primaryEntity,
     initialEntityMap,
     initialAnalysisMap,
+    parentContext,
   }: {
     primaryEntity?: Entity;
     initialEntityMap?: EntityMap;
     initialAnalysisMap?: AnalysisMap;
+    parentContext?: AnalysisContext;
   } = {}) {
     this.primaryEntity = primaryEntity;
     this.entityMap = initialEntityMap || {};
     this.entitiesAdded = []; // TODO: Remove this when we switch to immutable maps
     this.analysisMap = initialAnalysisMap || {};
     this.analysesAdded = []; // TODO: Remove this when we switch to immutable maps
+    this.parentContext = parentContext;
   }
   setPrimaryAnalysis(analysis: Analysis): void {
     if (!this.primaryEntity) {
@@ -102,15 +111,22 @@ export class AnalysisContext implements ImmutableAnalysisContext {
       primaryEntity: entity,
       initialEntityMap: { ...this.entityMap },
       initialAnalysisMap: { ...this.analysisMap },
+      parentContext: this,
     });
   }
 
   /**
-   * Get a read-only view of an entity by file path and entity name
+   * Get a read-only view of an entity by file path and entity name.
+   * Falls back to parent context if not found locally (for private contexts).
    * @returns The entity or undefined if not found
    */
   getEntity(filePath: string, entityName: string): ReadonlyEntity | undefined {
-    return this.entityMap[filePath]?.[entityName];
+    const entity = this.entityMap[filePath]?.[entityName];
+    // Fall back to parent context if not found locally
+    if (!entity && this.parentContext) {
+      return this.parentContext.getEntity(filePath, entityName);
+    }
+    return entity;
   }
 
   /**
@@ -126,7 +142,8 @@ export class AnalysisContext implements ImmutableAnalysisContext {
   }
 
   /**
-   * Get a read-only view of an analysis by file path and entity name
+   * Get a read-only view of an analysis by file path and entity name.
+   * Falls back to parent context if not found locally (for private contexts).
    * @returns The analysis or undefined if not found
    */
   getAnalysis(
@@ -134,7 +151,23 @@ export class AnalysisContext implements ImmutableAnalysisContext {
     entityName: string,
     withEntity = false,
   ): ReadonlyAnalysis | undefined {
-    const analysis = this.analysisMap[filePath]?.[entityName];
+    let analysis = this.analysisMap[filePath]?.[entityName];
+
+    // Fall back to parent context if not found locally
+    // This allows private contexts (created via forEntityAnalysis) to see
+    // analyses added to the main context after the fork
+    if (!analysis && this.parentContext) {
+      analysis = this.parentContext.getAnalysis(
+        filePath,
+        entityName,
+        withEntity,
+      ) as Analysis | undefined;
+      // If found in parent and withEntity was already handled by parent, return directly
+      if (analysis) {
+        return analysis;
+      }
+    }
+
     if (withEntity && analysis) {
       analysis.entity ||= this.getMutableEntity(filePath, entityName);
     }
@@ -183,6 +216,13 @@ export class AnalysisContext implements ImmutableAnalysisContext {
       this.analysisMap[filePath] = {};
     }
     this.analysisMap[filePath][entityName] = analysis;
+
+    // Also add the entity if it's attached to the analysis.
+    // This ensures that when getAnalysis is called with withEntity=true,
+    // the entity will be available in the entity map.
+    if (analysis.entity) {
+      this.addEntity(analysis.entity);
+    }
   }
 
   /**

package/analyzer-template/packages/analyze/src/lib/files/analyze/analyzeEntities/prepareDataStructures.ts

@@ -17,6 +17,7 @@ import {
   getConditionalEffects,
   getCompoundConditionals,
   getChildBoundaryGatingConditions,
+  getJsxRenderingUsages,
 } from '~codeyam/ai';
 import type { AnalysisOptions } from '../analyzeEntities';
 
@@ -134,6 +135,8 @@ export default async function prepareEntityDataStructures(
               // Include child boundary gating conditions for child component flow merging
               childBoundaryGatingConditions:
                 isolatedDataStructure.childBoundaryGatingConditions,
+              // Include JSX rendering usages for array size and text length flow generation
+              jsxRenderingUsages: isolatedDataStructure.jsxRenderingUsages,
             };
 
             // Detect wrapper requirements (Context providers, etc.)
@@ -557,19 +560,6 @@ async function getEntityDataStructureAndFunctionCalls({
 
   // Get compound conditionals (grouped conditions that must all be true)
   const compoundConditionals = getCompoundConditionals(dataStructure);
-
-  console.log(
-    `[ConditionalEffects] prepareDataStructures for ${entity.name}:`,
-    `dataStructure.conditionalEffects=${(dataStructure as any).conditionalEffects?.length ?? 0}`,
-    `getConditionalEffects returned ${conditionalEffects.length} effects`,
-    conditionalEffects
-      .slice(0, 5)
-      .map(
-        (e: any) =>
-          `${e.effect?.setterName}(${e.effect?.value?.slice?.(0, 20) ?? e.effect?.value})`,
-      ),
-  );
-
   const rawUsageEquivalencies = getUsageEquivalencies(dataStructure);
   const rawSourceEquivalencies = getSourceEquivalencies(dataStructure);
 
@@ -577,6 +567,9 @@ async function getEntityDataStructureAndFunctionCalls({
   const childBoundaryGatingConditions =
     getChildBoundaryGatingConditions(dataStructure);
 
+  // Get JSX rendering usages for array size and text length flow generation
+  const jsxRenderingUsages = getJsxRenderingUsages(dataStructure);
+
   const isolatedDataStructure = {
     signatureSchema: deduplicateFunctionSchemas(clonedRawSignature),
     returnValueSchema: deduplicateFunctionSchemas(clonedRawReturnValue),
@@ -604,6 +597,10 @@ async function getEntityDataStructureAndFunctionCalls({
       Object.keys(childBoundaryGatingConditions).length > 0
         ? childBoundaryGatingConditions
         : undefined,
+    // Include JSX rendering usages for array size and text length flow generation
+    // These track arrays rendered via .map() and strings interpolated in JSX
+    jsxRenderingUsages:
+      jsxRenderingUsages.length > 0 ? jsxRenderingUsages : undefined,
   };
 
   const functionCalls: Record<string, string[]> = {};

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

@@ -100,6 +100,12 @@ export function getCandidatesReadyForCapture(
       continue;
     }
 
+    // Skip notExported entities - they can't be imported into the simulation
+    // environment and will always fail capture. Don't mark them as ready.
+    if (candidate.entity?.metadata?.notExported) {
+      continue;
+    }
+
     // Get all transitive dependencies
     const candidateKey = `${candidate.filePath}:${candidate.entityName}`;
     const { missingDependencies } = getTransitiveDependencies(

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

@@ -1,5 +1,6 @@
 import type {
   Analysis,
+  Entity,
   ReadonlyAnalysisMap,
   ReadonlyAnalysis,
   ReadonlyEntity,
@@ -61,7 +62,10 @@ export default function validateDependencyAnalyses({
   for (const dependency of entity.metadata?.importedExports ?? []) {
     const dependencyFilePath =
       dependency.resolvedFilePath ?? dependency.filePath;
-    const dependencyName = dependency.resolvedName ?? dependency.name;
+    // Use the entity/import name, not the export name (resolvedName).
+    // For default exports, resolvedName is 'default' but the entity is stored
+    // under its actual identifier name (e.g., 'QuoteDetailsDrawer').
+    const dependencyName = dependency.name;
 
     // if the entity has duplicate dependencies, handle gracefully
     if (dependentAnalyses[dependencyFilePath]?.[dependencyName]) {
@@ -103,6 +107,23 @@ export default function validateDependencyAnalyses({
       continue;
     }
 
+    // Ensure the entity is attached to the analysis.
+    // The entity might not be attached if the analysis was loaded from the database
+    // without its entity being in the context's entity map.
+    // This is critical for generateDataStructure to merge child component tRPC calls.
+    let dependentEntity: ReadonlyEntity | undefined = dependentAnalysis.entity;
+    if (!dependentEntity) {
+      // Try to get the entity from the context
+      dependentEntity = context.getEntity(dependencyFilePath, dependencyName);
+      if (dependentEntity) {
+        // Attach the entity to the analysis (mutating, but necessary for downstream use)
+        // We need the double cast because ReadonlyEntity has readonly arrays that aren't
+        // assignable to Entity's mutable arrays.
+        (dependentAnalysis as unknown as Analysis).entity =
+          dependentEntity as unknown as Entity;
+      }
+    }
+
     // Store the dependent analysis
     dependentAnalyses[dependencyFilePath] ||= {};
     dependentAnalyses[dependencyFilePath][dependencyName] = dependentAnalysis;
@@ -125,12 +146,17 @@ export default function validateDependencyAnalyses({
       }
     }
 
-    validateDependencyAnalyses({
-      readonlyAnalysis: dependentAnalysis,
-      entity: dependentAnalysis.entity,
-      context: context,
-      dependentAnalyses,
-    });
+    // Only recurse if we have the entity. Without the entity, we can't process
+    // the dependency's own dependencies, but we can still use this dependency's
+    // analysis data (mergedDataStructure, etc.)
+    if (dependentEntity) {
+      validateDependencyAnalyses({
+        readonlyAnalysis: dependentAnalysis,
+        entity: dependentEntity,
+        context: context,
+        dependentAnalyses,
+      });
+    }
   }
 
   return { dependentAnalyses };

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,88 +87,103 @@ 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>> = {};
+
     for (const [path, type] of Object.entries(schema)) {
-      // Match signature[0].propName.field patterns
-      const match = path.match(/^signature\[0\]\.(\w+)\.(.+)$/);
+      // 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 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;
+        const [, propName, fieldPath] = match;
+        propGroups[propName] ||= {};
+        propGroups[propName][fieldPath] = type;
       }
     }
-    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);
-
-    const schema =
-      dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
-        ?.signatureSchema;
-    if (!schema) continue;
 
-    const propFields = extractPropFields(schema);
-    if (Object.keys(propFields).length > 0) {
-      childSignatureFields.push({
-        filePath: importedExport.filePath,
-        entityName: importedExport.name,
-        propFields,
-      });
+    // Store 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 });
+      }
     }
-  }
+  };
 
-  // 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();
+
+    // Direct match (e.g., "surveys" from function "surveys")
+    if (normalizedFunc === normalizedVar) return true;
 
-  // 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
+    // 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;
 
@@ -179,17 +200,65 @@ export default function enrichArrayTypesFromChildSignatures(
       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)
+        if (!couldBeDerivedFrom(localVarName, entityName)) {
+          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]) {
-          schema[fullPath] = type;
-        }
+    for (const [fieldPath, type] of Object.entries(matchedFields)) {
+      const fullPath = `${elementPath}.${fieldPath}`;
+      if (!schema[fullPath]) {
+        schema[fullPath] = type;
       }
     }
   }