@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.2a88920

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

@@ -65,6 +65,10 @@ export default async function generateExecutionFlows({
   }
 
   if (!analysis.metadata.executionFlows) {
+    console.log(
+      `[GenerateExecutionFlows] Starting for ${entity.name} (${entity.filePath})`,
+    );
+
     // Build childEntityMetadata from dependentAnalyses for child flow merging
     // This maps child component names to their metadata (specifically isolatedDataStructure)
     const childEntityMetadata = buildChildEntityMetadata(
@@ -72,6 +76,16 @@ export default async function generateExecutionFlows({
       dependentAnalyses,
     );
 
+    const childCount = Object.keys(childEntityMetadata).length;
+    console.log(
+      `[GenerateExecutionFlows] Built childEntityMetadata with ${childCount} children`,
+    );
+    if (childCount > 0) {
+      console.log(
+        `[GenerateExecutionFlows] Will merge flows from children: [${Object.keys(childEntityMetadata).join(', ')}]`,
+      );
+    }
+
     const {
       result: { executionFlows, llmCall: executionFlowsLLMCall },
     } = await measureAndReportExecutionTime(
@@ -80,15 +94,24 @@ export default async function generateExecutionFlows({
           entity,
           mergedDataStructure: analysis.metadata.mergedDataStructure,
           model,
-          childEntityMetadata:
-            Object.keys(childEntityMetadata).length > 0
-              ? childEntityMetadata
-              : undefined,
+          childEntityMetadata: childCount > 0 ? childEntityMetadata : undefined,
         }),
       `Generating execution flows`,
       updateProgress,
     );
 
+    console.log(
+      `[GenerateExecutionFlows] Generated ${executionFlows.length} execution flows for ${entity.name}`,
+    );
+    for (const flow of executionFlows) {
+      const reqValues = flow.requiredValues
+        .map((rv) => `${rv.attributePath}=${rv.value}`)
+        .join(', ');
+      console.log(
+        `[GenerateExecutionFlows]   - Flow '${flow.id}': ${flow.name} [${reqValues}]`,
+      );
+    }
+
     analysis.metadata.executionFlows = executionFlows;
 
     if (executionFlowsLLMCall) {
@@ -108,13 +131,20 @@ export default async function generateExecutionFlows({
  * then looks them up in importedExports to get their file paths,
  * then retrieves their metadata from dependentAnalyses.
  */
-function buildChildEntityMetadata(
+export function buildChildEntityMetadata(
   entity: Entity,
   dependentAnalyses?: ReadonlyAnalysisMap,
 ): Record<string, Entity['metadata']> {
   const childEntityMetadata: Record<string, Entity['metadata']> = {};
 
+  console.log(
+    `[BuildChildMetadata] Starting for entity: ${entity.name} (${entity.filePath})`,
+  );
+
   if (!dependentAnalyses) {
+    console.log(
+      `[BuildChildMetadata] No dependentAnalyses provided, returning empty`,
+    );
     return childEntityMetadata;
   }
 
@@ -122,18 +152,54 @@ function buildChildEntityMetadata(
     entity.metadata?.isolatedDataStructure?.childBoundaryGatingConditions;
 
   if (!childBoundaryGatingConditions) {
+    console.log(
+      `[BuildChildMetadata] No childBoundaryGatingConditions found in isolatedDataStructure`,
+    );
+    console.log(
+      `[BuildChildMetadata] isolatedDataStructure keys: ${Object.keys(entity.metadata?.isolatedDataStructure ?? {}).join(', ') || 'none'}`,
+    );
     return childEntityMetadata;
   }
 
+  const childNames = Object.keys(childBoundaryGatingConditions);
+  console.log(
+    `[BuildChildMetadata] Found ${childNames.length} children in childBoundaryGatingConditions: [${childNames.join(', ')}]`,
+  );
+
+  // Log gating conditions for each child
+  for (const [childName, conditions] of Object.entries(
+    childBoundaryGatingConditions,
+  )) {
+    const isUnconditional = conditions.some(
+      (c) => c.location === 'unconditional',
+    );
+    console.log(
+      `[BuildChildMetadata] Child '${childName}': ${conditions.length} gating conditions, unconditional=${isUnconditional}`,
+    );
+    for (const condition of conditions) {
+      console.log(
+        `[BuildChildMetadata]   - path='${condition.path}' location='${condition.location}' isNegated=${condition.isNegated ?? false}`,
+      );
+    }
+  }
+
   const importedExports = entity.metadata?.importedExports ?? [];
+  console.log(
+    `[BuildChildMetadata] Entity has ${importedExports.length} importedExports`,
+  );
+
+  for (const childName of childNames) {
+    console.log(`[BuildChildMetadata] Looking up child '${childName}'...`);
 
-  for (const childName of Object.keys(childBoundaryGatingConditions)) {
     // Find the child in importedExports to get its file path
     const importedExport = importedExports.find(
       (ie) => ie.name === childName || ie.resolvedName === childName,
     );
 
     if (!importedExport) {
+      console.log(
+        `[BuildChildMetadata] Child '${childName}' NOT FOUND in importedExports`,
+      );
       continue;
     }
 
@@ -142,15 +208,57 @@ function buildChildEntityMetadata(
       importedExport.resolvedFilePath ?? importedExport.filePath;
     const lookupName = importedExport.resolvedName ?? importedExport.name;
 
+    console.log(
+      `[BuildChildMetadata] Child '${childName}' found in importedExports: lookupPath='${lookupPath}' lookupName='${lookupName}'`,
+    );
+
     // Look up the child's analysis in dependentAnalyses
     const childAnalysis = dependentAnalyses[lookupPath]?.[lookupName];
 
-    if (childAnalysis?.entity?.metadata) {
-      // Cast to mutable type - the metadata is only read, not modified
-      childEntityMetadata[childName] = childAnalysis.entity
-        .metadata as Entity['metadata'];
+    if (!childAnalysis) {
+      console.log(
+        `[BuildChildMetadata] Child '${childName}' analysis NOT FOUND in dependentAnalyses[${lookupPath}][${lookupName}]`,
+      );
+      console.log(
+        `[BuildChildMetadata] Available paths in dependentAnalyses: [${Object.keys(dependentAnalyses).slice(0, 10).join(', ')}...]`,
+      );
+      continue;
+    }
+
+    if (!childAnalysis.entity?.metadata) {
+      console.log(
+        `[BuildChildMetadata] Child '${childName}' analysis found but entity.metadata is missing`,
+      );
+      continue;
+    }
+
+    // Log what we found in the child's metadata
+    const childIsolated = childAnalysis.entity.metadata.isolatedDataStructure;
+    const childConditionalUsages = childIsolated?.conditionalUsages ?? {};
+    const childConditionalCount = Object.keys(childConditionalUsages).length;
+
+    console.log(
+      `[BuildChildMetadata] Child '${childName}' FOUND with metadata:`,
+    );
+    console.log(
+      `[BuildChildMetadata]   - conditionalUsages: ${childConditionalCount} paths`,
+    );
+    if (childConditionalCount > 0) {
+      for (const [path, usages] of Object.entries(childConditionalUsages)) {
+        console.log(
+          `[BuildChildMetadata]     - '${path}': ${(usages as any[]).length} usages`,
+        );
+      }
     }
+
+    // Cast to mutable type - the metadata is only read, not modified
+    childEntityMetadata[childName] = childAnalysis.entity
+      .metadata as Entity['metadata'];
   }
 
+  console.log(
+    `[BuildChildMetadata] RESULT: Found metadata for ${Object.keys(childEntityMetadata).length} children: [${Object.keys(childEntityMetadata).join(', ')}]`,
+  );
+
   return childEntityMetadata;
 }

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

@@ -40,6 +40,52 @@ function getTypeParameter(functionName: string): string | null {
   return null;
 }
 
+// Primitive types that should not have child paths
+const PRIMITIVE_TYPES = new Set([
+  'number',
+  'string',
+  'boolean',
+  'null',
+  'undefined',
+]);
+
+// Check if a type string represents a primitive type
+// Handles union types like "string | undefined" or "number | null"
+function isPrimitiveType(typeStr: string): boolean {
+  if (PRIMITIVE_TYPES.has(typeStr)) {
+    return true;
+  }
+  // Check union types - if ALL parts of the union are primitives, it's primitive
+  // e.g., "string | undefined" -> ["string", "undefined"] -> both are primitive -> true
+  // e.g., "object | null" -> ["object", "null"] -> object is not primitive -> false
+  if (typeStr.includes('|')) {
+    const parts = typeStr.split('|').map((p) => p.trim());
+    return parts.every((part) => PRIMITIVE_TYPES.has(part));
+  }
+  return false;
+}
+
+// Check if a new schema path would go through a primitive type
+// e.g., if schema has 'entities[].scenarioCount': 'number', then
+// 'entities[].scenarioCount.sha' would go through a primitive and should be rejected
+function wouldGoThroughPrimitive(
+  newPath: string,
+  schema: { [key: string]: string },
+): boolean {
+  const pathParts = splitOutsideParenthesesAndArrays(newPath);
+
+  // Check each prefix of the path (excluding the full path itself)
+  for (let i = 1; i < pathParts.length; i++) {
+    const prefixPath = joinParenthesesAndArrays(pathParts.slice(0, i));
+    const prefixType = schema[prefixPath];
+    if (prefixType && isPrimitiveType(prefixType)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 // Check if schemaPathPart matches or is a function call variant of pathPart
 // e.g., 'isEntityBeingAnalyzed(entity.sha)' matches 'isEntityBeingAnalyzed'
 function pathPartMatches(pathPart: string, schemaPathPart: string): boolean {
@@ -57,10 +103,14 @@ function bestValueFromOptions(options: Array<string | undefined>) {
   options = options.filter(Boolean) as string[];
 
   const known = options.find((o) => !o.includes('unknown'));
-  if (known) return known;
+  if (known) {
+    return known;
+  }
 
   const notUnknown = options.find((o) => o !== 'unknown');
-  if (notUnknown) return notUnknown;
+  if (notUnknown) {
+    return notUnknown;
+  }
 
   return options[0] ?? 'unknown';
 }
@@ -152,10 +202,21 @@ export default function mergeInDependentDataStructure({
     equivalentPostfixes: Record<string, string>;
   }[] = [];
 
+  // Pre-build a lookup map from cleaned function name to dependency for O(1) lookups.
+  // This avoids O(n) linear search in findRelevantDependency which was causing O(n²) performance.
+  const dependencyByCleanedName = new Map<
+    string,
+    (typeof importedExports)[0]
+  >();
+  for (const dep of importedExports) {
+    const cleanedName = cleanFunctionName(dep.name);
+    if (!dependencyByCleanedName.has(cleanedName)) {
+      dependencyByCleanedName.set(cleanedName, dep);
+    }
+  }
+
   const findRelevantDependency = (functionName: any) => {
-    return importedExports.find(
-      (d) => cleanFunctionName(d.name) === cleanFunctionName(functionName),
-    );
+    return dependencyByCleanedName.get(cleanFunctionName(functionName));
   };
 
   const findRelevantDependentDataStructure = (functionName: any) => {
@@ -291,16 +352,16 @@ export default function mergeInDependentDataStructure({
       } else {
         equivalentSchemaPathsEntry.equivalentRoots.push(...equivalentRoots);
       }
+
+      // Deduplicate roots using a Set for O(n) instead of O(n²)
+      const seenRoots = new Set<string>();
       equivalentSchemaPathsEntry.equivalentRoots =
-        equivalentSchemaPathsEntry.equivalentRoots.filter(
-          (er, index, self) =>
-            index ===
-            self.findIndex(
-              (e) =>
-                e.schemaRootPath === er.schemaRootPath &&
-                e.function?.name === er.function?.name,
-            ),
-        );
+        equivalentSchemaPathsEntry.equivalentRoots.filter((er) => {
+          const key = er.schemaRootPath + '::' + (er.function?.name ?? '');
+          if (seenRoots.has(key)) return false;
+          seenRoots.add(key);
+          return true;
+        });
 
       return equivalentSchemaPathsEntry;
     };
@@ -880,7 +941,44 @@ export default function mergeInDependentDataStructure({
   equivalentSchemaPaths = mergeAllEquivalentSchemaPaths();
 
   for (const esp of equivalentSchemaPaths) {
-    for (const equivalentRoot of esp.equivalentRoots) {
+    // Pre-compute which postfixes have children to avoid O(n²) lookups in the inner loop.
+    // A postfix "has children" if there are other postfixes that extend it.
+    const postfixesWithChildren = new Set<string>();
+    const postfixKeys = Object.keys(esp.equivalentPostfixes);
+
+    // Check for empty postfix having children (any other postfixes exist)
+    if (postfixKeys.length > 1 && '' in esp.equivalentPostfixes) {
+      postfixesWithChildren.add('');
+    }
+
+    // Check for array element postfixes having children using a prefix set.
+    // This avoids O(n²) scans across large postfix lists.
+    // e.g., 'currentEntities[]' has children if a path like 'currentEntities[].sha' exists.
+    const postfixPrefixSet = new Set<string>();
+    for (const postfixPath of postfixKeys) {
+      if (!postfixPath) continue;
+      const parts = splitOutsideParenthesesAndArrays(postfixPath);
+      for (let i = 1; i < parts.length; i++) {
+        postfixPrefixSet.add(joinParenthesesAndArrays(parts.slice(0, i)));
+      }
+    }
+    for (const postfixPath of postfixKeys) {
+      if (postfixPath.endsWith('[]') && postfixPrefixSet.has(postfixPath)) {
+        postfixesWithChildren.add(postfixPath);
+      }
+    }
+
+    // Deduplicate equivalentRoots that would write to the same schema paths.
+    // Roots with the same (function, schemaRootPath, postfix) are redundant.
+    const seenRootKeys = new Set<string>();
+    const uniqueRoots = esp.equivalentRoots.filter((root) => {
+      const key = `${root.function?.filePath ?? ''}::${root.function?.name ?? ''}::${root.schemaRootPath}::${root.postfix ?? ''}`;
+      if (seenRootKeys.has(key)) return false;
+      seenRootKeys.add(key);
+      return true;
+    });
+
+    for (const equivalentRoot of uniqueRoots) {
       let merged:
         | {
             signatureSchema: { [key: string]: string };
@@ -905,9 +1003,21 @@ export default function mergeInDependentDataStructure({
       )) {
         let relevantPostfix = postfixPath;
         if (equivalentRoot.postfix) {
+          // Check if postfixPath starts with equivalentRoot.postfix at a path boundary.
+          // Must ensure exact path part match - "entityCode" should NOT match "entity" prefix.
+          // Valid: "entity.foo" starts with "entity" (boundary at '.')
+          // Valid: "entity[0]" starts with "entity" (boundary at '[')
+          // Invalid: "entityCode" starts with "entity" (no boundary, different property)
           if (!postfixPath.startsWith(equivalentRoot.postfix)) {
             continue;
           }
+          // Additional check: ensure the match is at a path boundary
+          const nextChar = postfixPath[equivalentRoot.postfix.length];
+          if (nextChar !== undefined && nextChar !== '.' && nextChar !== '[') {
+            // The postfixPath continues with more characters that aren't a path separator.
+            // This means "entity" matched "entityCode" which is wrong - they're different properties.
+            continue;
+          }
 
           const postFixPathParts =
             splitOutsideParenthesesAndArrays(postfixPath);
@@ -924,6 +1034,44 @@ export default function mergeInDependentDataStructure({
           relevantPostfix,
         ]);
 
+        // Skip paths that would go through a primitive type
+        // e.g., if schema has 'entities[].scenarioCount': 'number', skip 'entities[].scenarioCount.sha'
+        if (wouldGoThroughPrimitive(newSchemaPath, schema)) {
+          continue;
+        }
+
+        // Skip setting primitive type when there are child postfixes that indicate structure.
+        // This prevents downgrading an object/array element to a primitive type.
+        // Uses pre-computed postfixesWithChildren Set for O(1) lookup instead of O(n) iteration.
+        const hasChildPostfixes =
+          (relevantPostfix === '' || relevantPostfix.endsWith('[]')) &&
+          postfixesWithChildren.has(postfixPath);
+        if (PRIMITIVE_TYPES.has(postfixValue) && hasChildPostfixes) {
+          continue;
+        }
+
+        // Don't overwrite a more specific type with a less specific one
+        // This can happen when nested roots share entries with their parent roots
+        const existingType = schema[newSchemaPath];
+        if (existingType) {
+          // Don't overwrite a primitive type with 'object' or 'array'
+          // e.g., if schema has 'entities[].scenarioCount': 'number', don't overwrite with 'object'
+          if (
+            PRIMITIVE_TYPES.has(existingType) &&
+            (postfixValue === 'object' || postfixValue === 'array')
+          ) {
+            continue;
+          }
+          // Don't overwrite a complex/union type with a primitive
+          // e.g., if schema has 'scenarios[]': 'Scenario | null', don't overwrite with 'string'
+          if (
+            !PRIMITIVE_TYPES.has(existingType) &&
+            PRIMITIVE_TYPES.has(postfixValue)
+          ) {
+            continue;
+          }
+        }
+
         schema[newSchemaPath] = postfixValue;
       }
 
@@ -1134,6 +1282,83 @@ export default function mergeInDependentDataStructure({
     }
 
     cleanSchema(depSchema.returnValueSchema);
+
+    // Pull signature requirements from downstream functions into the mocked return value.
+    // When a mocked function's return flows into another function's signature (via usageEquivalencies),
+    // we need to include that function's signature requirements in the mock.
+    //
+    // Example: fromE5() returns a currency object that flows to calculateTotalPrice(price, quantity).
+    // calculateTotalPrice's signatureSchema shows signature[0].multiply() is required.
+    // We need to add multiply() to fromE5's mock return value.
+    const usageEquivalencies = srcSchema.usageEquivalencies ?? {};
+    for (const [returnPath, equivalencies] of Object.entries(
+      usageEquivalencies,
+    )) {
+      // Only process return value paths (functionCallReturnValue)
+      if (!returnPath.includes('.functionCallReturnValue')) continue;
+
+      for (const equiv of equivalencies) {
+        // Check if this equivalency points to a signature path
+        const signatureMatch = equiv.schemaPath.match(/\.signature\[(\d+)\]$/);
+        if (!signatureMatch) continue;
+
+        const targetFunctionName = cleanFunctionName(equiv.scopeNodeName);
+        const signatureIndex = signatureMatch[1];
+
+        // Look up the target function's analysis to get its signature requirements
+        // First try dependentAnalyses, then dependencySchemas
+        let targetSignatureSchema: Record<string, string> | undefined;
+
+        // Check dependentAnalyses first (has the full merged analysis)
+        for (const depFilePath in dependentAnalyses) {
+          const analysis = dependentAnalyses[depFilePath]?.[targetFunctionName];
+          if (analysis?.metadata?.mergedDataStructure?.signatureSchema) {
+            targetSignatureSchema =
+              analysis.metadata.mergedDataStructure.signatureSchema;
+            break;
+          }
+        }
+
+        // Fallback to dependencySchemas if not found
+        if (!targetSignatureSchema) {
+          for (const depFilePath in dependencySchemas) {
+            const schema = dependencySchemas[depFilePath]?.[targetFunctionName];
+            if (schema?.signatureSchema) {
+              targetSignatureSchema = schema.signatureSchema;
+              break;
+            }
+          }
+        }
+
+        if (!targetSignatureSchema) continue;
+
+        // Find all paths in the target's signatureSchema that extend from signature[N]
+        // e.g., signature[0].multiply(quantity) -> .multiply(quantity)
+        const signaturePrefix = `signature[${signatureIndex}]`;
+        for (const [sigPath, sigType] of Object.entries(
+          targetSignatureSchema,
+        )) {
+          if (!sigPath.startsWith(signaturePrefix)) continue;
+
+          // Skip the base signature[N] path itself - we only want the method/property extensions
+          if (sigPath === signaturePrefix) continue;
+
+          // Extract the suffix after signature[N] (e.g., ".multiply(quantity)")
+          const suffix = sigPath.slice(signaturePrefix.length);
+
+          // Build the path for the mocked return value
+          // e.g., fromE5(priceE5).functionCallReturnValue.multiply(quantity)
+          const returnValuePath = returnPath + suffix;
+
+          // Add to the mocked dependency's return value schema if not already present
+          if (!(returnValuePath in depSchema.returnValueSchema)) {
+            depSchema.returnValueSchema[returnValuePath] = sigType;
+          }
+        }
+      }
+    }
+
+    cleanSchema(depSchema.returnValueSchema);
   }
 
   // Process the input dependencySchemas FIRST (before child dependentAnalyses).
@@ -1177,6 +1402,40 @@ export default function mergeInDependentDataStructure({
         cleanSchema(depSchema.returnValueSchema);
       }
 
+      // TYPE REFINEMENT: Check if dependentAnalyses has a more specific type for this dependency.
+      // When a parent passes `entity.filePath` (string | undefined) to a child component
+      // that requires `filePath: string`, we should use the child's more specific type.
+      // This prevents mock data from having undefined values for required props.
+      //
+      // This runs REGARDLESS of whether equivalencies already processed the schema,
+      // because equivalencies copy the parent's type (string | undefined), not the child's
+      // required type (string).
+      const depSchema = findOrCreateDependentSchemas({ filePath, name });
+      const childAnalysis = dependentAnalyses[filePath]?.[name];
+      const childSignatureSchema =
+        childAnalysis?.metadata?.mergedDataStructure?.signatureSchema;
+
+      if (childSignatureSchema) {
+        for (const path in depSchema.signatureSchema) {
+          const parentType = depSchema.signatureSchema[path];
+          const childType = childSignatureSchema[path];
+
+          if (parentType && childType) {
+            // Check if parent has optional type and child has required type
+            const parentIsOptional =
+              parentType.includes('| undefined') ||
+              parentType.includes('| null');
+            const childIsOptional =
+              childType.includes('| undefined') || childType.includes('| null');
+
+            // If child requires a more specific type (not optional), use it
+            if (parentIsOptional && !childIsOptional) {
+              depSchema.signatureSchema[path] = childType;
+            }
+          }
+        }
+      }
+
       // For functions with multiple different type parameters, also create separate entries
       // for each type-parameterized variant. This allows gatherDataForMocks to look up
       // the specific schema for each call signature.
@@ -1275,8 +1534,8 @@ export default function mergeInDependentDataStructure({
             // Merge in the nested dependency schemas
             for (const path in nestedDepSchema.returnValueSchema) {
               if (!(path in targetDepSchema.returnValueSchema)) {
-                targetDepSchema.returnValueSchema[path] =
-                  nestedDepSchema.returnValueSchema[path];
+                const value = nestedDepSchema.returnValueSchema[path];
+                targetDepSchema.returnValueSchema[path] = value;
               }
             }
 

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

@@ -2,6 +2,49 @@ import { splitOutsideParenthesesAndArrays } from '~codeyam/ai';
 import { JsonTypeDefinition, ReadonlyAnalysisMap } from '~codeyam/types';
 import { awsLog } from '~codeyam/utils';
 
+/**
+ * Deep merge for JsonTypeDefinition schemas.
+ * Only recursively merges when BOTH sides are plain objects (not arrays, not primitives).
+ * This is different from the general deepMerge which is designed for data values -
+ * here we're merging type schemas where leaf values are strings like "boolean" or "function".
+ *
+ * When types are incompatible (e.g., array vs object), prefer keeping the base value
+ * since it was set first from the root entity's validatedVariables.
+ */
+function deepMergeSchemas(
+  base: JsonTypeDefinition,
+  override: JsonTypeDefinition,
+): JsonTypeDefinition {
+  // If override is null/undefined, return base
+  if (override === null || override === undefined) return base;
+  // If base is null/undefined, return override
+  if (base === null || base === undefined) return override;
+
+  // Only recursively merge if BOTH are plain objects (not arrays, not primitives)
+  const baseIsPlainObject =
+    typeof base === 'object' && !Array.isArray(base) && base !== null;
+  const overrideIsPlainObject =
+    typeof override === 'object' &&
+    !Array.isArray(override) &&
+    override !== null;
+
+  if (baseIsPlainObject && overrideIsPlainObject) {
+    const result: JsonTypeDefinition = { ...base };
+    for (const key in override) {
+      result[key] = deepMergeSchemas(
+        base[key] as JsonTypeDefinition,
+        override[key] as JsonTypeDefinition,
+      );
+    }
+    return result;
+  }
+
+  // For incompatible types (array vs object, string vs object, etc.), keep base
+  // This ensures the root entity's structure is preserved when a dependency
+  // has a different view of the same mock
+  return base;
+}
+
 export function mergeInStructure(
   name: string | number,
   key: string | number,
@@ -155,10 +198,10 @@ export default function mergeValidatedDataStructures({
       }
       activeValidatedParts = validatedVariables[usedName] as JsonTypeDefinition;
     }
-    dataForMocks = {
-      ...dataForMocks,
-      ...validatedData,
-    };
+    // Use deep merge instead of shallow spread to preserve previously merged
+    // dependency data. This fixes Issue #15 where multiple dependencies with
+    // the same top-level key (e.g., trpc) would overwrite each other.
+    dataForMocks = deepMergeSchemas(dataForMocks, validatedData);
   };
 
   for (const dependency of relevantDependencies) {
@@ -181,13 +224,15 @@ export default function mergeValidatedDataStructures({
     for (const mockName in dependencyDataForMocks) {
       addMockDataForEntity(mockName);
 
-      // If addMockDataForEntity didn't find matching entries in validatedVariables,
-      // copy the dependency's value directly. This handles cases like usePathname()
-      // which returns a simple "string" type but isn't in the root's validatedVariables.
-      if (dataForMocks[mockName] === undefined) {
-        dataForMocks[mockName] = dependencyDataForMocks[
-          mockName
-        ] as JsonTypeDefinition;
+      // Always deep merge the dependency's value to preserve nested structures.
+      // This handles cases like usePathname() which returns a simple "string" type,
+      // AND cases like trpc where both root and dependency have nested data that
+      // needs to be combined (e.g., trpc.quote from root + trpc.fastener.getAttributeValues
+      // from dependency).
+      if (dependencyDataForMocks[mockName] !== undefined) {
+        dataForMocks = deepMergeSchemas(dataForMocks, {
+          [mockName]: dependencyDataForMocks[mockName],
+        } as JsonTypeDefinition);
       }
     }
   }