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

package/packages/analyze/src/lib/files/scenarios/mergeInDependentDataStructure.js

@@ -1,5 +1,6 @@
 import { splitOutsideParenthesesAndArrays, joinParenthesesAndArrays, } from "../../../../../../packages/ai/index.js";
 import { cleanKnownObjectFunctionsFromMapping } from "../../../../../../packages/ai/index.js";
+import { transformationTracer } from "./TransformationTracer.js";
 function cleanFunctionName(functionName) {
     return functionName?.split('<')[0];
 }
@@ -24,6 +25,66 @@ function getTypeParameter(functionName) {
     }
     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) {
+    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) {
+    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) {
+    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, schema) {
+    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, schemaPathPart) {
@@ -38,15 +99,47 @@ function pathPartMatches(pathPart, schemaPathPart) {
 }
 function bestValueFromOptions(options) {
     options = options.filter(Boolean);
-    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)
+    if (notUnknown) {
         return notUnknown;
+    }
     return options[0] ?? 'unknown';
 }
-export default function mergeInDependentDataStructure({ importedExports, dependentAnalyses, rootScopeName, dataStructure, dependencySchemas, }) {
+/** 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 = 2000;
+export class DataStructureTimeoutError extends Error {
+    constructor(entityName, elapsedMs) {
+        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, }) {
+    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 = {
         signatureSchema: { ...(dataStructure.signatureSchema ?? {}) },
         returnValueSchema: { ...(dataStructure.returnValueSchema ?? {}) },
@@ -88,8 +181,32 @@ export default function mergeInDependentDataStructure({ importedExports, depende
         }
     }
     let equivalentSchemaPaths = [];
+    // 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();
+    const espIndexKey = (path, functionName) => {
+        const normalized = cleanFunctionName(functionName);
+        const funcKey = normalized === rootScopeName ? '__self__' : normalized || '__self__';
+        return `${path}::${funcKey}`;
+    };
+    const updateEspIndex = (entry) => {
+        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();
+    for (const dep of importedExports) {
+        const cleanedName = cleanFunctionName(dep.name);
+        if (!dependencyByCleanedName.has(cleanedName)) {
+            dependencyByCleanedName.set(cleanedName, dep);
+        }
+    }
     const findRelevantDependency = (functionName) => {
-        return importedExports.find((d) => cleanFunctionName(d.name) === cleanFunctionName(functionName));
+        return dependencyByCleanedName.get(cleanFunctionName(functionName));
     };
     const findRelevantDependentDataStructure = (functionName) => {
         const dependency = findRelevantDependency(functionName);
@@ -117,10 +234,19 @@ export default function mergeInDependentDataStructure({ importedExports, depende
         });
         return mergedDataStructure.dependencySchemas[filePath][name];
     };
-    const cleanSchema = (schema) => {
-        cleanKnownObjectFunctionsFromMapping(schema);
+    const cleanSchema = (schema, context) => {
+        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();
     const translatePath = (path, dependencyName) => {
+        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) {
@@ -128,36 +254,65 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                     // 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 = (functionName, sourceAndUsageEquivalencies, dataStructure) => {
+        checkDeadline();
         if (!sourceAndUsageEquivalencies)
             return;
+        const normalizedSchemaCache = new Map();
+        const getSchemaIndex = (schema) => {
+            if (!schema)
+                return { byFirstPart: new Map() };
+            const cached = normalizedSchemaCache.get(schema);
+            if (cached)
+                return cached;
+            const byFirstPart = new Map();
+            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 = { 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) => {
             const equivalentRoots = allPaths
                 .filter((p) => p.functionName === rootScopeName ||
@@ -169,19 +324,94 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                     : findRelevantDependency(p.functionName),
             }));
             let equivalentSchemaPathsEntry;
+            // Collect the signature indices from the new roots we want to add
+            const newRootSignatureIndices = new Set();
+            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();
+                    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;
+                    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);
@@ -189,10 +419,18 @@ export default function mergeInDependentDataStructure({ importedExports, depende
             else {
                 equivalentSchemaPathsEntry.equivalentRoots.push(...equivalentRoots);
             }
+            // Deduplicate roots using a Set for O(n) instead of O(n²)
+            const seenRoots = new Set();
             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;
         };
         // Helper to extract function name from a path that starts with a function call.
@@ -218,18 +456,40 @@ export default function mergeInDependentDataStructure({ importedExports, depende
         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 = [
+                const allPathsRaw = [
                     { path: translatedPath, functionName: effectiveFunctionName },
-                    ...usages.map((u) => ({
+                    ...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();
+                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
@@ -248,8 +508,11 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                     p.functionName === rootScopeName ||
                     p.functionName === effectiveFunctionName);
                 const derivedBasePaths = [];
+                const allPathSet = new Set(allPaths.map((p) => p.path));
+                const derivedBasePathSet = new Set();
                 // For each child path, find its equivalent parent path and derive bases
                 for (const childPathInfo of childPaths) {
+                    checkDeadline();
                     const childParts = splitOutsideParenthesesAndArrays(childPathInfo.path);
                     // Look for a parent path that shares a common suffix with this child path
                     for (const parentPathInfo of parentPaths) {
@@ -296,23 +559,23 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                                     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) {
+                                    // 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);
                                     }
                                 }
                             }
@@ -321,7 +584,27 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                 }
                 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
                         ? [
@@ -349,18 +632,17 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                         pathParts = pathParts.slice(1);
                     }
                     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)
@@ -419,13 +701,27 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                                 else {
                                     // Regular exact match - use the standard postfix logic
                                     const postfix = joinParenthesesAndArrays(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,
+                                            },
+                                        });
+                                    }
                                 }
                             }
                         }
@@ -441,6 +737,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
             // where we want both X().functionCallReturnValue and Y().functionCallReturnValue as bases
             const allBasePaths = new Set();
             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++) {
@@ -457,12 +754,17 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                 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;
@@ -474,12 +776,13 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                         continue;
                     }
                     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;
                 }
             }
         }
@@ -494,6 +797,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
         // 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
@@ -506,6 +810,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                         // 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)) {
+                            checkDeadline();
                             const transformedPostfix = joinParenthesesAndArrays(['[]', postfixPath].filter(Boolean));
                             if (!(transformedPostfix in parentEntry.equivalentPostfixes)) {
                                 parentEntry.equivalentPostfixes[transformedPostfix] =
@@ -518,6 +823,8 @@ export default function mergeInDependentDataStructure({ importedExports, depende
         }
         const findEquivalentSchemaPathEntry = (schemaSubPath, equivalentRootFunction) => {
             let postfix;
+            // Get the signature index we're looking for (if any)
+            const lookingForSignatureIndex = extractSignatureIndex(schemaSubPath);
             const equivalentEntry = mergedEquivalentSchemaPaths.find((esp) => esp.equivalentRoots.some((er) => {
                 if ((schemaSubPath.startsWith('returnValue') ||
                     schemaSubPath.startsWith('signature[')) &&
@@ -526,6 +833,26 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                     return false;
                 }
                 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;
                 }
@@ -536,6 +863,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
         const sortedEquivalentSchemaPaths = equivalentSchemaPaths.sort((a, b) => Math.max(...a.equivalentRoots.map((er) => splitOutsideParenthesesAndArrays(er.schemaRootPath).length)) -
             Math.max(...b.equivalentRoots.map((er) => splitOutsideParenthesesAndArrays(er.schemaRootPath).length)));
         for (const esp of sortedEquivalentSchemaPaths) {
+            checkDeadline();
             if (esp.equivalentRoots.length === 0)
                 continue;
             let bestCandidateLength;
@@ -595,6 +923,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
     // 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;
@@ -610,9 +939,65 @@ export default function mergeInDependentDataStructure({ importedExports, depende
             gatherAllEquivalentSchemaPaths(name, childMergedDataStructure);
         }
     }
+    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();
     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();
+        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();
+        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();
+        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();
+        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 = 5000;
+        for (const equivalentRoot of uniqueRoots) {
+            checkDeadline();
             let merged;
             if (equivalentRoot.function) {
                 merged = findOrCreateDependentSchemas(equivalentRoot.function);
@@ -625,25 +1010,124 @@ export default function mergeInDependentDataStructure({ importedExports, depende
             const schema = equivalentRoot.schemaRootPath.startsWith('signature[')
                 ? 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;
                     }
-                    const postFixPathParts = splitOutsideParenthesesAndArrays(postfixPath);
-                    const equivalentRootPostFixParts = splitOutsideParenthesesAndArrays(equivalentRoot.postfix);
+                    // 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);
+                    // 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));
                 }
                 const newSchemaPath = joinParenthesesAndArrays([
                     equivalentRoot.schemaRootPath,
                     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).
@@ -662,6 +1146,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
             const genericVariants = new Set();
             const genericRegex = new RegExp(`^${depName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}<[^>]+>\\(\\)`);
             for (const path in schemaToSearchForGenericVariants) {
+                checkDeadline();
                 const match = path.match(genericRegex);
                 if (match) {
                     genericVariants.add(match[0]);
@@ -673,6 +1158,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
             // create corresponding paths for each generic variant
             const pathsToAdd = [];
             for (const path in returnValueSchema) {
+                checkDeadline();
                 const value = returnValueSchema[path];
                 // Handle returnValue. paths
                 if (path.startsWith('returnValue.')) {
@@ -719,6 +1205,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
         // This includes both returnValue. (dot) and returnValue[ (array) paths.
         const pathsToNormalize = [];
         for (const path in depSchema.returnValueSchema) {
+            checkDeadline();
             if (path === 'returnValue' ||
                 path.startsWith('returnValue.') ||
                 path.startsWith('returnValue[')) {
@@ -740,10 +1227,19 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                 // e.g., returnValue[].label -> getOptions().functionCallReturnValue[].label
                 normalizedPath = path.replace(/^returnValue/, `${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:
             // 'returnValue.foo' -> 'dependencyName().functionCallReturnValue.foo'
@@ -806,7 +1302,10 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                 }
             }
         }
-        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),
         // we need to include that function's signature requirements in the mock.
@@ -871,7 +1370,10 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                 }
             }
         }
-        cleanSchema(depSchema.returnValueSchema);
+        cleanSchema(depSchema.returnValueSchema, {
+            stage: 'afterSignatureRequirementsMerge',
+            dependency: dependency.name,
+        });
     }
     // Process the input dependencySchemas FIRST (before child dependentAnalyses).
     // This ensures the parent entity's direct usage of dependencies takes precedence.
@@ -898,16 +1400,50 @@ export default function mergeInDependentDataStructure({ importedExports, depende
             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];
                 }
                 // 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);
+                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
             // for each type-parameterized variant. This allows gatherDataForMocks to look up
@@ -934,12 +1470,18 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                     });
                     // 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,
+                    });
                 }
             }
         }
@@ -950,6 +1492,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
     // 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;
             if (!dependentMergedDataStructure)
                 continue;
@@ -962,6 +1505,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                 // 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] =
@@ -970,6 +1514,7 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                 }
                 // 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] =
@@ -989,12 +1534,14 @@ export default function mergeInDependentDataStructure({ importedExports, depende
                         });
                         // 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];
@@ -1005,6 +1552,12 @@ export default function mergeInDependentDataStructure({ importedExports, depende
             }
         }
     }
+    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;
 }
 //# sourceMappingURL=mergeInDependentDataStructure.js.map