@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.c90f8c9

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

@@ -21,6 +21,25 @@ function cleanFunctionName(functionName: string) {
   return functionName?.split('<')[0];
 }
 
+// Extract the type parameter from a function name, e.g., 'useFetcher<{ data: UserData }>()' -> '{ data: UserData }'
+function getTypeParameter(functionName: string): string | null {
+  if (!functionName) return null;
+  const openBracket = functionName.indexOf('<');
+  if (openBracket === -1) return null;
+  // Find matching closing bracket, accounting for nested brackets
+  let depth = 0;
+  for (let i = openBracket; i < functionName.length; i++) {
+    if (functionName[i] === '<') depth++;
+    else if (functionName[i] === '>') {
+      depth--;
+      if (depth === 0) {
+        return functionName.slice(openBracket + 1, i);
+      }
+    }
+  }
+  return null;
+}
+
 // 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 {
@@ -74,47 +93,6 @@ export default function mergeInDependentDataStructure({
     };
   };
 }) {
-  // writeFile(
-  //   'mergeInDependentDataStructure-debug.json',
-  //   JSON.stringify(
-  //     {
-  //       importedExports: importedExports.map((d) => ({
-  //         filePath: d.filePath,
-  //         name: d.name,
-  //         isMocked: d.isMocked,
-  //       })),
-  //       dependentAnalyses: Object.keys(dependentAnalyses).reduce(
-  //         (pathAcc: Record<string, any>, filePath) => {
-  //           pathAcc[filePath] = Object.keys(dependentAnalyses[filePath]).reduce(
-  //             (nameAcc, name) => {
-  //               nameAcc[name] = {
-  //                 metadata: {
-  //                   mergedDataStructure:
-  //                     dependentAnalyses[filePath][name].metadata
-  //                       .mergedDataStructure,
-  //                 },
-  //               };
-  //               return nameAcc;
-  //             },
-  //             {} as { [name: string]: {
-  //               metadata?: {
-  //                 mergedDataStructure?: ReadonlyAnalysis['metadata']['mergedDataStructure'];
-  //               };
-  //             } },
-  //           );
-  //           return pathAcc;
-  //         },
-  //         {},
-  //       ),
-  //       rootScopeName,
-  //       dataStructure,
-  //       dependencySchemas,
-  //     },
-  //     null,
-  //     2,
-  //   ),
-  // ).catch(() => {});
-
   const mergedDataStructure: Omit<
     DataStructure,
     'equivalentSignatureVariables'
@@ -127,6 +105,44 @@ export default function mergeInDependentDataStructure({
     environmentVariables: [...(dataStructure.environmentVariables || [])],
   };
 
+  // Build a set of functions that have multiple DIFFERENT type parameters.
+  // For these functions, we must NOT normalize paths to avoid merging different schemas.
+  // e.g., if we have both useFetcher<{ data: UserData }>() and useFetcher<{ data: ConfigData }>(),
+  // they must stay separate and not both become 'returnValue'.
+  const functionsWithMultipleTypeParams = new Set<string>();
+  const typeParamsByFunction: Record<string, Set<string>> = {};
+
+  // Helper to scan a schema for type parameters
+  const scanSchemaForTypeParams = (schema: { [key: string]: string }) => {
+    for (const schemaPath of Object.keys(schema ?? {})) {
+      const parts = splitOutsideParenthesesAndArrays(schemaPath);
+      if (parts.length > 0) {
+        const firstPart = parts[0];
+        const typeParam = getTypeParameter(firstPart);
+        if (typeParam) {
+          const baseName = cleanFunctionName(firstPart);
+          typeParamsByFunction[baseName] ||= new Set();
+          typeParamsByFunction[baseName].add(typeParam);
+          if (typeParamsByFunction[baseName].size > 1) {
+            functionsWithMultipleTypeParams.add(baseName);
+          }
+        }
+      }
+    }
+  };
+
+  // Scan the root entity's schema
+  scanSchemaForTypeParams(dataStructure.returnValueSchema);
+
+  // Also scan all dependency schemas for type parameters
+  for (const filePath of Object.keys(dependencySchemas ?? {})) {
+    for (const name of Object.keys(dependencySchemas[filePath] ?? {})) {
+      scanSchemaForTypeParams(
+        dependencySchemas[filePath][name]?.returnValueSchema,
+      );
+    }
+  }
+
   let equivalentSchemaPaths: {
     equivalentRoots: {
       schemaRootPath: string;
@@ -185,6 +201,15 @@ export default function mergeInDependentDataStructure({
       const pathParts = splitOutsideParenthesesAndArrays(path);
       if (pathParts.length > 1) {
         if (pathParts[1].startsWith('functionCallReturnValue')) {
+          // Check if this function has multiple DIFFERENT type parameters.
+          // If so, DON'T normalize to returnValue - keep the full path to avoid
+          // merging different type-parameterized variants together.
+          // e.g., useFetcher<{ data: UserData }>().functionCallReturnValue.data
+          // should NOT be merged with useFetcher<{ data: ConfigData }>().functionCallReturnValue.data
+          const baseName = cleanFunctionName(pathParts[0]);
+          if (functionsWithMultipleTypeParams.has(baseName)) {
+            return path; // Keep the original path with type parameters
+          }
           // functionCallReturnValue immediately follows - normalize to returnValue
           // e.g., useAuth().functionCallReturnValue.user -> returnValue.user
           return joinParenthesesAndArrays([
@@ -280,19 +305,176 @@ export default function mergeInDependentDataStructure({
       return equivalentSchemaPathsEntry;
     };
 
-    for (const equivalencies of [
+    // Helper to extract function name from a path that starts with a function call.
+    // e.g., 'ScenarioViewer().signature[0].scenario' -> 'ScenarioViewer'
+    // Returns undefined if the path doesn't start with a function call or the function isn't a dependency.
+    const extractFunctionNameFromPath = (path: string): string | undefined => {
+      const parts = splitOutsideParenthesesAndArrays(path);
+      if (parts.length > 0 && parts[0].endsWith(')')) {
+        // Extract the function name without the () suffix and type params
+        const funcCallPart = parts[0];
+        const funcName = cleanFunctionName(funcCallPart.replace(/\(\)$/, ''));
+        // Check if this function is a dependency
+        if (findRelevantDependency(funcName)) {
+          return funcName;
+        }
+      }
+      return undefined;
+    };
+
+    const allEquivalencies = [
       sourceAndUsageEquivalencies.usageEquivalencies,
       sourceAndUsageEquivalencies.sourceEquivalencies,
-    ].filter(Boolean)) {
-      for (const [schemaPath, usages] of Object.entries(equivalencies)) {
+    ].filter(Boolean);
+
+    for (const equivalencies of allEquivalencies) {
+      const schemaPathEntries = Object.entries(equivalencies);
+      for (const [schemaPath, usages] of schemaPathEntries) {
+        // First, check if the raw schemaPath starts with a function call to a dependency.
+        // If so, use that dependency name for translation (so translatePath can strip the prefix).
+        const extractedFuncName = extractFunctionNameFromPath(schemaPath);
+        const effectiveFunctionName = extractedFuncName || functionName;
+        const translatedPath = translatePath(schemaPath, effectiveFunctionName);
+
         const allPaths: { path: string; functionName?: string }[] = [
-          { path: translatePath(schemaPath, functionName), functionName },
+          { path: translatedPath, functionName: effectiveFunctionName },
           ...usages.map((u) => ({
             path: translatePath(u.schemaPath, u.scopeNodeName),
             functionName: u.scopeNodeName,
           })),
         ].filter((pathInfo) => !pathInfo.path.includes('.map('));
 
+        // Fix 38: Derive base paths from property access paths.
+        // When we have equivalent paths like:
+        //   Parent: signature[0].scenarios[].name
+        //   Child:  signature[0].selectedScenario.name
+        // We want to derive the base paths by finding the common suffix:
+        //   Common suffix: .name
+        //   Parent base: signature[0].scenarios[]
+        //   Child base:  signature[0].selectedScenario
+        // This allows the merge to find nested child schema fields under the base prop.
+
+        // Find child signature paths (paths from child components)
+        const childPaths = allPaths.filter(
+          (p) =>
+            p.functionName &&
+            p.functionName !== rootScopeName &&
+            p.functionName !== effectiveFunctionName,
+        );
+        // Find parent paths (paths from this component)
+        const parentPaths = allPaths.filter(
+          (p) =>
+            !p.functionName ||
+            p.functionName === rootScopeName ||
+            p.functionName === effectiveFunctionName,
+        );
+
+        const derivedBasePaths: { path: string; functionName?: string }[] = [];
+
+        // For each child path, find its equivalent parent path and derive bases
+        for (const childPathInfo of childPaths) {
+          const childParts = splitOutsideParenthesesAndArrays(
+            childPathInfo.path,
+          );
+
+          // Look for a parent path that shares a common suffix with this child path
+          for (const parentPathInfo of parentPaths) {
+            const parentParts = splitOutsideParenthesesAndArrays(
+              parentPathInfo.path,
+            );
+
+            // Find the common suffix (from the end)
+            let commonSuffixLength = 0;
+            const minLen = Math.min(childParts.length, parentParts.length);
+            for (let i = 1; i <= minLen; i++) {
+              if (
+                childParts[childParts.length - i] ===
+                parentParts[parentParts.length - i]
+              ) {
+                commonSuffixLength = i;
+              } else {
+                break;
+              }
+            }
+
+            // If there's a common suffix and both paths have more parts than the suffix
+            if (
+              commonSuffixLength > 0 &&
+              childParts.length > commonSuffixLength &&
+              parentParts.length > commonSuffixLength
+            ) {
+              const childBaseParts = childParts.slice(
+                0,
+                childParts.length - commonSuffixLength,
+              );
+              const parentBaseParts = parentParts.slice(
+                0,
+                parentParts.length - commonSuffixLength,
+              );
+
+              // Only derive if BOTH paths look like signature paths.
+              // This ensures we're handling JSX child-to-parent prop mappings,
+              // not other complex equivalencies like function call returns.
+              const isChildSignaturePath =
+                childBaseParts[0]?.startsWith('signature[') ||
+                (childBaseParts[0]?.endsWith(')') &&
+                  childBaseParts[1]?.startsWith('signature['));
+              const isParentSignaturePath =
+                parentBaseParts[0]?.startsWith('signature[');
+
+              if (isChildSignaturePath && isParentSignaturePath) {
+                const childBase = joinParenthesesAndArrays(childBaseParts);
+                const parentBase = joinParenthesesAndArrays(parentBaseParts);
+
+                // Only derive if:
+                // 1. Parent has array iteration (e.g., scenarios[]) and child does NOT
+                // 2. Bases are different
+                // 3. Child base is NOT just "signature[N]" (too generic - every component has this)
+                //    We only want specific prop paths like "signature[0].selectedScenario"
+                // This targets array-to-object mappings like scenarios[] -> selectedScenario
+                const parentHasArrayIterator = parentBase.includes('[]');
+                const childHasArrayIterator = childBase.includes('[]');
+
+                // Skip if child base is just the generic signature marker (e.g., "signature[0]")
+                const childBaseIsGenericSignature = /^signature\[\d+\]$/.test(
+                  childBase,
+                );
+
+                if (
+                  childBase !== parentBase &&
+                  parentHasArrayIterator &&
+                  !childHasArrayIterator &&
+                  !childBaseIsGenericSignature
+                ) {
+                  // Add child base if not already present
+                  const childBaseExists =
+                    allPaths.some((p) => p.path === childBase) ||
+                    derivedBasePaths.some((p) => p.path === childBase);
+                  if (!childBaseExists) {
+                    derivedBasePaths.push({
+                      path: childBase,
+                      functionName: childPathInfo.functionName,
+                    });
+                  }
+
+                  // Add parent base if not already present
+                  const parentBaseExists =
+                    allPaths.some((p) => p.path === parentBase) ||
+                    derivedBasePaths.some((p) => p.path === parentBase);
+                  if (!parentBaseExists) {
+                    derivedBasePaths.push({
+                      path: parentBase,
+                      functionName: parentPathInfo.functionName,
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        allPaths.push(...derivedBasePaths);
+
         const entry = findOrCreateEquivalentSchemaPathsEntry(allPaths);
         for (const equivalentRoot of entry.equivalentRoots) {
           const dataStructures =
@@ -308,26 +490,52 @@ export default function mergeInDependentDataStructure({
                 ]
               : [dataStructure];
 
+          // Determine if this is a signature schema path.
+          // The path might be 'signature[0]...' directly, or 'FuncName().signature[0]...' if it has a function prefix.
+          const schemaRootParts = splitOutsideParenthesesAndArrays(
+            equivalentRoot.schemaRootPath,
+          );
+          const isSignaturePath =
+            equivalentRoot.schemaRootPath.startsWith('signature[') ||
+            (schemaRootParts[0]?.endsWith(')') &&
+              schemaRootParts[1]?.startsWith('signature['));
+
           const schemas = dataStructures.map((dataStructure) =>
-            equivalentRoot.schemaRootPath.startsWith('signature[')
+            isSignaturePath
               ? dataStructure?.signatureSchema
               : dataStructure?.returnValueSchema,
           );
 
-          const pathParts = splitOutsideParenthesesAndArrays(
+          let pathParts = splitOutsideParenthesesAndArrays(
             equivalentRoot.schemaRootPath,
           );
 
+          // Fix: When processing a child component's schema, the schemaRootPath has the function
+          // prefix (e.g., 'ScenarioViewer().signature[0].scenario'), but the child's schema paths
+          // don't have that prefix (e.g., 'signature[0].scenario.metadata.screenshotPaths').
+          // Strip the function prefix from pathParts so they can match.
+          if (
+            equivalentRoot.function &&
+            pathParts[0].endsWith(')') &&
+            pathParts[1]?.startsWith('signature[')
+          ) {
+            pathParts = pathParts.slice(1);
+          }
+
           for (const schema of schemas) {
             for (const schemaPath in schema) {
               let schemaPathParts =
                 splitOutsideParenthesesAndArrays(schemaPath);
 
               if (schemaPathParts[0].startsWith(functionName)) {
-                schemaPathParts =
-                  schemaPathParts[1] === 'functionCallReturnValue'
-                    ? ['returnValue', ...schemaPathParts.slice(2)]
-                    : schemaPathParts.slice(1);
+                // Only normalize if the function doesn't have multiple different type parameters
+                const baseName = cleanFunctionName(schemaPathParts[0]);
+                if (!functionsWithMultipleTypeParams.has(baseName)) {
+                  schemaPathParts =
+                    schemaPathParts[1] === 'functionCallReturnValue'
+                      ? ['returnValue', ...schemaPathParts.slice(2)]
+                      : schemaPathParts.slice(1);
+                }
               }
 
               if (schemaPathParts.length < pathParts.length) continue;
@@ -662,9 +870,10 @@ export default function mergeInDependentDataStructure({
         continue;
       }
 
-      const mergedDataStructure =
+      const childMergedDataStructure =
         dependentAnalyses[filePath][name].metadata?.mergedDataStructure || {};
-      gatherAllEquivalentSchemaPaths(name, mergedDataStructure);
+
+      gatherAllEquivalentSchemaPaths(name, childMergedDataStructure as any);
     }
   }
 
@@ -925,6 +1134,164 @@ 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).
+  // This ensures the parent entity's direct usage of dependencies takes precedence.
+  // When both parent and child use the same dependency (e.g., useLoaderData),
+  // the parent's schema paths are preserved, and child's paths are merged in later.
+  //
+  // Some dependencies (like .d.ts type declaration files) may not have:
+  // - Equivalencies with the root scope
+  // - A dependent analysis (they're just type declarations)
+  // - Be marked as mocked
+  // Without this, their schemas would be lost entirely.
+  for (const filePath in dependencySchemas) {
+    for (const name in dependencySchemas[filePath]) {
+      const srcSchema = dependencySchemas[filePath][name];
+      if (!srcSchema) continue;
+
+      // Skip mocked dependencies - they were already processed above with path normalization
+      if (mockedDependencies.has(`${filePath}::${name}`)) {
+        continue;
+      }
+
+      // Check if this dependency was already processed by equivalencies
+      const existingSchema =
+        mergedDataStructure.dependencySchemas[filePath]?.[name];
+
+      // Only add if no existing schema (equivalencies didn't process it)
+      if (!existingSchema) {
+        const depSchema = findOrCreateDependentSchemas({ filePath, name });
+        for (const path in srcSchema.returnValueSchema) {
+          depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
+        }
+        for (const path in srcSchema.signatureSchema) {
+          depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
+        }
+
+        // Clean known object functions (like String.prototype.replace, Array.prototype.map)
+        // from the copied schema. Without this, method call paths on primitives like
+        // "projectSlug.replace(...)" would cause convertDotNotation to create nested
+        // object structures instead of preserving the primitive type.
+        cleanSchema(depSchema.returnValueSchema);
+      }
+
+      // 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.
+      // This runs regardless of whether the base entry already existed, since we need
+      // the separate variant entries for proper schema lookup.
+      const baseName = cleanFunctionName(name);
+      if (functionsWithMultipleTypeParams.has(baseName)) {
+        // Find all unique type-parameterized call signatures in the schema
+        const typeParamVariants = new Set<string>();
+        for (const path of Object.keys(srcSchema.returnValueSchema)) {
+          const parts = splitOutsideParenthesesAndArrays(path);
+          if (
+            parts.length > 0 &&
+            parts[0].includes('<') &&
+            parts[0].endsWith(')')
+          ) {
+            typeParamVariants.add(parts[0]);
+          }
+        }
+
+        // Create a separate entry for each type-parameterized variant
+        for (const variant of typeParamVariants) {
+          const variantSchema = findOrCreateDependentSchemas({
+            filePath,
+            name: variant,
+          });
+
+          // Copy only paths that belong to this variant
+          for (const path in srcSchema.returnValueSchema) {
+            if (path.startsWith(variant)) {
+              variantSchema.returnValueSchema[path] =
+                srcSchema.returnValueSchema[path];
+            }
+          }
+          cleanSchema(variantSchema.returnValueSchema);
+        }
+      }
+    }
   }
 
   // Ensure ALL dependencies from dependentAnalyses are included in dependencySchemas,
@@ -1002,39 +1369,5 @@ export default function mergeInDependentDataStructure({
     }
   }
 
-  // Ensure ALL dependencies from the input dependencySchemas are preserved.
-  // Some dependencies (like .d.ts type declaration files) may not have:
-  // - Equivalencies with the root scope
-  // - A dependent analysis (they're just type declarations)
-  // - Be marked as mocked
-  // Without this, their schemas would be lost entirely.
-  //
-  // IMPORTANT: Only add schemas for dependencies that weren't already processed.
-  // If a dependency has an existing schema (even an empty one), it means the
-  // existing processing (mocked dependencies, equivalencies, dependentAnalyses)
-  // has already handled it and may have intentionally filtered out certain paths.
-  for (const filePath in dependencySchemas) {
-    for (const name in dependencySchemas[filePath]) {
-      const srcSchema = dependencySchemas[filePath][name];
-      if (!srcSchema) continue;
-
-      // Check if this dependency was already processed by any other mechanism
-      const existingSchema =
-        mergedDataStructure.dependencySchemas[filePath]?.[name];
-
-      // Only add if no existing schema at all - this means the dependency
-      // wasn't processed through equivalencies, mocked dependencies, or dependentAnalyses
-      if (!existingSchema) {
-        const depSchema = findOrCreateDependentSchemas({ filePath, name });
-        for (const path in srcSchema.returnValueSchema) {
-          depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
-        }
-        for (const path in srcSchema.signatureSchema) {
-          depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
-        }
-      }
-    }
-  }
-
   return mergedDataStructure;
 }

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);
       }
     }
   }

package/analyzer-template/packages/aws/codebuild/index.ts

@@ -4,3 +4,4 @@ export { default as codebuildCheckProject } from '../src/lib/codebuild/checkForC
 export { default as codebuildCreateProject } from '../src/lib/codebuild/createCodeBuildProject';
 export { default as codebuildTrigger } from '../src/lib/codebuild/triggerCodeBuild';
 export { default as codebuildWaitForBuild } from '../src/lib/codebuild/waitForBuild';
+export type { BuildResult } from '../src/lib/codebuild/waitForBuild';