@codeyam/codeyam-cli 0.1.0-staging.596f0eb → 0.1.0-staging.6e699e5

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

@@ -1,4 +1,3 @@
-// import { writeFile } from 'node:fs/promises';
 import {
   splitOutsideParenthesesAndArrays,
   joinParenthesesAndArrays,
@@ -22,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 {
@@ -75,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'
@@ -128,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;
@@ -186,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([
@@ -281,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 =
@@ -309,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;
@@ -481,6 +688,47 @@ export default function mergeInDependentDataStructure({
   const mergeAllEquivalentSchemaPaths = () => {
     const mergedEquivalentSchemaPaths: typeof equivalentSchemaPaths = [];
 
+    // Pre-pass: Connect entries with array/array-element relationships.
+    // This handles cases like:
+    // - Entry A has root 'surveys' (array)
+    // - Entry B has root 'surveys[]' (array element)
+    // These need to be connected so Entry B's field postfixes flow to Entry A.
+    // We do this before the main merge to ensure the connection happens regardless
+    // of processing order.
+    for (const esp of equivalentSchemaPaths) {
+      for (const root of esp.equivalentRoots) {
+        if (root.schemaRootPath.endsWith('[]')) {
+          // Find a matching parent entry with the base array path
+          const baseArrayPath = root.schemaRootPath.slice(0, -2);
+          const parentEntry = equivalentSchemaPaths.find(
+            (other) =>
+              other !== esp &&
+              other.equivalentRoots.some(
+                (otherRoot) =>
+                  otherRoot.schemaRootPath === baseArrayPath &&
+                  otherRoot.function?.name === root.function?.name &&
+                  otherRoot.function?.filePath === root.function?.filePath,
+              ),
+          );
+          if (parentEntry) {
+            // Add transformed postfixes from child (array element) to parent (array)
+            // so they can be applied with [] prefix to parent paths
+            for (const [postfixPath, postfixValue] of Object.entries(
+              esp.equivalentPostfixes,
+            )) {
+              const transformedPostfix = joinParenthesesAndArrays(
+                ['[]', postfixPath].filter(Boolean),
+              );
+              if (!(transformedPostfix in parentEntry.equivalentPostfixes)) {
+                parentEntry.equivalentPostfixes[transformedPostfix] =
+                  postfixValue;
+              }
+            }
+          }
+        }
+      }
+    }
+
     const findEquivalentSchemaPathEntry = (
       schemaSubPath: string,
       equivalentRootFunction: (typeof equivalentSchemaPaths)[0]['equivalentRoots'][0]['function'],
@@ -622,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);
     }
   }
 
@@ -885,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,
@@ -962,45 +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];
-        }
-      }
-    }
-  }
-
-  // writeFile(
-  //   'mergeInDependentDataStructure-debug-result.json',
-  //   // rootScopeName,
-  //   JSON.stringify(mergedDataStructure, null, 2),
-  // ).catch(() => {});
-
   return mergedDataStructure;
 }