@codeyam/codeyam-cli 0.1.0-staging.73a4bf4 → 0.1.0-staging.78c1cad

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

@@ -11,8 +11,10 @@ import {
   clearAttributesFromMapping,
   mergeJsonTypeDefinitions,
 } from '~codeyam/ai';
-import mergeInDependentDataStructure from './mergeInDependentDataStructure';
-import { awsLog } from '~codeyam/utils';
+import mergeInDependentDataStructure, {
+  DataStructureTimeoutError,
+} from './mergeInDependentDataStructure';
+import { awsLog, awsLogDebugLevel } from '~codeyam/utils';
 import gatherDataForMocks from './gatherDataForMocks';
 import enrichArrayTypesFromChildSignatures from './enrichArrayTypesFromChildSignatures';
 import enrichUnknownTypesFromSourceEquivalencies from './enrichUnknownTypesFromSourceEquivalencies';
@@ -328,12 +330,23 @@ export default function generateDataStructure({
 
     // Recursive function to traverse the dependency tree
     const processedAnalyses = new Set<string>();
+    const traverseStart = Date.now();
+    const TRAVERSE_TIMEOUT_MS = 2_000;
+    let traverseCount = 0;
     const traverseDependencyTree = (analyses: ReadonlyAnalysisMap) => {
       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;
@@ -443,6 +456,25 @@ export default function generateDataStructure({
     // 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(
@@ -461,6 +493,17 @@ export default function generateDataStructure({
 
     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,
@@ -473,6 +516,14 @@ export default function generateDataStructure({
       dependencySchemas: isolatedDataStructure.dependencySchemas,
     });
 
+    const mergeStart = Date.now();
+    // Shared deadline for all phases from merge onward
+    const genDeadline = mergeStart + 5_000; // 5s total budget for all phases
+    awsLogDebugLevel(
+      1,
+      `Starting mergeInDependentDataStructure for ${entity.name}...`,
+    );
+
     const mergedDataStructure = mergeInDependentDataStructure({
       importedExports: allImportedExports,
       dependentAnalyses: nonMockedDependentAnalyses,
@@ -487,6 +538,14 @@ export default function generateDataStructure({
       dependencySchemas: isolatedDataStructure?.dependencySchemas || {},
     });
 
+    const mergeTimedOut = !!(mergedDataStructure as any).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 || [];
 
@@ -500,6 +559,7 @@ export default function generateDataStructure({
     // 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]) {
         mergedDataStructure.dependencySchemas[schemaFilePath] ||= {};
@@ -550,7 +610,13 @@ export default function generateDataStructure({
       }
     }
 
+    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,
@@ -577,82 +643,237 @@ export default function generateDataStructure({
     //   ),
     // );
 
+    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
-    // Trace deduplication of signatureSchema
-    const sigBefore = { ...mergedDataStructure.signatureSchema };
-    mergedDataStructure.signatureSchema = deduplicateFunctionSchemas(
-      mergedDataStructure.signatureSchema,
-    );
-    transformationTracer.traceSchemaTransformResult(
-      entity.name,
-      'deduplicateFunctionSchemas',
-      sigBefore,
-      mergedDataStructure.signatureSchema,
-      { schemaType: 'signature' },
-    );
+    const dedupStart = Date.now();
 
-    // Trace deduplication of returnValueSchema
-    const rvBefore = { ...mergedDataStructure.returnValueSchema };
-    mergedDataStructure.returnValueSchema = deduplicateFunctionSchemas(
+    const sigKeyCount = Object.keys(mergedDataStructure.signatureSchema).length;
+    const retKeyCount = Object.keys(
       mergedDataStructure.returnValueSchema,
-    );
-    transformationTracer.traceSchemaTransformResult(
-      entity.name,
-      'deduplicateFunctionSchemas',
-      rvBefore,
-      mergedDataStructure.returnValueSchema,
-      { schemaType: 'returnValue' },
+    ).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 = 10_000;
+
+    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 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;
 
-        // Trace deduplication of dependency signatureSchema
-        const depSigBefore = { ...depSchema.signatureSchema };
-        depSchema.signatureSchema = deduplicateFunctionSchemas(
-          depSchema.signatureSchema,
-        );
-        transformationTracer.traceSchemaTransformResult(
-          entity.name,
-          'deduplicateFunctionSchemas',
-          depSigBefore,
-          depSchema.signatureSchema,
-          { filePath, dependencyName: depEntityName, schemaType: 'signature' },
-        );
+        const depOpStart = Date.now();
 
-        // Trace deduplication of dependency returnValueSchema
-        const depRvBefore = { ...depSchema.returnValueSchema };
-        depSchema.returnValueSchema = deduplicateFunctionSchemas(
-          depSchema.returnValueSchema,
-        );
-        transformationTracer.traceSchemaTransformResult(
-          entity.name,
-          'deduplicateFunctionSchemas',
-          depRvBefore,
-          depSchema.returnValueSchema,
-          {
-            filePath,
-            dependencyName: depEntityName,
-            schemaType: 'returnValue',
-          },
-        );
+        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
 
-        depSchema.signatureSchema = fillInDirectSchemaGapsAndUnknowns({
-          schema: depSchema.signatureSchema,
-        });
+        const FILL_IN_KEY_THRESHOLD = 5_000;
+        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})`,
+          );
+        }
 
-        depSchema.returnValueSchema = fillInDirectSchemaGapsAndUnknowns({
-          schema: depSchema.returnValueSchema,
-        });
+        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(
@@ -677,15 +898,46 @@ export default function generateDataStructure({
       }
     }
 
+    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.mergedDataStructure = mergedDataStructure;
+    if (mergeTimedOut) {
+      (analysis.metadata as any).mergeTimedOut = true;
+    }
+
+    const checkGenDeadline = (phase: string) => {
+      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
@@ -704,6 +956,8 @@ export default function generateDataStructure({
         ),
     );
 
+    checkGenDeadline('enrichArrayTypes');
+
     // Transformation tracing: capture after array types enriched
     transformationTracer.snapshot(entity.name, 'arrayTypesEnriched', {
       signatureSchema: mergedDataStructure.signatureSchema,
@@ -728,6 +982,8 @@ export default function generateDataStructure({
         ),
     );
 
+    checkGenDeadline('enrichUnknownTypes');
+
     // Transformation tracing: capture after unknown types enriched
     transformationTracer.snapshot(entity.name, 'unknownTypesEnriched', {
       signatureSchema: mergedDataStructure.signatureSchema,
@@ -748,6 +1004,8 @@ export default function generateDataStructure({
       { entityName: entity.name },
     );
 
+    checkGenDeadline('gatherDataForMocks');
+
     // Transformation tracing: capture after dataForMocks gathered
     transformationTracer.snapshot(entity.name, 'dataForMocksGathered', {
       signatureSchema: mergedDataStructure.signatureSchema,
@@ -777,6 +1035,8 @@ export default function generateDataStructure({
       }
     }
 
+    checkGenDeadline('mergeChildDataForMocks');
+
     const finalizedArgumentsSchema = { ...mergedDataStructure.signatureSchema };
 
     // Trace fillInDirectSchemaGapsAndUnknowns
@@ -797,9 +1057,13 @@ export default function generateDataStructure({
       { stage: 'finalization' },
     );
 
+    checkGenDeadline('fillInGaps+clearAttributes');
+
     const argumentsSchema = convertDotNotation(finalizedArgumentsSchema)
       .signature as JsonTypeDefinition[];
 
+    checkGenDeadline('convertDotNotation');
+
     analysis.metadata.scenariosDataStructure = {
       arguments: argumentsSchema,
       dataForMocks,

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

@@ -65,10 +65,6 @@ export default async function generateExecutionFlows({
   }
 
   if (!analysis.metadata.executionFlows) {
-    console.log(
-      `[GenerateExecutionFlows] Starting for ${entity.name} (${entity.filePath})`,
-    );
-
     // Build childEntityMetadata from dependentAnalyses for child flow merging
     // This maps child component names to their metadata (specifically isolatedDataStructure)
     const childEntityMetadata = buildChildEntityMetadata(
@@ -77,15 +73,6 @@ export default async function generateExecutionFlows({
     );
 
     const childCount = Object.keys(childEntityMetadata).length;
-    console.log(
-      `[GenerateExecutionFlows] Built childEntityMetadata with ${childCount} children`,
-    );
-    if (childCount > 0) {
-      console.log(
-        `[GenerateExecutionFlows] Will merge flows from children: [${Object.keys(childEntityMetadata).join(', ')}]`,
-      );
-    }
-
     const {
       result: { executionFlows, llmCall: executionFlowsLLMCall },
     } = await measureAndReportExecutionTime(
@@ -100,18 +87,6 @@ export default async function generateExecutionFlows({
       updateProgress,
     );
 
-    console.log(
-      `[GenerateExecutionFlows] Generated ${executionFlows.length} execution flows for ${entity.name}`,
-    );
-    for (const flow of executionFlows) {
-      const reqValues = flow.requiredValues
-        .map((rv) => `${rv.attributePath}=${rv.value}`)
-        .join(', ');
-      console.log(
-        `[GenerateExecutionFlows]   - Flow '${flow.id}': ${flow.name} [${reqValues}]`,
-      );
-    }
-
     analysis.metadata.executionFlows = executionFlows;
 
     if (executionFlowsLLMCall) {
@@ -137,14 +112,7 @@ export function buildChildEntityMetadata(
 ): Record<string, Entity['metadata']> {
   const childEntityMetadata: Record<string, Entity['metadata']> = {};
 
-  console.log(
-    `[BuildChildMetadata] Starting for entity: ${entity.name} (${entity.filePath})`,
-  );
-
   if (!dependentAnalyses) {
-    console.log(
-      `[BuildChildMetadata] No dependentAnalyses provided, returning empty`,
-    );
     return childEntityMetadata;
   }
 
@@ -152,54 +120,19 @@ export function buildChildEntityMetadata(
     entity.metadata?.isolatedDataStructure?.childBoundaryGatingConditions;
 
   if (!childBoundaryGatingConditions) {
-    console.log(
-      `[BuildChildMetadata] No childBoundaryGatingConditions found in isolatedDataStructure`,
-    );
-    console.log(
-      `[BuildChildMetadata] isolatedDataStructure keys: ${Object.keys(entity.metadata?.isolatedDataStructure ?? {}).join(', ') || 'none'}`,
-    );
     return childEntityMetadata;
   }
 
   const childNames = Object.keys(childBoundaryGatingConditions);
-  console.log(
-    `[BuildChildMetadata] Found ${childNames.length} children in childBoundaryGatingConditions: [${childNames.join(', ')}]`,
-  );
-
-  // Log gating conditions for each child
-  for (const [childName, conditions] of Object.entries(
-    childBoundaryGatingConditions,
-  )) {
-    const isUnconditional = conditions.some(
-      (c) => c.location === 'unconditional',
-    );
-    console.log(
-      `[BuildChildMetadata] Child '${childName}': ${conditions.length} gating conditions, unconditional=${isUnconditional}`,
-    );
-    for (const condition of conditions) {
-      console.log(
-        `[BuildChildMetadata]   - path='${condition.path}' location='${condition.location}' isNegated=${condition.isNegated ?? false}`,
-      );
-    }
-  }
-
   const importedExports = entity.metadata?.importedExports ?? [];
-  console.log(
-    `[BuildChildMetadata] Entity has ${importedExports.length} importedExports`,
-  );
 
   for (const childName of childNames) {
-    console.log(`[BuildChildMetadata] Looking up child '${childName}'...`);
-
     // Find the child in importedExports to get its file path
     const importedExport = importedExports.find(
       (ie) => ie.name === childName || ie.resolvedName === childName,
     );
 
     if (!importedExport) {
-      console.log(
-        `[BuildChildMetadata] Child '${childName}' NOT FOUND in importedExports`,
-      );
       continue;
     }
 
@@ -208,27 +141,14 @@ export function buildChildEntityMetadata(
       importedExport.resolvedFilePath ?? importedExport.filePath;
     const lookupName = importedExport.resolvedName ?? importedExport.name;
 
-    console.log(
-      `[BuildChildMetadata] Child '${childName}' found in importedExports: lookupPath='${lookupPath}' lookupName='${lookupName}'`,
-    );
-
     // Look up the child's analysis in dependentAnalyses
     const childAnalysis = dependentAnalyses[lookupPath]?.[lookupName];
 
     if (!childAnalysis) {
-      console.log(
-        `[BuildChildMetadata] Child '${childName}' analysis NOT FOUND in dependentAnalyses[${lookupPath}][${lookupName}]`,
-      );
-      console.log(
-        `[BuildChildMetadata] Available paths in dependentAnalyses: [${Object.keys(dependentAnalyses).slice(0, 10).join(', ')}...]`,
-      );
       continue;
     }
 
     if (!childAnalysis.entity?.metadata) {
-      console.log(
-        `[BuildChildMetadata] Child '${childName}' analysis found but entity.metadata is missing`,
-      );
       continue;
     }
 
@@ -237,28 +157,10 @@ export function buildChildEntityMetadata(
     const childConditionalUsages = childIsolated?.conditionalUsages ?? {};
     const childConditionalCount = Object.keys(childConditionalUsages).length;
 
-    console.log(
-      `[BuildChildMetadata] Child '${childName}' FOUND with metadata:`,
-    );
-    console.log(
-      `[BuildChildMetadata]   - conditionalUsages: ${childConditionalCount} paths`,
-    );
-    if (childConditionalCount > 0) {
-      for (const [path, usages] of Object.entries(childConditionalUsages)) {
-        console.log(
-          `[BuildChildMetadata]     - '${path}': ${(usages as any[]).length} usages`,
-        );
-      }
-    }
-
     // Cast to mutable type - the metadata is only read, not modified
     childEntityMetadata[childName] = childAnalysis.entity
       .metadata as Entity['metadata'];
   }
 
-  console.log(
-    `[BuildChildMetadata] RESULT: Found metadata for ${Object.keys(childEntityMetadata).length} children: [${Object.keys(childEntityMetadata).join(', ')}]`,
-  );
-
   return childEntityMetadata;
 }