@codeyam/codeyam-cli 0.1.0-staging.c1c8678 → 0.1.0-staging.c276166

package/analyzer-template/packages/ai/src/lib/generateExecutionFlows.ts

@@ -32,6 +32,30 @@ import resolvePathToControllable from './resolvePathToControllable';
 import { AI } from '~codeyam/ai';
 import type { JsxRenderingUsage, ConditionalUsage } from './astScopes/types';
 
+/**
+ * Patterns that indicate a child component is a modal/overlay/blocking element.
+ * Same patterns used in generateExecutionFlowsFromConditionalEffects.ts for
+ * state variable names — here applied to child component names.
+ */
+const BLOCKING_CHILD_PATTERNS = [
+  /modal/i,
+  /overlay/i,
+  /dialog/i,
+  /popup/i,
+  /drawer/i,
+  /sheet/i,
+  /lightbox/i,
+  /backdrop/i,
+];
+
+/**
+ * Check if a child component name suggests it's a blocking/modal element.
+ * Exported for testing.
+ */
+export function isBlockingChildComponent(componentName: string): boolean {
+  return BLOCKING_CHILD_PATTERNS.some((pattern) => pattern.test(componentName));
+}
+
 interface GenerateExecutionFlowsArgs {
   entity: Pick<Entity, 'sha' | 'name' | 'filePath' | 'code' | 'metadata'>;
   mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
@@ -105,19 +129,6 @@ export default function generateExecutionFlows({
     fullToShortPathMap[fullPath] = shortPath;
   }
 
-  console.log(
-    `[generateExecutionFlows] ${entity.name}: attributesMap has ${Object.keys(resolvedAttributesMap).length} keys, fullToShortPathMap has ${Object.keys(fullToShortPathMap).length} entries`,
-  );
-  console.log(
-    `[generateExecutionFlows] ${entity.name}: attributesMap keys: [${Object.keys(resolvedAttributesMap).join(', ')}]`,
-  );
-  console.log(
-    `[generateExecutionFlows] ${entity.name}: fullToShortPathMap: ${JSON.stringify(fullToShortPathMap)}`,
-  );
-  console.log(
-    `[generateExecutionFlows] ${entity.name}: equivalentSignatureVariables: ${JSON.stringify(equivalentSignatureVariables)}`,
-  );
-
   // Get pre-computed conditional data from metadata
   const conditionalUsages: Record<string, ConditionalUsage[]> =
     entity.metadata?.isolatedDataStructure?.conditionalUsages ?? {};
@@ -162,26 +173,6 @@ export default function generateExecutionFlows({
     }
   }
 
-  console.log(
-    `[generateExecutionFlows] ${entity.name}: conditionalUsages keys: [${Object.keys(conditionalUsages).join(', ')}]`,
-  );
-  console.log(
-    `[generateExecutionFlows] ${entity.name}: conditionalUsages sourceDataPaths: ${JSON.stringify(
-      Object.fromEntries(
-        Object.entries(conditionalUsages).map(([k, v]) => [
-          k,
-          (v as any[]).map((u: any) => u.sourceDataPath ?? '(none)'),
-        ]),
-      ),
-    )}`,
-  );
-  console.log(
-    `[generateExecutionFlows] ${entity.name}: compoundConditionals count: ${compoundConditionals.length}`,
-  );
-  console.log(
-    `[generateExecutionFlows] ${entity.name}: sourceEquivalencies keys count: ${Object.keys(mergedDataStructure.sourceEquivalencies ?? {}).length}`,
-  );
-
   const conditionalsBasedFlows = generateExecutionFlowsFromConditionals({
     conditionalUsages,
     compoundConditionals,
@@ -273,6 +264,11 @@ export default function generateExecutionFlows({
     calculateFlowPriority(flow, gatingPathToChildren);
   }
 
+  // Assign exclusiveGroup for truthy/falsy flow pairs that control child components.
+  // When the same gating path produces both a truthy flow (show component) and a
+  // falsy flow (hide component), they are mutually exclusive and should be grouped.
+  assignExclusiveGroupsForGatingPairs(allFlows);
+
   // Sort flows by priority (highest first)
   allFlows.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
 
@@ -361,6 +357,60 @@ function buildGatingPathToChildrenMap(
   return gatingPathToChildren;
 }
 
+/**
+ * Assign exclusiveGroup for truthy/falsy flow pairs that control child components.
+ *
+ * When the same attribute path produces both a truthy and falsy flow (e.g.,
+ * {diffView && <DiffModal/>}), they are mutually exclusive — only one can be
+ * active at a time. Grouping them ensures the scenario generator treats them
+ * as alternative states rather than combining them.
+ */
+function assignExclusiveGroupsForGatingPairs(flows: ExecutionFlow[]): void {
+  // Build a map: attributePath -> flows with truthy or falsy comparison for that path
+  const pathToFlows = new Map<
+    string,
+    { truthy: ExecutionFlow[]; falsy: ExecutionFlow[] }
+  >();
+
+  for (const flow of flows) {
+    // Only consider flows that control child components
+    if (!flow.childComponentsControlled?.length) continue;
+
+    for (const rv of flow.requiredValues) {
+      if (rv.comparison === 'truthy' || rv.comparison === 'falsy') {
+        if (!pathToFlows.has(rv.attributePath)) {
+          pathToFlows.set(rv.attributePath, { truthy: [], falsy: [] });
+        }
+        pathToFlows.get(rv.attributePath)![rv.comparison].push(flow);
+      }
+    }
+  }
+
+  // Also check falsy flows that DON'T have childComponentsControlled —
+  // they still pair with truthy flows that do
+  for (const flow of flows) {
+    if (flow.childComponentsControlled?.length) continue; // Already processed
+
+    for (const rv of flow.requiredValues) {
+      if (rv.comparison === 'falsy' && pathToFlows.has(rv.attributePath)) {
+        pathToFlows.get(rv.attributePath)!.falsy.push(flow);
+      }
+    }
+  }
+
+  // Assign exclusiveGroup where both truthy and falsy flows exist
+  for (const [attributePath, { truthy, falsy }] of pathToFlows) {
+    if (truthy.length > 0 && falsy.length > 0) {
+      const groupName = `gating:${attributePath}`;
+      for (const flow of [...truthy, ...falsy]) {
+        if (!flow.exclusiveGroup) {
+          flow.exclusiveGroup = groupName;
+        }
+      }
+    }
+  }
+}
+
 /**
  * Calculate priority and childComponentsControlled for a flow.
  *
@@ -415,6 +465,19 @@ function calculateFlowPriority(
     if (flow.impact !== 'high') {
       flow.impact = 'high';
     }
+
+    // Check if any controlled child component is a modal/dialog/overlay.
+    // Only truthy flows (which SHOW the component) should be marked as blocking.
+    // Falsy flows (which HIDE the component) should not be blocking.
+    const isTruthyFlow = flow.requiredValues.some(
+      (rv) => rv.comparison === 'truthy' || rv.comparison === 'equals',
+    );
+    if (
+      isTruthyFlow &&
+      Array.from(childComponentsControlled).some(isBlockingChildComponent)
+    ) {
+      flow.blocksOtherFlows = true;
+    }
   }
 
   // Calculate priority score

package/analyzer-template/packages/analyze/src/lib/ProjectAnalyzer.ts

@@ -46,6 +46,12 @@ export class ProjectAnalyzer {
       lib.asts.createProgramFromTsConfigPath(configPath, excludePatterns),
     );
 
+    if (this.programs.length === 0) {
+      throw new Error(
+        'No TypeScript programs could be created — no tsconfig.json found',
+      );
+    }
+
     // Primary program is the first one (usually root) for backward compatibility
     this.program = this.programs[0];
     this.typeChecker = this.program.getTypeChecker();
@@ -334,17 +340,23 @@ export class ProjectAnalyzer {
    * Refresh the TypeScript program to pick up file changes
    */
   refreshProgram(): void {
-    // Memory logging: Capture state before refresh
-    const memBefore = process.memoryUsage();
-
     // Apply the same unapprovedPaths filtering when refreshing
     const excludePatterns =
       this.project.metadata?.unapprovedPaths?.filter(Boolean) || [];
 
-    // Refresh all programs
-    this.programs = this.tsConfigPaths.map((configPath) =>
-      lib.asts.createProgramFromTsConfigPath(configPath, excludePatterns),
-    );
+    // Release old programs and caches BEFORE creating new ones to reduce peak memory.
+    // Without this, both old (~1.7GB) and new (~1.7GB) programs coexist during creation,
+    // causing OOM on monorepos with multiple tsconfigs.
+    this.programs = [];
+    this.sourceFileByPath.clear();
+    this.typeCheckerByPath.clear();
+
+    // Create programs one at a time so each old program can be GC'd before the next
+    for (const configPath of this.tsConfigPaths) {
+      this.programs.push(
+        lib.asts.createProgramFromTsConfigPath(configPath, excludePatterns),
+      );
+    }
 
     // Update primary program for backward compatibility
     this.program = this.programs[0];

package/analyzer-template/packages/analyze/src/lib/asts/index.ts

@@ -95,8 +95,13 @@ export function createProgramFromTsConfigPath(
     throw new Error('Could not parse tsconfig.json');
   }
 
-  // Filter file names based on exclude patterns to reduce memory usage
-  let fileNames = parsedCommandLine.fileNames;
+  // Always filter out node_modules from root files to prevent OOM on large projects.
+  // This only removes them as root compilation targets — TypeScript's module resolution
+  // still follows imports into node_modules for type info when processing source files.
+  let fileNames = parsedCommandLine.fileNames.filter(
+    (f) => !f.includes('/node_modules/'),
+  );
+
   if (excludePatterns && excludePatterns.length > 0) {
     const regexPatterns = excludePatterns
       .map((pattern) => {

package/analyzer-template/packages/analyze/src/lib/asts/nodes/getNodeType.ts

@@ -39,6 +39,7 @@ export function getNodeType(node: ts.Node, sourceFile: ts.SourceFile) {
     case 'StringLiteral':
     case 'NumericLiteral':
     case 'ObjectLiteralExpression':
+    case 'ArrayLiteralExpression':
       nodeType = 'data';
       break;
     case 'TypeAliasDeclaration':

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

@@ -310,7 +310,15 @@ export default async function analyzeEntities({
   );
 
   // Flush transformation trace if tracing is enabled
-  transformationTracer.flush();
+  // Wrapped in try/catch because trace data can exceed V8's max string length
+  // for large projects, and we must not crash the analysis process over tracing.
+  try {
+    transformationTracer.flush();
+  } catch (e) {
+    console.warn(
+      `CodeYam Warning: Failed to flush transformation trace: ${e.message}`,
+    );
+  }
 
   return analyses;
 

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

@@ -100,12 +100,6 @@ export function getCandidatesReadyForCapture(
       continue;
     }
 
-    // Skip notExported entities - they can't be imported into the simulation
-    // environment and will always fail capture. Don't mark them as ready.
-    if (candidate.entity?.metadata?.notExported) {
-      continue;
-    }
-
     // Get all transitive dependencies
     const candidateKey = `${candidate.filePath}:${candidate.entityName}`;
     const { missingDependencies } = getTransitiveDependencies(

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

@@ -138,6 +138,18 @@ export default async function findOrCreateEntity({
           break;
         }
       }
+
+      // Mark previous versions as superseded
+      const entitiesToSupersede = previousEntities.filter(
+        (e) => !e.metadata?.isSuperseded,
+      );
+      if (entitiesToSupersede.length > 0) {
+        for (const prev of entitiesToSupersede) {
+          prev.metadata = prev.metadata || {};
+          prev.metadata.isSuperseded = true;
+        }
+        await upsertEntities(entitiesToSupersede);
+      }
     }
 
     entity = {

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

@@ -404,22 +404,15 @@ export class TransformationTracer {
   }
 
   /**
-   * Write the trace to the output file.
+   * Compute the summary data for the current traces.
    */
-  flush(): void {
-    if (!this.isEnabled()) return;
-    if (this.traces.size === 0) {
-      this.log('flush: no traces to write');
-      return;
-    }
-
-    const entities = Array.from(this.traces.keys());
-    const stageCounts = entities
-      .map((e) => `${e}(${this.traces.get(e)!.stages.length})`)
-      .join(', ');
-    this.log(`flush: writing ${entities.length} entities: ${stageCounts}`);
-
-    // Compute summary
+  private computeFlushSummary(): {
+    stageChangeCounts: Record<
+      string,
+      { added: number; removed: number; changed: number }
+    >;
+    entitiesWithMostChanges: string[];
+  } {
     const stageChangeCounts: Record<
       string,
       { added: number; removed: number; changed: number }
@@ -484,17 +477,39 @@ export class TransformationTracer {
       .slice(0, 10)
       .map(([name]) => name);
 
-    const traceFile: TraceFile = {
-      meta: {
-        timestamp: new Date().toISOString(),
-        projectSlug: this.projectSlug,
-        entityCount: this.traces.size,
-      },
-      summary: {
-        stageChangeCounts,
-        entitiesWithMostChanges,
-      },
-      entities: Object.fromEntries(this.traces),
+    return { stageChangeCounts, entitiesWithMostChanges };
+  }
+
+  /**
+   * Write the trace to the output file.
+   * Uses streaming per-entity writes to avoid exceeding V8's max string length
+   * on large projects.
+   */
+  flush(): void {
+    if (!this.isEnabled()) return;
+    if (this.traces.size === 0) {
+      this.log('flush: no traces to write');
+      return;
+    }
+
+    const entities = Array.from(this.traces.keys());
+    const stageCounts = entities
+      .map((e) => `${e}(${this.traces.get(e)!.stages.length})`)
+      .join(', ');
+    this.log(`flush: writing ${entities.length} entities: ${stageCounts}`);
+
+    const { stageChangeCounts, entitiesWithMostChanges } =
+      this.computeFlushSummary();
+
+    const meta = {
+      timestamp: new Date().toISOString(),
+      projectSlug: this.projectSlug,
+      entityCount: this.traces.size,
+    };
+
+    const summary = {
+      stageChangeCounts,
+      entitiesWithMostChanges,
     };
 
     // Ensure directory exists
@@ -503,8 +518,30 @@ export class TransformationTracer {
       fs.mkdirSync(dir, { recursive: true });
     }
 
-    fs.writeFileSync(this.outputPath, JSON.stringify(traceFile, null, 2));
-    this.log(`flush: wrote trace to ${this.outputPath}`);
+    // Stream JSON per-entity to avoid exceeding V8's max string length.
+    // Each entity is serialized individually so no single JSON.stringify
+    // call needs to produce the entire trace.
+    const fd = fs.openSync(this.outputPath, 'w');
+    try {
+      fs.writeSync(fd, '{\n  "meta": ');
+      fs.writeSync(fd, JSON.stringify(meta, null, 2));
+      fs.writeSync(fd, ',\n  "summary": ');
+      fs.writeSync(fd, JSON.stringify(summary, null, 2));
+      fs.writeSync(fd, ',\n  "entities": {');
+
+      let first = true;
+      for (const [entityName, entityTrace] of this.traces) {
+        if (!first) fs.writeSync(fd, ',');
+        fs.writeSync(fd, `\n    ${JSON.stringify(entityName)}: `);
+        fs.writeSync(fd, JSON.stringify(entityTrace, null, 2));
+        first = false;
+      }
+
+      fs.writeSync(fd, '\n  }\n}\n');
+      this.log(`flush: wrote trace to ${this.outputPath}`);
+    } finally {
+      fs.closeSync(fd);
+    }
   }
 
   /**

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

@@ -461,6 +461,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,
@@ -643,6 +654,78 @@ export default function generateDataStructure({
           },
         );
 
+        // 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
 

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;
 }