@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.39719f5

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

@@ -4,6 +4,7 @@ import {
 } from '~codeyam/ai';
 import { cleanKnownObjectFunctionsFromMapping } from '~codeyam/ai';
 import { DataStructure, Entity, ReadonlyAnalysis } from '~codeyam/types';
+import { transformationTracer } from './TransformationTracer';
 
 export interface DataStructureInfo {
   signatureSchema: { [key: string]: string };
@@ -40,6 +41,79 @@ function getTypeParameter(functionName: string): string | null {
   return null;
 }
 
+/**
+ * Check if a schema path contains a Set/Map collection method call.
+ * Paths like `.has(articleId)`, `.delete(articleId)`, `.add(articleId)` represent
+ * membership checks on Sets/Maps, not meaningful data flow for schema generation.
+ * These create massive combinatorial explosions when every filter field (filterRatings,
+ * filterPublications, filterAuthors, etc.) × every method (has, delete, add) gets
+ * tracked as a separate equivalency.
+ */
+const COLLECTION_METHOD_PATTERN = /\.(?:has|delete|add|clear|get|set)\(/;
+function isCollectionMethodPath(path: string): boolean {
+  return COLLECTION_METHOD_PATTERN.test(path);
+}
+
+// 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"
+// Also handles string literal unions like "'suggestion' | 'warning' | 'tip'"
+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
+  // e.g., "'suggestion' | 'warning'" -> string literal union -> true
+  if (typeStr.includes('|')) {
+    const parts = typeStr.split('|').map((p) => p.trim());
+    return parts.every(
+      (part) =>
+        PRIMITIVE_TYPES.has(part) ||
+        // String literal values like 'suggestion', 'warning' are primitives
+        (part.startsWith("'") && part.endsWith("'")),
+    );
+  }
+  return false;
+}
+
+// Extract signature index from a path like "signature[0]" or "signature[0].foo"
+// Returns the index number or undefined if not a signature path
+function extractSignatureIndex(path: string): number | undefined {
+  const match = path.match(/^signature\[(\d+)\]/);
+  return match ? parseInt(match[1], 10) : undefined;
+}
+
+// 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 {
@@ -56,21 +130,51 @@ function pathPartMatches(pathPart: string, schemaPathPart: string): boolean {
 function bestValueFromOptions(options: Array<string | undefined>) {
   options = options.filter(Boolean) as string[];
 
-  const known = options.find((o) => !o.includes('unknown'));
-  if (known) return known;
+  const known = options.filter((o) => !o.includes('unknown'));
+  if (known.length > 0) {
+    // Among known values, prefer string literal unions over bare primitives.
+    // e.g., "'draft' | 'inProgress' | 'paused' | 'completed'" is more specific than "string".
+    // This handles cases where a dependency schema has a bare type like "string" but the
+    // child entity's analysis has the actual literal union from TypeScript type resolution.
+    if (known.length > 1 && known.some((o) => PRIMITIVE_TYPES.has(o))) {
+      const literalUnion = known.find(
+        (o) => !PRIMITIVE_TYPES.has(o) && o.includes("'"),
+      );
+      if (literalUnion) {
+        return literalUnion;
+      }
+    }
+    return known[0];
+  }
 
   const notUnknown = options.find((o) => o !== 'unknown');
-  if (notUnknown) return notUnknown;
+  if (notUnknown) {
+    return notUnknown;
+  }
 
   return options[0] ?? 'unknown';
 }
 
+/** Timeout (ms) for the merge operation. Throws DataStructureTimeoutError if exceeded.
+ *  All successful merges complete in <300ms. Anything exceeding 2s is pathological. */
+const MERGE_TIMEOUT_MS = 2_000;
+
+export class DataStructureTimeoutError extends Error {
+  constructor(entityName: string, elapsedMs: number) {
+    super(
+      `Data structure merge timed out for ${entityName} after ${Math.round(elapsedMs / 1000)}s (limit: ${MERGE_TIMEOUT_MS / 1000}s)`,
+    );
+    this.name = 'DataStructureTimeoutError';
+  }
+}
+
 export default function mergeInDependentDataStructure({
   importedExports,
   dependentAnalyses,
   rootScopeName,
   dataStructure,
   dependencySchemas,
+  timeoutMs = MERGE_TIMEOUT_MS,
 }: {
   importedExports: Pick<
     Entity['metadata']['importedExports'][0],
@@ -92,7 +196,23 @@ export default function mergeInDependentDataStructure({
       [name: string]: DataStructureInfo;
     };
   };
+  /** Override the default timeout (ms). Set to 0 to disable. */
+  timeoutMs?: number;
 }) {
+  const mergeStartTime = Date.now();
+  const mergeDeadline = timeoutMs > 0 ? mergeStartTime + timeoutMs : 0;
+
+  /** Call in hot loops. Throws DataStructureTimeoutError if deadline exceeded.
+   *  Date.now() is ~20ns — negligible vs the ms-scale string ops in each iteration. */
+  const checkDeadline = () => {
+    if (!mergeDeadline) return;
+    if (Date.now() > mergeDeadline) {
+      throw new DataStructureTimeoutError(
+        rootScopeName,
+        Date.now() - mergeStartTime,
+      );
+    }
+  };
   const mergedDataStructure: Omit<
     DataStructure,
     'equivalentSignatureVariables'
@@ -152,10 +272,38 @@ export default function mergeInDependentDataStructure({
     equivalentPostfixes: Record<string, string>;
   }[] = [];
 
+  // O(1) index for findOrCreateEquivalentSchemaPathsEntry.
+  // Maps "(rootPath)::(normalizedFuncName)" → the entry containing that root.
+  // This replaces the O(E) linear search that was causing O(E²) gather performance.
+  const espIndex = new Map<string, (typeof equivalentSchemaPaths)[0]>();
+  const espIndexKey = (path: string, functionName: string | undefined) => {
+    const normalized = cleanFunctionName(functionName);
+    const funcKey =
+      normalized === rootScopeName ? '__self__' : normalized || '__self__';
+    return `${path}::${funcKey}`;
+  };
+  const updateEspIndex = (entry: (typeof equivalentSchemaPaths)[0]) => {
+    for (const root of entry.equivalentRoots) {
+      const funcName = root.function?.name ?? rootScopeName;
+      espIndex.set(espIndexKey(root.schemaRootPath, funcName), entry);
+    }
+  };
+
+  // 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) => {
@@ -192,11 +340,30 @@ export default function mergeInDependentDataStructure({
     return mergedDataStructure.dependencySchemas[filePath][name];
   };
 
-  const cleanSchema = (schema: { [key: string]: string }) => {
-    cleanKnownObjectFunctionsFromMapping(schema);
+  const cleanSchema = (
+    schema: { [key: string]: string },
+    context?: Record<string, any>,
+  ) => {
+    transformationTracer.traceSchemaTransform(
+      rootScopeName,
+      'cleanKnownObjectFunctionsFromMapping',
+      schema,
+      cleanKnownObjectFunctionsFromMapping,
+      context,
+    );
   };
 
+  // Cache translatePath results — the same path is often translated multiple times
+  // (once per equivalency entry that references it). Avoids redundant
+  // splitOutsideParenthesesAndArrays calls on long paths.
+  const translatePathCache = new Map<string, string>();
+
   const translatePath = (path: string, dependencyName: string) => {
+    const cacheKey = `${dependencyName}\0${path}`;
+    const cached = translatePathCache.get(cacheKey);
+    if (cached !== undefined) return cached;
+
+    let result = path;
     if (path.startsWith(dependencyName)) {
       const pathParts = splitOutsideParenthesesAndArrays(path);
       if (pathParts.length > 1) {
@@ -204,33 +371,26 @@ export default function mergeInDependentDataStructure({
           // 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
+          if (!functionsWithMultipleTypeParams.has(baseName)) {
+            // functionCallReturnValue immediately follows - normalize to returnValue
+            result = joinParenthesesAndArrays([
+              'returnValue',
+              ...pathParts.slice(2),
+            ]);
           }
-          // functionCallReturnValue immediately follows - normalize to returnValue
-          // e.g., useAuth().functionCallReturnValue.user -> returnValue.user
-          return joinParenthesesAndArrays([
-            'returnValue',
-            ...pathParts.slice(2),
-          ]);
         } else if (
           pathParts[0].endsWith(')') &&
           pathParts[1].startsWith('signature[')
         ) {
-          // Hook-style with signature access (e.g., BranchChangesTab().signature[0]...)
-          // Strip the function name for signature equivalency matching
-          return joinParenthesesAndArrays(pathParts.slice(1));
+          // Hook-style with signature access
+          result = joinParenthesesAndArrays(pathParts.slice(1));
         }
-        // For all other cases (object-style APIs like getSupabase().auth and
-        // direct object references like supabase.from), preserve the path as-is.
-        // The prefix must be kept for proper schema lookups in constructMockCode
-        // and gatherDataForMocks.
       }
     }
-    return path;
+
+    translatePathCache.set(cacheKey, result);
+    return result;
   };
 
   const gatherAllEquivalentSchemaPaths = (
@@ -244,8 +404,58 @@ export default function mergeInDependentDataStructure({
       'signatureSchema' | 'returnValueSchema'
     >,
   ) => {
+    checkDeadline();
     if (!sourceAndUsageEquivalencies) return;
 
+    // Pre-computed normalized schema index cache.
+    // Avoids repeated splitOutsideParenthesesAndArrays calls and function-name
+    // normalization for the same schema paths across multiple equivalency iterations.
+    // The normalization depends on `functionName` (constant per gatherAllEquivalentSchemaPaths call),
+    // so this cache is scoped to this call.
+    type NormalizedEntry = { path: string; parts: string[] };
+    const normalizedSchemaCache = new Map<
+      object,
+      {
+        byFirstPart: Map<string, NormalizedEntry[]>;
+      }
+    >();
+    const getSchemaIndex = (
+      schema: Record<string, string> | undefined,
+    ): { byFirstPart: Map<string, NormalizedEntry[]> } => {
+      if (!schema) return { byFirstPart: new Map() };
+      const cached = normalizedSchemaCache.get(schema);
+      if (cached) return cached;
+      const byFirstPart = new Map<string, NormalizedEntry[]>();
+      for (const path in schema) {
+        checkDeadline();
+        let parts = splitOutsideParenthesesAndArrays(path);
+        if (parts[0].startsWith(functionName)) {
+          const baseName = cleanFunctionName(parts[0]);
+          if (!functionsWithMultipleTypeParams.has(baseName)) {
+            parts =
+              parts[1] === 'functionCallReturnValue'
+                ? ['returnValue', ...parts.slice(2)]
+                : parts.slice(1);
+          }
+        }
+        const entry: NormalizedEntry = { path, parts };
+        // Index by the base of the first part (before any function call args)
+        const firstPart = parts[0] ?? '';
+        const parenIdx = firstPart.indexOf('(');
+        const firstPartBase =
+          parenIdx >= 0 ? firstPart.slice(0, parenIdx) : firstPart;
+        let bucket = byFirstPart.get(firstPartBase);
+        if (!bucket) {
+          bucket = [];
+          byFirstPart.set(firstPartBase, bucket);
+        }
+        bucket.push(entry);
+      }
+      const result = { byFirstPart };
+      normalizedSchemaCache.set(schema, result);
+      return result;
+    };
+
     const findOrCreateEquivalentSchemaPathsEntry = (
       allPaths: { path: string; functionName?: string }[],
     ) => {
@@ -266,41 +476,122 @@ export default function mergeInDependentDataStructure({
       let equivalentSchemaPathsEntry:
         | (typeof equivalentSchemaPaths)[0]
         | undefined;
+
+      // Collect the signature indices from the new roots we want to add
+      const newRootSignatureIndices = new Set<number>();
+      for (const root of equivalentRoots) {
+        const idx = extractSignatureIndex(root.schemaRootPath);
+        if (idx !== undefined) {
+          newRootSignatureIndices.add(idx);
+        }
+      }
+
+      // Use espIndex Map for O(1) lookup instead of O(E) linear search.
+      // Falls back to linear search only when Map hit has a signature index conflict.
       for (const pathInfo of allPaths) {
-        if (!equivalentSchemaPathsEntry) {
-          equivalentSchemaPathsEntry = equivalentSchemaPaths.find((esp) =>
-            esp.equivalentRoots.some(
-              (er) =>
-                er.schemaRootPath === pathInfo.path &&
-                (er.function?.name ===
-                  cleanFunctionName(pathInfo.functionName) ||
-                  (!er.function &&
-                    cleanFunctionName(pathInfo.functionName) ===
-                      rootScopeName)),
-            ),
-          );
+        checkDeadline();
+        if (equivalentSchemaPathsEntry) break;
+        const candidate = espIndex.get(
+          espIndexKey(pathInfo.path, pathInfo.functionName),
+        );
+        if (!candidate) continue;
+
+        // Verify no signature index conflict with the candidate entry
+        if (newRootSignatureIndices.size > 0) {
+          const existingIndicesByFunction = new Map<string, Set<number>>();
+          for (const er of candidate.equivalentRoots) {
+            const funcKey = er.function
+              ? `${er.function.name}::${er.function.filePath}`
+              : '__self__';
+            const idx = extractSignatureIndex(er.schemaRootPath);
+            if (idx !== undefined) {
+              if (!existingIndicesByFunction.has(funcKey)) {
+                existingIndicesByFunction.set(funcKey, new Set());
+              }
+              existingIndicesByFunction.get(funcKey)!.add(idx);
+            }
+          }
+
+          let hasConflict = false;
+          for (const newRoot of equivalentRoots) {
+            const funcKey = newRoot.function
+              ? `${newRoot.function.name}::${newRoot.function.filePath}`
+              : '__self__';
+            const newIdx = extractSignatureIndex(newRoot.schemaRootPath);
+            if (newIdx !== undefined) {
+              const existingIndices = existingIndicesByFunction.get(funcKey);
+              if (existingIndices && existingIndices.size > 0) {
+                if (!existingIndices.has(newIdx)) {
+                  hasConflict = true;
+                  break;
+                }
+              }
+            }
+          }
+
+          if (hasConflict) continue;
         }
+
+        equivalentSchemaPathsEntry = candidate;
       }
 
       if (!equivalentSchemaPathsEntry) {
+        // Before creating a new entry, filter out roots that have conflicting
+        // signature indices from the same function. An entry should never contain
+        // roots with different signature indices from the same function.
+        // This prevents the bug where signature[1], signature[2], signature[4]
+        // all get merged together due to incorrect sourceEquivalencies.
+        let filteredRoots = equivalentRoots;
+        if (newRootSignatureIndices.size > 1) {
+          // There are multiple signature indices - we need to filter to keep only
+          // one consistent set. We'll keep the roots that match the PRIMARY index
+          // (the first signature index we encounter from self, or the lowest index).
+
+          // First, determine the primary index - prefer the self root's index
+          let primaryIndex: number | undefined;
+          for (const root of equivalentRoots) {
+            if (!root.function) {
+              // This is a self root
+              const idx = extractSignatureIndex(root.schemaRootPath);
+              if (idx !== undefined) {
+                primaryIndex = idx;
+                break;
+              }
+            }
+          }
+          // If no self root has a signature index, use the lowest index
+          if (primaryIndex === undefined) {
+            primaryIndex = Math.min(...newRootSignatureIndices);
+          }
+
+          // Filter roots: keep if no signature index OR signature index matches primary
+          filteredRoots = equivalentRoots.filter((root) => {
+            const idx = extractSignatureIndex(root.schemaRootPath);
+            return idx === undefined || idx === primaryIndex;
+          });
+        }
+
         equivalentSchemaPathsEntry = {
-          equivalentRoots,
+          equivalentRoots: filteredRoots,
           equivalentPostfixes: {},
         };
         equivalentSchemaPaths.push(equivalentSchemaPathsEntry);
       } 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;
+        });
+
+      // Keep the espIndex in sync after adding/deduplicating roots
+      updateEspIndex(equivalentSchemaPathsEntry);
 
       return equivalentSchemaPathsEntry;
     };
@@ -330,20 +621,43 @@ export default function mergeInDependentDataStructure({
     for (const equivalencies of allEquivalencies) {
       const schemaPathEntries = Object.entries(equivalencies);
       for (const [schemaPath, usages] of schemaPathEntries) {
+        checkDeadline();
+
+        // Skip equivalency entries whose source path is a Set/Map membership operation.
+        // Patterns like `.has(articleId)`, `.delete(articleId)`, `.add(articleId)` on
+        // Sets/Maps represent membership checks, not meaningful data flow for schema generation.
+        // In the Margo LibraryPage case, these account for 74% of all equivalency targets
+        // (19,444 of 26,340) and cause a combinatorial explosion in the merge.
+        if (isCollectionMethodPath(schemaPath)) continue;
+
         // 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 }[] = [
+        const allPathsRaw: { path: string; functionName?: string }[] = [
           { path: translatedPath, functionName: effectiveFunctionName },
-          ...usages.map((u) => ({
-            path: translatePath(u.schemaPath, u.scopeNodeName),
-            functionName: u.scopeNodeName,
-          })),
+          ...usages
+            .filter((u) => !isCollectionMethodPath(u.schemaPath))
+            .map((u) => ({
+              path: translatePath(u.schemaPath, u.scopeNodeName),
+              functionName: u.scopeNodeName,
+            })),
         ].filter((pathInfo) => !pathInfo.path.includes('.map('));
 
+        // Deduplicate by translated path + function name.
+        // Multiple call variants (e.g., loadView(viewKey(null,null)) vs loadView(viewKey(newTag,newCol)))
+        // translate to the same path after stripping arguments. Processing duplicates
+        // creates O(n²) work in the schema matching loops below.
+        const seenPathKeys = new Set<string>();
+        const allPaths = allPathsRaw.filter((p) => {
+          const key = `${p.functionName ?? ''}::${p.path}`;
+          if (seenPathKeys.has(key)) return false;
+          seenPathKeys.add(key);
+          return true;
+        });
+
         // Fix 38: Derive base paths from property access paths.
         // When we have equivalent paths like:
         //   Parent: signature[0].scenarios[].name
@@ -370,9 +684,12 @@ export default function mergeInDependentDataStructure({
         );
 
         const derivedBasePaths: { path: string; functionName?: string }[] = [];
+        const allPathSet = new Set(allPaths.map((p) => p.path));
+        const derivedBasePathSet = new Set<string>();
 
         // For each child path, find its equivalent parent path and derive bases
         for (const childPathInfo of childPaths) {
+          checkDeadline();
           const childParts = splitOutsideParenthesesAndArrays(
             childPathInfo.path,
           );
@@ -446,26 +763,28 @@ export default function mergeInDependentDataStructure({
                   !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) {
+                  // Add child base if not already present (O(1) Set lookup)
+                  if (
+                    !allPathSet.has(childBase) &&
+                    !derivedBasePathSet.has(childBase)
+                  ) {
                     derivedBasePaths.push({
                       path: childBase,
                       functionName: childPathInfo.functionName,
                     });
+                    derivedBasePathSet.add(childBase);
                   }
 
-                  // Add parent base if not already present
-                  const parentBaseExists =
-                    allPaths.some((p) => p.path === parentBase) ||
-                    derivedBasePaths.some((p) => p.path === parentBase);
-                  if (!parentBaseExists) {
+                  // Add parent base if not already present (O(1) Set lookup)
+                  if (
+                    !allPathSet.has(parentBase) &&
+                    !derivedBasePathSet.has(parentBase)
+                  ) {
                     derivedBasePaths.push({
                       path: parentBase,
                       functionName: parentPathInfo.functionName,
                     });
+                    derivedBasePathSet.add(parentBase);
                   }
                 }
               }
@@ -476,7 +795,28 @@ export default function mergeInDependentDataStructure({
         allPaths.push(...derivedBasePaths);
 
         const entry = findOrCreateEquivalentSchemaPathsEntry(allPaths);
+
+        // Trace equivalency gathering - helps debug why paths may not be connected
+        if (allPaths.length > 1) {
+          transformationTracer.operation(rootScopeName, {
+            operation: 'gatherEquivalency',
+            stage: 'gathering',
+            path: translatedPath,
+            context: {
+              sourceFunction: functionName,
+              equivalentPaths: allPaths.map((p) => ({
+                path: p.path,
+                function: p.functionName,
+              })),
+              equivalentRoots: entry.equivalentRoots.map((r) => ({
+                path: r.schemaRootPath,
+                function: r.function?.name,
+              })),
+            },
+          });
+        }
         for (const equivalentRoot of entry.equivalentRoots) {
+          checkDeadline();
           const dataStructures =
             equivalentRoot.function &&
             equivalentRoot.function.name !== rootScopeName
@@ -523,21 +863,21 @@ export default function mergeInDependentDataStructure({
           }
 
           for (const schema of schemas) {
-            for (const schemaPath in schema) {
-              let schemaPathParts =
-                splitOutsideParenthesesAndArrays(schemaPath);
-
-              if (schemaPathParts[0].startsWith(functionName)) {
-                // 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);
-                }
-              }
-
+            // Use pre-computed index to only iterate schema entries whose
+            // normalized first part matches pathParts[0], instead of all entries.
+            const schemaIndex = getSchemaIndex(schema);
+            const lookupPart = pathParts[0] ?? '';
+            const lookupParenIdx = lookupPart.indexOf('(');
+            const lookupBase =
+              lookupParenIdx >= 0
+                ? lookupPart.slice(0, lookupParenIdx)
+                : lookupPart;
+            const candidates = schemaIndex.byFirstPart.get(lookupBase) || [];
+            for (const {
+              path: schemaPath,
+              parts: schemaPathParts,
+            } of candidates) {
+              checkDeadline();
               if (schemaPathParts.length < pathParts.length) continue;
 
               // Check if all path parts match (allowing function call variants)
@@ -606,13 +946,29 @@ export default function mergeInDependentDataStructure({
                     schemaPathParts.slice(matchedUpToIndex),
                   );
 
-                  entry.equivalentPostfixes[postfix] = entry
-                    .equivalentPostfixes[postfix]
-                    ? bestValueFromOptions([
-                        entry.equivalentPostfixes[postfix],
-                        schema[schemaPath],
-                      ])
-                    : schema[schemaPath];
+                  const previousValue = entry.equivalentPostfixes[postfix];
+                  const newValue = schema[schemaPath];
+                  entry.equivalentPostfixes[postfix] = previousValue
+                    ? bestValueFromOptions([previousValue, newValue])
+                    : newValue;
+
+                  // Trace postfix gathering - shows where type info comes from
+                  if (entry.equivalentPostfixes[postfix] !== previousValue) {
+                    transformationTracer.operation(rootScopeName, {
+                      operation: 'gatherPostfix',
+                      stage: 'gathering',
+                      path: postfix || '(root)',
+                      before: previousValue,
+                      after: entry.equivalentPostfixes[postfix],
+                      context: {
+                        sourceSchemaPath: schemaPath,
+                        sourceFunction:
+                          equivalentRoot.function?.name || rootScopeName,
+                        equivalentRootPath: equivalentRoot.schemaRootPath,
+                        rawValue: newValue,
+                      },
+                    });
+                  }
                 }
               }
             }
@@ -629,6 +985,7 @@ export default function mergeInDependentDataStructure({
       // where we want both X().functionCallReturnValue and Y().functionCallReturnValue as bases
       const allBasePaths = new Set<string>();
       for (const path of Object.keys(dataStructure.returnValueSchema)) {
+        checkDeadline();
         const parts = splitOutsideParenthesesAndArrays(path);
         // Find all positions of functionCallReturnValue and create base paths for each
         for (let i = 0; i < parts.length; i++) {
@@ -649,13 +1006,21 @@ export default function mergeInDependentDataStructure({
         const entry = findOrCreateEquivalentSchemaPathsEntry([
           { path: translatedBasePath, functionName: functionName },
         ]);
-        entry.equivalentRoots.push({
+        const newRoot = {
           schemaRootPath: translatedBasePath,
           function: findRelevantDependency(functionName),
-        });
+        };
+        entry.equivalentRoots.push(newRoot);
+        // Update index for the newly added root
+        const newRootFuncName = newRoot.function?.name ?? rootScopeName;
+        espIndex.set(
+          espIndexKey(newRoot.schemaRootPath, newRootFuncName),
+          entry,
+        );
 
         const basePathParts = splitOutsideParenthesesAndArrays(basePath);
         for (const schemaPath in dataStructure.returnValueSchema) {
+          checkDeadline();
           const schemaPathParts = splitOutsideParenthesesAndArrays(schemaPath);
           if (schemaPathParts.length < basePathParts.length) continue;
 
@@ -672,14 +1037,14 @@ export default function mergeInDependentDataStructure({
           const postfix = joinParenthesesAndArrays(
             schemaPathParts.slice(basePathParts.length),
           );
-          entry.equivalentPostfixes[postfix] = entry.equivalentPostfixes[
-            postfix
-          ]
+          const newValue = entry.equivalentPostfixes[postfix]
             ? bestValueFromOptions([
                 entry.equivalentPostfixes[postfix],
                 dataStructure.returnValueSchema[schemaPath],
               ])
             : dataStructure.returnValueSchema[schemaPath];
+
+          entry.equivalentPostfixes[postfix] = newValue;
         }
       }
     }
@@ -696,6 +1061,7 @@ export default function mergeInDependentDataStructure({
     // We do this before the main merge to ensure the connection happens regardless
     // of processing order.
     for (const esp of equivalentSchemaPaths) {
+      checkDeadline();
       for (const root of esp.equivalentRoots) {
         if (root.schemaRootPath.endsWith('[]')) {
           // Find a matching parent entry with the base array path
@@ -716,6 +1082,7 @@ export default function mergeInDependentDataStructure({
             for (const [postfixPath, postfixValue] of Object.entries(
               esp.equivalentPostfixes,
             )) {
+              checkDeadline();
               const transformedPostfix = joinParenthesesAndArrays(
                 ['[]', postfixPath].filter(Boolean),
               );
@@ -734,6 +1101,10 @@ export default function mergeInDependentDataStructure({
       equivalentRootFunction: (typeof equivalentSchemaPaths)[0]['equivalentRoots'][0]['function'],
     ) => {
       let postfix: string | undefined;
+
+      // Get the signature index we're looking for (if any)
+      const lookingForSignatureIndex = extractSignatureIndex(schemaSubPath);
+
       const equivalentEntry = mergedEquivalentSchemaPaths.find((esp) =>
         esp.equivalentRoots.some((er) => {
           if (
@@ -746,6 +1117,35 @@ export default function mergeInDependentDataStructure({
           }
 
           if (schemaSubPath === er.schemaRootPath) {
+            // Additional check: if we're looking for a signature path, make sure
+            // the entry doesn't already have DIFFERENT signature indices.
+            // This prevents entries with signature[1], signature[2], signature[4]
+            // from all being merged together.
+            if (lookingForSignatureIndex !== undefined) {
+              const hasConflictingSignatureIndex = esp.equivalentRoots.some(
+                (otherRoot) => {
+                  // Only check roots from the same function
+                  if (
+                    otherRoot.function?.name !== equivalentRootFunction?.name ||
+                    otherRoot.function?.filePath !==
+                      equivalentRootFunction?.filePath
+                  ) {
+                    return false;
+                  }
+                  const otherIndex = extractSignatureIndex(
+                    otherRoot.schemaRootPath,
+                  );
+                  return (
+                    otherIndex !== undefined &&
+                    otherIndex !== lookingForSignatureIndex
+                  );
+                },
+              );
+              if (hasConflictingSignatureIndex) {
+                return false;
+              }
+            }
+
             postfix = er.postfix;
             return true;
           }
@@ -772,6 +1172,7 @@ export default function mergeInDependentDataStructure({
     );
 
     for (const esp of sortedEquivalentSchemaPaths) {
+      checkDeadline();
       if (esp.equivalentRoots.length === 0) continue;
       let bestCandidateLength: number | undefined;
       let bestCandidate: (typeof equivalentSchemaPaths)[0] | undefined;
@@ -853,6 +1254,7 @@ export default function mergeInDependentDataStructure({
   // dependencySchemas contains usage information (how dependencies are called),
   // not internal implementation, so we want this for mocked dependencies too
   for (const dependency of importedExports) {
+    checkDeadline();
     const dependentDataStructure =
       dependencySchemas?.[dependency.filePath]?.[dependency.name];
     if (!dependentDataStructure) continue;
@@ -877,10 +1279,75 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  const gatherElapsed = Date.now() - mergeStartTime;
+
   equivalentSchemaPaths = mergeAllEquivalentSchemaPaths();
 
+  const mergeEspElapsed = Date.now() - mergeStartTime;
+
+  // Collect schemas that need cleaning — batch the calls for the end instead of
+  // calling cleanSchema inside the inner root loop (which was O(roots * schemaSize)).
+  const schemasToClean = new Set<{ [key: string]: string }>();
+
   for (const esp of equivalentSchemaPaths) {
-    for (const equivalentRoot of esp.equivalentRoots) {
+    checkDeadline();
+    // 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);
+
+    // Pre-parse ALL postfix paths once. These parsed parts are reused in:
+    // 1. The children detection loop below
+    // 2. The inner postfix application loop (lines that split postfixPath and equivalentRoot.postfix)
+    // This eliminates thousands of redundant splitOutsideParenthesesAndArrays calls.
+    const postfixPartsCache = new Map<string, string[]>();
+    for (const postfixPath of postfixKeys) {
+      if (!postfixPath) continue;
+      postfixPartsCache.set(
+        postfixPath,
+        splitOutsideParenthesesAndArrays(postfixPath),
+      );
+    }
+
+    // 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 = postfixPartsCache.get(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;
+    });
+
+    // Cap schema size to prevent combinatorial explosion.
+    // Successful merges produce <3K ret keys. Beyond 5K, further postfixes
+    // add noise but no useful data — they're cross-products of unrelated equivalencies.
+    const SCHEMA_KEY_CAP = 5_000;
+
+    for (const equivalentRoot of uniqueRoots) {
+      checkDeadline();
       let merged:
         | {
             signatureSchema: { [key: string]: string };
@@ -900,20 +1367,44 @@ export default function mergeInDependentDataStructure({
         ? merged.signatureSchema
         : merged.returnValueSchema;
 
+      // Skip if this schema has already grown past the cap
+      if (Object.keys(schema).length > SCHEMA_KEY_CAP) continue;
+
       for (const [postfixPath, postfixValue] of Object.entries(
         esp.equivalentPostfixes,
       )) {
+        checkDeadline();
         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 =
+            postfixPartsCache.get(postfixPath) ??
             splitOutsideParenthesesAndArrays(postfixPath);
-          const equivalentRootPostFixParts = splitOutsideParenthesesAndArrays(
+          // Cache equivalentRoot.postfix parts — same root reused across all postfixes
+          if (!postfixPartsCache.has(equivalentRoot.postfix)) {
+            postfixPartsCache.set(
+              equivalentRoot.postfix,
+              splitOutsideParenthesesAndArrays(equivalentRoot.postfix),
+            );
+          }
+          const equivalentRootPostFixParts = postfixPartsCache.get(
             equivalentRoot.postfix,
-          );
+          )!;
           relevantPostfix = joinParenthesesAndArrays(
             postFixPathParts.slice(equivalentRootPostFixParts.length),
           );
@@ -924,13 +1415,102 @@ 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)) {
+          transformationTracer.operation(rootScopeName, {
+            operation: 'skipPrimitivePath',
+            stage: 'merged',
+            path: newSchemaPath,
+            context: {
+              reason: 'would go through primitive type',
+              postfixValue,
+            },
+          });
+          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')
+          ) {
+            transformationTracer.operation(rootScopeName, {
+              operation: 'skipTypeDowngrade',
+              stage: 'merged',
+              path: newSchemaPath,
+              context: {
+                reason: 'would overwrite primitive with object/array',
+                existingType,
+                newType: postfixValue,
+              },
+            });
+            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)
+          ) {
+            transformationTracer.operation(rootScopeName, {
+              operation: 'skipTypeDowngrade',
+              stage: 'merged',
+              path: newSchemaPath,
+              context: {
+                reason: 'would overwrite complex type with primitive',
+                existingType,
+                newType: postfixValue,
+              },
+            });
+            continue;
+          }
+        }
+
+        // Log the successful postfix merge
+        transformationTracer.operation(rootScopeName, {
+          operation: 'mergePostfix',
+          stage: 'merged',
+          path: newSchemaPath,
+          before: existingType,
+          after: postfixValue,
+          context: {
+            schemaRootPath: equivalentRoot.schemaRootPath,
+            postfix: relevantPostfix,
+            dependency: equivalentRoot.function?.name,
+          },
+        });
         schema[newSchemaPath] = postfixValue;
       }
 
-      cleanSchema(schema);
+      schemasToClean.add(schema);
     }
   }
 
+  const postfixElapsed = Date.now() - mergeStartTime;
+
+  // Batch-clean all modified schemas once (instead of once per root per ESP entry)
+  for (const schema of schemasToClean) {
+    cleanSchema(schema, { stage: 'afterMergePostfix' });
+  }
+
+  const cleanElapsed = Date.now() - mergeStartTime;
+
   // Propagate equivalency-derived attributes to generic function call variants.
   // When attributes are traced via equivalencies (e.g., fileComparisons from buildDataMap.signature[2]),
   // they get written to non-generic paths (returnValue.data.x or funcName().functionCallReturnValue.data.x).
@@ -956,6 +1536,7 @@ export default function mergeInDependentDataStructure({
       );
 
       for (const path in schemaToSearchForGenericVariants) {
+        checkDeadline();
         const match = path.match(genericRegex);
         if (match) {
           genericVariants.add(match[0]);
@@ -969,6 +1550,7 @@ export default function mergeInDependentDataStructure({
       const pathsToAdd: [string, string][] = [];
 
       for (const path in returnValueSchema) {
+        checkDeadline();
         const value = returnValueSchema[path];
 
         // Handle returnValue. paths
@@ -1022,6 +1604,7 @@ export default function mergeInDependentDataStructure({
     // This includes both returnValue. (dot) and returnValue[ (array) paths.
     const pathsToNormalize: [string, string][] = [];
     for (const path in depSchema.returnValueSchema) {
+      checkDeadline();
       if (
         path === 'returnValue' ||
         path.startsWith('returnValue.') ||
@@ -1049,11 +1632,20 @@ export default function mergeInDependentDataStructure({
           `${dependency.name}().functionCallReturnValue`,
         );
       }
+      transformationTracer.operation(rootScopeName, {
+        operation: 'normalizeReturnValuePath',
+        stage: 'merged',
+        path: normalizedPath,
+        before: path,
+        after: normalizedPath,
+        context: { dependency: dependency.name, value },
+      });
       depSchema.returnValueSchema[normalizedPath] = value;
     }
 
     // Now copy paths from the source schema (dependencySchemas)
     for (const path in srcSchema.returnValueSchema) {
+      checkDeadline();
       const value = srcSchema.returnValueSchema[path];
 
       // Normalize paths starting with 'returnValue' to use the standard format:
@@ -1133,7 +1725,10 @@ export default function mergeInDependentDataStructure({
       }
     }
 
-    cleanSchema(depSchema.returnValueSchema);
+    cleanSchema(depSchema.returnValueSchema, {
+      stage: 'afterMockedDependencyMerge',
+      dependency: dependency.name,
+    });
 
     // 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),
@@ -1210,7 +1805,10 @@ export default function mergeInDependentDataStructure({
       }
     }
 
-    cleanSchema(depSchema.returnValueSchema);
+    cleanSchema(depSchema.returnValueSchema, {
+      stage: 'afterSignatureRequirementsMerge',
+      dependency: dependency.name,
+    });
   }
 
   // Process the input dependencySchemas FIRST (before child dependentAnalyses).
@@ -1241,9 +1839,11 @@ export default function mergeInDependentDataStructure({
       if (!existingSchema) {
         const depSchema = findOrCreateDependentSchemas({ filePath, name });
         for (const path in srcSchema.returnValueSchema) {
+          checkDeadline();
           depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
         }
         for (const path in srcSchema.signatureSchema) {
+          checkDeadline();
           depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
         }
 
@@ -1251,7 +1851,46 @@ export default function mergeInDependentDataStructure({
         // 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);
+        cleanSchema(depSchema.returnValueSchema, {
+          stage: 'afterDependencySchemaCopy',
+          filePath,
+          dependency: name,
+        });
+      }
+
+      // 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) {
+          checkDeadline();
+          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
@@ -1283,12 +1922,18 @@ export default function mergeInDependentDataStructure({
 
           // Copy only paths that belong to this variant
           for (const path in srcSchema.returnValueSchema) {
+            checkDeadline();
             if (path.startsWith(variant)) {
               variantSchema.returnValueSchema[path] =
                 srcSchema.returnValueSchema[path];
             }
           }
-          cleanSchema(variantSchema.returnValueSchema);
+          cleanSchema(variantSchema.returnValueSchema, {
+            stage: 'afterTypeVariantCopy',
+            filePath,
+            dependency: name,
+            variant,
+          });
         }
       }
     }
@@ -1300,6 +1945,7 @@ export default function mergeInDependentDataStructure({
   // EXCEPT: Skip mocked dependencies - we don't want their internal implementation details.
   for (const filePath in dependentAnalyses) {
     for (const name in dependentAnalyses[filePath]) {
+      checkDeadline();
       const dependentMergedDataStructure =
         dependentAnalyses[filePath][name].metadata?.mergedDataStructure;
 
@@ -1316,6 +1962,7 @@ export default function mergeInDependentDataStructure({
         // Copy over all paths from the dependent's returnValueSchema
         // Only add paths that don't already exist (don't overwrite values set by equivalencies)
         for (const path in dependentMergedDataStructure.returnValueSchema) {
+          checkDeadline();
           const translatedPath = translatePath(path, name);
           if (!(translatedPath in depSchema.returnValueSchema)) {
             depSchema.returnValueSchema[translatedPath] =
@@ -1325,6 +1972,7 @@ export default function mergeInDependentDataStructure({
 
         // Copy over signature schema as well
         for (const path in dependentMergedDataStructure.signatureSchema) {
+          checkDeadline();
           const translatedPath = translatePath(path, name);
           if (!(translatedPath in depSchema.signatureSchema)) {
             depSchema.signatureSchema[translatedPath] =
@@ -1351,13 +1999,15 @@ export default function mergeInDependentDataStructure({
 
             // Merge in the nested dependency schemas
             for (const path in nestedDepSchema.returnValueSchema) {
+              checkDeadline();
               if (!(path in targetDepSchema.returnValueSchema)) {
-                targetDepSchema.returnValueSchema[path] =
-                  nestedDepSchema.returnValueSchema[path];
+                const value = nestedDepSchema.returnValueSchema[path];
+                targetDepSchema.returnValueSchema[path] = value;
               }
             }
 
             for (const path in nestedDepSchema.signatureSchema) {
+              checkDeadline();
               if (!(path in targetDepSchema.signatureSchema)) {
                 targetDepSchema.signatureSchema[path] =
                   nestedDepSchema.signatureSchema[path];
@@ -1369,5 +2019,15 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  const totalElapsed = Date.now() - mergeStartTime;
+  const retKeys = Object.keys(mergedDataStructure.returnValueSchema).length;
+
+  // Only log phase breakdown for slow merges (>2s)
+  if (totalElapsed > 2000) {
+    console.log(
+      `CodeYam Log Level 2: ${rootScopeName} merge phases: gather=${gatherElapsed}ms mergeESP=${mergeEspElapsed - gatherElapsed}ms postfix=${postfixElapsed - mergeEspElapsed}ms clean=${cleanElapsed - postfixElapsed}ms depCopy=${totalElapsed - cleanElapsed}ms total=${totalElapsed}ms ret=${retKeys}`,
+    );
+  }
+
   return mergedDataStructure;
 }