@codeyam/codeyam-cli 0.1.0-staging.09652b8 → 0.1.0-staging.0a69043

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

@@ -1,20 +1,19 @@
-import { convertDotNotation, fillInDirectSchemaGapsAndUnknowns, deduplicateFunctionSchemas, clearAttributesFromMapping, } from "../../../../../../packages/ai/index.js";
-import mergeInDependentDataStructure from "./mergeInDependentDataStructure.js";
-import { awsLog } from "../../../../../../packages/utils/index.js";
+import { convertDotNotation, fillInDirectSchemaGapsAndUnknowns, deduplicateFunctionSchemas, clearAttributesFromMapping, mergeJsonTypeDefinitions, } from "../../../../../../packages/ai/index.js";
+import mergeInDependentDataStructure, { DataStructureTimeoutError, } from "./mergeInDependentDataStructure.js";
+import { awsLog, awsLogDebugLevel } from "../../../../../../packages/utils/index.js";
 import gatherDataForMocks from "./gatherDataForMocks.js";
+import enrichArrayTypesFromChildSignatures from "./enrichArrayTypesFromChildSignatures.js";
+import enrichUnknownTypesFromSourceEquivalencies from "./enrichUnknownTypesFromSourceEquivalencies.js";
+import { transformationTracer } from "./TransformationTracer.js";
 export default function generateDataStructure({ entity, dependentAnalyses, analysis, }) {
+    var _a, _b;
     try {
-        if (!['visual', 'library'].includes(entity.entityType))
+        if (!['visual', 'library'].includes(entity.entityType)) {
             return analysis;
+        }
         awsLog('CodeYam: Generating data structure for', {
             filePath: entity.filePath,
             entityName: entity.name,
-            // dependentAnalyses: Object.keys(dependentAnalyses).flatMap((path) =>
-            //   Object.keys(dependentAnalyses[path]).flatMap((entityName) => ({
-            //     path,
-            //     entityName,
-            //   })),
-            // ),
         });
         const allImportedExports = [
             ...(entity.metadata.importedExports ?? []),
@@ -23,11 +22,55 @@ export default function generateDataStructure({ entity, dependentAnalyses, analy
                 ...imported,
             }))),
         ];
+        // For implicit dependencies (like root.tsx layouts), include their mocked nodeModuleImports
+        // This ensures layout file dependencies (like useLoaderData in root.tsx) are included in dataForMocks
+        // when simulating routes that are wrapped by those layout files
+        for (const importedExport of entity.metadata.importedExports ?? []) {
+            if (!('isImplicitDependency' in importedExport) ||
+                !importedExport.isImplicitDependency) {
+                continue;
+            }
+            // Look up the implicit dependency's analysis
+            const implicitDepAnalysis = dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+            // Access nodeModuleImports from the entity attached to the analysis
+            const nodeModuleImports = implicitDepAnalysis?.entity?.metadata?.nodeModuleImports;
+            if (!nodeModuleImports) {
+                continue;
+            }
+            // Add the implicit dependency's mocked nodeModuleImports to allImportedExports
+            for (const moduleName of Object.keys(nodeModuleImports)) {
+                const moduleImports = nodeModuleImports[moduleName] || [];
+                for (const imported of moduleImports) {
+                    if (!imported.isMocked)
+                        continue;
+                    // Only add if not already present (avoid duplicates)
+                    const alreadyExists = allImportedExports.some((existing) => existing.filePath === moduleName &&
+                        existing.name === imported.name);
+                    if (!alreadyExists) {
+                        allImportedExports.push({
+                            filePath: moduleName,
+                            name: imported.name,
+                            isDefault: imported.isDefault,
+                            isMocked: imported.isMocked,
+                            calls: imported.calls ? [...imported.calls] : undefined,
+                            callVariableNames: imported.callVariableNames
+                                ? [...imported.callVariableNames]
+                                : undefined,
+                        });
+                    }
+                }
+            }
+        }
         const nonMockedDependentAnalyses = allImportedExports.reduce((acc, importedExport) => {
             var _a;
             if (importedExport.isMocked)
                 return acc;
-            const relevantDependencyAnalysis = dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+            // Use resolvedFilePath when available (for re-exports from index files)
+            // to find the actual analysis of the component
+            const lookupPath = ('resolvedFilePath' in importedExport &&
+                importedExport.resolvedFilePath) ||
+                importedExport.filePath;
+            const relevantDependencyAnalysis = dependentAnalyses[lookupPath]?.[importedExport.name];
             if (!relevantDependencyAnalysis) {
                 // console.info(
                 //   'CodeYam Warn: No relevant dependency analysis found for importedExport',
@@ -70,6 +113,247 @@ export default function generateDataStructure({ entity, dependentAnalyses, analy
                 relevantDependencyAnalysis;
             return acc;
         }, {});
+        // Include same-file child components in nonMockedDependentAnalyses.
+        // Same-file components (e.g., AgentCard defined in the same file as AgentTranscriptsPage)
+        // are NOT in importedExports, so the reduce above never includes them.
+        // But they ARE in dependentAnalyses and their full signatureSchema (with all prop fields)
+        // needs to be merged into the parent's dependencySchemas for array enrichment to work.
+        const sameFileAnalyses = dependentAnalyses[entity.filePath];
+        if (sameFileAnalyses) {
+            for (const name in sameFileAnalyses) {
+                if (name === entity.name)
+                    continue;
+                if (nonMockedDependentAnalyses[entity.filePath]?.[name])
+                    continue;
+                const childAnalysis = sameFileAnalyses[name];
+                if (childAnalysis?.entityType === 'visual') {
+                    nonMockedDependentAnalyses[_a = entity.filePath] || (nonMockedDependentAnalyses[_a] = {});
+                    nonMockedDependentAnalyses[entity.filePath][name] = childAnalysis;
+                }
+            }
+        }
+        const childDependencySchemas = {};
+        // Helper function to add mocked imports from an entity to allImportedExports
+        const addMockedImportsFromEntity = (childEntity) => {
+            if (!childEntity?.metadata)
+                return;
+            // Add child's mocked nodeModuleImports
+            const childNodeModuleImports = childEntity.metadata.nodeModuleImports;
+            if (childNodeModuleImports) {
+                for (const moduleName of Object.keys(childNodeModuleImports)) {
+                    const moduleImports = childNodeModuleImports[moduleName] || [];
+                    for (const imported of moduleImports) {
+                        if (!imported.isMocked)
+                            continue;
+                        // Check if this import already exists in allImportedExports
+                        const existingImport = allImportedExports.find((existing) => existing.filePath === moduleName &&
+                            existing.name === imported.name);
+                        if (existingImport) {
+                            // Merge callVariableNames if the same dependency exists with different patterns
+                            if (imported.callVariableNames && imported.calls) {
+                                existingImport.calls = existingImport.calls || [];
+                                existingImport.callVariableNames =
+                                    existingImport.callVariableNames || [];
+                                // Add each call/variable pair that doesn't already exist
+                                for (let i = 0; i < imported.calls.length; i++) {
+                                    const call = imported.calls[i];
+                                    const varName = imported.callVariableNames[i];
+                                    if (!varName)
+                                        continue;
+                                    // Check if this specific callVariableName already exists
+                                    if (!existingImport.callVariableNames.includes(varName)) {
+                                        existingImport.calls.push(call);
+                                        existingImport.callVariableNames.push(varName);
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            // Add new import
+                            allImportedExports.push({
+                                filePath: moduleName,
+                                name: imported.name,
+                                isDefault: imported.isDefault,
+                                isMocked: imported.isMocked,
+                                calls: imported.calls ? [...imported.calls] : undefined,
+                                callVariableNames: imported.callVariableNames
+                                    ? [...imported.callVariableNames]
+                                    : undefined,
+                            });
+                        }
+                    }
+                }
+            }
+            // Add child's mocked importedExports
+            const childImportedExports = childEntity.metadata.importedExports;
+            if (childImportedExports) {
+                for (const imported of childImportedExports) {
+                    if (!imported.isMocked)
+                        continue;
+                    // Check if this import already exists in allImportedExports
+                    const existingImport = allImportedExports.find((existing) => existing.filePath === imported.filePath &&
+                        existing.name === imported.name);
+                    if (existingImport) {
+                        // Merge calls from child into existing import
+                        // Note: Check length > 0 because empty array [] is truthy but has no variable names
+                        if (imported.callVariableNames?.length && imported.calls) {
+                            // Case 1: Both calls and callVariableNames are set - merge as pairs
+                            existingImport.calls = existingImport.calls || [];
+                            existingImport.callVariableNames =
+                                existingImport.callVariableNames || [];
+                            // Add each call/variable pair that doesn't already exist
+                            for (let i = 0; i < imported.calls.length; i++) {
+                                const call = imported.calls[i];
+                                const varName = imported.callVariableNames[i];
+                                if (!varName)
+                                    continue;
+                                // Check if this specific callVariableName already exists
+                                if (!existingImport.callVariableNames.includes(varName)) {
+                                    existingImport.calls.push(call);
+                                    existingImport.callVariableNames.push(varName);
+                                }
+                            }
+                        }
+                        else if (imported.calls) {
+                            // Case 2: Only calls are set (no callVariableNames) - common with tRPC
+                            // where destructuring like `const { data, isLoading } = trpc.xxx.useQuery()`
+                            // doesn't create a variable name for the hook call itself
+                            existingImport.calls = existingImport.calls || [];
+                            // Add each call that doesn't already exist
+                            for (const call of imported.calls) {
+                                if (!existingImport.calls.includes(call)) {
+                                    existingImport.calls.push(call);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Add new import
+                        allImportedExports.push({
+                            filePath: imported.filePath,
+                            name: imported.name,
+                            isDefault: imported.isDefault,
+                            isMocked: imported.isMocked,
+                            calls: imported.calls ? [...imported.calls] : undefined,
+                            callVariableNames: imported.callVariableNames
+                                ? [...imported.callVariableNames]
+                                : undefined,
+                        });
+                    }
+                }
+            }
+        };
+        // Recursive function to traverse the dependency tree
+        const processedAnalyses = new Set();
+        const traverseStart = Date.now();
+        const TRAVERSE_TIMEOUT_MS = 2000;
+        let traverseCount = 0;
+        const traverseDependencyTree = (analyses) => {
+            for (const filePath in analyses) {
+                for (const name in analyses[filePath]) {
+                    const analysisKey = `${filePath}:${name}`;
+                    if (processedAnalyses.has(analysisKey))
+                        continue;
+                    processedAnalyses.add(analysisKey);
+                    traverseCount++;
+                    if (Date.now() - traverseStart > TRAVERSE_TIMEOUT_MS) {
+                        throw new DataStructureTimeoutError(entity.name, Date.now() - traverseStart);
+                    }
+                    const childAnalysis = analyses[filePath][name];
+                    const childEntity = childAnalysis?.entity;
+                    // Add mocked imports from this child entity
+                    addMockedImportsFromEntity(childEntity);
+                    // Recursively process this child's non-mocked children
+                    // via their mergedDataStructure's nested dependentAnalyses
+                    const childMergedDataStructure = childAnalysis?.metadata?.mergedDataStructure;
+                    // Collect the child's dependency schemas for merging later.
+                    // This ensures schemas for child imports are available in gatherDataForMocks.
+                    if (childMergedDataStructure?.dependencySchemas) {
+                        for (const schemaFilePath in childMergedDataStructure.dependencySchemas) {
+                            for (const schemaName in childMergedDataStructure
+                                .dependencySchemas[schemaFilePath]) {
+                                childDependencySchemas[schemaFilePath] || (childDependencySchemas[schemaFilePath] = {});
+                                const existingSchema = childDependencySchemas[schemaFilePath][schemaName];
+                                const newSchema = childMergedDataStructure.dependencySchemas[schemaFilePath][schemaName];
+                                if (existingSchema) {
+                                    // Merge schemas if the same dependency exists from multiple children
+                                    childDependencySchemas[schemaFilePath][schemaName] = {
+                                        signatureSchema: {
+                                            ...existingSchema.signatureSchema,
+                                            ...newSchema.signatureSchema,
+                                        },
+                                        returnValueSchema: mergeJsonTypeDefinitions(existingSchema.returnValueSchema, newSchema.returnValueSchema),
+                                    };
+                                }
+                                else {
+                                    childDependencySchemas[schemaFilePath][schemaName] = {
+                                        signatureSchema: { ...newSchema.signatureSchema },
+                                        returnValueSchema: { ...newSchema.returnValueSchema },
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    // Also collect the child's OWN signatureSchema for enrichment.
+                    // This allows enrichArrayTypesFromChildSignatures to find what fields
+                    // non-mocked child components expect on their props (e.g., SurveyCard
+                    // expecting survey.createdAt, survey.updatedAt, etc.)
+                    if (childMergedDataStructure?.signatureSchema) {
+                        childDependencySchemas[filePath] || (childDependencySchemas[filePath] = {});
+                        const existingSchema = childDependencySchemas[filePath][name];
+                        if (existingSchema) {
+                            childDependencySchemas[filePath][name] = {
+                                signatureSchema: {
+                                    ...existingSchema.signatureSchema,
+                                    ...childMergedDataStructure.signatureSchema,
+                                },
+                                returnValueSchema: existingSchema.returnValueSchema,
+                            };
+                        }
+                        else {
+                            childDependencySchemas[filePath][name] = {
+                                signatureSchema: {
+                                    ...childMergedDataStructure.signatureSchema,
+                                },
+                                returnValueSchema: {},
+                            };
+                        }
+                    }
+                    if (childMergedDataStructure?.dependencySchemas) {
+                        // We need to find non-mocked child components in the dependency tree
+                        // These would be in the child's importedExports that are NOT mocked
+                        const childImportedExports = childEntity?.metadata?.importedExports ?? [];
+                        const nonMockedChildDeps = {};
+                        for (const dep of childImportedExports) {
+                            if (dep.isMocked)
+                                continue;
+                            if (dep.entityType !== 'visual')
+                                continue;
+                            // Try to find this dependency in dependentAnalyses
+                            const depFilePath = dep.resolvedFilePath ?? dep.filePath;
+                            const depName = dep.resolvedName ?? dep.name;
+                            if (dependentAnalyses[depFilePath]?.[depName]) {
+                                nonMockedChildDeps[depFilePath] || (nonMockedChildDeps[depFilePath] = {});
+                                nonMockedChildDeps[depFilePath][depName] =
+                                    dependentAnalyses[depFilePath][depName];
+                            }
+                        }
+                        if (Object.keys(nonMockedChildDeps).length > 0) {
+                            traverseDependencyTree(nonMockedChildDeps);
+                        }
+                    }
+                }
+            }
+        };
+        // Start traversal from direct non-mocked children
+        traverseDependencyTree(nonMockedDependentAnalyses);
+        const traverseElapsed = Date.now() - traverseStart;
+        const childSchemaKeyCount = Object.values(childDependencySchemas).reduce((sum, fileMap) => sum +
+            Object.values(fileMap).reduce((s, schema) => s +
+                Object.keys(schema.signatureSchema || {}).length +
+                Object.keys(schema.returnValueSchema || {}).length, 0), 0);
+        awsLogDebugLevel(1, `Dependency tree traversal for ${entity.name}: ${traverseCount} analyses, ` +
+            `${childSchemaKeyCount} child schema keys, ${allImportedExports.length} imports, ${traverseElapsed}ms`);
         // console.info(
         //   'CODEYAM DEBUG: start merge',
         //   JSON.stringify(
@@ -86,6 +370,28 @@ export default function generateDataStructure({ entity, dependentAnalyses, analy
         //   ),
         // );
         const { isolatedDataStructure } = entity.metadata;
+        if (!isolatedDataStructure) {
+            awsLog('CodeYam: Skipping data structure generation — isolatedDataStructure is undefined (scope analysis may have failed)', {
+                entityName: entity.name,
+                filePath: entity.filePath,
+            });
+            return analysis;
+        }
+        // Transformation tracing: start entity and capture isolated data structure
+        transformationTracer.startEntity({
+            name: entity.name,
+            entityType: entity.entityType,
+            filePath: entity.filePath,
+        });
+        transformationTracer.snapshot(entity.name, 'isolated', {
+            signatureSchema: isolatedDataStructure.signatureSchema,
+            returnValueSchema: isolatedDataStructure.returnValueSchema,
+            dependencySchemas: isolatedDataStructure.dependencySchemas,
+        });
+        const mergeStart = Date.now();
+        // Shared deadline for all phases from merge onward
+        const genDeadline = mergeStart + 5000; // 5s total budget for all phases
+        awsLogDebugLevel(1, `Starting mergeInDependentDataStructure for ${entity.name}...`);
         const mergedDataStructure = mergeInDependentDataStructure({
             importedExports: allImportedExports,
             dependentAnalyses: nonMockedDependentAnalyses,
@@ -99,8 +405,76 @@ export default function generateDataStructure({ entity, dependentAnalyses, analy
             },
             dependencySchemas: isolatedDataStructure?.dependencySchemas || {},
         });
+        const mergeTimedOut = !!mergedDataStructure.timedOut;
+        awsLogDebugLevel(1, `mergeInDependentDataStructure ${mergeTimedOut ? 'PARTIAL' : 'complete'} for ${entity.name}: ` +
+            `${Object.keys(mergedDataStructure.signatureSchema).length} sig, ` +
+            `${Object.keys(mergedDataStructure.returnValueSchema).length} ret, ${Date.now() - mergeStart}ms`);
         mergedDataStructure.environmentVariables =
             isolatedDataStructure.environmentVariables || [];
+        // Transformation tracing: capture merged data structure
+        transformationTracer.snapshot(entity.name, 'merged', {
+            signatureSchema: mergedDataStructure.signatureSchema,
+            returnValueSchema: mergedDataStructure.returnValueSchema,
+            dependencySchemas: mergedDataStructure.dependencySchemas,
+        });
+        // Merge collected child dependency schemas into mergedDataStructure.
+        // This ensures that when gatherDataForMocks looks up schemas for child imports,
+        // the child's schemas are available.
+        const childMergeStart = Date.now();
+        for (const schemaFilePath in childDependencySchemas) {
+            for (const schemaName in childDependencySchemas[schemaFilePath]) {
+                (_b = mergedDataStructure.dependencySchemas)[schemaFilePath] || (_b[schemaFilePath] = {});
+                const existingSchema = mergedDataStructure.dependencySchemas[schemaFilePath][schemaName];
+                const childSchema = childDependencySchemas[schemaFilePath][schemaName];
+                if (existingSchema) {
+                    // Merge schemas - child schemas add to parent schemas
+                    // But prefer more specific types (without | undefined) when both exist
+                    const mergedSignatureSchema = { ...existingSchema.signatureSchema };
+                    for (const path in childSchema.signatureSchema) {
+                        const existingType = mergedSignatureSchema[path];
+                        const childType = childSchema.signatureSchema[path];
+                        if (!existingType) {
+                            mergedSignatureSchema[path] = childType;
+                        }
+                        else {
+                            // Prefer the more specific (narrower) type
+                            const existingIsOptional = existingType.includes('| undefined') ||
+                                existingType.includes('| null');
+                            const childIsOptional = childType.includes('| undefined') ||
+                                childType.includes('| null');
+                            if (childIsOptional && !existingIsOptional) {
+                                // Keep existing - it's more specific
+                            }
+                            else if (!childIsOptional && existingIsOptional) {
+                                // Use child - it's more specific
+                                mergedSignatureSchema[path] = childType;
+                            }
+                            else {
+                                // Same specificity - use child (original behavior)
+                                mergedSignatureSchema[path] = childType;
+                            }
+                        }
+                    }
+                    mergedDataStructure.dependencySchemas[schemaFilePath][schemaName] = {
+                        signatureSchema: mergedSignatureSchema,
+                        returnValueSchema: mergeJsonTypeDefinitions(existingSchema.returnValueSchema, childSchema.returnValueSchema),
+                    };
+                }
+                else {
+                    // No existing schema - just add the child's schema
+                    mergedDataStructure.dependencySchemas[schemaFilePath][schemaName] =
+                        childSchema;
+                }
+            }
+        }
+        awsLogDebugLevel(1, `Child schema merge for ${entity.name}: ${Date.now() - childMergeStart}ms`);
+        // Transformation tracing: capture after child schemas merged
+        const snapshotStart = Date.now();
+        transformationTracer.snapshot(entity.name, 'childSchemasMerged', {
+            signatureSchema: mergedDataStructure.signatureSchema,
+            returnValueSchema: mergedDataStructure.returnValueSchema,
+            dependencySchemas: mergedDataStructure.dependencySchemas,
+        });
         // console.info(
         //   'CODEYAM DEBUG: end merge',
         //   JSON.stringify(
@@ -120,45 +494,252 @@ export default function generateDataStructure({ entity, dependentAnalyses, analy
         //     2,
         //   ),
         // );
+        awsLogDebugLevel(1, `Transformation snapshot for ${entity.name}: ${Date.now() - snapshotStart}ms`);
         // Deduplicate function schemas in the merged data structure
         // The merge process might introduce duplicates even if individual schemas were clean
-        mergedDataStructure.signatureSchema = deduplicateFunctionSchemas(mergedDataStructure.signatureSchema);
-        mergedDataStructure.returnValueSchema = deduplicateFunctionSchemas(mergedDataStructure.returnValueSchema);
-        // Also deduplicate dependency schemas
+        const dedupStart = Date.now();
+        const sigKeyCount = Object.keys(mergedDataStructure.signatureSchema).length;
+        const retKeyCount = Object.keys(mergedDataStructure.returnValueSchema).length;
+        // Skip dedup on very large schemas — the O(keys × variants × keyLength) cost
+        // is not worth it for schemas with 10K+ keys where function dedup rarely matters.
+        const DEDUP_KEY_THRESHOLD = 10000;
+        if (sigKeyCount < DEDUP_KEY_THRESHOLD) {
+            const sigBefore = { ...mergedDataStructure.signatureSchema };
+            mergedDataStructure.signatureSchema = deduplicateFunctionSchemas(mergedDataStructure.signatureSchema);
+            transformationTracer.traceSchemaTransformResult(entity.name, 'deduplicateFunctionSchemas', sigBefore, mergedDataStructure.signatureSchema, { schemaType: 'signature' });
+        }
+        else {
+            awsLogDebugLevel(2, `${entity.name}: skipping sig dedup (${sigKeyCount} keys > ${DEDUP_KEY_THRESHOLD})`);
+        }
+        if (retKeyCount < DEDUP_KEY_THRESHOLD) {
+            const rvBefore = { ...mergedDataStructure.returnValueSchema };
+            mergedDataStructure.returnValueSchema = deduplicateFunctionSchemas(mergedDataStructure.returnValueSchema);
+            transformationTracer.traceSchemaTransformResult(entity.name, 'deduplicateFunctionSchemas', rvBefore, mergedDataStructure.returnValueSchema, { schemaType: 'returnValue' });
+        }
+        else {
+            awsLogDebugLevel(2, `${entity.name}: skipping ret dedup (${retKeyCount} keys > ${DEDUP_KEY_THRESHOLD})`);
+        }
+        awsLogDebugLevel(1, `${entity.name}: root schema dedup ${Date.now() - dedupStart}ms (sig=${sigKeyCount}, ret=${retKeyCount})`);
+        // Also deduplicate dependency schemas and clear known attributes
+        let depProcessed = 0;
+        const depStart = Date.now();
         for (const filePath in mergedDataStructure.dependencySchemas) {
-            for (const entityName in mergedDataStructure.dependencySchemas[filePath]) {
-                const depSchema = mergedDataStructure.dependencySchemas[filePath][entityName];
-                depSchema.signatureSchema = deduplicateFunctionSchemas(depSchema.signatureSchema);
-                depSchema.returnValueSchema = deduplicateFunctionSchemas(depSchema.returnValueSchema);
-                clearAttributesFromMapping(depSchema.signatureSchema);
-                clearAttributesFromMapping(depSchema.returnValueSchema);
+            for (const depEntityName in mergedDataStructure.dependencySchemas[filePath]) {
+                if (Date.now() > genDeadline) {
+                    throw new DataStructureTimeoutError(entity.name, Date.now() - mergeStart);
+                }
+                const depSchema = mergedDataStructure.dependencySchemas[filePath][depEntityName];
+                const depSigKeys = Object.keys(depSchema.signatureSchema || {}).length;
+                const depRetKeys = Object.keys(depSchema.returnValueSchema || {}).length;
+                const depOpStart = Date.now();
+                if (depSigKeys < DEDUP_KEY_THRESHOLD) {
+                    const depSigBefore = { ...depSchema.signatureSchema };
+                    depSchema.signatureSchema = deduplicateFunctionSchemas(depSchema.signatureSchema);
+                    transformationTracer.traceSchemaTransformResult(entity.name, 'deduplicateFunctionSchemas', depSigBefore, depSchema.signatureSchema, {
+                        filePath,
+                        dependencyName: depEntityName,
+                        schemaType: 'signature',
+                    });
+                }
+                if (depRetKeys < DEDUP_KEY_THRESHOLD) {
+                    const depRvBefore = { ...depSchema.returnValueSchema };
+                    depSchema.returnValueSchema = deduplicateFunctionSchemas(depSchema.returnValueSchema);
+                    transformationTracer.traceSchemaTransformResult(entity.name, 'deduplicateFunctionSchemas', depRvBefore, depSchema.returnValueSchema, {
+                        filePath,
+                        dependencyName: depEntityName,
+                        schemaType: 'returnValue',
+                    });
+                }
+                const depOpElapsed = Date.now() - depOpStart;
+                if (depOpElapsed > 1000) {
+                    awsLogDebugLevel(2, `${entity.name}: slow dep dedup ${depEntityName} sig=${depSigKeys} ret=${depRetKeys} ${depOpElapsed}ms`);
+                }
+                depProcessed++;
+                // Infer function types from child component usage BEFORE fillInSchemaGapsAndUnknowns.
+                // When a hook returns a property with type 'unknown' that is passed to a child
+                // component which calls it as a function (e.g., isEntityPending(entity)),
+                // promote it to 'function'. Without this, name heuristics like isLikelyBoolean
+                // would mistype "isEntityPending" as boolean because of the "is" prefix.
+                //
+                // sourceEquivalencies are in isolatedDataStructure.dependencySchemas (not in
+                // mergedDataStructure.dependencySchemas — they're dropped during the merge).
+                // The child's signatureSchema (with function call evidence) IS in the merged schemas.
+                {
+                    const isolatedDepSchemas = entity.metadata.isolatedDataStructure?.dependencySchemas;
+                    if (isolatedDepSchemas) {
+                        for (const childFilePath in isolatedDepSchemas) {
+                            const childIsolated = isolatedDepSchemas[childFilePath];
+                            for (const childName in childIsolated) {
+                                const sourceEq = childIsolated[childName]?.sourceEquivalencies;
+                                if (!sourceEq)
+                                    continue;
+                                // Get the child's signatureSchema from the MERGED schemas (richer)
+                                const mergedChildSchema = mergedDataStructure.dependencySchemas[childFilePath]?.[childName];
+                                const sigSchema = mergedChildSchema?.signatureSchema;
+                                if (!sigSchema)
+                                    continue;
+                                for (const childPath in sourceEq) {
+                                    for (const source of sourceEq[childPath]) {
+                                        const fcrvSuffix = '.functionCallReturnValue.';
+                                        const fcrvIndex = source.schemaPath.indexOf(fcrvSuffix);
+                                        if (fcrvIndex === -1)
+                                            continue;
+                                        const propName = source.schemaPath.slice(fcrvIndex + fcrvSuffix.length);
+                                        // Find the corresponding child signature path
+                                        const entityCallPrefix = childName + '().';
+                                        const sigPathBase = childPath.startsWith(entityCallPrefix)
+                                            ? childPath.slice(entityCallPrefix.length)
+                                            : childPath;
+                                        // Check if the child's signatureSchema has a function call version
+                                        let isFunction = false;
+                                        for (const sigKey in sigSchema) {
+                                            if (sigKey.startsWith(sigPathBase + '(') &&
+                                                sigSchema[sigKey] === 'function') {
+                                                isFunction = true;
+                                                break;
+                                            }
+                                        }
+                                        if (isFunction) {
+                                            for (const rvKey in depSchema.returnValueSchema) {
+                                                if (rvKey.endsWith('.' + propName) &&
+                                                    depSchema.returnValueSchema[rvKey] === 'unknown') {
+                                                    depSchema.returnValueSchema[rvKey] = 'function';
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                // Fill in type gaps BEFORE clearing attributes, so evidence like .includes()
+                // is used for type inference before being deleted
+                const FILL_IN_KEY_THRESHOLD = 5000;
+                const fillStart = Date.now();
+                if (depSigKeys < FILL_IN_KEY_THRESHOLD) {
+                    depSchema.signatureSchema = fillInDirectSchemaGapsAndUnknowns({
+                        schema: depSchema.signatureSchema,
+                    });
+                }
+                if (depRetKeys < FILL_IN_KEY_THRESHOLD) {
+                    depSchema.returnValueSchema = fillInDirectSchemaGapsAndUnknowns({
+                        schema: depSchema.returnValueSchema,
+                    });
+                }
+                else {
+                    awsLogDebugLevel(2, `${entity.name}: skipping fillInGaps for ${depEntityName} ret (${depRetKeys} keys > ${FILL_IN_KEY_THRESHOLD})`);
+                }
+                const fillElapsed = Date.now() - fillStart;
+                if (fillElapsed > 1000) {
+                    awsLogDebugLevel(2, `${entity.name}: slow fillInGaps ${depEntityName} sig=${depSigKeys} ret=${depRetKeys} ${fillElapsed}ms`);
+                }
+                // Trace clearAttributesFromMapping on dependency schemas
+                transformationTracer.traceSchemaTransform(entity.name, 'clearAttributesFromMapping', depSchema.signatureSchema, clearAttributesFromMapping, { filePath, dependencyName: depEntityName, schemaType: 'signature' });
+                transformationTracer.traceSchemaTransform(entity.name, 'clearAttributesFromMapping', depSchema.returnValueSchema, clearAttributesFromMapping, {
+                    filePath,
+                    dependencyName: depEntityName,
+                    schemaType: 'returnValue',
+                });
             }
         }
+        awsLogDebugLevel(1, `${entity.name}: dep schema processing: ${depProcessed} deps in ${Date.now() - depStart}ms`);
+        awsLogDebugLevel(1, `Dedup + dep schema processing for ${entity.name}: ${Date.now() - dedupStart}ms`);
+        // Transformation tracing: capture after deduplication
+        const dedupSnapshotStart = Date.now();
+        transformationTracer.snapshot(entity.name, 'deduplicated', {
+            signatureSchema: mergedDataStructure.signatureSchema,
+            returnValueSchema: mergedDataStructure.returnValueSchema,
+            dependencySchemas: mergedDataStructure.dependencySchemas,
+        });
+        awsLogDebugLevel(1, `Dedup snapshot for ${entity.name}: ${Date.now() - dedupSnapshotStart}ms`);
         analysis.metadata || (analysis.metadata = {});
         analysis.metadata.mergedDataStructure = mergedDataStructure;
-        const dataForMocks = gatherDataForMocks(allImportedExports, mergedDataStructure.dependencySchemas);
-        // console.info(
-        //   'CODEYAM DEBUG: dataForMocks',
-        //   JSON.stringify(
-        //     {
-        //       filePath: entity.filePath,
-        //       entityName: entity.name,
-        //       dataForMocks,
-        //     },
-        //     null,
-        //     2,
-        //   ),
-        // );
-        const finalizedArgumentsSchema = fillInDirectSchemaGapsAndUnknowns({
-            schema: { ...mergedDataStructure.signatureSchema },
+        if (mergeTimedOut) {
+            analysis.metadata.mergeTimedOut = true;
+        }
+        const checkGenDeadline = (phase) => {
+            if (Date.now() > genDeadline) {
+                throw new DataStructureTimeoutError(entity.name, Date.now() - mergeStart);
+            }
+            awsLogDebugLevel(1, `${entity.name}: ${phase} complete (${Date.now() - mergeStart}ms total)`);
+        };
+        // Enrich mocked dependency array types with fields from child component signatures
+        // This ensures that when getSurveysAction returns { data: array }, and SurveyCard
+        // expects survey.updatedAt, the array element type includes updatedAt.
+        // Uses usageEquivalencies to trace data flow and only enrich arrays with fields
+        // from children that actually receive elements from that specific array.
+        transformationTracer.traceDependencySchemaChanges(entity.name, 'enrichArrayTypesFromChildSignatures', mergedDataStructure.dependencySchemas, () => enrichArrayTypesFromChildSignatures(allImportedExports, mergedDataStructure.dependencySchemas, mergedDataStructure.usageEquivalencies));
+        checkGenDeadline('enrichArrayTypes');
+        // Transformation tracing: capture after array types enriched
+        transformationTracer.snapshot(entity.name, 'arrayTypesEnriched', {
+            signatureSchema: mergedDataStructure.signatureSchema,
+            returnValueSchema: mergedDataStructure.returnValueSchema,
+            dependencySchemas: mergedDataStructure.dependencySchemas,
+        });
+        // Enrich mocked dependency unknown types using sourceEquivalencies
+        // When a mocked dependency returns unknown, but that data flows to a child component
+        // with a known type, propagate the type back to the mocked dependency.
+        // This prevents fillInDirectSchemaGapsAndUnknowns from guessing incorrectly
+        // (e.g., 'data' becoming 'number' because pluralize thinks it's plural)
+        transformationTracer.traceDependencySchemaChanges(entity.name, 'enrichUnknownTypesFromSourceEquivalencies', mergedDataStructure.dependencySchemas, () => enrichUnknownTypesFromSourceEquivalencies(isolatedDataStructure.dependencySchemas || {}, mergedDataStructure.dependencySchemas, allImportedExports));
+        checkGenDeadline('enrichUnknownTypes');
+        // Transformation tracing: capture after unknown types enriched
+        transformationTracer.snapshot(entity.name, 'unknownTypesEnriched', {
+            signatureSchema: mergedDataStructure.signatureSchema,
+            returnValueSchema: mergedDataStructure.returnValueSchema,
+            dependencySchemas: mergedDataStructure.dependencySchemas,
         });
-        clearAttributesFromMapping(finalizedArgumentsSchema);
+        // DISABLED: Testing if ternary fix eliminates the need for this heuristic
+        // Propagate array item schemas between arrays that likely have the same type.
+        // When one array (e.g., entities) has item schema traced but another similar array
+        // (e.g., currentEntities) doesn't (because it's only used in an OR expression fallback),
+        // copy the item schema from the rich array to the empty one.
+        // propagateArrayItemSchemas(mergedDataStructure.dependencySchemas);
+        let dataForMocks = gatherDataForMocks(allImportedExports, mergedDataStructure.dependencySchemas, { entityName: entity.name });
+        checkGenDeadline('gatherDataForMocks');
+        // Transformation tracing: capture after dataForMocks gathered
+        transformationTracer.snapshot(entity.name, 'dataForMocksGathered', {
+            signatureSchema: mergedDataStructure.signatureSchema,
+            returnValueSchema: mergedDataStructure.returnValueSchema,
+            dependencySchemas: mergedDataStructure.dependencySchemas,
+            dataForMocks,
+        });
+        // Merge dataForMocks from non-mocked child analyses to include transitive dependency data.
+        // This handles cases where grandchild trpc calls aren't in allImportedExports because
+        // the grandchild's analysis wasn't in dependentAnalyses.
+        //
+        // Issue 19 fix: The child's dataForMocks already contains merged data from its
+        // dependencies (including grandchildren). By merging the child's dataForMocks,
+        // we transitively include all nested dependency data.
+        for (const filePath in nonMockedDependentAnalyses) {
+            for (const name in nonMockedDependentAnalyses[filePath]) {
+                const childAnalysis = nonMockedDependentAnalyses[filePath][name];
+                const childDataForMocks = childAnalysis?.metadata?.scenariosDataStructure?.dataForMocks;
+                if (childDataForMocks && Object.keys(childDataForMocks).length > 0) {
+                    dataForMocks = mergeJsonTypeDefinitions(dataForMocks, childDataForMocks);
+                }
+            }
+        }
+        checkGenDeadline('mergeChildDataForMocks');
+        const finalizedArgumentsSchema = { ...mergedDataStructure.signatureSchema };
+        // Trace fillInDirectSchemaGapsAndUnknowns
+        transformationTracer.traceSchemaTransform(entity.name, 'fillInDirectSchemaGapsAndUnknowns', finalizedArgumentsSchema, (schema) => fillInDirectSchemaGapsAndUnknowns({ schema }), { stage: 'finalization' });
+        // Trace clearAttributesFromMapping
+        transformationTracer.traceSchemaTransform(entity.name, 'clearAttributesFromMapping', finalizedArgumentsSchema, clearAttributesFromMapping, { stage: 'finalization' });
+        checkGenDeadline('fillInGaps+clearAttributes');
         const argumentsSchema = convertDotNotation(finalizedArgumentsSchema)
             .signature;
+        checkGenDeadline('convertDotNotation');
         analysis.metadata.scenariosDataStructure = {
             arguments: argumentsSchema,
             dataForMocks,
         };
+        // Transformation tracing: capture final scenariosDataStructure
+        transformationTracer.snapshot(entity.name, 'finalized', {
+            signatureSchema: finalizedArgumentsSchema,
+            dataForMocks,
+        });
         return analysis;
     }
     catch (e) {